From 2e6d18e7dce19ec7e4a9a44b208b445ac17e69ae Mon Sep 17 00:00:00 2001 From: XCynthia <942884029@qq.com> Date: Thu, 9 Nov 2023 11:53:40 +0800 Subject: [PATCH] feat: improve pgsql grammar and add unit tests(#201) * feat(pgsql: upgrade keywords and refresh them to parser file): pgsql * feat(pgsql: check create table's syntax): pgsql * feat(pgsql: check and update drop syntax): pgsql: check and update drop syntax * feat: pgsql: check create's sql syntax and update g4 file * feat: pgsql:complete other's sql and syntax except select, insert, drop * feat: pgsql: update create, delete, insert, select, update and others' syntax * test: pgsql: update alter's sql * feat: pgsql: update syntax g4 file * feat: pgsql: upgrade keywords to without '_P' in lexer and parser file * docs: pgsql: update copyright and Reference of parser and lexer --------- Co-authored-by: zhaoge <> --- src/grammar/pgsql/PostgreSQLLexer.g4 | 1570 +- src/grammar/pgsql/PostgreSQLParser.g4 | 3517 +- src/lib/pgsql/PostgreSQLLexer.interp | 1969 +- src/lib/pgsql/PostgreSQLLexer.tokens | 1644 +- src/lib/pgsql/PostgreSQLLexer.ts | 6817 +- src/lib/pgsql/PostgreSQLLexerBase.ts | 67 - src/lib/pgsql/PostgreSQLParser.interp | 1007 +- src/lib/pgsql/PostgreSQLParser.tokens | 1644 +- src/lib/pgsql/PostgreSQLParser.ts | 77201 ++++++++-------- src/lib/pgsql/PostgreSQLParserBase.ts | 97 - src/lib/pgsql/PostgreSQLParserListener.ts | 171 +- src/lib/pgsql/PostgreSQLParserVisitor.ts | 115 +- test/parser/pgsql/fixtures/select.sql | 244 - test/parser/pgsql/selectStatement.test.ts | 18 - test/parser/pgsql/syntax.test.ts | 24 - .../pgsql/syntax/alterStatement.test.ts | 16 + .../pgsql/syntax/createStatement.test.ts | 16 + .../pgsql/syntax/deleteStatement.test.ts | 16 + .../parser/pgsql/syntax/dropStatement.test.ts | 16 + test/parser/pgsql/syntax/fixtures/alter.sql | 314 + test/parser/pgsql/syntax/fixtures/create.sql | 512 + test/parser/pgsql/syntax/fixtures/delete.sql | 11 + test/parser/pgsql/syntax/fixtures/drop.sql | 144 + test/parser/pgsql/syntax/fixtures/insert.sql | 37 + test/parser/pgsql/syntax/fixtures/others.sql | 287 + test/parser/pgsql/syntax/fixtures/select.sql | 176 + test/parser/pgsql/syntax/fixtures/update.sql | 38 + .../pgsql/syntax/insertStatement.test.ts | 16 + test/parser/pgsql/syntax/others.test.ts | 16 + .../pgsql/syntax/selectStatement.test.ts | 16 + .../pgsql/syntax/updateStatement.test.ts | 16 + 31 files changed, 49877 insertions(+), 47875 deletions(-) delete mode 100644 src/lib/pgsql/PostgreSQLLexerBase.ts delete mode 100644 src/lib/pgsql/PostgreSQLParserBase.ts delete mode 100644 test/parser/pgsql/fixtures/select.sql delete mode 100644 test/parser/pgsql/selectStatement.test.ts delete mode 100644 test/parser/pgsql/syntax.test.ts create mode 100644 test/parser/pgsql/syntax/alterStatement.test.ts create mode 100644 test/parser/pgsql/syntax/createStatement.test.ts create mode 100644 test/parser/pgsql/syntax/deleteStatement.test.ts create mode 100644 test/parser/pgsql/syntax/dropStatement.test.ts create mode 100644 test/parser/pgsql/syntax/fixtures/alter.sql create mode 100644 test/parser/pgsql/syntax/fixtures/create.sql create mode 100644 test/parser/pgsql/syntax/fixtures/delete.sql create mode 100644 test/parser/pgsql/syntax/fixtures/drop.sql create mode 100644 test/parser/pgsql/syntax/fixtures/insert.sql create mode 100644 test/parser/pgsql/syntax/fixtures/others.sql create mode 100644 test/parser/pgsql/syntax/fixtures/select.sql create mode 100644 test/parser/pgsql/syntax/fixtures/update.sql create mode 100644 test/parser/pgsql/syntax/insertStatement.test.ts create mode 100644 test/parser/pgsql/syntax/others.test.ts create mode 100644 test/parser/pgsql/syntax/selectStatement.test.ts create mode 100644 test/parser/pgsql/syntax/updateStatement.test.ts diff --git a/src/grammar/pgsql/PostgreSQLLexer.g4 b/src/grammar/pgsql/PostgreSQLLexer.g4 index 8734112..b4c4ccb 100644 --- a/src/grammar/pgsql/PostgreSQLLexer.g4 +++ b/src/grammar/pgsql/PostgreSQLLexer.g4 @@ -1,44 +1,40 @@ /* - * [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 + * [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. + * + * 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. */ + /** - * This file is an adaptation of tunnelvisionlabs's antlr4-grammar-postgresql/src/com/tunnelvisionlabs/postgresql/PostgreSqlLexer.g4 grammar. - * Reference: https://github.com/tunnelvisionlabs/antlr4-grammar-postgresql/blob/master/src/com/tunnelvisionlabs/postgresql/PostgreSqlLexer.g4 + * This file is an adaptation of antlr's sql/postgresql/PostgreSQLLexer.g4 grammar. + * Reference: https://github.com/antlr/grammars-v4/blob/master/sql/postgresql/PostgreSQLLexer.g4 */ lexer grammar PostgreSQLLexer; /** - * Reference Doc: http://www.postgresql.org/docs/9.3/static/sql-syntax-lexical.html + * Reference Doc: https://www.postgresql.org/docs/9.3/sql-commands.html */ - -options { - superClass = PostgreSQLLexerBase; - caseInsensitive = true; -} - -@lexer::header { -import PostgreSQLLexerBase from "./PostgreSQLLexerBase"; -} - // SPECIAL CHARACTERS (4.1.4) // @@ -48,60 +44,33 @@ import PostgreSQLLexerBase from "./PostgreSQLLexerBase"; // 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])+; // @@ -114,27 +83,25 @@ PARAM: '$' ([0-9])+; Operator: ( ( OperatorCharacter - | ('+' | '-' {this.checkLA('-')}?)+ ( + | ('+' | '-')+ ( OperatorCharacter - | '/' {this.checkLA('*')}? + | '/' ? ) - | '/' {this.checkLA('*')}? + | '/' )+ | // special handling for the single-character operators + and - [+-] ) //TODO somehow rewrite this part without using Actions - { - this.HandleLessLessGreaterGreater(); - }; + ; OperatorEndingWithPlusMinus: ( OperatorCharacterNotAllowPlusMinusAtEnd - | '-' {this.checkLA('-')}? - | '/' {this.checkLA('*')}? + | '-' + | '/' )* OperatorCharacterAllowPlusMinusAtEnd Operator? ( '+' - | '-' {this.checkLA('-')}? + | '-' )+ -> type (Operator); // Each of the following fragment rules omits the +, -, and / characters, which must always be handled in a special way @@ -159,990 +126,527 @@ fragment OperatorCharacterAllowPlusMinusAtEnd: [~!@%^&|`?#]; // -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'; - +KW_ALL: 'ALL'; +KW_ANALYSE: 'ANALYSE'; +KW_ANALYZE: 'ANALYZE'; +KW_AND: 'AND'; +KW_ANY: 'ANY'; +KW_ARRAY: 'ARRAY'; +KW_AS: 'AS'; +KW_ASC: 'ASC'; +KW_ASYMMETRIC: 'ASYMMETRIC'; +KW_BOTH: 'BOTH'; +KW_CASE: 'CASE'; +KW_CAST: 'CAST'; +KW_CHECK: 'CHECK'; +KW_COLLATE: 'COLLATE'; +KW_COLUMN: 'COLUMN'; +KW_CONSTRAINT: 'CONSTRAINT'; +KW_CREATE: 'CREATE'; +KW_CURRENT_CATALOG: 'CURRENT_CATALOG'; +KW_CURRENT_DATE: 'CURRENT_DATE'; +KW_CURRENT_ROLE: 'CURRENT_ROLE'; +KW_CURRENT_TIME: 'CURRENT_TIME'; +KW_CURRENT_TIMESTAMP: 'CURRENT_TIMESTAMP'; +KW_CURRENT_USER: 'CURRENT_USER'; +KW_DEFAULT: 'DEFAULT'; +KW_DEFERRABLE: 'DEFERRABLE'; +KW_DESC: 'DESC'; +KW_DISTINCT: 'DISTINCT'; +KW_DO: 'DO'; +KW_ELSE: 'ELSE'; +KW_EXCEPT: 'EXCEPT'; +KW_FALSE: 'FALSE'; +KW_FETCH: 'FETCH'; +KW_FOR: 'FOR'; +KW_FOREIGN: 'FOREIGN'; +KW_FROM: 'FROM'; +KW_GRANT: 'GRANT'; +KW_GROUP: 'GROUP'; +KW_HAVING: 'HAVING'; +KW_IN: 'IN'; +KW_INITIALLY: 'INITIALLY'; +KW_INTERSECT: 'INTERSECT'; +KW_INTO: 'INTO'; +KW_LATERAL: 'LATERAL'; +KW_LEADING: 'LEADING'; +KW_LIMIT: 'LIMIT'; +KW_LOCALTIME: 'LOCALTIME'; +KW_LOCALTIMESTAMP: 'LOCALTIMESTAMP'; +KW_NOT: 'NOT'; +KW_NULL: 'NULL'; +KW_OFFSET: 'OFFSET'; +KW_ON: 'ON'; +KW_ONLY: 'ONLY'; +KW_OR: 'OR'; +KW_ORDER: 'ORDER'; +KW_PLACING: 'PLACING'; +KW_PRIMARY: 'PRIMARY'; +KW_REFERENCES: 'REFERENCES'; +KW_RETURNING: 'RETURNING'; +KW_SELECT: 'SELECT'; +KW_SESSION_USER: 'SESSION_USER'; +KW_SOME: 'SOME'; +KW_SYMMETRIC: 'SYMMETRIC'; +KW_TABLE: 'TABLE'; +KW_THEN: 'THEN'; +KW_TO: 'TO'; +KW_TRAILING: 'TRAILING'; +KW_TRUE: 'TRUE'; +KW_UNION: 'UNION'; +KW_UNIQUE: 'UNIQUE'; +KW_USER: 'USER'; +KW_USING: 'USING'; +KW_VARIADIC: 'VARIADIC'; +KW_WHEN: 'WHEN'; +KW_WHERE: 'WHERE'; +KW_WINDOW: 'WINDOW'; +KW_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'; +KW_AUTHORIZATION: 'AUTHORIZATION'; +KW_BINARY: 'BINARY'; +KW_COLLATION: 'COLLATION'; +KW_CONCURRENTLY: 'CONCURRENTLY'; +KW_CROSS: 'CROSS'; +KW_CURRENT_SCHEMA: 'CURRENT_SCHEMA'; +KW_FREEZE: 'FREEZE'; +KW_FULL: 'FULL'; +KW_ILIKE: 'ILIKE'; +KW_INNER: 'INNER'; +KW_IS: 'IS'; +KW_ISNULL: 'ISNULL'; +KW_JOIN: 'JOIN'; +KW_LEFT: 'LEFT'; +KW_LIKE: 'LIKE'; +KW_NATURAL: 'NATURAL'; +KW_NOTNULL: 'NOTNULL'; +KW_OUTER: 'OUTER'; +KW_OVER: 'OVER'; +KW_OVERLAPS: 'OVERLAPS'; +KW_RIGHT: 'RIGHT'; +KW_SIMILAR: 'SIMILAR'; +KW_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'; +KW_ABORT: 'ABORT'; +KW_ABSOLUTE: 'ABSOLUTE'; +KW_ACCESS: 'ACCESS'; +KW_ACTION: 'ACTION'; +KW_ADD: 'ADD'; +KW_ADMIN: 'ADMIN'; +KW_AFTER: 'AFTER'; +KW_AGGREGATE: 'AGGREGATE'; +KW_ALSO: 'ALSO'; +KW_ALTER: 'ALTER'; +KW_ALWAYS: 'ALWAYS'; +KW_ASSERTION: 'ASSERTION'; +KW_ASSIGNMENT: 'ASSIGNMENT'; +KW_AT: 'AT'; +KW_ATTRIBUTE: 'ATTRIBUTE'; +KW_BACKWARD: 'BACKWARD'; +KW_BEFORE: 'BEFORE'; +KW_BEGIN: 'BEGIN'; +KW_BY: 'BY'; +KW_CACHE: 'CACHE'; +KW_CALLED: 'CALLED'; +KW_CASCADE: 'CASCADE'; +KW_CASCADED: 'CASCADED'; +KW_CATALOG: 'CATALOG'; +KW_CHAIN: 'CHAIN'; +KW_CHARACTERISTICS: 'CHARACTERISTICS'; +KW_CHECKPOINT: 'CHECKPOINT'; +KW_CLASS: 'CLASS'; +KW_CLOSE: 'CLOSE'; +KW_CLUSTER: 'CLUSTER'; +KW_COMMENT: 'COMMENT'; +KW_COMMENTS: 'COMMENTS'; +KW_COMMIT: 'COMMIT'; +KW_COMMITTED: 'COMMITTED'; +KW_CONFIGURATION: 'CONFIGURATION'; +KW_CONNECTION: 'CONNECTION'; +KW_CONSTRAINTS: 'CONSTRAINTS'; +KW_CONTENT: 'CONTENT'; +KW_CONTINUE: 'CONTINUE'; +KW_CONVERSION: 'CONVERSION'; +KW_COPY: 'COPY'; +KW_COST: 'COST'; +KW_CSV: 'CSV'; +KW_CURSOR: 'CURSOR'; +KW_CYCLE: 'CYCLE'; +KW_DATA: 'DATA'; +KW_DATABASE: 'DATABASE'; +KW_DAY: 'DAY'; +KW_DEALLOCATE: 'DEALLOCATE'; +KW_DECLARE: 'DECLARE'; +KW_DEFAULTS: 'DEFAULTS'; +KW_DEFERRED: 'DEFERRED'; +KW_DEFINER: 'DEFINER'; +KW_DELETE: 'DELETE'; +KW_DELIMITER: 'DELIMITER'; +KW_DELIMITERS: 'DELIMITERS'; +KW_DICTIONARY: 'DICTIONARY'; +KW_DISABLE: 'DISABLE'; +KW_DISCARD: 'DISCARD'; +KW_DOCUMENT: 'DOCUMENT'; +KW_DOMAIN: 'DOMAIN'; +KW_DOUBLE: 'DOUBLE'; +KW_DROP: 'DROP'; +KW_EACH: 'EACH'; +KW_ENABLE: 'ENABLE'; +KW_ENCODING: 'ENCODING'; +KW_ENCRYPTED: 'ENCRYPTED'; +KW_ENUM: 'ENUM'; +KW_ESCAPE: 'ESCAPE'; +KW_EVENT: 'EVENT'; +KW_EXCLUDE: 'EXCLUDE'; +KW_EXCLUDING: 'EXCLUDING'; +KW_EXCLUSIVE: 'EXCLUSIVE'; +KW_EXECUTE: 'EXECUTE'; +KW_EXPLAIN: 'EXPLAIN'; +KW_EXTENSION: 'EXTENSION'; +KW_EXTERNAL: 'EXTERNAL'; +KW_FAMILY: 'FAMILY'; +KW_FIRST: 'FIRST'; +KW_FOLLOWING: 'FOLLOWING'; +KW_FORCE: 'FORCE'; +KW_FORWARD: 'FORWARD'; +KW_FUNCTION: 'FUNCTION'; +KW_FUNCTIONS: 'FUNCTIONS'; +KW_GLOBAL: 'GLOBAL'; +KW_GRANTED: 'GRANTED'; +KW_HANDLER: 'HANDLER'; +KW_HEADER: 'HEADER'; +KW_HOLD: 'HOLD'; +KW_HOUR: 'HOUR'; +KW_IDENTITY: 'IDENTITY'; +KW_IF: 'IF'; +KW_IMMEDIATE: 'IMMEDIATE'; +KW_IMMUTABLE: 'IMMUTABLE'; +KW_IMPLICIT: 'IMPLICIT'; +KW_INCLUDING: 'INCLUDING'; +KW_INCREMENT: 'INCREMENT'; +KW_INDEX: 'INDEX'; +KW_INDEXES: 'INDEXES'; +KW_INHERIT: 'INHERIT'; +KW_NOINHERIT: 'NOINHERIT'; +KW_SUPERUSER: 'SUPERUSER'; +KW_NOSUPERUSER: 'NOSUPERUSER'; +KW_CREATEDB: 'CREATEDB'; +KW_NOCREATEDB: 'NOCREATEDB'; +KW_CREATEROLE: 'CREATEROLE'; +KW_NOCREATEROLE: 'NOCREATEROLE'; +KW_CREATEUSER: 'CREATEUSER'; +KW_NOCREATEUSER: 'NOCREATEUSER'; +KW_INHERITS: 'INHERITS'; +KW_INLINE: 'INLINE'; +KW_INSENSITIVE: 'INSENSITIVE'; +KW_INSERT: 'INSERT'; +KW_INSTEAD: 'INSTEAD'; +KW_INVOKER: 'INVOKER'; +KW_ISOLATION: 'ISOLATION'; +KW_KEY: 'KEY'; +KW_LABEL: 'LABEL'; +KW_LANGUAGE: 'LANGUAGE'; +KW_LARGE: 'LARGE'; +KW_LAST: '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'; +KW_LEAKPROOF: 'LEAKPROOF'; +KW_LEVEL: 'LEVEL'; +KW_LISTEN: 'LISTEN'; +KW_LOAD: 'LOAD'; +KW_LOCAL: 'LOCAL'; +KW_LOCATION: 'LOCATION'; +KW_LOCK: 'LOCK'; +KW_MAPPING: 'MAPPING'; +KW_MATCH: 'MATCH'; +KW_MATERIALIZED: 'MATERIALIZED'; +KW_MAXVALUE: 'MAXVALUE'; +KW_MINUTE: 'MINUTE'; +KW_MINVALUE: 'MINVALUE'; +KW_MODE: 'MODE'; +KW_MONTH: 'MONTH'; +KW_MOVE: 'MOVE'; +KW_NAME: 'NAME'; +KW_NAMES: 'NAMES'; +KW_NEXT: 'NEXT'; +KW_NO: 'NO'; +KW_NOTHING: 'NOTHING'; +KW_NOTIFY: 'NOTIFY'; +KW_NOWAIT: 'NOWAIT'; +KW_NULLS: 'NULLS'; +KW_OBJECT: 'OBJECT'; +KW_OF: 'OF'; +KW_OFF: 'OFF'; +KW_OIDS: 'OIDS'; +KW_OPERATOR: 'OPERATOR'; +KW_OPTION: 'OPTION'; +KW_OPTIONS: 'OPTIONS'; +KW_OWNED: 'OWNED'; +KW_OWNER: 'OWNER'; +KW_PARSER: 'PARSER'; +KW_PARTIAL: 'PARTIAL'; +KW_PARTITION: 'PARTITION'; +KW_PASSING: 'PASSING'; +KW_PASSWORD: 'PASSWORD'; +KW_PLANS: 'PLANS'; +KW_PRECEDING: 'PRECEDING'; +KW_PREPARE: 'PREPARE'; +KW_PREPARED: 'PREPARED'; +KW_PRESERVE: 'PRESERVE'; +KW_PRIOR: 'PRIOR'; +KW_PRIVILEGES: 'PRIVILEGES'; +KW_PROCEDURAL: 'PROCEDURAL'; +KW_PROCEDURE: 'PROCEDURE'; +KW_PROGRAM: 'PROGRAM'; +KW_QUOTE: 'QUOTE'; +KW_RANGE: 'RANGE'; +KW_READ: 'READ'; +KW_REASSIGN: 'REASSIGN'; +KW_RECHECK: 'RECHECK'; +KW_RECURSIVE: 'RECURSIVE'; +KW_REF: 'REF'; +KW_REFRESH: 'REFRESH'; +KW_REINDEX: 'REINDEX'; +KW_RELATIVE: 'RELATIVE'; +KW_RELEASE: 'RELEASE'; +KW_RENAME: 'RENAME'; +KW_REPEATABLE: 'REPEATABLE'; +KW_REPLACE: 'REPLACE'; +KW_REPLICA: 'REPLICA'; +KW_RESET: 'RESET'; +KW_RESTART: 'RESTART'; +KW_RESTRICT: 'RESTRICT'; +KW_RETURNS: 'RETURNS'; +KW_REVOKE: 'REVOKE'; +KW_ROLE: 'ROLE'; +KW_ROLLBACK: 'ROLLBACK'; +KW_ROWS: 'ROWS'; +KW_RULE: 'RULE'; +KW_SAVEPOINT: 'SAVEPOINT'; +KW_SCHEMA: 'SCHEMA'; +KW_SCROLL: 'SCROLL'; +KW_SEARCH: 'SEARCH'; +KW_SECOND: 'SECOND'; +KW_SECURITY: 'SECURITY'; +KW_SEQUENCE: 'SEQUENCE'; +KW_SEQUENCES: 'SEQUENCES'; +KW_SERIALIZABLE: 'SERIALIZABLE'; +KW_SERVER: 'SERVER'; +KW_SESSION: 'SESSION'; +KW_SET: 'SET'; +KW_SHARE: 'SHARE'; +KW_SHOW: 'SHOW'; +KW_SIMPLE: 'SIMPLE'; +KW_SNAPSHOT: 'SNAPSHOT'; +KW_STABLE: 'STABLE'; +KW_STANDALONE: 'STANDALONE'; +KW_START: 'START'; +KW_STATEMENT: 'STATEMENT'; +KW_STATISTICS: 'STATISTICS'; +KW_STDIN: 'STDIN'; +KW_STDOUT: 'STDOUT'; +KW_STORAGE: 'STORAGE'; +KW_STRICT: 'STRICT'; +KW_STRIP: 'STRIP'; +KW_SYSID: 'SYSID'; +KW_SYSTEM: 'SYSTEM'; +KW_TABLES: 'TABLES'; +KW_TABLESPACE: 'TABLESPACE'; +KW_TEMP: 'TEMP'; +KW_TEMPLATE: 'TEMPLATE'; +KW_TEMPORARY: 'TEMPORARY'; +KW_TEXT: 'TEXT'; +KW_TRANSACTION: 'TRANSACTION'; +KW_TRIGGER: 'TRIGGER'; +KW_TRUNCATE: 'TRUNCATE'; +KW_TRUSTED: 'TRUSTED'; +KW_TYPE: 'TYPE'; +KW_TYPES: 'TYPES'; +KW_UNBOUNDED: 'UNBOUNDED'; +KW_UNCOMMITTED: 'UNCOMMITTED'; +KW_UNENCRYPTED: 'UNENCRYPTED'; +KW_UNKNOWN: 'UNKNOWN'; +KW_UNLISTEN: 'UNLISTEN'; +KW_UNLOGGED: 'UNLOGGED'; +KW_UNTIL: 'UNTIL'; +KW_UPDATE: 'UPDATE'; +KW_VACUUM: 'VACUUM'; +KW_VALID: 'VALID'; +KW_VALIDATE: 'VALIDATE'; +KW_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'; +KW_VARYING: 'VARYING'; +KW_VERSION: 'VERSION'; +KW_VIEW: 'VIEW'; +KW_VOLATILE: 'VOLATILE'; +KW_WHITESPACE: 'WHITESPACE'; +KW_WITHOUT: 'WITHOUT'; +KW_WORK: 'WORK'; +KW_WRAPPER: 'WRAPPER'; +KW_WRITE: 'WRITE'; +KW_XML: 'XML'; +KW_YEAR: 'YEAR'; +KW_YES: 'YES'; +KW_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'; +KW_BETWEEN: 'BETWEEN'; +KW_BIGINT: 'BIGINT'; +KW_BIT: 'BIT'; +KW_BOOLEAN: 'BOOLEAN'; +KW_CHAR: 'CHAR'; +KW_CHARACTER: 'CHARACTER'; +KW_COALESCE: 'COALESCE'; +KW_DEC: 'DEC'; +KW_DECIMAL: 'DECIMAL'; +KW_EXISTS: 'EXISTS'; +KW_EXTRACT: 'EXTRACT'; +KW_FLOAT: 'FLOAT'; +KW_GREATEST: 'GREATEST'; +KW_INOUT: 'INOUT'; +KW_INT: 'INT'; +KW_INTEGER: 'INTEGER'; +KW_INTERVAL: 'INTERVAL'; +KW_LEAST: 'LEAST'; +KW_NATIONAL: 'NATIONAL'; +KW_NCHAR: 'NCHAR'; +KW_NONE: 'NONE'; +KW_NULLIF: 'NULLIF'; +KW_NUMERIC: 'NUMERIC'; +KW_OVERLAY: 'OVERLAY'; +KW_POSITION: 'POSITION'; +KW_PRECISION: 'PRECISION'; +KW_REAL: 'REAL'; +KW_ROW: 'ROW'; +KW_SETOF: 'SETOF'; +KW_SMALLINT: 'SMALLINT'; +KW_SUBSTRING: 'SUBSTRING'; +KW_TIME: 'TIME'; +KW_TIMESTAMP: 'TIMESTAMP'; +KW_TREAT: 'TREAT'; +KW_TRIM: 'TRIM'; +KW_VALUES: 'VALUES'; +KW_VARCHAR: 'VARCHAR'; +KW_XMLATTRIBUTES: 'XMLATTRIBUTES'; +KW_XMLCONCAT: 'XMLCONCAT'; +KW_XMLELEMENT: 'XMLELEMENT'; +KW_XMLEXISTS: 'XMLEXISTS'; +KW_XMLFOREST: 'XMLFOREST'; +KW_XMLPARSE: 'XMLPARSE'; +KW_XMLPI: 'XMLPI'; +KW_XMLROOT: 'XMLROOT'; +KW_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'; +KW_CALL: 'CALL'; +KW_CURRENT: 'CURRENT'; +KW_ATTACH: 'ATTACH'; +KW_DETACH: 'DETACH'; +KW_EXPRESSION: 'EXPRESSION'; +KW_GENERATED: 'GENERATED'; +KW_LOGGED: 'LOGGED'; +KW_STORED: 'STORED'; +KW_INCLUDE: 'INCLUDE'; +KW_ROUTINE: 'ROUTINE'; +KW_TRANSFORM: 'TRANSFORM'; +KW_IMPORT: 'IMPORT'; +KW_POLICY: 'POLICY'; +KW_METHOD: 'METHOD'; +KW_REFERENCING: 'REFERENCING'; +KW_NEW: 'NEW'; +KW_OLD: 'OLD'; +KW_VALUE: 'VALUE'; +KW_SUBSCRIPTION: 'SUBSCRIPTION'; +KW_PUBLICATION: 'PUBLICATION'; +KW_OUT: 'OUT'; +KW_END: 'END'; +KW_ROUTINES: 'ROUTINES'; +KW_SCHEMAS: 'SCHEMAS'; +KW_PROCEDURES: 'PROCEDURES'; +KW_INPUT: 'INPUT'; +KW_SUPPORT: 'SUPPORT'; +KW_PARALLEL: 'PARALLEL'; +KW_SQL: 'SQL'; +KW_DEPENDS: 'DEPENDS'; +KW_OVERRIDING: 'OVERRIDING'; +KW_CONFLICT: 'CONFLICT'; +KW_SKIP: 'SKIP'; +KW_LOCKED: 'LOCKED'; +KW_TIES: 'TIES'; +KW_ROLLUP: 'ROLLUP'; +KW_CUBE: 'CUBE'; +KW_GROUPING: 'GROUPING'; +KW_SETS: 'SETS'; +KW_TABLESAMPLE: 'TABLESAMPLE'; +KW_ORDINALITY: 'ORDINALITY'; +KW_XMLTABLE: 'XMLTABLE'; +KW_COLUMNS: 'COLUMNS'; +KW_XMLNAMESPACES: 'XMLNAMESPACES'; +KW_ROWTYPE: 'ROWTYPE'; +KW_NORMALIZED: 'NORMALIZED'; +KW_WITHIN: 'WITHIN'; +KW_FILTER: 'FILTER'; +KW_GROUPS: 'GROUPS'; +KW_OTHERS: 'OTHERS'; +KW_NFC: 'NFC'; +KW_NFD: 'NFD'; +KW_NFKC: 'NFKC'; +KW_NFKD: 'NFKD'; +KW_UESCAPE: 'UESCAPE'; +KW_VIEWS: 'VIEWS'; +KW_NORMALIZE: 'NORMALIZE'; +KW_DUMP: 'DUMP'; +KW_PRINT_STRICT_PARAMS: 'PRINT_STRICT_PARAMS'; +KW_VARIABLE_CONFLICT: 'VARIABLE_CONFLICT'; +KW_ERROR: 'ERROR'; +KW_USE_VARIABLE: 'USE_VARIABLE'; +KW_USE_COLUMN: 'USE_COLUMN'; +KW_ALIAS: 'ALIAS'; +KW_CONSTANT: 'CONSTANT'; +KW_PERFORM: 'PERFORM'; +KW_GET: 'GET'; +KW_DIAGNOSTICS: 'DIAGNOSTICS'; +KW_STACKED: 'STACKED'; +KW_ELSIF: 'ELSIF'; +KW_WHILE: 'WHILE'; +KW_REVERSE: 'REVERSE'; +KW_FOREACH: 'FOREACH'; +KW_SLICE: 'SLICE'; +KW_EXIT: 'EXIT'; +KW_RETURN: 'RETURN'; +KW_QUERY: 'QUERY'; +KW_RAISE: 'RAISE'; +KW_SQLSTATE: 'SQLSTATE'; +KW_DEBUG: 'DEBUG'; +KW_LOG: 'LOG'; +KW_INFO: 'INFO'; +KW_NOTICE: 'NOTICE'; +KW_WARNING: 'WARNING'; +KW_EXCEPTION: 'EXCEPTION'; +KW_ASSERT: 'ASSERT'; +KW_LOOP: 'LOOP'; +KW_OPEN: 'OPEN'; + +KW_PEFERENCES: 'PEFERENCES'; +KW_USAGE: 'USAGE'; +KW_CONNECT: 'CONNECT'; +KW_PUBLIC: 'PUBLIC'; // // IDENTIFIERS (4.1.1) @@ -1156,11 +660,9 @@ fragment IdentifierStartChar: // these are the valid identifier start characters | // 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] {this.charIsLetter()}? + [\u0100-\uD7FF\uE000-\uFFFF] | // letters which require multiple UTF-16 code units - [\uD800-\uDBFF] [\uDC00-\uDFFF] { - this.CheckIfUtf32Letter() - }?; + [\uD800-\uDBFF] [\uDC00-\uDFFF]; fragment IdentifierChar: StrictIdentifierChar | '$'; @@ -1241,7 +743,7 @@ UnterminatedUnicodeEscapeStringConstant: // Dollar-quoted String Constants (4.1.2.4) BeginDollarStringConstant: - '$' Tag? '$' {this.pushTag();} -> pushMode (DollarQuotedStringMode); + '$' Tag? '$' -> 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." */ @@ -1273,7 +775,7 @@ InvalidUnterminatedHexadecimalStringConstant: Integral: Digits; -NumericFail: Digits '..' {this.HandleNumericFail();}; +NumericFail: Digits '..'; Numeric: Digits '.' Digits? /*? replaced with + to solve problem with DOT_DOT .. but this surely must be rewriten */ @@ -1326,9 +828,7 @@ UnterminatedBlockComment: // 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 - { - this.UnterminatedBlockCommentDebugAssert(); - }; + ; // // META-COMMANDS @@ -1421,4 +921,4 @@ DollarText: // not part of the ending tag. '$' ~ '$'*; -EndDollarStringConstant: ('$' Tag? '$') {this.isTag()}? {this.popTag();} -> popMode; +EndDollarStringConstant: ('$' Tag? '$') -> popMode; diff --git a/src/grammar/pgsql/PostgreSQLParser.g4 b/src/grammar/pgsql/PostgreSQLParser.g4 index 54ea7d6..d854b7e 100644 --- a/src/grammar/pgsql/PostgreSQLParser.g4 +++ b/src/grammar/pgsql/PostgreSQLParser.g4 @@ -1,11 +1,43 @@ +/* + * [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. + */ + +/** + * This file is an adaptation of antlr's sql/postgresql/PostgreSQLParser.g4 grammar. + * Reference: https://github.com/antlr/grammars-v4/blob/master/sql/postgresql/PostgreSQLParser.g4 + */ + +/** + * Reference Doc: https://www.postgresql.org/docs/9.3/sql-commands.html + */ + parser grammar PostgreSQLParser; + options { tokenVocab = PostgreSQLLexer; - superClass = PostgreSQLParserBase; -} -@parser::header { -import PostgreSQLParserBase from "./PostgreSQLParserBase"; } program: stmtmulti; @@ -142,12 +174,12 @@ stmt: plsqlconsolecommand: MetaCommand EndMetaCommand?; -callstmt: CALL func_application; +callstmt: KW_CALL func_application; -createrolestmt: CREATE ROLE roleid opt_with? optrolelist; +createrolestmt: KW_CREATE KW_ROLE roleid opt_with? optrolelist; opt_with: - WITH + KW_WITH ; //| WITH_LA optrolelist: createoptroleelem*; @@ -155,43 +187,47 @@ optrolelist: createoptroleelem*; alteroptrolelist: alteroptroleelem*; alteroptroleelem: - PASSWORD (sconst | NULL_P) - | (ENCRYPTED | UNENCRYPTED) PASSWORD sconst - | INHERIT - | CONNECTION LIMIT signediconst - | VALID UNTIL sconst - | USER role_list + KW_PASSWORD (sconst | KW_NULL) + | (KW_ENCRYPTED | KW_UNENCRYPTED) KW_PASSWORD sconst + | (KW_INHERIT | KW_NOINHERIT) + | (KW_CREATEUSER | KW_NOCREATEUSER) + | (KW_CREATEROLE | KW_NOCREATEROLE) + | (KW_CREATEDB | KW_NOCREATEDB) + | (KW_SUPERUSER | KW_NOSUPERUSER) + | KW_CONNECTION KW_LIMIT signediconst + | KW_VALID KW_UNTIL sconst + | KW_USER role_list | identifier; createoptroleelem: alteroptroleelem - | SYSID iconst - | ADMIN role_list - | ROLE role_list - | IN_P (ROLE | GROUP_P) role_list; + | KW_SYSID iconst + | KW_ADMIN role_list + | KW_ROLE role_list + | KW_IN (KW_ROLE | KW_GROUP) role_list; -createuserstmt: CREATE USER roleid opt_with? optrolelist; +createuserstmt: KW_CREATE KW_USER roleid opt_with? optrolelist; alterrolestmt: - ALTER (ROLE | USER) rolespec opt_with? alteroptrolelist; + KW_ALTER (KW_ROLE | KW_USER) rolespec opt_with? alteroptrolelist; -opt_in_database: | IN_P DATABASE name; +opt_in_database: | KW_IN KW_DATABASE name; alterrolesetstmt: - ALTER (ROLE | USER) ALL? rolespec opt_in_database setresetclause; + KW_ALTER (KW_ROLE | KW_USER) (KW_ALL | rolespec) opt_in_database setresetclause; droprolestmt: - DROP (ROLE | USER | GROUP_P) (IF_P EXISTS)? role_list; + KW_DROP (KW_ROLE | KW_USER | KW_GROUP) (KW_IF KW_EXISTS)? role_list; -creategroupstmt: CREATE GROUP_P roleid opt_with? optrolelist; +creategroupstmt: KW_CREATE KW_GROUP groupname opt_with? optrolelist; -altergroupstmt: ALTER GROUP_P rolespec add_drop USER role_list; +altergroupstmt: KW_ALTER KW_GROUP rolespec add_drop KW_USER role_list; -add_drop: ADD_P | DROP; +add_drop: KW_ADD | KW_DROP; createschemastmt: - CREATE SCHEMA (IF_P NOT EXISTS)? ( - optschemaname? AUTHORIZATION rolespec + KW_CREATE KW_SCHEMA (KW_IF KW_NOT KW_EXISTS)? ( + optschemaname? KW_AUTHORIZATION rolespec | colid ) optschemaeltlist; @@ -207,26 +243,26 @@ schema_stmt: | grantstmt | viewstmt; -variablesetstmt: SET (LOCAL | SESSION)? set_rest; +variablesetstmt: KW_SET (KW_LOCAL | KW_SESSION)? set_rest; set_rest: - TRANSACTION transaction_mode_list - | SESSION CHARACTERISTICS AS TRANSACTION transaction_mode_list + KW_TRANSACTION transaction_mode_list + | KW_SESSION KW_CHARACTERISTICS KW_AS KW_TRANSACTION transaction_mode_list | set_rest_more; -generic_set: var_name (TO | EQUAL) var_list; +generic_set: var_name (KW_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 KW_FROM KW_CURRENT + | KW_TIME KW_ZONE zone_value + | KW_CATALOG sconst + | KW_SCHEMA sconst + | KW_NAMES opt_encoding? + | KW_ROLE nonreservedword_or_sconst + | KW_SESSION KW_AUTHORIZATION nonreservedword_or_sconst + | KW_XML KW_OPTION document_or_content + | KW_TRANSACTION KW_SNAPSHOT sconst; var_name: colid (DOT colid)*; @@ -235,14 +271,14 @@ var_list: var_value (COMMA var_value)*; var_value: opt_boolean_or_string | numericonly; iso_level: - READ (UNCOMMITTED | COMMITTED) - | REPEATABLE READ - | SERIALIZABLE; + KW_READ (KW_UNCOMMITTED | KW_COMMITTED) + | KW_REPEATABLE KW_READ + | KW_SERIALIZABLE; opt_boolean_or_string: - TRUE_P - | FALSE_P - | ON + KW_TRUE + | KW_FALSE + | KW_ON | nonreservedword_or_sconst; zone_value: @@ -251,149 +287,149 @@ zone_value: | constinterval sconst opt_interval? | constinterval OPEN_PAREN iconst CLOSE_PAREN sconst | numericonly - | DEFAULT - | LOCAL; + | KW_DEFAULT + | KW_LOCAL; -opt_encoding: sconst | DEFAULT; +opt_encoding: sconst | KW_DEFAULT; nonreservedword_or_sconst: nonreservedword | sconst; -variableresetstmt: RESET reset_rest; +variableresetstmt: KW_RESET reset_rest; reset_rest: generic_reset - | TIME ZONE - | TRANSACTION ISOLATION LEVEL - | SESSION AUTHORIZATION; + | KW_TIME KW_ZONE + | KW_TRANSACTION KW_ISOLATION KW_LEVEL + | KW_SESSION KW_AUTHORIZATION; -generic_reset: var_name | ALL; +generic_reset: var_name | KW_ALL; -setresetclause: SET set_rest | variableresetstmt; +setresetclause: KW_SET set_rest | variableresetstmt; -functionsetresetclause: SET set_rest_more | variableresetstmt; +functionsetresetclause: KW_SET set_rest_more | variableresetstmt; variableshowstmt: - SHOW ( + KW_SHOW ( var_name - | TIME ZONE - | TRANSACTION ISOLATION LEVEL - | SESSION AUTHORIZATION - | ALL + | KW_TIME KW_ZONE + | KW_TRANSACTION KW_ISOLATION KW_LEVEL + | KW_SESSION KW_AUTHORIZATION + | KW_ALL ); constraintssetstmt: - SET CONSTRAINTS constraints_set_list constraints_set_mode; + KW_SET KW_CONSTRAINTS constraints_set_list constraints_set_mode; -constraints_set_list: ALL | qualified_name_list; +constraints_set_list: KW_ALL | qualified_name_list; -constraints_set_mode: DEFERRED | IMMEDIATE; +constraints_set_mode: KW_DEFERRED | KW_IMMEDIATE; -checkpointstmt: CHECKPOINT; +checkpointstmt: KW_CHECKPOINT; discardstmt: - DISCARD (ALL | TEMP | TEMPORARY | PLANS | SEQUENCES); + KW_DISCARD (KW_ALL | KW_TEMP | KW_TEMPORARY | KW_PLANS | KW_SEQUENCES); altertablestmt: - ALTER TABLE (IF_P EXISTS)? relation_expr ( + KW_ALTER KW_TABLE (KW_IF KW_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 ( + | KW_ALTER KW_TABLE KW_ALL KW_IN KW_TABLESPACE name (KW_OWNED KW_BY role_list)? KW_SET KW_TABLESPACE name opt_nowait? + | KW_ALTER KW_INDEX (KW_IF KW_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; + | KW_ALTER KW_INDEX KW_ALL KW_IN KW_TABLESPACE name (KW_OWNED KW_BY role_list)? KW_SET KW_TABLESPACE name opt_nowait? + | KW_ALTER KW_SEQUENCE (KW_IF KW_EXISTS)? qualified_name alter_table_cmds + | KW_ALTER KW_VIEW (KW_IF KW_EXISTS)? qualified_name alter_table_cmds + | KW_ALTER KW_MATERIALIZED KW_VIEW (KW_IF KW_EXISTS)? qualified_name alter_table_cmds + | KW_ALTER KW_MATERIALIZED KW_VIEW KW_ALL KW_IN KW_TABLESPACE name ( + KW_OWNED KW_BY role_list + )? KW_SET KW_TABLESPACE name opt_nowait? + | KW_ALTER KW_FOREIGN KW_TABLE (KW_IF KW_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; + KW_ATTACH KW_PARTITION qualified_name partitionboundspec + | KW_DETACH KW_PARTITION qualified_name; -index_partition_cmd: ATTACH PARTITION qualified_name; +index_partition_cmd: KW_ATTACH KW_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 + KW_ADD columnDef + | KW_ADD KW_IF KW_NOT KW_EXISTS columnDef + | KW_ADD KW_COLUMN columnDef + | KW_ADD KW_COLUMN KW_IF KW_NOT KW_EXISTS columnDef + | KW_ALTER opt_column? colid alter_column_default + | KW_ALTER opt_column? colid KW_DROP KW_NOT KW_NULL + | KW_ALTER opt_column? colid KW_SET KW_NOT KW_NULL + | KW_ALTER opt_column? colid KW_DROP KW_EXPRESSION + | KW_ALTER opt_column? colid KW_DROP KW_EXPRESSION KW_IF KW_EXISTS + | KW_ALTER opt_column? colid KW_SET KW_STATISTICS signediconst + | KW_ALTER opt_column? iconst KW_SET KW_STATISTICS signediconst + | KW_ALTER opt_column? colid KW_SET reloptions + | KW_ALTER opt_column? colid KW_RESET reloptions + | KW_ALTER opt_column? colid KW_SET KW_STORAGE colid + | KW_ALTER opt_column? colid KW_ADD KW_GENERATED generated_when KW_AS KW_IDENTITY 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 + | KW_ALTER opt_column? colid alter_identity_column_option_list + | KW_ALTER opt_column? colid KW_DROP KW_IDENTITY + | KW_ALTER opt_column? colid KW_DROP KW_IDENTITY KW_IF KW_EXISTS + | KW_DROP opt_column? KW_IF KW_EXISTS colid opt_drop_behavior? + | KW_DROP opt_column? colid opt_drop_behavior? + | KW_ALTER opt_column? colid opt_set_data? KW_TYPE typename opt_collate_clause? alter_using? + | KW_ALTER opt_column? colid alter_generic_options + | KW_ADD tableconstraint + | KW_ALTER KW_CONSTRAINT name constraintattributespec + | KW_VALIDATE KW_CONSTRAINT name + | KW_DROP KW_CONSTRAINT KW_IF KW_EXISTS name opt_drop_behavior? + | KW_DROP KW_CONSTRAINT name opt_drop_behavior? + | KW_SET KW_WITHOUT KW_OIDS + | KW_CLUSTER KW_ON name + | KW_SET KW_WITHOUT KW_CLUSTER + | KW_SET KW_LOGGED + | KW_SET KW_UNLOGGED + | KW_ENABLE KW_TRIGGER name + | KW_ENABLE KW_ALWAYS KW_TRIGGER name + | KW_ENABLE KW_REPLICA KW_TRIGGER name + | KW_ENABLE KW_TRIGGER KW_ALL + | KW_ENABLE KW_TRIGGER KW_USER + | KW_DISABLE KW_TRIGGER name + | KW_DISABLE KW_TRIGGER KW_ALL + | KW_DISABLE KW_TRIGGER KW_USER + | KW_ENABLE KW_RULE name + | KW_ENABLE KW_ALWAYS KW_RULE name + | KW_ENABLE KW_REPLICA KW_RULE name + | KW_DISABLE KW_RULE name + | KW_INHERIT qualified_name + | KW_NO KW_INHERIT qualified_name + | KW_OF any_name + | KW_NOT KW_OF + | KW_OWNER KW_TO rolespec + | KW_SET KW_TABLESPACE name + | KW_SET reloptions + | KW_RESET reloptions + | KW_REPLICA KW_IDENTITY replica_identity + | KW_ENABLE KW_ROW KW_LEVEL KW_SECURITY + | KW_DISABLE KW_ROW KW_LEVEL KW_SECURITY + | KW_FORCE KW_ROW KW_LEVEL KW_SECURITY + | KW_NO KW_FORCE KW_ROW KW_LEVEL KW_SECURITY | alter_generic_options; -alter_column_default: SET DEFAULT a_expr | DROP DEFAULT; +alter_column_default: KW_SET KW_DEFAULT a_expr | KW_DROP KW_DEFAULT; -opt_drop_behavior: CASCADE | RESTRICT; +opt_drop_behavior: KW_CASCADE | KW_RESTRICT; -opt_collate_clause: COLLATE any_name; +opt_collate_clause: KW_COLLATE any_name; -alter_using: USING a_expr; +alter_using: KW_USING a_expr; -replica_identity: NOTHING | FULL | DEFAULT | USING INDEX name; +replica_identity: KW_NOTHING | KW_FULL | KW_DEFAULT | KW_USING KW_INDEX name; reloptions: OPEN_PAREN reloption_list CLOSE_PAREN; -opt_reloptions: WITH reloptions; +opt_reloptions: KW_WITH reloptions; reloption_list: reloption_elem (COMMA reloption_elem)*; @@ -404,42 +440,42 @@ alter_identity_column_option_list: alter_identity_column_option+; alter_identity_column_option: - RESTART (opt_with? numericonly)? - | SET (seqoptelem | GENERATED generated_when); + KW_RESTART (opt_with? numericonly)? + | KW_SET (seqoptelem | KW_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; + KW_FOR KW_VALUES KW_WITH OPEN_PAREN hash_partbound CLOSE_PAREN + | KW_FOR KW_VALUES KW_IN OPEN_PAREN expr_list CLOSE_PAREN + | KW_FOR KW_VALUES KW_FROM OPEN_PAREN expr_list CLOSE_PAREN KW_TO OPEN_PAREN expr_list CLOSE_PAREN + | KW_DEFAULT; hash_partbound_elem: nonreservedword iconst; hash_partbound: hash_partbound_elem (COMMA hash_partbound_elem)*; -altercompositetypestmt: ALTER TYPE_P any_name alter_type_cmds; +altercompositetypestmt: KW_ALTER KW_TYPE 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?; + KW_ADD KW_ATTRIBUTE tablefuncelement opt_drop_behavior? + | KW_DROP KW_ATTRIBUTE (KW_IF KW_EXISTS)? colid opt_drop_behavior? + | KW_ALTER KW_ATTRIBUTE colid opt_set_data? KW_TYPE typename opt_collate_clause? opt_drop_behavior?; -closeportalstmt: CLOSE (cursor_name | ALL); +closeportalstmt: KW_CLOSE (cursor_name | KW_ALL); copystmt: - COPY opt_binary? qualified_name opt_column_list? copy_from opt_program? copy_file_name + KW_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? + | KW_COPY OPEN_PAREN preparablestmt CLOSE_PAREN KW_TO opt_program? copy_file_name opt_with? copy_options; -copy_from: FROM | TO; +copy_from: KW_FROM | KW_TO; -opt_program: PROGRAM; +opt_program: KW_PROGRAM; -copy_file_name: sconst | STDIN | STDOUT; +copy_file_name: sconst | KW_STDIN | KW_STDOUT; copy_options: copy_opt_list @@ -448,25 +484,25 @@ copy_options: 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; + KW_BINARY + | KW_FREEZE + | KW_DELIMITER opt_as? sconst + | KW_NULL opt_as? sconst + | KW_CSV + | KW_HEADER + | KW_QUOTE opt_as? sconst + | KW_ESCAPE opt_as? sconst + | KW_FORCE KW_QUOTE columnlist + | KW_FORCE KW_QUOTE STAR + | KW_FORCE KW_NOT KW_NULL columnlist + | KW_FORCE KW_NULL columnlist + | KW_ENCODING sconst; -opt_binary: BINARY; +opt_binary: KW_BINARY; -copy_delimiter: opt_using? DELIMITERS sconst; +copy_delimiter: opt_using? KW_DELIMITERS sconst; -opt_using: USING; +opt_using: KW_USING; copy_generic_opt_list: copy_generic_opt_elem (COMMA copy_generic_opt_elem)*; @@ -487,21 +523,23 @@ copy_generic_opt_arg_list: 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? + KW_CREATE opttemp? KW_TABLE (KW_IF KW_NOT KW_EXISTS)? table_qualified_name ( + OPEN_PAREN table_column_list? CLOSE_PAREN optinherit? optpartitionspec? table_access_method_clause? optwith? oncommitoption? opttablespace? - | OF any_name opttypedtableelementlist? optpartitionspec? table_access_method_clause? + | KW_OF any_name opttypedtableelementlist? optpartitionspec? table_access_method_clause? optwith? oncommitoption? opttablespace? - | PARTITION OF qualified_name opttypedtableelementlist? partitionboundspec optpartitionspec? + | KW_PARTITION KW_OF qualified_name opttypedtableelementlist? partitionboundspec optpartitionspec? table_access_method_clause? optwith? oncommitoption? opttablespace? ); opttemp: - TEMPORARY - | TEMP - | LOCAL (TEMPORARY | TEMP) - | GLOBAL (TEMPORARY | TEMP) - | UNLOGGED; + KW_TEMPORARY + | KW_TEMP + | KW_LOCAL (KW_TEMPORARY | KW_TEMP) + | KW_GLOBAL (KW_TEMPORARY | KW_TEMP) + | KW_UNLOGGED; + +table_column_list: tableelementlist; opttableelementlist: tableelementlist; @@ -517,75 +555,76 @@ tableelement: columnDef | tablelikeclause | tableconstraint; typedtableelement: columnOptions | tableconstraint; -columnDef: colid typename create_generic_options? colquallist; +columnDef: colid typename create_generic_options? (KW_COLLATE any_name)? colquallist; -columnOptions: colid (WITH OPTIONS)? colquallist; +columnOptions: colid (KW_WITH KW_OPTIONS)? colquallist; colquallist: colconstraint*; colconstraint: - CONSTRAINT name colconstraintelem - | colconstraintelem - | constraintattr - | COLLATE any_name; + (KW_CONSTRAINT name)? colconstraintelem deferrable_trigger? initially_trigger? + | colconstraintelem deferrable_trigger? initially_trigger? + ; 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 + KW_NOT KW_NULL + | KW_NULL + | KW_UNIQUE opt_definition? optconstablespace? + | KW_PRIMARY KW_KEY opt_definition? optconstablespace? + | KW_CHECK OPEN_PAREN a_expr CLOSE_PAREN opt_no_inherit? + | KW_DEFAULT b_expr + | KW_GENERATED generated_when KW_AS ( + KW_IDENTITY optparenthesizedseqoptlist? + | OPEN_PAREN a_expr CLOSE_PAREN KW_STORED ) - | REFERENCES qualified_name opt_column_list? key_match? key_actions?; + | KW_REFERENCES qualified_name opt_column_list? key_match? key_actions?; -generated_when: ALWAYS | BY DEFAULT; +generated_when: KW_ALWAYS | KW_BY KW_DEFAULT; -constraintattr: - DEFERRABLE - | NOT DEFERRABLE - | INITIALLY (DEFERRED | IMMEDIATE); +deferrable_trigger: + KW_DEFERRABLE + | KW_NOT KW_DEFERRABLE; -tablelikeclause: LIKE qualified_name tablelikeoptionlist; +initially_trigger: + KW_INITIALLY (KW_DEFERRED | KW_IMMEDIATE); -tablelikeoptionlist: ((INCLUDING | EXCLUDING) tablelikeoption)*; +tablelikeclause: KW_LIKE qualified_name tablelikeoptionlist; + +tablelikeoptionlist: ((KW_INCLUDING | KW_EXCLUDING) tablelikeoption)*; tablelikeoption: - COMMENTS - | CONSTRAINTS - | DEFAULTS - | IDENTITY_P - | GENERATED - | INDEXES - | STATISTICS - | STORAGE - | ALL; + KW_COMMENTS + | KW_CONSTRAINTS + | KW_DEFAULTS + | KW_IDENTITY + | KW_GENERATED + | KW_INDEXES + | KW_STATISTICS + | KW_STORAGE + | KW_ALL; tableconstraint: - CONSTRAINT name constraintelem + KW_CONSTRAINT name constraintelem | constraintelem; constraintelem: - CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec - | UNIQUE ( + KW_CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec + | KW_UNIQUE ( OPEN_PAREN columnlist CLOSE_PAREN opt_c_include? opt_definition? optconstablespace? constraintattributespec | existingindex constraintattributespec ) - | PRIMARY KEY ( + | KW_PRIMARY KW_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? + | KW_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? + | KW_FOREIGN KW_KEY OPEN_PAREN columnlist CLOSE_PAREN KW_REFERENCES qualified_name opt_column_list? key_match? key_actions? constraintattributespec; -opt_no_inherit: NO INHERIT; +opt_no_inherit: KW_NO KW_INHERIT; opt_column_list: OPEN_PAREN columnlist CLOSE_PAREN; @@ -593,20 +632,20 @@ columnlist: columnElem (COMMA columnElem)*; columnElem: colid; -opt_c_include: INCLUDE OPEN_PAREN columnlist CLOSE_PAREN; +opt_c_include: KW_INCLUDE OPEN_PAREN columnlist CLOSE_PAREN; -key_match: MATCH (FULL | PARTIAL | SIMPLE); +key_match: KW_MATCH (KW_FULL | KW_PARTIAL | KW_SIMPLE); exclusionconstraintlist: exclusionconstraintelem (COMMA exclusionconstraintelem)*; exclusionconstraintelem: - index_elem WITH ( + index_elem KW_WITH ( any_operator - | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + | KW_OPERATOR OPEN_PAREN any_operator CLOSE_PAREN ); -exclusionwhereclause: WHERE OPEN_PAREN a_expr CLOSE_PAREN; +exclusionwhereclause: KW_WHERE OPEN_PAREN a_expr CLOSE_PAREN; key_actions: key_update @@ -614,22 +653,22 @@ key_actions: | key_update key_delete | key_delete key_update; -key_update: ON UPDATE key_action; +key_update: KW_ON KW_UPDATE key_action; -key_delete: ON DELETE_P key_action; +key_delete: KW_ON KW_DELETE key_action; key_action: - NO ACTION - | RESTRICT - | CASCADE - | SET (NULL_P | DEFAULT); + KW_NO KW_ACTION + | KW_RESTRICT + | KW_CASCADE + | KW_SET (KW_NULL | KW_DEFAULT); -optinherit: INHERITS OPEN_PAREN qualified_name_list CLOSE_PAREN; +optinherit: KW_INHERITS OPEN_PAREN qualified_name_list CLOSE_PAREN; optpartitionspec: partitionspec; partitionspec: - PARTITION BY colid OPEN_PAREN part_params CLOSE_PAREN; + KW_PARTITION KW_BY colid OPEN_PAREN part_params CLOSE_PAREN; part_params: part_elem (COMMA part_elem)*; @@ -638,51 +677,51 @@ part_elem: | func_expr_windowless opt_collate? opt_class? | OPEN_PAREN a_expr CLOSE_PAREN opt_collate? opt_class?; -table_access_method_clause: USING name; +table_access_method_clause: KW_USING name; -optwith: WITH reloptions | WITHOUT OIDS; +optwith: KW_WITH reloptions | KW_WITHOUT KW_OIDS | KW_WITH KW_OIDS; oncommitoption: - ON COMMIT (DROP | DELETE_P ROWS | PRESERVE ROWS); + KW_ON KW_COMMIT (KW_DROP | KW_DELETE KW_ROWS | KW_PRESERVE KW_ROWS); -opttablespace: TABLESPACE name; +opttablespace: KW_TABLESPACE name; -optconstablespace: USING INDEX TABLESPACE name; +optconstablespace: KW_USING KW_INDEX KW_TABLESPACE name; -existingindex: USING INDEX name; +existingindex: KW_USING KW_INDEX name; createstatsstmt: - CREATE STATISTICS (IF_P NOT EXISTS)? any_name opt_name_list? ON expr_list FROM from_list; + KW_CREATE KW_STATISTICS (KW_IF KW_NOT KW_EXISTS)? any_name opt_name_list? KW_ON expr_list KW_FROM from_list; alterstatsstmt: - ALTER STATISTICS (IF_P EXISTS)? any_name SET STATISTICS signediconst; + KW_ALTER KW_STATISTICS (KW_IF KW_EXISTS)? any_name KW_SET KW_STATISTICS signediconst; createasstmt: - CREATE opttemp? TABLE (IF_P NOT EXISTS)? create_as_target AS selectstmt opt_with_data?; + KW_CREATE opttemp? KW_TABLE (KW_IF KW_NOT KW_EXISTS)? create_as_target KW_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); +opt_with_data: KW_WITH (KW_DATA | KW_NO KW_DATA); creatematviewstmt: - CREATE optnolog? MATERIALIZED VIEW (IF_P NOT EXISTS)? create_mv_target AS selectstmt + KW_CREATE optnolog? KW_MATERIALIZED KW_VIEW (KW_IF KW_NOT KW_EXISTS)? create_mv_target KW_AS selectstmt opt_with_data?; create_mv_target: qualified_name opt_column_list? table_access_method_clause? opt_reloptions? opttablespace?; -optnolog: UNLOGGED; +optnolog: KW_UNLOGGED; refreshmatviewstmt: - REFRESH MATERIALIZED VIEW opt_concurrently? qualified_name opt_with_data?; + KW_REFRESH KW_MATERIALIZED KW_VIEW opt_concurrently? qualified_name opt_with_data?; createseqstmt: - CREATE opttemp? SEQUENCE (IF_P NOT EXISTS)? qualified_name optseqoptlist?; + KW_CREATE opttemp? KW_SEQUENCE (KW_IF KW_NOT KW_EXISTS)? qualified_name optseqoptlist?; alterseqstmt: - ALTER SEQUENCE (IF_P EXISTS)? qualified_name seqoptlist; + KW_ALTER KW_SEQUENCE (KW_IF KW_EXISTS)? qualified_name seqoptlist; optseqoptlist: seqoptlist; @@ -691,115 +730,115 @@ 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?; + KW_AS simpletypename + | KW_CACHE numericonly + | KW_CYCLE + | KW_INCREMENT opt_by? numericonly + | KW_MAXVALUE numericonly + | KW_MINVALUE numericonly + | KW_NO (KW_MAXVALUE | KW_MINVALUE | KW_CYCLE) + | KW_OWNED KW_BY any_name + | KW_SEQUENCE KW_NAME any_name + | KW_START opt_with? numericonly + | KW_RESTART opt_with? numericonly?; -opt_by: BY; +opt_by: KW_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? + KW_CREATE opt_or_replace? opt_trusted? opt_procedural? KW_LANGUAGE name ( + KW_HANDLER handler_name opt_inline_handler? opt_validator? )?; -opt_trusted: TRUSTED; +opt_trusted: KW_TRUSTED; handler_name: name attrs?; -opt_inline_handler: INLINE_P handler_name; +opt_inline_handler: KW_INLINE handler_name; -validator_clause: VALIDATOR handler_name | NO VALIDATOR; +validator_clause: KW_VALIDATOR handler_name | KW_NO KW_VALIDATOR; opt_validator: validator_clause; -opt_procedural: PROCEDURAL; +opt_procedural: KW_PROCEDURAL; createtablespacestmt: - CREATE TABLESPACE name opttablespaceowner? LOCATION sconst opt_reloptions?; + KW_CREATE KW_TABLESPACE name opttablespaceowner? KW_LOCATION sconst opt_reloptions?; -opttablespaceowner: OWNER rolespec; +opttablespaceowner: KW_OWNER rolespec; -droptablespacestmt: DROP TABLESPACE (IF_P EXISTS)? name; +droptablespacestmt: KW_DROP KW_TABLESPACE (KW_IF KW_EXISTS)? name; createextensionstmt: - CREATE EXTENSION (IF_P NOT EXISTS)? name opt_with? create_extension_opt_list; + KW_CREATE KW_EXTENSION (KW_IF KW_NOT KW_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; + KW_SCHEMA name + | KW_VERSION nonreservedword_or_sconst + | KW_FROM nonreservedword_or_sconst + | KW_CASCADE; alterextensionstmt: - ALTER EXTENSION name UPDATE alter_extension_opt_list; + KW_ALTER KW_EXTENSION name KW_UPDATE alter_extension_opt_list; alter_extension_opt_list: alter_extension_opt_item*; -alter_extension_opt_item: TO nonreservedword_or_sconst; +alter_extension_opt_item: KW_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; + KW_ALTER KW_EXTENSION name add_drop object_type_name name + | KW_ALTER KW_EXTENSION name add_drop object_type_any_name any_name + | KW_ALTER KW_EXTENSION name add_drop KW_AGGREGATE aggregate_with_argtypes + | KW_ALTER KW_EXTENSION name add_drop KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN + | KW_ALTER KW_EXTENSION name add_drop KW_DOMAIN typename + | KW_ALTER KW_EXTENSION name add_drop KW_FUNCTION function_with_argtypes + | KW_ALTER KW_EXTENSION name add_drop KW_OPERATOR operator_with_argtypes + | KW_ALTER KW_EXTENSION name add_drop KW_OPERATOR KW_CLASS any_name KW_USING name + | KW_ALTER KW_EXTENSION name add_drop KW_OPERATOR KW_FAMILY any_name KW_USING name + | KW_ALTER KW_EXTENSION name add_drop KW_PROCEDURE function_with_argtypes + | KW_ALTER KW_EXTENSION name add_drop KW_ROUTINE function_with_argtypes + | KW_ALTER KW_EXTENSION name add_drop KW_TRANSFORM KW_FOR typename KW_LANGUAGE name + | KW_ALTER KW_EXTENSION name add_drop KW_TYPE typename; createfdwstmt: - CREATE FOREIGN DATA_P WRAPPER name opt_fdw_options? create_generic_options?; + KW_CREATE KW_FOREIGN KW_DATA KW_WRAPPER name opt_fdw_options? create_generic_options?; fdw_option: - HANDLER handler_name - | NO HANDLER - | VALIDATOR handler_name - | NO VALIDATOR; + KW_HANDLER handler_name + | KW_NO KW_HANDLER + | KW_VALIDATOR handler_name + | KW_NO KW_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; + KW_ALTER KW_FOREIGN KW_DATA KW_WRAPPER name opt_fdw_options? alter_generic_options + | KW_ALTER KW_FOREIGN KW_DATA KW_WRAPPER name fdw_options; create_generic_options: - OPTIONS OPEN_PAREN generic_option_list CLOSE_PAREN; + KW_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; + KW_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; + | KW_SET generic_option_elem + | KW_ADD generic_option_elem + | KW_DROP generic_option_elem; generic_option_elem: generic_option_name generic_option_arg; @@ -808,183 +847,187 @@ generic_option_name: collabel; generic_option_arg: sconst; createforeignserverstmt: - CREATE SERVER name opt_type? opt_foreign_server_version? FOREIGN DATA_P WRAPPER name + KW_CREATE KW_SERVER name opt_type? opt_foreign_server_version? KW_FOREIGN KW_DATA KW_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?; + | KW_CREATE KW_SERVER KW_IF KW_NOT KW_EXISTS name opt_type? opt_foreign_server_version? KW_FOREIGN KW_DATA + KW_WRAPPER name create_generic_options?; -opt_type: TYPE_P sconst; +opt_type: KW_TYPE sconst; -foreign_server_version: VERSION_P (sconst | NULL_P); +foreign_server_version: KW_VERSION (sconst | KW_NULL); opt_foreign_server_version: foreign_server_version; alterforeignserverstmt: - ALTER SERVER name ( + KW_ALTER KW_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?; + KW_CREATE KW_FOREIGN KW_TABLE qualified_name OPEN_PAREN opttableelementlist? CLOSE_PAREN optinherit? + KW_SERVER name create_generic_options? + | KW_CREATE KW_FOREIGN KW_TABLE KW_IF KW_NOT KW_EXISTS qualified_name OPEN_PAREN opttableelementlist? + CLOSE_PAREN optinherit? KW_SERVER name create_generic_options? + | KW_CREATE KW_FOREIGN KW_TABLE qualified_name KW_PARTITION KW_OF qualified_name opttypedtableelementlist? + partitionboundspec KW_SERVER name create_generic_options? + | KW_CREATE KW_FOREIGN KW_TABLE KW_IF KW_NOT KW_EXISTS qualified_name KW_PARTITION KW_OF qualified_name + opttypedtableelementlist? partitionboundspec KW_SERVER name create_generic_options?; importforeignschemastmt: - IMPORT_P FOREIGN SCHEMA name import_qualification? FROM SERVER name INTO name + KW_IMPORT KW_FOREIGN KW_SCHEMA name import_qualification? KW_FROM KW_SERVER name KW_INTO name create_generic_options?; -import_qualification_type: LIMIT TO | EXCEPT; +import_qualification_type: KW_LIMIT KW_TO | KW_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?; + KW_CREATE KW_USER KW_MAPPING KW_FOR auth_ident KW_SERVER name create_generic_options? + | KW_CREATE KW_USER KW_MAPPING KW_IF KW_NOT KW_EXISTS KW_FOR auth_ident KW_SERVER name create_generic_options?; -auth_ident: rolespec | USER; +auth_ident: rolespec | KW_USER; dropusermappingstmt: - DROP USER MAPPING FOR auth_ident SERVER name - | DROP USER MAPPING IF_P EXISTS FOR auth_ident SERVER name; + KW_DROP KW_USER KW_MAPPING KW_FOR auth_ident KW_SERVER name + | KW_DROP KW_USER KW_MAPPING KW_IF KW_EXISTS KW_FOR auth_ident KW_SERVER name; alterusermappingstmt: - ALTER USER MAPPING FOR auth_ident SERVER name alter_generic_options; + KW_ALTER KW_USER KW_MAPPING KW_FOR auth_ident KW_SERVER name alter_generic_options; createpolicystmt: - CREATE POLICY name ON qualified_name rowsecuritydefaultpermissive? rowsecuritydefaultforcmd? + KW_CREATE KW_POLICY name KW_ON qualified_name rowsecuritydefaultpermissive? rowsecuritydefaultforcmd? rowsecuritydefaulttorole? rowsecurityoptionalexpr? rowsecurityoptionalwithcheck?; alterpolicystmt: - ALTER POLICY name ON qualified_name rowsecurityoptionaltorole? rowsecurityoptionalexpr? + KW_ALTER KW_POLICY name KW_ON qualified_name rowsecurityoptionaltorole? rowsecurityoptionalexpr? rowsecurityoptionalwithcheck?; -rowsecurityoptionalexpr: USING OPEN_PAREN a_expr CLOSE_PAREN; +rowsecurityoptionalexpr: KW_USING OPEN_PAREN a_expr CLOSE_PAREN; rowsecurityoptionalwithcheck: - WITH CHECK OPEN_PAREN a_expr CLOSE_PAREN; + KW_WITH KW_CHECK OPEN_PAREN a_expr CLOSE_PAREN; -rowsecuritydefaulttorole: TO role_list; +rowsecuritydefaulttorole: KW_TO role_list; -rowsecurityoptionaltorole: TO role_list; +rowsecurityoptionaltorole: KW_TO role_list; -rowsecuritydefaultpermissive: AS identifier; +rowsecuritydefaultpermissive: KW_AS identifier; -rowsecuritydefaultforcmd: FOR row_security_cmd; +rowsecuritydefaultforcmd: KW_FOR row_security_cmd; -row_security_cmd: ALL | SELECT | INSERT | UPDATE | DELETE_P; +row_security_cmd: KW_ALL | KW_SELECT | KW_INSERT | KW_UPDATE | KW_DELETE; createamstmt: - CREATE ACCESS METHOD name TYPE_P am_type HANDLER handler_name; + KW_CREATE KW_ACCESS KW_METHOD name KW_TYPE am_type KW_HANDLER handler_name; -am_type: INDEX | TABLE; +am_type: KW_INDEX | KW_TABLE; createtrigstmt: - CREATE TRIGGER name triggeractiontime triggerevents ON qualified_name triggerreferencing? - triggerforspec? triggerwhen? EXECUTE function_or_procedure func_name OPEN_PAREN + KW_CREATE KW_TRIGGER name triggeractiontime triggerevents KW_ON qualified_name triggerreferencing? + triggerforspec? triggerwhen? KW_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 + | KW_CREATE KW_CONSTRAINT? KW_TRIGGER name triggeractiontime triggerevents KW_ON qualified_name optconstrfromtable? + constraintattributespec foreachrow? triggerwhen? KW_EXECUTE function_or_procedure func_name OPEN_PAREN triggerfuncargs CLOSE_PAREN; -triggeractiontime: BEFORE | AFTER | INSTEAD OF; +triggeractiontime: KW_BEFORE | KW_AFTER | KW_INSTEAD KW_OF; -triggerevents: triggeroneevent (OR triggeroneevent)*; +foreachrow: KW_FOR KW_EACH? roworstatment; + +roworstatment: KW_ROW | KW_STATEMENT; + +triggerevents: triggeroneevent (KW_OR triggeroneevent)*; triggeroneevent: - INSERT - | DELETE_P - | UPDATE - | UPDATE OF columnlist - | TRUNCATE; + KW_INSERT + | KW_DELETE + | KW_UPDATE + | KW_UPDATE KW_OF columnlist + | KW_TRUNCATE; -triggerreferencing: REFERENCING triggertransitions; +triggerreferencing: KW_REFERENCING triggertransitions; triggertransitions: triggertransition+; triggertransition: transitionoldornew transitionrowortable opt_as? transitionrelname; -transitionoldornew: NEW | OLD; +transitionoldornew: KW_NEW | KW_OLD; -transitionrowortable: TABLE | ROW; +transitionrowortable: KW_TABLE | KW_ROW; transitionrelname: colid; -triggerforspec: FOR triggerforopteach? triggerfortype; +triggerforspec: KW_FOR triggerforopteach? triggerfortype; -triggerforopteach: EACH; +triggerforopteach: KW_EACH; -triggerfortype: ROW | STATEMENT; +triggerfortype: KW_ROW | KW_STATEMENT; -triggerwhen: WHEN OPEN_PAREN a_expr CLOSE_PAREN; +triggerwhen: KW_WHEN OPEN_PAREN a_expr CLOSE_PAREN; -function_or_procedure: FUNCTION | PROCEDURE; +function_or_procedure: KW_FUNCTION | KW_PROCEDURE; triggerfuncargs: (triggerfuncarg |) (COMMA triggerfuncarg)*; triggerfuncarg: iconst | fconst | sconst | collabel; -optconstrfromtable: FROM qualified_name; +optconstrfromtable: KW_FROM qualified_name; constraintattributespec: constraintattributeElem*; constraintattributeElem: - NOT DEFERRABLE - | DEFERRABLE - | INITIALLY IMMEDIATE - | INITIALLY DEFERRED - | NOT VALID - | NO INHERIT; + KW_NOT KW_DEFERRABLE + | KW_DEFERRABLE + | KW_INITIALLY KW_IMMEDIATE + | KW_INITIALLY KW_DEFERRED + | KW_NOT KW_VALID + | KW_NO KW_INHERIT; createeventtrigstmt: - CREATE EVENT TRIGGER name ON collabel EXECUTE function_or_procedure func_name OPEN_PAREN + KW_CREATE KW_EVENT KW_TRIGGER name KW_ON collabel KW_EXECUTE function_or_procedure func_name OPEN_PAREN CLOSE_PAREN - | CREATE EVENT TRIGGER name ON collabel WHEN event_trigger_when_list EXECUTE + | KW_CREATE KW_EVENT KW_TRIGGER name KW_ON collabel KW_WHEN event_trigger_when_list KW_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 (KW_AND event_trigger_when_item)*; event_trigger_when_item: - colid IN_P OPEN_PAREN event_trigger_value_list CLOSE_PAREN; + colid KW_IN OPEN_PAREN event_trigger_value_list CLOSE_PAREN; event_trigger_value_list: sconst (COMMA sconst)*; -altereventtrigstmt: ALTER EVENT TRIGGER name enable_trigger; +altereventtrigstmt: KW_ALTER KW_EVENT KW_TRIGGER name enable_trigger; enable_trigger: - ENABLE_P - | ENABLE_P REPLICA - | ENABLE_P ALWAYS - | DISABLE_P; + KW_ENABLE + | KW_ENABLE KW_REPLICA + | KW_ENABLE KW_ALWAYS + | KW_DISABLE; createassertionstmt: - CREATE ASSERTION any_name CHECK OPEN_PAREN a_expr CLOSE_PAREN constraintattributespec; + KW_CREATE KW_ASSERTION any_name KW_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; + KW_CREATE opt_or_replace? KW_AGGREGATE func_name aggr_args definition + | KW_CREATE opt_or_replace? KW_AGGREGATE func_name old_aggr_definition + | KW_CREATE KW_OPERATOR any_operator definition + | KW_CREATE KW_TYPE any_name definition + | KW_CREATE KW_TYPE any_name + | KW_CREATE KW_TYPE any_name KW_AS OPEN_PAREN opttablefuncelementlist? CLOSE_PAREN + | KW_CREATE KW_TYPE any_name KW_AS KW_ENUM OPEN_PAREN opt_enum_val_list? CLOSE_PAREN + | KW_CREATE KW_TYPE any_name KW_AS KW_RANGE definition + | KW_CREATE KW_TEXT KW_SEARCH KW_PARSER any_name definition + | KW_CREATE KW_TEXT KW_SEARCH KW_DICTIONARY any_name definition + | KW_CREATE KW_TEXT KW_SEARCH KW_TEMPLATE any_name definition + | KW_CREATE KW_TEXT KW_SEARCH KW_CONFIGURATION any_name definition + | KW_CREATE KW_COLLATION any_name definition + | KW_CREATE KW_COLLATION KW_IF KW_NOT KW_EXISTS any_name definition + | KW_CREATE KW_COLLATION any_name KW_FROM any_name + | KW_CREATE KW_COLLATION KW_IF KW_NOT KW_EXISTS any_name KW_FROM any_name; definition: OPEN_PAREN def_list CLOSE_PAREN; @@ -998,7 +1041,7 @@ def_arg: | qual_all_op | numericonly | sconst - | NONE; + | KW_NONE; old_aggr_definition: OPEN_PAREN old_aggr_list CLOSE_PAREN; @@ -1011,105 +1054,105 @@ 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; + KW_ALTER KW_TYPE any_name KW_ADD KW_VALUE opt_if_not_exists? sconst + | KW_ALTER KW_TYPE any_name KW_ADD KW_VALUE opt_if_not_exists? sconst KW_BEFORE sconst + | KW_ALTER KW_TYPE any_name KW_ADD KW_VALUE opt_if_not_exists? sconst KW_AFTER sconst + | KW_ALTER KW_TYPE any_name KW_RENAME KW_VALUE sconst KW_TO sconst; -opt_if_not_exists: IF_P NOT EXISTS; +opt_if_not_exists: KW_IF KW_NOT KW_EXISTS; createopclassstmt: - CREATE OPERATOR CLASS any_name opt_default? FOR TYPE_P typename USING name opt_opfamily? AS + KW_CREATE KW_OPERATOR KW_CLASS any_name opt_default? KW_FOR KW_TYPE typename KW_USING name opt_opfamily? KW_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; + KW_OPERATOR iconst any_operator opclass_purpose? opt_recheck? + | KW_OPERATOR iconst operator_with_argtypes opclass_purpose? opt_recheck? + | KW_FUNCTION iconst function_with_argtypes + | KW_FUNCTION iconst OPEN_PAREN type_list CLOSE_PAREN function_with_argtypes + | KW_STORAGE typename; -opt_default: DEFAULT; +opt_default: KW_DEFAULT; -opt_opfamily: FAMILY any_name; +opt_opfamily: KW_FAMILY any_name; -opclass_purpose: FOR SEARCH | FOR ORDER BY any_name; +opclass_purpose: KW_FOR KW_SEARCH | KW_FOR KW_ORDER KW_BY any_name; -opt_recheck: RECHECK; +opt_recheck: KW_RECHECK; -createopfamilystmt: CREATE OPERATOR FAMILY any_name USING name; +createopfamilystmt: KW_CREATE KW_OPERATOR KW_FAMILY any_name KW_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; + KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_ADD opclass_item_list + | KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_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; + KW_OPERATOR iconst OPEN_PAREN type_list CLOSE_PAREN + | KW_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?; + KW_DROP KW_OPERATOR KW_CLASS any_name KW_USING name opt_drop_behavior? + | KW_DROP KW_OPERATOR KW_CLASS KW_IF KW_EXISTS any_name KW_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?; + KW_DROP KW_OPERATOR KW_FAMILY any_name KW_USING name opt_drop_behavior? + | KW_DROP KW_OPERATOR KW_FAMILY KW_IF KW_EXISTS any_name KW_USING name opt_drop_behavior?; -dropownedstmt: DROP OWNED BY role_list opt_drop_behavior?; +dropownedstmt: KW_DROP KW_OWNED KW_BY role_list opt_drop_behavior?; -reassignownedstmt: REASSIGN OWNED BY role_list TO rolespec; +reassignownedstmt: KW_REASSIGN KW_OWNED KW_BY role_list KW_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?; + KW_DROP object_type_any_name KW_IF KW_EXISTS any_name_list opt_drop_behavior? + | KW_DROP object_type_any_name any_name_list opt_drop_behavior? + | KW_DROP drop_type_name KW_IF KW_EXISTS name_list opt_drop_behavior? + | KW_DROP drop_type_name name_list opt_drop_behavior? + | KW_DROP object_type_name_on_any_name name KW_ON any_name opt_drop_behavior? + | KW_DROP object_type_name_on_any_name KW_IF KW_EXISTS name KW_ON any_name opt_drop_behavior? + | KW_DROP KW_TYPE type_name_list opt_drop_behavior? + | KW_DROP KW_TYPE KW_IF KW_EXISTS type_name_list opt_drop_behavior? + | KW_DROP KW_DOMAIN type_name_list opt_drop_behavior? + | KW_DROP KW_DOMAIN KW_IF KW_EXISTS type_name_list opt_drop_behavior? + | KW_DROP KW_INDEX KW_CONCURRENTLY any_name_list opt_drop_behavior? + | KW_DROP KW_INDEX KW_CONCURRENTLY KW_IF KW_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; + KW_TABLE + | KW_SEQUENCE + | KW_VIEW + | KW_MATERIALIZED KW_VIEW + | KW_INDEX + | KW_FOREIGN KW_TABLE + | KW_COLLATION + | KW_CONVERSION + | KW_STATISTICS + | KW_TEXT KW_SEARCH KW_PARSER + | KW_TEXT KW_SEARCH KW_DICTIONARY + | KW_TEXT KW_SEARCH KW_TEMPLATE + | KW_TEXT KW_SEARCH KW_CONFIGURATION; object_type_name: drop_type_name - | DATABASE - | ROLE - | SUBSCRIPTION - | TABLESPACE; + | KW_DATABASE + | KW_ROLE + | KW_SUBSCRIPTION + | KW_TABLESPACE; drop_type_name: - ACCESS METHOD - | EVENT TRIGGER - | EXTENSION - | FOREIGN DATA_P WRAPPER - | opt_procedural? LANGUAGE - | PUBLICATION - | SCHEMA - | SERVER; + KW_ACCESS KW_METHOD + | KW_EVENT KW_TRIGGER + | KW_EXTENSION + | KW_FOREIGN KW_DATA KW_WRAPPER + | opt_procedural? KW_LANGUAGE + | KW_PUBLICATION + | KW_SCHEMA + | KW_SERVER; -object_type_name_on_any_name: POLICY | RULE | TRIGGER; +object_type_name_on_any_name: KW_POLICY | KW_RULE | KW_TRIGGER; any_name_list: any_name (COMMA any_name)*; @@ -1120,173 +1163,193 @@ attrs: (DOT attr_name)+; type_name_list: typename (COMMA typename)*; truncatestmt: - TRUNCATE opt_table? relation_expr_list opt_restart_seqs? opt_drop_behavior?; + KW_TRUNCATE opt_table? relation_expr_list opt_restart_seqs? opt_drop_behavior?; -opt_restart_seqs: CONTINUE_P IDENTITY_P | RESTART IDENTITY_P; +opt_restart_seqs: KW_CONTINUE KW_IDENTITY | KW_RESTART KW_IDENTITY; 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; + KW_COMMENT KW_ON object_type_any_name any_name KW_IS comment_text + | KW_COMMENT KW_ON KW_COLUMN any_name KW_IS comment_text + | KW_COMMENT KW_ON object_type_name name KW_IS comment_text + | KW_COMMENT KW_ON KW_TYPE typename KW_IS comment_text + | KW_COMMENT KW_ON KW_DOMAIN typename KW_IS comment_text + | KW_COMMENT KW_ON KW_AGGREGATE aggregate_with_argtypes KW_IS comment_text + | KW_COMMENT KW_ON KW_FUNCTION function_with_argtypes KW_IS comment_text + | KW_COMMENT KW_ON KW_OPERATOR operator_with_argtypes KW_IS comment_text + | KW_COMMENT KW_ON KW_CONSTRAINT name KW_ON any_name KW_IS comment_text + | KW_COMMENT KW_ON KW_CONSTRAINT name KW_ON KW_DOMAIN any_name KW_IS comment_text + | KW_COMMENT KW_ON object_type_name_on_any_name name KW_ON any_name KW_IS comment_text + | KW_COMMENT KW_ON KW_PROCEDURE function_with_argtypes KW_IS comment_text + | KW_COMMENT KW_ON KW_ROUTINE function_with_argtypes KW_IS comment_text + | KW_COMMENT KW_ON KW_TRANSFORM KW_FOR typename KW_LANGUAGE name KW_IS comment_text + | KW_COMMENT KW_ON KW_OPERATOR KW_CLASS any_name KW_USING name KW_IS comment_text + | KW_COMMENT KW_ON KW_OPERATOR KW_FAMILY any_name KW_USING name KW_IS comment_text + | KW_COMMENT KW_ON KW_LARGE KW_OBJECT numericonly KW_IS comment_text + | KW_COMMENT KW_ON KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN KW_IS comment_text; -comment_text: sconst | NULL_P; +comment_text: sconst | KW_NULL; 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; + KW_SECURITY KW_LABEL opt_provider? KW_ON object_type_any_name any_name KW_IS security_label + | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_COLUMN any_name KW_IS security_label + | KW_SECURITY KW_LABEL opt_provider? KW_ON object_type_name name KW_IS security_label + | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_TYPE typename KW_IS security_label + | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_DOMAIN typename KW_IS security_label + | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_AGGREGATE aggregate_with_argtypes KW_IS security_label + | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_FUNCTION function_with_argtypes KW_IS security_label + | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_LARGE KW_OBJECT numericonly KW_IS security_label + | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_PROCEDURE function_with_argtypes KW_IS security_label + | KW_SECURITY KW_LABEL opt_provider? KW_ON KW_ROUTINE function_with_argtypes KW_IS security_label; -opt_provider: FOR nonreservedword_or_sconst; +opt_provider: KW_FOR nonreservedword_or_sconst; -security_label: sconst | NULL_P; +security_label: sconst | KW_NULL; -fetchstmt: FETCH fetch_args | MOVE fetch_args; +fetchstmt: KW_FETCH fetch_args | KW_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 + | KW_NEXT opt_from_in? cursor_name + | KW_PRIOR opt_from_in? cursor_name + | KW_FIRST opt_from_in? cursor_name + | KW_LAST opt_from_in? cursor_name + | KW_ABSOLUTE signediconst opt_from_in? cursor_name + | KW_RELATIVE 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; + | KW_ALL opt_from_in? cursor_name + | KW_FORWARD opt_from_in? cursor_name + | KW_FORWARD signediconst opt_from_in? cursor_name + | KW_FORWARD KW_ALL opt_from_in? cursor_name + | KW_BACKWARD opt_from_in? cursor_name + | KW_BACKWARD signediconst opt_from_in? cursor_name + | KW_BACKWARD KW_ALL opt_from_in? cursor_name; -from_in: FROM | IN_P; +from_in: KW_FROM | KW_IN; opt_from_in: from_in; grantstmt: - GRANT privileges ON privilege_target TO grantee_list opt_grant_grant_option?; + KW_GRANT privileges KW_ON privilege_target KW_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?; + KW_REVOKE privileges KW_ON privilege_target KW_FROM grantee_list opt_drop_behavior? + | KW_REVOKE KW_GRANT KW_OPTION KW_FOR privileges KW_ON privilege_target KW_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; + | KW_ALL + | KW_ALL KW_PRIVILEGES + | KW_ALL OPEN_PAREN columnlist CLOSE_PAREN + | KW_ALL KW_PRIVILEGES OPEN_PAREN columnlist CLOSE_PAREN + | beforeprivilegeselectlist + ; + +beforeprivilegeselectlist: beforeprivilegeselect (COMMA beforeprivilegeselect)*; + +beforeprivilegeselect: + KW_SELECT + | KW_INSERT + | KW_UPDATE + | KW_DELETE + | KW_TRUNCATE + | KW_PEFERENCES + | KW_TRIGGER + | KW_USAGE + | KW_CREATE + | KW_CONNECT + | KW_TEMPORARY + | KW_TEMP + | KW_EXECUTE + ; privilege_list: privilege (COMMA privilege)*; privilege: - SELECT opt_column_list? - | REFERENCES opt_column_list? - | CREATE opt_column_list? + KW_SELECT opt_column_list? + | KW_REFERENCES opt_column_list? + | KW_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; + | KW_TABLE qualified_name_list + | KW_SEQUENCE qualified_name_list + | KW_FOREIGN KW_DATA KW_WRAPPER name_list + | KW_FOREIGN KW_SERVER name_list + | KW_FUNCTION function_with_argtypes_list + | KW_PROCEDURE function_with_argtypes_list + | KW_ROUTINE function_with_argtypes_list + | KW_DATABASE name_list + | KW_DOMAIN any_name_list + | KW_LANGUAGE name_list + | KW_LARGE KW_OBJECT numericonly_list + | KW_SCHEMA name_list + | KW_TABLESPACE name_list + | KW_TYPE any_name_list + | KW_ALL KW_TABLES KW_IN KW_SCHEMA name_list + | KW_ALL KW_SEQUENCES KW_IN KW_SCHEMA name_list + | KW_ALL KW_FUNCTIONS KW_IN KW_SCHEMA name_list + | KW_ALL KW_PROCEDURES KW_IN KW_SCHEMA name_list + | KW_ALL KW_ROUTINES KW_IN KW_SCHEMA name_list; grantee_list: grantee (COMMA grantee)*; -grantee: rolespec | GROUP_P rolespec; +grantee: rolespec | KW_GROUP rolespec; -opt_grant_grant_option: WITH GRANT OPTION; +opt_grant_grant_option: KW_WITH KW_GRANT KW_OPTION; grantrolestmt: - GRANT privilege_list TO role_list opt_grant_admin_option? opt_granted_by?; + KW_GRANT privilege_list KW_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?; + KW_REVOKE privilege_list KW_FROM role_list opt_granted_by? opt_drop_behavior? + | KW_REVOKE KW_ADMIN KW_OPTION KW_FOR privilege_list KW_FROM role_list opt_granted_by? opt_drop_behavior?; -opt_grant_admin_option: WITH ADMIN OPTION; +opt_grant_admin_option: KW_WITH KW_ADMIN KW_OPTION; -opt_granted_by: GRANTED BY rolespec; +opt_granted_by: KW_GRANTED KW_BY rolespec; alterdefaultprivilegesstmt: - ALTER DEFAULT PRIVILEGES defacloptionlist defaclaction; + KW_ALTER KW_DEFAULT KW_PRIVILEGES defacloptionlist defaclaction; defacloptionlist: defacloption*; defacloption: - IN_P SCHEMA name_list - | FOR ROLE role_list - | FOR USER role_list; + KW_IN KW_SCHEMA name_list + | KW_FOR KW_ROLE role_list + | KW_FOR KW_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 + KW_GRANT privileges KW_ON defacl_privilege_target KW_TO grantee_list opt_grant_grant_option? + | KW_REVOKE privileges KW_ON defacl_privilege_target KW_FROM grantee_list opt_drop_behavior? + | KW_REVOKE KW_GRANT KW_OPTION KW_FOR privileges KW_ON defacl_privilege_target KW_FROM grantee_list opt_drop_behavior?; defacl_privilege_target: - TABLES - | FUNCTIONS - | ROUTINES - | SEQUENCES - | TYPES_P - | SCHEMAS; + KW_TABLES + | KW_FUNCTIONS + | KW_ROUTINES + | KW_SEQUENCES + | KW_TYPES + | KW_SCHEMAS; //create index indexstmt: - CREATE opt_unique? INDEX opt_concurrently? opt_index_name? ON relation_expr access_method_clause + KW_CREATE opt_unique? KW_INDEX opt_concurrently? opt_index_name? KW_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 + | KW_CREATE opt_unique? KW_INDEX opt_concurrently? KW_IF KW_NOT KW_EXISTS name KW_ON relation_expr access_method_clause? OPEN_PAREN index_params CLOSE_PAREN opt_include? opt_reloptions? opttablespace? where_clause?; -opt_unique: UNIQUE; +opt_unique: KW_UNIQUE; -opt_concurrently: CONCURRENTLY; +opt_concurrently: KW_CONCURRENTLY; opt_index_name: name; -access_method_clause: USING name; +access_method_clause: KW_USING name; index_params: index_elem (COMMA index_elem)*; @@ -1300,27 +1363,29 @@ index_elem: | OPEN_PAREN a_expr CLOSE_PAREN index_elem_options; opt_include: - INCLUDE OPEN_PAREN index_including_params CLOSE_PAREN; + KW_INCLUDE OPEN_PAREN index_including_params CLOSE_PAREN; index_including_params: index_elem (COMMA index_elem)*; -opt_collate: COLLATE any_name; +opt_collate: KW_COLLATE any_name; opt_class: any_name; -opt_asc_desc: ASC | DESC; +opt_asc_desc: KW_ASC | KW_DESC; -opt_nulls_order: NULLS_P FIRST_P | NULLS_P LAST_P; +opt_nulls_order: KW_NULLS KW_FIRST | KW_NULLS KW_LAST; createfunctionstmt: - CREATE opt_or_replace? (FUNCTION | PROCEDURE) func_name func_args_with_defaults ( - RETURNS ( + KW_CREATE opt_or_replace? (KW_FUNCTION | KW_PROCEDURE) func_name func_args_with_defaults ( + KW_RETURNS ( func_return - | TABLE OPEN_PAREN table_func_column_list CLOSE_PAREN + | KW_TABLE OPEN_PAREN table_func_column_list CLOSE_PAREN ) - )? createfunc_opt_list; + )? createfunc_opt_list (KW_WITH attrilist)?; // TODO --> WITH 后面的( attribute [, ...] )表达式还需要再修改 -opt_or_replace: OR REPLACE; +attrilist: OPEN_PAREN colid (COMMA colid)* CLOSE_PAREN; + +opt_or_replace: KW_OR KW_REPLACE; func_args: OPEN_PAREN func_args_list? CLOSE_PAREN; @@ -1345,7 +1410,7 @@ func_arg: | param_name arg_class? func_type | func_type; -arg_class: IN_P OUT_P? | OUT_P | INOUT | VARIADIC; +arg_class: KW_IN KW_OUT? | KW_OUT | KW_INOUT | KW_VARIADIC; param_name: type_function_name; @@ -1353,10 +1418,10 @@ func_return: func_type; func_type: typename - | type_function_name attrs PERCENT TYPE_P - | SETOF type_function_name attrs PERCENT TYPE_P; + | type_function_name attrs PERCENT KW_TYPE + | KW_SETOF type_function_name attrs PERCENT KW_TYPE; -func_arg_with_default: func_arg ((DEFAULT | EQUAL) a_expr)?; +func_arg_with_default: func_arg ((KW_DEFAULT | EQUAL) a_expr)?; aggr_arg: func_arg; @@ -1364,8 +1429,8 @@ aggr_args: OPEN_PAREN ( STAR | aggr_args_list - | ORDER BY aggr_args_list - | aggr_args_list ORDER BY aggr_args_list + | KW_ORDER KW_BY aggr_args_list + | aggr_args_list KW_ORDER KW_BY aggr_args_list ) CLOSE_PAREN; aggr_args_list: aggr_arg (COMMA aggr_arg)*; @@ -1376,51 +1441,49 @@ aggregate_with_argtypes_list: aggregate_with_argtypes (COMMA aggregate_with_argtypes)*; createfunc_opt_list: - createfunc_opt_item+ { - this.ParseRoutineBody(_localctx); - }; + 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 + KW_CALLED KW_ON KW_NULL KW_INPUT + | KW_RETURNS KW_NULL KW_ON KW_NULL KW_INPUT + | KW_STRICT + | KW_IMMUTABLE + | KW_STABLE + | KW_VOLATILE + | KW_EXTERNAL KW_SECURITY KW_DEFINER + | KW_EXTERNAL KW_SECURITY KW_INVOKER + | KW_SECURITY KW_DEFINER + | KW_SECURITY KW_INVOKER + | KW_LEAKPROOF + | KW_NOT KW_LEAKPROOF + | KW_COST numericonly + | KW_ROWS numericonly + | KW_SUPPORT any_name | functionsetresetclause - | PARALLEL colid; + | KW_PARALLEL colid; createfunc_opt_item: - AS func_as - | LANGUAGE nonreservedword_or_sconst - | TRANSFORM transform_type_list - | WINDOW + KW_AS func_as + | KW_LANGUAGE nonreservedword_or_sconst + | KW_TRANSFORM transform_type_list + | KW_WINDOW | common_func_opt_item; //https://www.postgresql.org/docs/9.1/sql-createfunction.html -// | AS 'definition' +// | KW_AS 'definition' -// | AS 'obj_file', 'link_symbol' +// | KW_AS 'obj_file', 'link_symbol' func_as locals[ParserRuleContext Definition]: - /* |AS 'definition'*/ def = sconst - /*| AS 'obj_file', 'link_symbol'*/ + /* |KW_AS 'definition'*/ def = sconst + /*| KW_AS 'obj_file', 'link_symbol'*/ | sconst COMMA sconst; transform_type_list: - FOR TYPE_P typename (COMMA FOR TYPE_P typename)*; + KW_FOR KW_TYPE typename (COMMA KW_FOR KW_TYPE typename)*; -opt_definition: WITH definition; +opt_definition: KW_WITH definition; table_func_column: param_name func_type; @@ -1428,33 +1491,33 @@ table_func_column_list: table_func_column (COMMA table_func_column)*; alterfunctionstmt: - ALTER (FUNCTION | PROCEDURE | ROUTINE) function_with_argtypes alterfunc_opt_list opt_restrict?; + KW_ALTER (KW_FUNCTION | KW_PROCEDURE | KW_ROUTINE) function_with_argtypes alterfunc_opt_list opt_restrict?; alterfunc_opt_list: common_func_opt_item+; -opt_restrict: RESTRICT; +opt_restrict: KW_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?; + KW_DROP KW_FUNCTION function_with_argtypes_list opt_drop_behavior? + | KW_DROP KW_FUNCTION KW_IF KW_EXISTS function_with_argtypes_list opt_drop_behavior? + | KW_DROP KW_PROCEDURE function_with_argtypes_list opt_drop_behavior? + | KW_DROP KW_PROCEDURE KW_IF KW_EXISTS function_with_argtypes_list opt_drop_behavior? + | KW_DROP KW_ROUTINE function_with_argtypes_list opt_drop_behavior? + | KW_DROP KW_ROUTINE KW_IF KW_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?; + KW_DROP KW_AGGREGATE aggregate_with_argtypes_list opt_drop_behavior? + | KW_DROP KW_AGGREGATE KW_IF KW_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?; + KW_DROP KW_OPERATOR operator_with_argtypes_list opt_drop_behavior? + | KW_DROP KW_OPERATOR KW_IF KW_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; + | OPEN_PAREN KW_NONE COMMA typename CLOSE_PAREN + | OPEN_PAREN typename COMMA KW_NONE CLOSE_PAREN; any_operator: (colid DOT)* all_op; @@ -1463,168 +1526,168 @@ operator_with_argtypes_list: operator_with_argtypes: any_operator oper_argtypes; -dostmt: DO dostmt_opt_list; +dostmt: KW_DO dostmt_opt_list; dostmt_opt_list: dostmt_opt_item+; -dostmt_opt_item: sconst | LANGUAGE nonreservedword_or_sconst; +dostmt_opt_item: sconst | KW_LANGUAGE nonreservedword_or_sconst; createcaststmt: - CREATE CAST OPEN_PAREN typename AS typename CLOSE_PAREN WITH FUNCTION function_with_argtypes + KW_CREATE KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN KW_WITH KW_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?; + | KW_CREATE KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN KW_WITHOUT KW_FUNCTION cast_context? + | KW_CREATE KW_CAST OPEN_PAREN typename KW_AS typename CLOSE_PAREN KW_WITH KW_INOUT cast_context?; -cast_context: AS IMPLICIT_P | AS ASSIGNMENT; +cast_context: KW_AS KW_IMPLICIT | KW_AS KW_ASSIGNMENT; dropcaststmt: - DROP CAST opt_if_exists? OPEN_PAREN typename AS typename CLOSE_PAREN opt_drop_behavior?; + KW_DROP KW_CAST opt_if_exists? OPEN_PAREN typename KW_AS typename CLOSE_PAREN opt_drop_behavior?; -opt_if_exists: IF_P EXISTS; +opt_if_exists: KW_IF KW_EXISTS; createtransformstmt: - CREATE opt_or_replace? TRANSFORM FOR typename LANGUAGE name OPEN_PAREN transform_element_list + KW_CREATE opt_or_replace? KW_TRANSFORM KW_FOR typename KW_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 + KW_FROM KW_SQL KW_WITH KW_FUNCTION function_with_argtypes COMMA KW_TO KW_SQL KW_WITH KW_FUNCTION function_with_argtypes - | TO SQL_P WITH FUNCTION function_with_argtypes COMMA FROM SQL_P WITH FUNCTION + | KW_TO KW_SQL KW_WITH KW_FUNCTION function_with_argtypes COMMA KW_FROM KW_SQL KW_WITH KW_FUNCTION function_with_argtypes - | FROM SQL_P WITH FUNCTION function_with_argtypes - | TO SQL_P WITH FUNCTION function_with_argtypes; + | KW_FROM KW_SQL KW_WITH KW_FUNCTION function_with_argtypes + | KW_TO KW_SQL KW_WITH KW_FUNCTION function_with_argtypes; droptransformstmt: - DROP TRANSFORM opt_if_exists? FOR typename LANGUAGE name opt_drop_behavior?; + KW_DROP KW_TRANSFORM opt_if_exists? KW_FOR typename KW_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? + KW_REINDEX reindex_target_type opt_concurrently? qualified_name + | KW_REINDEX reindex_target_multitable opt_concurrently? name + | KW_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? + | KW_REINDEX OPEN_PAREN reindex_option_list CLOSE_PAREN reindex_target_multitable opt_concurrently? name; -reindex_target_type: INDEX | TABLE; +reindex_target_type: KW_INDEX | KW_TABLE; -reindex_target_multitable: SCHEMA | SYSTEM_P | DATABASE; +reindex_target_multitable: KW_SCHEMA | KW_SYSTEM | KW_DATABASE; reindex_option_list: reindex_option_elem (COMMA reindex_option_elem)*; -reindex_option_elem: VERBOSE; +reindex_option_elem: KW_VERBOSE; altertblspcstmt: - ALTER TABLESPACE name SET reloptions - | ALTER TABLESPACE name RESET reloptions; + KW_ALTER KW_TABLESPACE name KW_SET reloptions + | KW_ALTER KW_TABLESPACE name KW_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?; + KW_ALTER KW_AGGREGATE aggregate_with_argtypes KW_RENAME KW_TO name + | KW_ALTER KW_COLLATION any_name KW_RENAME KW_TO name + | KW_ALTER KW_CONVERSION any_name KW_RENAME KW_TO name + | KW_ALTER KW_DATABASE name KW_RENAME KW_TO name + | KW_ALTER KW_DOMAIN any_name KW_RENAME KW_TO name + | KW_ALTER KW_DOMAIN any_name KW_RENAME KW_CONSTRAINT name KW_TO name + | KW_ALTER KW_FOREIGN KW_DATA KW_WRAPPER name KW_RENAME KW_TO name + | KW_ALTER KW_FUNCTION function_with_argtypes KW_RENAME KW_TO name + | KW_ALTER KW_GROUP roleid KW_RENAME KW_TO roleid + | KW_ALTER opt_procedural? KW_LANGUAGE name KW_RENAME KW_TO name + | KW_ALTER KW_OPERATOR KW_CLASS any_name KW_USING name KW_RENAME KW_TO name + | KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_RENAME KW_TO name + | KW_ALTER KW_POLICY name KW_ON qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_POLICY KW_IF KW_EXISTS name KW_ON qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_PROCEDURE function_with_argtypes KW_RENAME KW_TO name + | KW_ALTER KW_PUBLICATION name KW_RENAME KW_TO name + | KW_ALTER KW_ROUTINE function_with_argtypes KW_RENAME KW_TO name + | KW_ALTER KW_SCHEMA name KW_RENAME KW_TO name + | KW_ALTER KW_SERVER name KW_RENAME KW_TO name + | KW_ALTER KW_SUBSCRIPTION name KW_RENAME KW_TO name + | KW_ALTER KW_TABLE relation_expr KW_RENAME KW_TO name + | KW_ALTER KW_TABLE KW_IF KW_EXISTS relation_expr KW_RENAME KW_TO name + | KW_ALTER KW_SEQUENCE qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_SEQUENCE KW_IF KW_EXISTS qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_VIEW qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_VIEW KW_IF KW_EXISTS qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_MATERIALIZED KW_VIEW qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_MATERIALIZED KW_VIEW KW_IF KW_EXISTS qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_INDEX qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_INDEX KW_IF KW_EXISTS qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_FOREIGN KW_TABLE relation_expr KW_RENAME KW_TO name + | KW_ALTER KW_FOREIGN KW_TABLE KW_IF KW_EXISTS relation_expr KW_RENAME KW_TO name + | KW_ALTER KW_TABLE relation_expr KW_RENAME opt_column? name KW_TO name + | KW_ALTER KW_TABLE KW_IF KW_EXISTS relation_expr KW_RENAME opt_column? name KW_TO name + | KW_ALTER KW_VIEW qualified_name KW_RENAME opt_column? name KW_TO name + | KW_ALTER KW_VIEW KW_IF KW_EXISTS qualified_name KW_RENAME opt_column? name KW_TO name + | KW_ALTER KW_MATERIALIZED KW_VIEW qualified_name KW_RENAME opt_column? name KW_TO name + | KW_ALTER KW_MATERIALIZED KW_VIEW KW_IF KW_EXISTS qualified_name KW_RENAME opt_column? name KW_TO name + | KW_ALTER KW_TABLE relation_expr KW_RENAME KW_CONSTRAINT name KW_TO name + | KW_ALTER KW_TABLE KW_IF KW_EXISTS relation_expr KW_RENAME KW_CONSTRAINT name KW_TO name + | KW_ALTER KW_FOREIGN KW_TABLE relation_expr KW_RENAME opt_column? name KW_TO name + | KW_ALTER KW_FOREIGN KW_TABLE KW_IF KW_EXISTS relation_expr KW_RENAME opt_column? name KW_TO name + | KW_ALTER KW_RULE name KW_ON qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_TRIGGER name KW_ON qualified_name KW_RENAME KW_TO name + | KW_ALTER KW_EVENT KW_TRIGGER name KW_RENAME KW_TO name + | KW_ALTER KW_ROLE roleid KW_RENAME KW_TO roleid + | KW_ALTER KW_USER roleid KW_RENAME KW_TO roleid + | KW_ALTER KW_TABLESPACE name KW_RENAME KW_TO name + | KW_ALTER KW_STATISTICS any_name KW_RENAME KW_TO name + | KW_ALTER KW_TEXT KW_SEARCH KW_PARSER any_name KW_RENAME KW_TO name + | KW_ALTER KW_TEXT KW_SEARCH KW_DICTIONARY any_name KW_RENAME KW_TO name + | KW_ALTER KW_TEXT KW_SEARCH KW_TEMPLATE any_name KW_RENAME KW_TO name + | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_RENAME KW_TO name + | KW_ALTER KW_TYPE any_name KW_RENAME KW_TO name + | KW_ALTER KW_TYPE any_name KW_RENAME KW_ATTRIBUTE name KW_TO name opt_drop_behavior?; -opt_column: COLUMN; +opt_column: KW_COLUMN; -opt_set_data: SET DATA_P; +opt_set_data: KW_SET KW_DATA; 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; + KW_ALTER KW_FUNCTION function_with_argtypes opt_no? KW_DEPENDS KW_ON KW_EXTENSION name + | KW_ALTER KW_PROCEDURE function_with_argtypes opt_no? KW_DEPENDS KW_ON KW_EXTENSION name + | KW_ALTER KW_ROUTINE function_with_argtypes opt_no? KW_DEPENDS KW_ON KW_EXTENSION name + | KW_ALTER KW_TRIGGER name KW_ON qualified_name opt_no? KW_DEPENDS KW_ON KW_EXTENSION name + | KW_ALTER KW_MATERIALIZED KW_VIEW qualified_name opt_no? KW_DEPENDS KW_ON KW_EXTENSION name + | KW_ALTER KW_INDEX qualified_name opt_no? KW_DEPENDS KW_ON KW_EXTENSION name; -opt_no: NO; +opt_no: KW_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; + KW_ALTER KW_AGGREGATE aggregate_with_argtypes KW_SET KW_SCHEMA name + | KW_ALTER KW_COLLATION any_name KW_SET KW_SCHEMA name + | KW_ALTER KW_CONVERSION any_name KW_SET KW_SCHEMA name + | KW_ALTER KW_DOMAIN any_name KW_SET KW_SCHEMA name + | KW_ALTER KW_EXTENSION name KW_SET KW_SCHEMA name + | KW_ALTER KW_FUNCTION function_with_argtypes KW_SET KW_SCHEMA name + | KW_ALTER KW_OPERATOR operator_with_argtypes KW_SET KW_SCHEMA name + | KW_ALTER KW_OPERATOR KW_CLASS any_name KW_USING name KW_SET KW_SCHEMA name + | KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_SET KW_SCHEMA name + | KW_ALTER KW_PROCEDURE function_with_argtypes KW_SET KW_SCHEMA name + | KW_ALTER KW_ROUTINE function_with_argtypes KW_SET KW_SCHEMA name + | KW_ALTER KW_TABLE relation_expr KW_SET KW_SCHEMA name + | KW_ALTER KW_TABLE KW_IF KW_EXISTS relation_expr KW_SET KW_SCHEMA name + | KW_ALTER KW_STATISTICS any_name KW_SET KW_SCHEMA name + | KW_ALTER KW_TEXT KW_SEARCH KW_PARSER any_name KW_SET KW_SCHEMA name + | KW_ALTER KW_TEXT KW_SEARCH KW_DICTIONARY any_name KW_SET KW_SCHEMA name + | KW_ALTER KW_TEXT KW_SEARCH KW_TEMPLATE any_name KW_SET KW_SCHEMA name + | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_SET KW_SCHEMA name + | KW_ALTER KW_SEQUENCE qualified_name KW_SET KW_SCHEMA name + | KW_ALTER KW_SEQUENCE KW_IF KW_EXISTS qualified_name KW_SET KW_SCHEMA name + | KW_ALTER KW_VIEW qualified_name KW_SET KW_SCHEMA name + | KW_ALTER KW_VIEW KW_IF KW_EXISTS qualified_name KW_SET KW_SCHEMA name + | KW_ALTER KW_MATERIALIZED KW_VIEW qualified_name KW_SET KW_SCHEMA name + | KW_ALTER KW_MATERIALIZED KW_VIEW KW_IF KW_EXISTS qualified_name KW_SET KW_SCHEMA name + | KW_ALTER KW_FOREIGN KW_TABLE relation_expr KW_SET KW_SCHEMA name + | KW_ALTER KW_FOREIGN KW_TABLE KW_IF KW_EXISTS relation_expr KW_SET KW_SCHEMA name + | KW_ALTER KW_TYPE any_name KW_SET KW_SCHEMA name; alteroperatorstmt: - ALTER OPERATOR operator_with_argtypes SET OPEN_PAREN operator_def_list CLOSE_PAREN; + KW_ALTER KW_OPERATOR operator_with_argtypes KW_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 KW_NONE | collabel EQUAL operator_def_arg; operator_def_arg: @@ -1635,51 +1698,51 @@ operator_def_arg: | sconst; altertypestmt: - ALTER TYPE_P any_name SET OPEN_PAREN operator_def_list CLOSE_PAREN; + KW_ALTER KW_TYPE any_name KW_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; + KW_ALTER KW_AGGREGATE aggregate_with_argtypes KW_OWNER KW_TO rolespec + | KW_ALTER KW_COLLATION any_name KW_OWNER KW_TO rolespec + | KW_ALTER KW_CONVERSION any_name KW_OWNER KW_TO rolespec + | KW_ALTER KW_DATABASE name KW_OWNER KW_TO rolespec + | KW_ALTER KW_DOMAIN any_name KW_OWNER KW_TO rolespec + | KW_ALTER KW_FUNCTION function_with_argtypes KW_OWNER KW_TO rolespec + | KW_ALTER opt_procedural? KW_LANGUAGE name KW_OWNER KW_TO rolespec + | KW_ALTER KW_LARGE KW_OBJECT numericonly KW_OWNER KW_TO rolespec + | KW_ALTER KW_OPERATOR operator_with_argtypes KW_OWNER KW_TO rolespec + | KW_ALTER KW_OPERATOR KW_CLASS any_name KW_USING name KW_OWNER KW_TO rolespec + | KW_ALTER KW_OPERATOR KW_FAMILY any_name KW_USING name KW_OWNER KW_TO rolespec + | KW_ALTER KW_PROCEDURE function_with_argtypes KW_OWNER KW_TO rolespec + | KW_ALTER KW_ROUTINE function_with_argtypes KW_OWNER KW_TO rolespec + | KW_ALTER KW_SCHEMA name KW_OWNER KW_TO rolespec + | KW_ALTER KW_TYPE any_name KW_OWNER KW_TO rolespec + | KW_ALTER KW_TABLESPACE name KW_OWNER KW_TO rolespec + | KW_ALTER KW_STATISTICS any_name KW_OWNER KW_TO rolespec + | KW_ALTER KW_TEXT KW_SEARCH KW_DICTIONARY any_name KW_OWNER KW_TO rolespec + | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_OWNER KW_TO rolespec + | KW_ALTER KW_FOREIGN KW_DATA KW_WRAPPER name KW_OWNER KW_TO rolespec + | KW_ALTER KW_SERVER name KW_OWNER KW_TO rolespec + | KW_ALTER KW_EVENT KW_TRIGGER name KW_OWNER KW_TO rolespec + | KW_ALTER KW_PUBLICATION name KW_OWNER KW_TO rolespec + | KW_ALTER KW_SUBSCRIPTION name KW_OWNER KW_TO rolespec; createpublicationstmt: - CREATE PUBLICATION name opt_publication_for_tables? opt_definition?; + KW_CREATE KW_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; + KW_FOR KW_TABLE relation_expr_list + | KW_FOR KW_ALL KW_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; + KW_ALTER KW_PUBLICATION name KW_SET definition + | KW_ALTER KW_PUBLICATION name KW_ADD KW_TABLE relation_expr_list + | KW_ALTER KW_PUBLICATION name KW_SET KW_TABLE relation_expr_list + | KW_ALTER KW_PUBLICATION name KW_DROP KW_TABLE relation_expr_list; createsubscriptionstmt: - CREATE SUBSCRIPTION name CONNECTION sconst PUBLICATION publication_name_list opt_definition?; + KW_CREATE KW_SUBSCRIPTION name KW_CONNECTION sconst KW_PUBLICATION publication_name_list opt_definition?; publication_name_list: publication_name_item (COMMA publication_name_item)*; @@ -1687,23 +1750,23 @@ publication_name_list: 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; + KW_ALTER KW_SUBSCRIPTION name KW_SET definition + | KW_ALTER KW_SUBSCRIPTION name KW_CONNECTION sconst + | KW_ALTER KW_SUBSCRIPTION name KW_REFRESH KW_PUBLICATION opt_definition? + | KW_ALTER KW_SUBSCRIPTION name KW_SET KW_PUBLICATION publication_name_list opt_definition? + | KW_ALTER KW_SUBSCRIPTION name KW_ENABLE + | KW_ALTER KW_SUBSCRIPTION name KW_DISABLE; dropsubscriptionstmt: - DROP SUBSCRIPTION name opt_drop_behavior? - | DROP SUBSCRIPTION IF_P EXISTS name opt_drop_behavior?; + KW_DROP KW_SUBSCRIPTION name opt_drop_behavior? + | KW_DROP KW_SUBSCRIPTION KW_IF KW_EXISTS name opt_drop_behavior?; rulestmt: - CREATE opt_or_replace? RULE name AS ON event TO qualified_name where_clause? DO opt_instead? + KW_CREATE opt_or_replace? KW_RULE name KW_AS KW_ON event KW_TO qualified_name where_clause? KW_DO opt_instead? ruleactionlist; ruleactionlist: - NOTHING + KW_NOTHING | ruleactionstmt | OPEN_PAREN ruleactionmulti CLOSE_PAREN; @@ -1719,61 +1782,61 @@ ruleactionstmt: ruleactionstmtOrEmpty: ruleactionstmt; -event: SELECT | UPDATE | DELETE_P | INSERT; +event: KW_SELECT | KW_UPDATE | KW_DELETE | KW_INSERT; -opt_instead: INSTEAD | ALSO; +opt_instead: KW_INSTEAD | KW_ALSO; -notifystmt: NOTIFY colid notify_payload?; +notifystmt: KW_NOTIFY colid notify_payload?; notify_payload: COMMA sconst; -listenstmt: LISTEN colid; +listenstmt: KW_LISTEN colid; -unlistenstmt: UNLISTEN colid | UNLISTEN STAR; +unlistenstmt: KW_UNLISTEN colid | KW_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; + KW_ABORT opt_transaction? opt_transaction_chain? + | KW_BEGIN opt_transaction? transaction_mode_list_or_empty? + | KW_START KW_TRANSACTION transaction_mode_list_or_empty? + | KW_COMMIT opt_transaction? opt_transaction_chain? + | KW_END opt_transaction? opt_transaction_chain? + | KW_ROLLBACK opt_transaction? opt_transaction_chain? + | KW_SAVEPOINT colid + | KW_RELEASE KW_SAVEPOINT colid + | KW_RELEASE colid + | KW_ROLLBACK opt_transaction? KW_TO KW_SAVEPOINT colid + | KW_ROLLBACK opt_transaction? KW_TO colid + | KW_PREPARE KW_TRANSACTION sconst + | KW_COMMIT KW_PREPARED sconst + | KW_ROLLBACK KW_PREPARED sconst; -opt_transaction: WORK | TRANSACTION; +opt_transaction: KW_WORK | KW_TRANSACTION; transaction_mode_item: - ISOLATION LEVEL iso_level - | READ ONLY - | READ WRITE - | DEFERRABLE - | NOT DEFERRABLE; + KW_ISOLATION KW_LEVEL iso_level + | KW_READ KW_ONLY + | KW_READ KW_WRITE + | KW_DEFERRABLE + | KW_NOT KW_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; +opt_transaction_chain: KW_AND KW_NO? KW_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?; + KW_CREATE (KW_OR KW_REPLACE)? opttemp? ( + KW_VIEW qualified_name opt_column_list? opt_reloptions? + | KW_RECURSIVE KW_VIEW qualified_name OPEN_PAREN columnlist CLOSE_PAREN opt_reloptions? + ) KW_AS selectstmt opt_check_option?; -opt_check_option: WITH (CASCADED | LOCAL)? CHECK OPTION; +opt_check_option: KW_WITH (KW_CASCADED | KW_LOCAL)? KW_CHECK KW_OPTION; -loadstmt: LOAD file_name; +loadstmt: KW_LOAD file_name; -createdbstmt: CREATE DATABASE name opt_with? createdb_opt_list?; +createdbstmt: KW_CREATE KW_DATABASE name opt_with? createdb_opt_list?; createdb_opt_list: createdb_opt_items; @@ -1783,86 +1846,86 @@ createdb_opt_item: createdb_opt_name opt_equal? ( signediconst | opt_boolean_or_string - | DEFAULT + | KW_DEFAULT ); createdb_opt_name: identifier - | CONNECTION LIMIT - | ENCODING - | LOCATION - | OWNER - | TABLESPACE - | TEMPLATE; + | KW_CONNECTION KW_LIMIT + | KW_ENCODING + | KW_LOCATION + | KW_OWNER + | KW_TABLESPACE + | KW_TEMPLATE; opt_equal: EQUAL; alterdatabasestmt: - ALTER DATABASE name ( - WITH createdb_opt_list? + KW_ALTER KW_DATABASE name ( + KW_WITH createdb_opt_list? | createdb_opt_list? - | SET TABLESPACE name + | KW_SET KW_TABLESPACE name ); -alterdatabasesetstmt: ALTER DATABASE name setresetclause; +alterdatabasesetstmt: KW_ALTER KW_DATABASE name setresetclause; dropdbstmt: - DROP DATABASE (IF_P EXISTS)? name ( + KW_DROP KW_DATABASE (KW_IF KW_EXISTS)? name ( opt_with? OPEN_PAREN drop_option_list CLOSE_PAREN )?; drop_option_list: drop_option (COMMA drop_option)*; -drop_option: FORCE; +drop_option: KW_FORCE; -altercollationstmt: ALTER COLLATION any_name REFRESH VERSION_P; +altercollationstmt: KW_ALTER KW_COLLATION any_name KW_REFRESH KW_VERSION; -altersystemstmt: ALTER SYSTEM_P (SET | RESET) generic_set; +altersystemstmt: KW_ALTER KW_SYSTEM (KW_SET | KW_RESET) generic_set; createdomainstmt: - CREATE DOMAIN_P any_name opt_as? typename colquallist; + KW_CREATE KW_DOMAIN any_name opt_as? typename colquallist; alterdomainstmt: - ALTER DOMAIN_P any_name ( + KW_ALTER KW_DOMAIN 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 + | KW_DROP KW_NOT KW_NULL + | KW_SET KW_NOT KW_NULL + | KW_ADD tableconstraint + | KW_DROP KW_CONSTRAINT (KW_IF KW_EXISTS)? name opt_drop_behavior? + | KW_VALIDATE KW_CONSTRAINT name ); -opt_as: AS; +opt_as: KW_AS; altertsdictionarystmt: - ALTER TEXT_P SEARCH DICTIONARY any_name definition; + KW_ALTER KW_TEXT KW_SEARCH KW_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 + KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_ADD KW_MAPPING KW_FOR name_list any_with any_name_list + | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_ALTER KW_MAPPING KW_FOR name_list any_with any_name_list + | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_ALTER KW_MAPPING KW_REPLACE any_name any_with any_name + | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_ALTER KW_MAPPING KW_FOR name_list KW_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; + | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_DROP KW_MAPPING KW_FOR name_list + | KW_ALTER KW_TEXT KW_SEARCH KW_CONFIGURATION any_name KW_DROP KW_MAPPING KW_IF KW_EXISTS KW_FOR name_list; any_with: - WITH + KW_WITH ; // | WITH_LA createconversionstmt: - CREATE opt_default? CONVERSION_P any_name FOR sconst TO sconst FROM any_name; + KW_CREATE opt_default? KW_CONVERSION any_name KW_FOR sconst KW_TO sconst KW_FROM any_name; clusterstmt: - CLUSTER opt_verbose? qualified_name cluster_index_specification? - | CLUSTER opt_verbose? - | CLUSTER opt_verbose? name ON qualified_name; + KW_CLUSTER opt_verbose? qualified_name cluster_index_specification? + | KW_CLUSTER opt_verbose? + | KW_CLUSTER opt_verbose? name KW_ON qualified_name; -cluster_index_specification: USING name; +cluster_index_specification: KW_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?; + KW_VACUUM opt_full? opt_freeze? opt_verbose? opt_analyze? opt_vacuum_relation_list? + | KW_VACUUM OPEN_PAREN vac_analyze_option_list CLOSE_PAREN opt_vacuum_relation_list?; analyzestmt: analyze_keyword opt_verbose? opt_vacuum_relation_list? @@ -1871,7 +1934,7 @@ analyzestmt: vac_analyze_option_list: vac_analyze_option_elem (COMMA vac_analyze_option_elem)*; -analyze_keyword: ANALYZE | ANALYSE; +analyze_keyword: KW_ANALYZE | KW_ANALYSE; vac_analyze_option_elem: vac_analyze_option_name vac_analyze_option_arg?; @@ -1882,11 +1945,11 @@ vac_analyze_option_arg: opt_boolean_or_string | numericonly; opt_analyze: analyze_keyword; -opt_verbose: VERBOSE; +opt_verbose: KW_VERBOSE; -opt_full: FULL; +opt_full: KW_FULL; -opt_freeze: FREEZE; +opt_freeze: KW_FREEZE; opt_name_list: OPEN_PAREN name_list CLOSE_PAREN; @@ -1897,10 +1960,10 @@ 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; + KW_EXPLAIN explainablestmt + | KW_EXPLAIN analyze_keyword opt_verbose? explainablestmt + | KW_EXPLAIN KW_VERBOSE explainablestmt + | KW_EXPLAIN OPEN_PAREN explain_option_list CLOSE_PAREN explainablestmt; explainablestmt: selectstmt @@ -1922,7 +1985,7 @@ explain_option_name: nonreservedword | analyze_keyword; explain_option_arg: opt_boolean_or_string | numericonly; -preparestmt: PREPARE name prep_type_clause? AS preparablestmt; +preparestmt: KW_PREPARE name prep_type_clause? KW_AS preparablestmt; prep_type_clause: OPEN_PAREN type_list CLOSE_PAREN; @@ -1933,33 +1996,33 @@ preparablestmt: | 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? + KW_EXECUTE name execute_param_clause? + | KW_CREATE opttemp? KW_TABLE create_as_target KW_AS KW_EXECUTE name execute_param_clause? opt_with_data? + | KW_CREATE opttemp? KW_TABLE KW_IF KW_NOT KW_EXISTS create_as_target KW_AS KW_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; + KW_DEALLOCATE name + | KW_DEALLOCATE KW_PREPARE name + | KW_DEALLOCATE KW_ALL + | KW_DEALLOCATE KW_PREPARE KW_ALL; insertstmt: - opt_with_clause? INSERT INTO insert_target insert_rest opt_on_conflict? returning_clause?; + opt_with_clause? KW_INSERT KW_INTO insert_target insert_rest opt_on_conflict? returning_clause?; -insert_target: qualified_name (AS colid)?; +insert_target: qualified_name (KW_AS colid)?; insert_rest: selectstmt - | OVERRIDING override_kind VALUE_P selectstmt + | KW_OVERRIDING override_kind KW_VALUE selectstmt | OPEN_PAREN insert_column_list CLOSE_PAREN ( - OVERRIDING override_kind VALUE_P + KW_OVERRIDING override_kind KW_VALUE )? selectstmt - | DEFAULT VALUES; + | KW_DEFAULT KW_VALUES; -override_kind: USER | SYSTEM_P; +override_kind: KW_USER | KW_SYSTEM; insert_column_list: insert_column_item (COMMA insert_column_item)*; @@ -1967,40 +2030,40 @@ insert_column_list: insert_column_item: colid opt_indirection; opt_on_conflict: - ON CONFLICT opt_conf_expr? DO ( - UPDATE SET set_clause_list where_clause? - | NOTHING + KW_ON KW_CONFLICT opt_conf_expr? KW_DO ( + KW_UPDATE KW_SET set_clause_list where_clause? + | KW_NOTHING ); opt_conf_expr: OPEN_PAREN index_params CLOSE_PAREN where_clause? - | ON CONSTRAINT name; + | KW_ON KW_CONSTRAINT name; -returning_clause: RETURNING target_list; +returning_clause: KW_RETURNING target_list; deletestmt: - opt_with_clause? DELETE_P FROM relation_expr_opt_alias using_clause? where_or_current_clause? + opt_with_clause? KW_DELETE KW_FROM relation_expr_opt_alias using_clause? where_or_current_clause? returning_clause?; -using_clause: USING from_list; +using_clause: KW_USING from_list; lockstmt: - LOCK_P opt_table? relation_expr_list opt_lock? opt_nowait?; + KW_LOCK opt_table? relation_expr_list opt_lock? opt_nowait?; -opt_lock: IN_P lock_type MODE; +opt_lock: KW_IN lock_type KW_MODE; lock_type: - ACCESS (SHARE | EXCLUSIVE) - | ROW (SHARE | EXCLUSIVE) - | SHARE (UPDATE EXCLUSIVE | ROW EXCLUSIVE)? - | EXCLUSIVE; + KW_ACCESS (KW_SHARE | KW_EXCLUSIVE) + | KW_ROW (KW_SHARE | KW_EXCLUSIVE) + | KW_SHARE (KW_UPDATE KW_EXCLUSIVE | KW_ROW KW_EXCLUSIVE)? + | KW_EXCLUSIVE; -opt_nowait: NOWAIT; +opt_nowait: KW_NOWAIT; -opt_nowait_or_skip: NOWAIT | SKIP_P LOCKED; +opt_nowait_or_skip: KW_NOWAIT | KW_SKIP KW_LOCKED; updatestmt: - opt_with_clause? UPDATE relation_expr_opt_alias SET set_clause_list from_clause? + opt_with_clause? KW_UPDATE relation_expr_opt_alias KW_SET set_clause_list from_clause? where_or_current_clause? returning_clause?; set_clause_list: set_clause (COMMA set_clause)*; @@ -2014,13 +2077,13 @@ set_target: colid opt_indirection; set_target_list: set_target (COMMA set_target)*; declarecursorstmt: - DECLARE cursor_name cursor_options CURSOR opt_hold FOR selectstmt; + KW_DECLARE cursor_name cursor_options KW_CURSOR opt_hold KW_FOR selectstmt; cursor_name: name; -cursor_options: (NO SCROLL | SCROLL | BINARY | INSENSITIVE)*; +cursor_options: (KW_NO KW_SCROLL | KW_SCROLL | KW_BINARY | KW_INSENSITIVE)*; -opt_hold: | WITH HOLD | WITHOUT HOLD; +opt_hold: | KW_WITH KW_HOLD | KW_WITHOUT KW_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 @@ -2050,12 +2113,12 @@ select_no_parens: select_clause: simple_select | select_with_parens; simple_select: ( - SELECT ( + KW_SELECT ( opt_all_clause? into_clause? opt_target_list? - | distinct_clause target_list + | distinct_clause? target_list? ) into_clause? from_clause? where_clause? group_clause? having_clause? window_clause? | values_clause - | TABLE relation_expr + | KW_TABLE relation_expr | select_with_parens set_operator_with_all_or_distinct ( simple_select | select_with_parens @@ -2068,50 +2131,50 @@ simple_select: ( )*; set_operator: - UNION # union - | INTERSECT # intersect - | EXCEPT # except; + KW_UNION # union + | KW_INTERSECT # intersect + | KW_EXCEPT # except; set_operator_with_all_or_distinct: set_operator all_or_distinct?; -with_clause: WITH RECURSIVE? cte_list; +with_clause: KW_WITH KW_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; + name opt_name_list? KW_AS opt_materialized? OPEN_PAREN preparablestmt CLOSE_PAREN; -opt_materialized: MATERIALIZED | NOT MATERIALIZED; +opt_materialized: KW_MATERIALIZED | KW_NOT KW_MATERIALIZED; opt_with_clause: with_clause; -into_clause: INTO (opt_strict opttempTableName | into_target); +into_clause: KW_INTO (opt_strict opttempTableName | into_target); -opt_strict: | STRICT_P; +opt_strict: | KW_STRICT; -opttempTableName: (LOCAL | GLOBAL)? (TEMPORARY | TEMP) opt_table? qualified_name - | UNLOGGED opt_table? qualified_name - | TABLE qualified_name +opttempTableName: (KW_LOCAL | KW_GLOBAL)? (KW_TEMPORARY | KW_TEMP) opt_table? qualified_name + | KW_UNLOGGED opt_table? qualified_name + | KW_TABLE qualified_name | qualified_name; -opt_table: TABLE; +opt_table: KW_TABLE; -all_or_distinct: ALL | DISTINCT; +all_or_distinct: KW_ALL | KW_DISTINCT; distinct_clause: - DISTINCT (ON OPEN_PAREN expr_list CLOSE_PAREN)?; + KW_DISTINCT (KW_ON OPEN_PAREN expr_list CLOSE_PAREN)?; -opt_all_clause: ALL; +opt_all_clause: KW_ALL; opt_sort_clause: sort_clause; -sort_clause: ORDER BY sortby_list; +sort_clause: KW_ORDER KW_BY sortby_list; sortby_list: sortby (COMMA sortby)*; sortby: - a_expr (USING qual_all_op | opt_asc_desc?) opt_nulls_order?; + a_expr (KW_USING qual_all_op | opt_asc_desc)? opt_nulls_order?; select_limit: limit_clause offset_clause? @@ -2120,19 +2183,19 @@ select_limit: 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) + KW_LIMIT select_limit_value (COMMA select_offset_value)? + | KW_FETCH first_or_next ( + select_fetch_first_value row_or_rows (KW_ONLY | KW_WITH KW_TIES) + | row_or_rows (KW_ONLY | KW_WITH KW_TIES) ); offset_clause: - OFFSET ( + KW_OFFSET ( select_offset_value | select_fetch_first_value row_or_rows ); -select_limit_value: a_expr | ALL; +select_limit_value: a_expr | KW_ALL; select_offset_value: a_expr; @@ -2143,11 +2206,11 @@ select_fetch_first_value: i_or_f_const: iconst | fconst; -row_or_rows: ROW | ROWS; +row_or_rows: KW_ROW | KW_ROWS; -first_or_next: FIRST_P | NEXT; +first_or_next: KW_FIRST | KW_NEXT; -group_clause: GROUP_P BY group_by_list; +group_clause: KW_GROUP KW_BY group_by_list; group_by_list: group_by_item (COMMA group_by_item)*; @@ -2160,16 +2223,16 @@ group_by_item: empty_grouping_set: OPEN_PAREN CLOSE_PAREN; -rollup_clause: ROLLUP OPEN_PAREN expr_list CLOSE_PAREN; +rollup_clause: KW_ROLLUP OPEN_PAREN expr_list CLOSE_PAREN; -cube_clause: CUBE OPEN_PAREN expr_list CLOSE_PAREN; +cube_clause: KW_CUBE OPEN_PAREN expr_list CLOSE_PAREN; grouping_sets_clause: - GROUPING SETS OPEN_PAREN group_by_list CLOSE_PAREN; + KW_GROUPING KW_SETS OPEN_PAREN group_by_list CLOSE_PAREN; -having_clause: HAVING a_expr; +having_clause: KW_HAVING a_expr; -for_locking_clause: for_locking_items | FOR READ ONLY; +for_locking_clause: for_locking_items | KW_FOR KW_READ KW_ONLY; opt_for_locking_clause: for_locking_clause; @@ -2178,16 +2241,16 @@ 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); +for_locking_strength: KW_FOR ((KW_NO KW_KEY)? KW_UPDATE | KW_KEY? KW_SHARE); -locked_rels_list: OF qualified_name_list; +locked_rels_list: KW_OF qualified_name_list; values_clause: - VALUES OPEN_PAREN expr_list CLOSE_PAREN ( + KW_VALUES OPEN_PAREN expr_list CLOSE_PAREN ( COMMA OPEN_PAREN expr_list CLOSE_PAREN )*; -from_clause: FROM from_list; +from_clause: KW_FROM from_list; from_list: table_ref (COMMA table_ref)*; @@ -2196,67 +2259,67 @@ table_ref: ( | func_table func_alias_clause? | xmltable opt_alias_clause? | select_with_parens opt_alias_clause? - | LATERAL_P ( + | KW_LATERAL ( 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 + KW_CROSS KW_JOIN table_ref + | KW_NATURAL join_type? KW_JOIN table_ref + | join_type? KW_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 + KW_CROSS KW_JOIN table_ref + | KW_NATURAL join_type? KW_JOIN table_ref + | join_type? KW_JOIN table_ref join_qual )*; -alias_clause: AS? colid (OPEN_PAREN name_list CLOSE_PAREN)?; +alias_clause: KW_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; + | (KW_AS colid? | colid) OPEN_PAREN tablefuncelementlist CLOSE_PAREN; -join_type: (FULL | LEFT | RIGHT | INNER_P) OUTER_P?; +join_type: (KW_FULL | KW_LEFT | KW_RIGHT | KW_INNER) KW_OUTER?; -join_qual: USING OPEN_PAREN name_list CLOSE_PAREN | ON a_expr; +join_qual: KW_USING OPEN_PAREN name_list CLOSE_PAREN | KW_ON a_expr; relation_expr: - qualified_name STAR? - | ONLY ( + KW_ONLY? qualified_name STAR? + | KW_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)?; +relation_expr_opt_alias: relation_expr (KW_AS? colid)?; tablesample_clause: - TABLESAMPLE func_name OPEN_PAREN expr_list CLOSE_PAREN opt_repeatable_clause?; + KW_TABLESAMPLE func_name OPEN_PAREN expr_list CLOSE_PAREN opt_repeatable_clause?; -opt_repeatable_clause: REPEATABLE OPEN_PAREN a_expr CLOSE_PAREN; +opt_repeatable_clause: KW_REPEATABLE OPEN_PAREN a_expr CLOSE_PAREN; func_table: func_expr_windowless opt_ordinality? - | ROWS FROM OPEN_PAREN rowsfrom_list CLOSE_PAREN opt_ordinality?; + | KW_ROWS KW_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; + KW_AS OPEN_PAREN tablefuncelementlist CLOSE_PAREN; -opt_ordinality: WITH ORDINALITY; +opt_ordinality: KW_WITH KW_ORDINALITY; -where_clause: WHERE a_expr; +where_clause: KW_WHERE a_expr; where_or_current_clause: - WHERE (CURRENT_P OF cursor_name | a_expr); + KW_WHERE (KW_CURRENT KW_OF cursor_name | a_expr); opttablefuncelementlist: tablefuncelementlist; @@ -2266,10 +2329,10 @@ tablefuncelementlist: 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 + KW_XMLTABLE OPEN_PAREN ( + c_expr xmlexists_argument KW_COLUMNS xmltable_column_list + | KW_XMLNAMESPACES OPEN_PAREN xml_namespace_list CLOSE_PAREN COMMA c_expr xmlexists_argument + KW_COLUMNS xmltable_column_list ) CLOSE_PAREN; xmltable_column_list: @@ -2278,27 +2341,27 @@ xmltable_column_list: xmltable_column_el: colid ( typename xmltable_column_option_list? - | FOR ORDINALITY + | KW_FOR KW_ORDINALITY ); xmltable_column_option_list: xmltable_column_option_el+; xmltable_column_option_el: - DEFAULT a_expr + KW_DEFAULT a_expr | identifier a_expr - | NOT NULL_P - | NULL_P; + | KW_NOT KW_NULL + | KW_NULL; xml_namespace_list: xml_namespace_el (COMMA xml_namespace_el)*; -xml_namespace_el: b_expr AS collabel | DEFAULT b_expr; +xml_namespace_el: b_expr KW_AS collabel | KW_DEFAULT b_expr; typename: - SETOF? simpletypename ( + KW_SETOF? simpletypename ( opt_array_bounds - | ARRAY (OPEN_BRACKET iconst CLOSE_BRACKET)? + | KW_ARRAY (OPEN_BRACKET iconst CLOSE_BRACKET)? ) - | qualified_name PERCENT (ROWTYPE | TYPE_P); + | qualified_name PERCENT (KW_ROWTYPE | KW_TYPE); opt_array_bounds: (OPEN_BRACKET iconst? CLOSE_BRACKET)*; @@ -2324,17 +2387,17 @@ 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; + KW_INT + | KW_INTEGER + | KW_SMALLINT + | KW_BIGINT + | KW_REAL + | KW_FLOAT opt_float? + | KW_DOUBLE KW_PRECISION + | KW_DECIMAL opt_type_modifiers? + | KW_DEC opt_type_modifiers? + | KW_NUMERIC opt_type_modifiers? + | KW_BOOLEAN; opt_float: OPEN_PAREN iconst CLOSE_PAREN; @@ -2343,49 +2406,49 @@ bit: bitwithlength | bitwithoutlength; constbit: bitwithlength | bitwithoutlength; bitwithlength: - BIT opt_varying? OPEN_PAREN expr_list CLOSE_PAREN; + KW_BIT opt_varying? OPEN_PAREN expr_list CLOSE_PAREN; -bitwithoutlength: BIT opt_varying?; +bitwithoutlength: KW_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?; +character_c: (KW_CHARACTER | KW_CHAR | KW_NCHAR) opt_varying? + | KW_VARCHAR + | KW_NATIONAL (KW_CHARACTER | KW_CHAR) opt_varying?; -opt_varying: VARYING; +opt_varying: KW_VARYING; -constdatetime: (TIMESTAMP | TIME) (OPEN_PAREN iconst CLOSE_PAREN)? opt_timezone?; +constdatetime: (KW_TIMESTAMP | KW_TIME) (OPEN_PAREN iconst CLOSE_PAREN)? opt_timezone?; -constinterval: INTERVAL; +constinterval: KW_INTERVAL; //TODO with_la was used -opt_timezone: WITH TIME ZONE | WITHOUT TIME ZONE; +opt_timezone: KW_WITH KW_TIME KW_ZONE | KW_WITHOUT KW_TIME KW_ZONE; opt_interval: - YEAR_P - | MONTH_P - | DAY_P - | HOUR_P - | MINUTE_P + KW_YEAR + | KW_MONTH + | KW_DAY + | KW_HOUR + | KW_MINUTE | 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; + | KW_YEAR KW_TO KW_MONTH + | KW_DAY KW_TO (KW_HOUR | KW_MINUTE | interval_second) + | KW_HOUR KW_TO (KW_MINUTE | interval_second) + | KW_MINUTE KW_TO interval_second; -interval_second: SECOND_P (OPEN_PAREN iconst CLOSE_PAREN)?; +interval_second: KW_SECOND (OPEN_PAREN iconst CLOSE_PAREN)?; -opt_escape: ESCAPE a_expr; +opt_escape: KW_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 + TYPECAST typename -- 1 | a_expr KW_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 @@ -2393,13 +2456,13 @@ opt_escape: ESCAPE a_expr; 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 ) -- + FALSE, IS NULL, IS KW_DISTINCT FROM, etc | a_expr IS NOT? ( NULL_P |TRUE_P |FALSE_P |UNKNOWN |KW_DISTINCT + KW_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 ; + CLOSE_PAREN) -- 21 | UNIQUE select_with_parens -- 22 | KW_DEFAULT -- 23 ; */ a_expr: a_expr_qual; @@ -2420,36 +2483,36 @@ a_expr_lessless: a_expr_or ((LESS_LESS | GREATER_GREATER) a_expr_or)*; /*17*/ -a_expr_or: a_expr_and (OR a_expr_and)*; +a_expr_or: a_expr_and (KW_OR a_expr_and)*; /*16*/ -a_expr_and: a_expr_in (AND a_expr_in)*; +a_expr_and: a_expr_in (KW_AND a_expr_in)*; /*20*/ -a_expr_in: a_expr_unary_not (NOT? IN_P in_expr)?; +a_expr_in: a_expr_unary_not (KW_NOT? KW_IN in_expr)?; /*15*/ -a_expr_unary_not: NOT? a_expr_isnull; +a_expr_unary_not: KW_NOT? a_expr_isnull; /*14*/ /*moved to c_expr*/ /*13*/ -a_expr_isnull: a_expr_is_not (ISNULL | NOTNULL)?; +a_expr_isnull: a_expr_is_not (KW_ISNULL | KW_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 + KW_IS KW_NOT? ( + KW_NULL + | KW_TRUE + | KW_FALSE + | KW_UNKNOWN + | KW_DISTINCT KW_FROM a_expr + | KW_OF OPEN_PAREN type_list CLOSE_PAREN + | KW_DOCUMENT + | unicode_normal_form? KW_NORMALIZED ) )?; /*11*/ @@ -2473,7 +2536,7 @@ a_expr_compare: a_expr_like: a_expr_qual_op ( - NOT? (LIKE | ILIKE | SIMILAR TO | BETWEEN SYMMETRIC?) a_expr_qual_op opt_escape? + KW_NOT? (KW_LIKE | KW_ILIKE | KW_SIMILAR KW_TO | KW_BETWEEN KW_SYMMETRIC?) a_expr_qual_op opt_escape? )?; /* 8*/ @@ -2497,10 +2560,10 @@ a_expr_caret: a_expr_unary_sign (CARET a_expr)?; 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)?; +a_expr_at_time_zone: a_expr_collate (KW_AT KW_TIME KW_ZONE a_expr)?; /* 2*/ -a_expr_collate: a_expr_typecast (COLLATE any_name)?; +a_expr_collate: a_expr_typecast (KW_COLLATE any_name)?; /* 1*/ a_expr_typecast: c_expr (TYPECAST typename)*; @@ -2529,19 +2592,19 @@ b_expr: ) 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 + //S ISNULL NOTNULL IS TRUE, IS FALSE, IS NULL, IS KW_DISTINCT FROM, etc + | b_expr KW_IS KW_NOT? ( + KW_DISTINCT KW_FROM b_expr + | KW_OF OPEN_PAREN type_list CLOSE_PAREN + | KW_DOCUMENT ); c_expr: - EXISTS select_with_parens # c_expr_exists - | ARRAY (select_with_parens | array_expr) # c_expr_expr + KW_EXISTS select_with_parens # c_expr_exists + | KW_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 + | KW_GROUPING OPEN_PAREN expr_list CLOSE_PAREN # c_expr_expr + | /*22*/ KW_UNIQUE select_with_parens # c_expr_expr | columnref # c_expr_expr | aexprconst # c_expr_expr | plsqlvariablename # c_expr_expr @@ -2551,15 +2614,15 @@ c_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; + | row KW_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? + func_arg_list (COMMA KW_VARIADIC func_arg_expr)? opt_sort_clause? + | KW_VARIADIC func_arg_expr opt_sort_clause? + | (KW_ALL | KW_DISTINCT) func_arg_list opt_sort_clause? | STAR | ) CLOSE_PAREN; @@ -2573,82 +2636,82 @@ func_expr_windowless: | 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 ( + KW_COLLATION KW_FOR OPEN_PAREN a_expr CLOSE_PAREN + | KW_CURRENT_DATE + | KW_CURRENT_TIME (OPEN_PAREN iconst CLOSE_PAREN)? + | KW_CURRENT_TIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? + | KW_LOCALTIME (OPEN_PAREN iconst CLOSE_PAREN)? + | KW_LOCALTIMESTAMP (OPEN_PAREN iconst CLOSE_PAREN)? + | KW_CURRENT_ROLE + | KW_CURRENT_USER + | KW_SESSION_USER + | KW_USER + | KW_CURRENT_CATALOG + | KW_CURRENT_SCHEMA + | KW_CAST OPEN_PAREN a_expr KW_AS typename CLOSE_PAREN + | KW_EXTRACT OPEN_PAREN extract_list? CLOSE_PAREN + | KW_NORMALIZE OPEN_PAREN a_expr (COMMA unicode_normal_form)? CLOSE_PAREN + | KW_OVERLAY OPEN_PAREN overlay_list CLOSE_PAREN + | KW_POSITION OPEN_PAREN position_list? CLOSE_PAREN + | KW_SUBSTRING OPEN_PAREN substr_list? CLOSE_PAREN + | KW_TREAT OPEN_PAREN a_expr KW_AS typename CLOSE_PAREN + | KW_TRIM OPEN_PAREN (KW_BOTH | KW_LEADING | KW_TRAILING)? trim_list CLOSE_PAREN + | KW_NULLIF OPEN_PAREN a_expr COMMA a_expr CLOSE_PAREN + | KW_COALESCE OPEN_PAREN expr_list CLOSE_PAREN + | KW_GREATEST OPEN_PAREN expr_list CLOSE_PAREN + | KW_LEAST OPEN_PAREN expr_list CLOSE_PAREN + | KW_XMLCONCAT OPEN_PAREN expr_list CLOSE_PAREN + | KW_XMLELEMENT OPEN_PAREN KW_NAME 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; + | KW_XMLEXISTS OPEN_PAREN c_expr xmlexists_argument CLOSE_PAREN + | KW_XMLFOREST OPEN_PAREN xml_attribute_list CLOSE_PAREN + | KW_XMLPARSE OPEN_PAREN document_or_content a_expr xml_whitespace_option? CLOSE_PAREN + | KW_XMLPI OPEN_PAREN KW_NAME collabel (COMMA a_expr)? CLOSE_PAREN + | KW_XMLROOT OPEN_PAREN KW_XML a_expr COMMA xml_root_version opt_xml_root_standalone? CLOSE_PAREN + | KW_XMLSERIALIZE OPEN_PAREN document_or_content a_expr KW_AS simpletypename CLOSE_PAREN; -xml_root_version: VERSION_P a_expr | VERSION_P NO VALUE_P; +xml_root_version: KW_VERSION a_expr | KW_VERSION KW_NO KW_VALUE; opt_xml_root_standalone: - COMMA STANDALONE_P YES_P - | COMMA STANDALONE_P NO - | COMMA STANDALONE_P NO VALUE_P; + COMMA KW_STANDALONE KW_YES + | COMMA KW_STANDALONE KW_NO + | COMMA KW_STANDALONE KW_NO KW_VALUE; xml_attributes: - XMLATTRIBUTES OPEN_PAREN xml_attribute_list CLOSE_PAREN; + KW_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)?; +xml_attribute_el: a_expr (KW_AS collabel)?; -document_or_content: DOCUMENT_P | CONTENT_P; +document_or_content: KW_DOCUMENT | KW_CONTENT; xml_whitespace_option: - PRESERVE WHITESPACE_P - | STRIP_P WHITESPACE_P; + KW_PRESERVE KW_WHITESPACE + | KW_STRIP KW_WHITESPACE; 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; + KW_PASSING c_expr + | KW_PASSING c_expr xml_passing_mech + | KW_PASSING xml_passing_mech c_expr + | KW_PASSING xml_passing_mech c_expr xml_passing_mech; -xml_passing_mech: BY (REF | VALUE_P); +xml_passing_mech: KW_BY (KW_REF | KW_VALUE); within_group_clause: - WITHIN GROUP_P OPEN_PAREN sort_clause CLOSE_PAREN; + KW_WITHIN KW_GROUP OPEN_PAREN sort_clause CLOSE_PAREN; -filter_clause: FILTER OPEN_PAREN WHERE a_expr CLOSE_PAREN; +filter_clause: KW_FILTER OPEN_PAREN KW_WHERE a_expr CLOSE_PAREN; -window_clause: WINDOW window_definition_list; +window_clause: KW_WINDOW window_definition_list; window_definition_list: window_definition (COMMA window_definition)*; -window_definition: colid AS window_specification; +window_definition: colid KW_AS window_specification; -over_clause: OVER (window_specification | colid); +over_clause: KW_OVER (window_specification | colid); window_specification: OPEN_PAREN opt_existing_window_name? opt_partition_clause? opt_sort_clause? opt_frame_clause? @@ -2656,32 +2719,32 @@ window_specification: opt_existing_window_name: colid; -opt_partition_clause: PARTITION BY expr_list; +opt_partition_clause: KW_PARTITION KW_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?; + KW_RANGE frame_extent opt_window_exclusion_clause? + | KW_ROWS frame_extent opt_window_exclusion_clause? + | KW_GROUPS frame_extent opt_window_exclusion_clause?; -frame_extent: frame_bound | BETWEEN frame_bound AND frame_bound; +frame_extent: frame_bound | KW_BETWEEN frame_bound KW_AND frame_bound; frame_bound: - UNBOUNDED (PRECEDING | FOLLOWING) - | CURRENT_P ROW - | a_expr (PRECEDING | FOLLOWING); + KW_UNBOUNDED (KW_PRECEDING | KW_FOLLOWING) + | KW_CURRENT KW_ROW + | a_expr (KW_PRECEDING | KW_FOLLOWING); opt_window_exclusion_clause: - EXCLUDE (CURRENT_P ROW | GROUP_P | TIES | NO OTHERS); + KW_EXCLUDE (KW_CURRENT KW_ROW | KW_GROUP | KW_TIES | KW_NO KW_OTHERS); row: - ROW OPEN_PAREN expr_list? CLOSE_PAREN + KW_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; +explicit_row: KW_ROW OPEN_PAREN expr_list? CLOSE_PAREN; implicit_row: OPEN_PAREN expr_list COMMA a_expr CLOSE_PAREN; -sub_type: ANY | SOME | ALL; +sub_type: KW_ANY | KW_SOME | KW_ALL; all_op: Operator | mathop; @@ -2701,19 +2764,19 @@ mathop: qual_op: Operator - | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN; + | KW_OPERATOR OPEN_PAREN any_operator CLOSE_PAREN; qual_all_op: all_op - | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN; + | KW_OPERATOR OPEN_PAREN any_operator CLOSE_PAREN; subquery_Op: all_op - | OPERATOR OPEN_PAREN any_operator CLOSE_PAREN - | LIKE - | NOT LIKE - | ILIKE - | NOT ILIKE; + | KW_OPERATOR OPEN_PAREN any_operator CLOSE_PAREN + | KW_LIKE + | KW_NOT KW_LIKE + | KW_ILIKE + | KW_NOT KW_ILIKE; expr_list: a_expr (COMMA a_expr)*; @@ -2730,45 +2793,45 @@ array_expr: array_expr_list: array_expr (COMMA array_expr)*; -extract_list: extract_arg FROM a_expr; +extract_list: extract_arg KW_FROM a_expr; extract_arg: identifier - | YEAR_P - | MONTH_P - | DAY_P - | HOUR_P - | MINUTE_P - | SECOND_P + | KW_YEAR + | KW_MONTH + | KW_DAY + | KW_HOUR + | KW_MINUTE + | KW_SECOND | sconst; -unicode_normal_form: NFC | NFD | NFKC | NFKD; +unicode_normal_form: KW_NFC | KW_NFD | KW_NFKC | KW_NFKD; -overlay_list: a_expr PLACING a_expr FROM a_expr (FOR a_expr)?; +overlay_list: a_expr KW_PLACING a_expr KW_FROM a_expr (KW_FOR a_expr)?; -position_list: b_expr IN_P b_expr; +position_list: b_expr KW_IN 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 + a_expr KW_FROM a_expr KW_FOR a_expr + | a_expr KW_FOR a_expr KW_FROM a_expr + | a_expr KW_FROM a_expr + | a_expr KW_FOR a_expr + | a_expr KW_SIMILAR a_expr KW_ESCAPE a_expr | expr_list; -trim_list: a_expr FROM expr_list | FROM expr_list | expr_list; +trim_list: a_expr KW_FROM expr_list | KW_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; +case_expr: KW_CASE case_arg? when_clause_list case_default? KW_END; when_clause_list: when_clause+; -when_clause: WHEN a_expr THEN a_expr; +when_clause: KW_WHEN a_expr KW_THEN a_expr; -case_default: ELSE a_expr; +case_default: KW_ELSE a_expr; case_arg: a_expr; @@ -2792,11 +2855,13 @@ opt_target_list: target_list; target_list: target_el (COMMA target_el)*; target_el: - a_expr (AS collabel | identifier |) # target_label + a_expr (KW_AS collabel | identifier |) # target_label | STAR # target_star; qualified_name_list: qualified_name (COMMA qualified_name)*; +table_qualified_name: colid indirection?; + qualified_name: colid indirection?; name_list: name (COMMA name)*; @@ -2824,9 +2889,9 @@ aexprconst: sconst opt_interval? | OPEN_PAREN iconst CLOSE_PAREN sconst ) - | TRUE_P - | FALSE_P - | NULL_P; + | KW_TRUE + | KW_FALSE + | KW_NULL; xconst: HexadecimalStringConstant; @@ -2844,13 +2909,15 @@ anysconst: | BeginDollarStringConstant DollarText* EndDollarStringConstant | EscapeStringConstant; -opt_uescape: UESCAPE anysconst; +opt_uescape: KW_UESCAPE anysconst; signediconst: iconst | PLUS iconst | MINUS iconst; +groupname: rolespec; + roleid: rolespec; -rolespec: nonreservedword | CURRENT_USER | SESSION_USER; +rolespec: nonreservedword | KW_CURRENT_USER | KW_SESSION_USER | KW_PUBLIC; role_list: rolespec (COMMA rolespec)*; @@ -2860,6 +2927,18 @@ colid: | col_name_keyword | plsql_unreserved_keyword; +index_method_choices: + identifier; + +exclude_element: + opt_definition | (OPEN_PAREN a_expr CLOSE_PAREN) identifier opt_asc_desc? opt_nulls_order?; + +index_paramenters: + (KW_WITH reloptions)? optconstablespace?; + +wherePredicate: + KW_WHERE identifier; + type_function_name: identifier | unreserved_keyword @@ -2891,467 +2970,467 @@ identifier: 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; + KW_ABORT + | KW_ABSOLUTE + | KW_ACCESS + | KW_ACTION + | KW_ADD + | KW_ADMIN + | KW_AFTER + | KW_AGGREGATE + | KW_ALSO + | KW_ALTER + | KW_ALWAYS + | KW_ASSERTION + | KW_ASSIGNMENT + | KW_AT + | KW_ATTACH + | KW_ATTRIBUTE + | KW_BACKWARD + | KW_BEFORE + | KW_BEGIN + | KW_BY + | KW_CACHE + | KW_CALL + | KW_CALLED + | KW_CASCADE + | KW_CASCADED + | KW_CATALOG + | KW_CHAIN + | KW_CHARACTERISTICS + | KW_CHECKPOINT + | KW_CLASS + | KW_CLOSE + | KW_CLUSTER + | KW_COLUMNS + | KW_COMMENT + | KW_COMMENTS + | KW_COMMIT + | KW_COMMITTED + | KW_CONFIGURATION + | KW_CONFLICT + | KW_CONNECTION + | KW_CONSTRAINTS + | KW_CONTENT + | KW_CONTINUE + | KW_CONVERSION + | KW_COPY + | KW_COST + | KW_CSV + | KW_CUBE + | KW_CURRENT + | KW_CURSOR + | KW_CYCLE + | KW_DATA + | KW_DATABASE + | KW_DAY + | KW_DEALLOCATE + | KW_DECLARE + | KW_DEFAULTS + | KW_DEFERRED + | KW_DEFINER + | KW_DELETE + | KW_DELIMITER + | KW_DELIMITERS + | KW_DEPENDS + | KW_DETACH + | KW_DICTIONARY + | KW_DISABLE + | KW_DISCARD + | KW_DOCUMENT + | KW_DOMAIN + | KW_DOUBLE + | KW_DROP + | KW_EACH + | KW_ENABLE + | KW_ENCODING + | KW_ENCRYPTED + | KW_ENUM + | KW_ESCAPE + | KW_EVENT + | KW_EXCLUDE + | KW_EXCLUDING + | KW_EXCLUSIVE + | KW_EXECUTE + | KW_EXPLAIN + | KW_EXPRESSION + | KW_EXTENSION + | KW_EXTERNAL + | KW_FAMILY + | KW_FILTER + | KW_FIRST + | KW_FOLLOWING + | KW_FORCE + | KW_FORWARD + | KW_FUNCTION + | KW_FUNCTIONS + | KW_GENERATED + | KW_GLOBAL + | KW_GRANTED + | KW_GROUPS + | KW_HANDLER + | KW_HEADER + | KW_HOLD + | KW_HOUR + | KW_IDENTITY + | KW_IF + | KW_IMMEDIATE + | KW_IMMUTABLE + | KW_IMPLICIT + | KW_IMPORT + | KW_INCLUDE + | KW_INCLUDING + | KW_INCREMENT + | KW_INDEX + | KW_INDEXES + | KW_INHERIT + | KW_INHERITS + | KW_INLINE + | KW_INPUT + | KW_INSENSITIVE + | KW_INSERT + | KW_INSTEAD + | KW_INVOKER + | KW_ISOLATION + | KW_KEY + | KW_LABEL + | KW_LANGUAGE + | KW_LARGE + | KW_LAST + | KW_LEAKPROOF + | KW_LEVEL + | KW_LISTEN + | KW_LOAD + | KW_LOCAL + | KW_LOCATION + | KW_LOCK + | KW_LOCKED + | KW_LOGGED + | KW_MAPPING + | KW_MATCH + | KW_MATERIALIZED + | KW_MAXVALUE + | KW_METHOD + | KW_MINUTE + | KW_MINVALUE + | KW_MODE + | KW_MONTH + | KW_MOVE + | KW_NAME + | KW_NAMES + | KW_NEW + | KW_NEXT + | KW_NFC + | KW_NFD + | KW_NFKC + | KW_NFKD + | KW_NO + | KW_NORMALIZED + | KW_NOTHING + | KW_NOTIFY + | KW_NOWAIT + | KW_NULLS + | KW_OBJECT + | KW_OF + | KW_OFF + | KW_OIDS + | KW_OLD + | KW_OPERATOR + | KW_OPTION + | KW_OPTIONS + | KW_ORDINALITY + | KW_OTHERS + | KW_OVER + | KW_OVERRIDING + | KW_OWNED + | KW_OWNER + | KW_PARALLEL + | KW_PARSER + | KW_PARTIAL + | KW_PARTITION + | KW_PASSING + | KW_PASSWORD + | KW_PLANS + | KW_POLICY + | KW_PRECEDING + | KW_PREPARE + | KW_PREPARED + | KW_PRESERVE + | KW_PRIOR + | KW_PRIVILEGES + | KW_PROCEDURAL + | KW_PROCEDURE + | KW_PROCEDURES + | KW_PROGRAM + | KW_PUBLICATION + | KW_QUOTE + | KW_RANGE + | KW_READ + | KW_REASSIGN + | KW_RECHECK + | KW_RECURSIVE + | KW_REF + | KW_REFERENCING + | KW_REFRESH + | KW_REINDEX + | KW_RELATIVE + | KW_RELEASE + | KW_RENAME + | KW_REPEATABLE + | KW_REPLACE + | KW_REPLICA + | KW_RESET + | KW_RESTART + | KW_RESTRICT + | KW_RETURNS + | KW_REVOKE + | KW_ROLE + | KW_ROLLBACK + | KW_ROLLUP + | KW_ROUTINE + | KW_ROUTINES + | KW_ROWS + | KW_RULE + | KW_SAVEPOINT + | KW_SCHEMA + | KW_SCHEMAS + | KW_SCROLL + | KW_SEARCH + | KW_SECOND + | KW_SECURITY + | KW_SEQUENCE + | KW_SEQUENCES + | KW_SERIALIZABLE + | KW_SERVER + | KW_SESSION + | KW_SET + | KW_SETS + | KW_SHARE + | KW_SHOW + | KW_SIMPLE + | KW_SKIP + | KW_SNAPSHOT + | KW_SQL + | KW_STABLE + | KW_STANDALONE + | KW_START + | KW_STATEMENT + | KW_STATISTICS + | KW_STDIN + | KW_STDOUT + | KW_STORAGE + | KW_STORED + | KW_STRICT + | KW_STRIP + | KW_SUBSCRIPTION + | KW_SUPPORT + | KW_SYSID + | KW_SYSTEM + | KW_TABLES + | KW_TABLESPACE + | KW_TEMP + | KW_TEMPLATE + | KW_TEMPORARY + | KW_TEXT + | KW_TIES + | KW_TRANSACTION + | KW_TRANSFORM + | KW_TRIGGER + | KW_TRUNCATE + | KW_TRUSTED + | KW_TYPE + | KW_TYPES + | KW_UESCAPE + | KW_UNBOUNDED + | KW_UNCOMMITTED + | KW_UNENCRYPTED + | KW_UNKNOWN + | KW_UNLISTEN + | KW_UNLOGGED + | KW_UNTIL + | KW_UPDATE + | KW_VACUUM + | KW_VALID + | KW_VALIDATE + | KW_VALIDATOR + | KW_VALUE + | KW_VARYING + | KW_VERSION + | KW_VIEW + | KW_VIEWS + | KW_VOLATILE + | KW_WHITESPACE + | KW_WITHIN + | KW_WITHOUT + | KW_WORK + | KW_WRAPPER + | KW_WRITE + | KW_XML + | KW_YEAR + | KW_YES + | KW_ZONE; col_name_keyword: - BETWEEN - | BIGINT + KW_BETWEEN + | KW_BIGINT | bit - | BOOLEAN_P - | CHAR_P + | KW_BOOLEAN + | KW_CHAR | character - | COALESCE - | DEC - | DECIMAL_P - | EXISTS - | EXTRACT - | FLOAT_P - | GREATEST - | GROUPING - | INOUT - | INT_P - | INTEGER - | INTERVAL - | LEAST - | NATIONAL - | NCHAR - | NONE - | NORMALIZE - | NULLIF + | KW_COALESCE + | KW_DEC + | KW_DECIMAL + | KW_EXISTS + | KW_EXTRACT + | KW_FLOAT + | KW_GREATEST + | KW_GROUPING + | KW_INOUT + | KW_INT + | KW_INTEGER + | KW_INTERVAL + | KW_LEAST + | KW_NATIONAL + | KW_NCHAR + | KW_NONE + | KW_NORMALIZE + | KW_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; + | KW_OUT + | KW_OVERLAY + | KW_POSITION + | KW_PRECISION + | KW_REAL + | KW_ROW + | KW_SETOF + | KW_SMALLINT + | KW_SUBSTRING + | KW_TIME + | KW_TIMESTAMP + | KW_TREAT + | KW_TRIM + | KW_VALUES + | KW_VARCHAR + | KW_XMLATTRIBUTES + | KW_XMLCONCAT + | KW_XMLELEMENT + | KW_XMLEXISTS + | KW_XMLFOREST + | KW_XMLNAMESPACES + | KW_XMLPARSE + | KW_XMLPI + | KW_XMLROOT + | KW_XMLSERIALIZE + | KW_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; + KW_AUTHORIZATION + | KW_BINARY + | KW_COLLATION + | KW_CONCURRENTLY + | KW_CROSS + | KW_CURRENT_SCHEMA + | KW_FREEZE + | KW_FULL + | KW_ILIKE + | KW_INNER + | KW_IS + | KW_ISNULL + | KW_JOIN + | KW_LEFT + | KW_LIKE + | KW_NATURAL + | KW_NOTNULL + | KW_OUTER + | KW_OVERLAPS + | KW_RIGHT + | KW_SIMILAR + | KW_TABLESAMPLE + | KW_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 + KW_ALL + | KW_ANALYSE + | KW_ANALYZE + | KW_AND + | KW_ANY + | KW_ARRAY + | KW_AS + | KW_ASC + | KW_ASYMMETRIC + | KW_BOTH + | KW_CASE + | KW_CAST + | KW_CHECK + | KW_COLLATE + | KW_COLUMN + | KW_CONSTRAINT + | KW_CREATE + | KW_CURRENT_CATALOG + | KW_CURRENT_DATE + | KW_CURRENT_ROLE + | KW_CURRENT_TIME + | KW_CURRENT_TIMESTAMP + | KW_CURRENT_USER + // | KW_DEFAULT + | KW_DEFERRABLE + | KW_DESC + | KW_DISTINCT + | KW_DO + | KW_ELSE + | KW_END + | KW_EXCEPT + | KW_FALSE + | KW_FETCH + | KW_FOR + | KW_FOREIGN + | KW_FROM + | KW_GRANT + | KW_GROUP + | KW_HAVING + | KW_IN + | KW_INITIALLY + | KW_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; + | KW_LATERAL + | KW_LEADING + | KW_LIMIT + | KW_LOCALTIME + | KW_LOCALTIMESTAMP + | KW_NOT + | KW_NULL + | KW_OFFSET + | KW_ON + | KW_ONLY + | KW_OR + | KW_ORDER + | KW_PLACING + | KW_PRIMARY + | KW_REFERENCES + | KW_RETURNING + | KW_SELECT + | KW_SESSION_USER + | KW_SOME + | KW_SYMMETRIC + | KW_TABLE + | KW_THEN + | KW_TO + | KW_TRAILING + | KW_TRUE + | KW_UNION + | KW_UNIQUE + | KW_USER + | KW_USING + | KW_VARIADIC + | KW_WHEN + | KW_WHERE + | KW_WINDOW + | KW_WITH; /************************************************************************************************************************************************************/ /*PL/SQL GRAMMAR */ @@ -3364,11 +3443,11 @@ reserved_keyword: 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 KW_OPTION KW_DUMP + | sharp KW_PRINT_STRICT_PARAMS option_value + | sharp KW_VARIABLE_CONFLICT KW_ERROR + | sharp KW_VARIABLE_CONFLICT KW_USE_VARIABLE + | sharp KW_VARIABLE_CONFLICT KW_USE_COLUMN; sharp: Operator; @@ -3382,26 +3461,26 @@ 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 KW_BEGIN proc_sect exception_sect KW_END opt_label; decl_sect: opt_block_label (decl_start decl_stmts?)?; -decl_start: DECLARE; +decl_start: KW_DECLARE; decl_stmts: decl_stmt+; label_decl: LESS_LESS any_identifier GREATER_GREATER; -decl_stmt: decl_statement | DECLARE | label_decl; +decl_stmt: decl_statement | KW_DECLARE | label_decl; decl_statement: decl_varname ( - ALIAS FOR decl_aliasitem + KW_ALIAS KW_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 + | opt_scrollable KW_CURSOR decl_cursor_args decl_is_for decl_cursor_query ) SEMI; -opt_scrollable: | NO SCROLL | SCROLL; +opt_scrollable: | KW_NO KW_SCROLL | KW_SCROLL; decl_cursor_query: selectstmt; @@ -3411,23 +3490,23 @@ decl_cursor_arglist: decl_cursor_arg (COMMA decl_cursor_arg)*; decl_cursor_arg: decl_varname decl_datatype; -decl_is_for: IS | FOR; +decl_is_for: KW_IS | KW_FOR; decl_aliasitem: PARAM | colid; decl_varname: any_identifier; -decl_const: | CONSTANT; +decl_const: | KW_CONSTANT; decl_datatype: typename; //TODO: $$ = read_datatype(yychar); -decl_collate: | COLLATE any_name; +decl_collate: | KW_COLLATE any_name; -decl_notnull: | NOT NULL_P; +decl_notnull: | KW_NOT KW_NULL; decl_defval: | decl_defkey sql_expression; -decl_defkey: assign_operator | DEFAULT; +decl_defkey: assign_operator | KW_DEFAULT; assign_operator: EQUAL | COLON_EQUALS; @@ -3460,20 +3539,20 @@ proc_stmt: | stmt_rollback | stmt_set; -stmt_perform: PERFORM expr_until_semi SEMI; +stmt_perform: KW_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; + KW_CALL any_identifier OPEN_PAREN opt_expr_list CLOSE_PAREN SEMI + | KW_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; + KW_GET getdiag_area_opt KW_DIAGNOSTICS getdiag_list SEMI; -getdiag_area_opt: | CURRENT_P | STACKED; +getdiag_area_opt: | KW_CURRENT | KW_STACKED; getdiag_list: getdiag_list_item (COMMA getdiag_list_item)*; @@ -3488,65 +3567,65 @@ assign_var: (any_name | PARAM) ( )*; stmt_if: - IF_P expr_until_then THEN proc_sect stmt_elsifs stmt_else END_P IF_P SEMI; + KW_IF expr_until_then KW_THEN proc_sect stmt_elsifs stmt_else KW_END KW_IF SEMI; -stmt_elsifs: (ELSIF a_expr THEN proc_sect)*; +stmt_elsifs: (KW_ELSIF a_expr KW_THEN proc_sect)*; -stmt_else: | ELSE proc_sect; +stmt_else: | KW_ELSE proc_sect; stmt_case: - CASE opt_expr_until_when case_when_list opt_case_else END_P CASE SEMI; + KW_CASE opt_expr_until_when case_when_list opt_case_else KW_END KW_CASE SEMI; opt_expr_until_when: | sql_expression; case_when_list: case_when+; -case_when: WHEN expr_list THEN proc_sect; +case_when: KW_WHEN expr_list KW_THEN proc_sect; -opt_case_else: | ELSE proc_sect; +opt_case_else: | KW_ELSE proc_sect; stmt_loop: opt_loop_label loop_body; -stmt_while: opt_loop_label WHILE expr_until_loop loop_body; +stmt_while: opt_loop_label KW_WHILE expr_until_loop loop_body; -stmt_for: opt_loop_label FOR for_control loop_body; +stmt_for: opt_loop_label KW_FOR for_control loop_body; //TODO: rewrite using read_sql_expression logic? for_control: - for_variable IN_P ( + for_variable KW_IN ( cursor_name opt_cursor_parameters | selectstmt | explainstmt - | EXECUTE a_expr opt_for_using_expression + | KW_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_for_using_expression: | KW_USING expr_list; opt_cursor_parameters: | OPEN_PAREN a_expr (COMMA a_expr)* CLOSE_PAREN; -opt_reverse: | REVERSE; +opt_reverse: | KW_REVERSE; -opt_by_expression: | BY a_expr; +opt_by_expression: | KW_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; + opt_loop_label KW_FOREACH for_variable foreach_slice KW_IN KW_ARRAY a_expr loop_body; -foreach_slice: | SLICE iconst; +foreach_slice: | KW_SLICE iconst; stmt_exit: exit_type opt_label opt_exitcond? SEMI; -exit_type: EXIT | CONTINUE_P; +exit_type: KW_EXIT | KW_CONTINUE; //todo implement RETURN statement according to initial grammar line 1754 stmt_return: - RETURN ( - NEXT sql_expression - | QUERY ( - EXECUTE a_expr opt_for_using_expression + KW_RETURN ( + KW_NEXT sql_expression + | KW_QUERY ( + KW_EXECUTE a_expr opt_for_using_expression | selectstmt ) | opt_return_result @@ -3566,23 +3645,23 @@ opt_return_result: | sql_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; + KW_RAISE opt_stmt_raise_level? sconst opt_raise_list opt_raise_using SEMI + | KW_RAISE opt_stmt_raise_level? identifier opt_raise_using SEMI + | KW_RAISE opt_stmt_raise_level? KW_SQLSTATE sconst opt_raise_using SEMI + | KW_RAISE opt_stmt_raise_level? opt_raise_using SEMI + | KW_RAISE; opt_stmt_raise_level: - DEBUG - | LOG - | INFO - | NOTICE - | WARNING - | EXCEPTION; + KW_DEBUG + | KW_LOG + | KW_INFO + | KW_NOTICE + | KW_WARNING + | KW_EXCEPTION; opt_raise_list: | (COMMA a_expr)+; -opt_raise_using: | USING opt_raise_using_elem_list; +opt_raise_using: | KW_USING opt_raise_using_elem_list; opt_raise_using_elem: identifier EQUAL a_expr; @@ -3590,11 +3669,11 @@ 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; +stmt_assert: KW_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; +loop_body: KW_LOOP proc_sect KW_END KW_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 @@ -3609,33 +3688,33 @@ stmt_execsql: //EXECUTE command-string [ INTO [STRICT] target ] [ USING expression [, ... ] ]; stmt_dynexecute: - EXECUTE a_expr ( + KW_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: | KW_USING opt_execute_using_list; opt_execute_using_list: a_expr (COMMA a_expr)*; -opt_execute_into: | INTO STRICT_P? into_target; +opt_execute_into: | KW_INTO KW_STRICT? 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 ] KW_FOR query; -//OPEN unbound_cursorvar [ [ NO ] SCROLL ] FOR EXECUTE query_string +//OPEN unbound_cursorvar [ [ NO ] SCROLL ] KW_FOR EXECUTE query_string // [ USING expression [, ... ] ]; //OPEN bound_cursorvar [ ( [ argument_name := ] argument_value [, ...] ) ]; stmt_open: - OPEN ( - cursor_variable opt_scroll_option FOR ( + KW_OPEN ( + cursor_variable opt_scroll_option KW_FOR ( selectstmt - | EXECUTE sql_expression opt_open_using + | KW_EXECUTE sql_expression opt_open_using ) | colid (OPEN_PAREN opt_open_bound_list CLOSE_PAREN)? ) SEMI; @@ -3645,63 +3724,63 @@ 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_open_using: | KW_USING expr_list; -opt_scroll_option: | opt_scroll_option_no SCROLL; +opt_scroll_option: | opt_scroll_option_no KW_SCROLL; -opt_scroll_option_no: | NO; +opt_scroll_option_no: | KW_NO; //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING -//FETCH [ direction { FROM | IN } ] cursor INTO target; +//FETCH [ direction { KW_FROM | IN } ] cursor INTO target; stmt_fetch: - FETCH direction = opt_fetch_direction? opt_cursor_from cursor_variable INTO into_target SEMI; + KW_FETCH direction = opt_fetch_direction? opt_cursor_from cursor_variable KW_INTO into_target SEMI; into_target: expr_list; -opt_cursor_from: | FROM | IN_P; +opt_cursor_from: | KW_FROM | KW_IN; opt_fetch_direction: - NEXT - | PRIOR - | FIRST_P - | LAST_P - | ABSOLUTE_P a_expr - | RELATIVE_P a_expr + KW_NEXT + | KW_PRIOR + | KW_FIRST + | KW_LAST + | KW_ABSOLUTE a_expr + | KW_RELATIVE a_expr | a_expr - | ALL - | (FORWARD | BACKWARD) (a_expr | ALL)?; + | KW_ALL + | (KW_FORWARD | KW_BACKWARD) (a_expr | KW_ALL)?; //https://www.postgresql.org/docs/current/plpgsql-cursors.html#PLPGSQL-CURSOR-OPENING -//MOVE [ direction { FROM | IN } ] cursor; +//MOVE [ direction { KW_FROM | IN } ] cursor; -stmt_move: MOVE opt_fetch_direction? cursor_variable SEMI; +stmt_move: KW_MOVE opt_fetch_direction? cursor_variable SEMI; -stmt_close: CLOSE cursor_variable SEMI; +stmt_close: KW_CLOSE cursor_variable SEMI; -stmt_null: NULL_P SEMI; +stmt_null: KW_NULL SEMI; -stmt_commit: COMMIT plsql_opt_transaction_chain? SEMI; +stmt_commit: KW_COMMIT plsql_opt_transaction_chain? SEMI; -stmt_rollback: ROLLBACK plsql_opt_transaction_chain? SEMI; +stmt_rollback: KW_ROLLBACK plsql_opt_transaction_chain? SEMI; -plsql_opt_transaction_chain: AND NO? CHAIN; +plsql_opt_transaction_chain: KW_AND KW_NO? KW_CHAIN; stmt_set: - SET any_name TO DEFAULT SEMI - | RESET (any_name | ALL) SEMI; + KW_SET any_name KW_TO KW_DEFAULT SEMI + | KW_RESET (any_name | KW_ALL) SEMI; cursor_variable: colid | PARAM; -exception_sect: | EXCEPTION proc_exceptions; +exception_sect: | KW_EXCEPTION proc_exceptions; proc_exceptions: proc_exception+; -proc_exception: WHEN proc_conditions THEN proc_sect; +proc_exception: KW_WHEN proc_conditions KW_THEN proc_sect; -proc_conditions: proc_condition (OR proc_condition)*; +proc_conditions: proc_condition (KW_OR proc_condition)*; -proc_condition: any_identifier | SQLSTATE sconst; +proc_condition: any_identifier | KW_SQLSTATE sconst; //expr_until_semi: //; @@ -3720,64 +3799,64 @@ opt_loop_label: | label_decl; opt_label: | any_identifier; -opt_exitcond: WHEN expr_until_semi; +opt_exitcond: KW_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 + KW_ABSOLUTE + | KW_ALIAS + | KW_AND + | KW_ARRAY + | KW_ASSERT + | KW_BACKWARD + | KW_CALL + | KW_CHAIN + | KW_CLOSE + | KW_COLLATE + | KW_COLUMN //| COLUMN_NAME - | COMMIT - | CONSTANT - | CONSTRAINT + | KW_COMMIT + | KW_CONSTANT + | KW_CONSTRAINT //| CONSTRAINT_NAME - | CONTINUE_P - | CURRENT_P - | CURSOR + | KW_CONTINUE + | KW_CURRENT + | KW_CURSOR //| DATATYPE - | DEBUG - | DEFAULT + | KW_DEBUG + | KW_DEFAULT //| DETAIL - | DIAGNOSTICS - | DO - | DUMP - | ELSIF + | KW_DIAGNOSTICS + | KW_DO + | KW_DUMP + | KW_ELSIF //| ERRCODE - | ERROR - | EXCEPTION - | EXIT - | FETCH - | FIRST_P - | FORWARD - | GET + | KW_ERROR + | KW_EXCEPTION + | KW_EXIT + | KW_FETCH + | KW_FIRST + | KW_FORWARD + | KW_GET //| HINT //| IMPORT - | INFO - | INSERT - | IS - | LAST_P - | LOG + | KW_INFO + | KW_INSERT + | KW_IS + | KW_LAST + | KW_LOG //| MESSAGE //| MESSAGE_TEXT - | MOVE - | NEXT - | NO - | NOTICE - | OPEN - | OPTION - | PERFORM + | KW_MOVE + | KW_NEXT + | KW_NO + | KW_NOTICE + | KW_OPEN + | KW_OPTION + | KW_PERFORM //| PG_CONTEXT //| PG_DATATYPE_NAME @@ -3787,33 +3866,33 @@ plsql_unreserved_keyword: //| PG_EXCEPTION_DETAIL //| PG_EXCEPTION_HINT - | PRINT_STRICT_PARAMS - | PRIOR - | QUERY - | RAISE - | RELATIVE_P - | RESET - | RETURN + | KW_PRINT_STRICT_PARAMS + | KW_PRIOR + | KW_QUERY + | KW_RAISE + | KW_RELATIVE + | KW_RESET + | KW_RETURN //| RETURNED_SQLSTATE - | REVERSE - | ROLLBACK + | KW_REVERSE + | KW_ROLLBACK //| ROW_COUNT - | ROWTYPE - | SCHEMA + | KW_ROWTYPE + | KW_SCHEMA //| SCHEMA_NAME - | SCROLL - | SET - | SLICE - | SQLSTATE - | STACKED - | TABLE + | KW_SCROLL + | KW_SET + | KW_SLICE + | KW_SQLSTATE + | KW_STACKED + | KW_TABLE //| TABLE_NAME - | TYPE_P - | USE_COLUMN - | USE_VARIABLE - | VARIABLE_CONFLICT - | WARNING - | OUTER_P; + | KW_TYPE + | KW_USE_COLUMN + | KW_USE_VARIABLE + | KW_VARIABLE_CONFLICT + | KW_WARNING + | KW_OUTER; sql_expression: opt_target_list? into_clause? from_clause? where_clause? group_clause? having_clause? @@ -3829,4 +3908,4 @@ expr_until_loop: a_expr; make_execsql_stmt: stmt opt_returning_clause_into?; -opt_returning_clause_into: INTO opt_strict into_target; +opt_returning_clause_into: KW_INTO opt_strict into_target; diff --git a/src/lib/pgsql/PostgreSQLLexer.interp b/src/lib/pgsql/PostgreSQLLexer.interp index 8baaa6b..891881f 100644 --- a/src/lib/pgsql/PostgreSQLLexer.interp +++ b/src/lib/pgsql/PostgreSQLLexer.interp @@ -228,6 +228,15 @@ null 'INDEX' 'INDEXES' 'INHERIT' +'NOINHERIT' +'SUPERUSER' +'NOSUPERUSER' +'CREATEDB' +'NOCREATEDB' +'CREATEROLE' +'NOCREATEROLE' +'CREATEUSER' +'NOCREATEUSER' 'INHERITS' 'INLINE' 'INSENSITIVE' @@ -511,6 +520,10 @@ null 'ASSERT' 'LOOP' 'OPEN' +'PEFERENCES' +'USAGE' +'CONNECT' +'PUBLIC' null null null @@ -585,488 +598,501 @@ 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 +KW_ALL +KW_ANALYSE +KW_ANALYZE +KW_AND +KW_ANY +KW_ARRAY +KW_AS +KW_ASC +KW_ASYMMETRIC +KW_BOTH +KW_CASE +KW_CAST +KW_CHECK +KW_COLLATE +KW_COLUMN +KW_CONSTRAINT +KW_CREATE +KW_CURRENT_CATALOG +KW_CURRENT_DATE +KW_CURRENT_ROLE +KW_CURRENT_TIME +KW_CURRENT_TIMESTAMP +KW_CURRENT_USER +KW_DEFAULT +KW_DEFERRABLE +KW_DESC +KW_DISTINCT +KW_DO +KW_ELSE +KW_EXCEPT +KW_FALSE +KW_FETCH +KW_FOR +KW_FOREIGN +KW_FROM +KW_GRANT +KW_GROUP +KW_HAVING +KW_IN +KW_INITIALLY +KW_INTERSECT +KW_INTO +KW_LATERAL +KW_LEADING +KW_LIMIT +KW_LOCALTIME +KW_LOCALTIMESTAMP +KW_NOT +KW_NULL +KW_OFFSET +KW_ON +KW_ONLY +KW_OR +KW_ORDER +KW_PLACING +KW_PRIMARY +KW_REFERENCES +KW_RETURNING +KW_SELECT +KW_SESSION_USER +KW_SOME +KW_SYMMETRIC +KW_TABLE +KW_THEN +KW_TO +KW_TRAILING +KW_TRUE +KW_UNION +KW_UNIQUE +KW_USER +KW_USING +KW_VARIADIC +KW_WHEN +KW_WHERE +KW_WINDOW +KW_WITH +KW_AUTHORIZATION +KW_BINARY +KW_COLLATION +KW_CONCURRENTLY +KW_CROSS +KW_CURRENT_SCHEMA +KW_FREEZE +KW_FULL +KW_ILIKE +KW_INNER +KW_IS +KW_ISNULL +KW_JOIN +KW_LEFT +KW_LIKE +KW_NATURAL +KW_NOTNULL +KW_OUTER +KW_OVER +KW_OVERLAPS +KW_RIGHT +KW_SIMILAR +KW_VERBOSE +KW_ABORT +KW_ABSOLUTE +KW_ACCESS +KW_ACTION +KW_ADD +KW_ADMIN +KW_AFTER +KW_AGGREGATE +KW_ALSO +KW_ALTER +KW_ALWAYS +KW_ASSERTION +KW_ASSIGNMENT +KW_AT +KW_ATTRIBUTE +KW_BACKWARD +KW_BEFORE +KW_BEGIN +KW_BY +KW_CACHE +KW_CALLED +KW_CASCADE +KW_CASCADED +KW_CATALOG +KW_CHAIN +KW_CHARACTERISTICS +KW_CHECKPOINT +KW_CLASS +KW_CLOSE +KW_CLUSTER +KW_COMMENT +KW_COMMENTS +KW_COMMIT +KW_COMMITTED +KW_CONFIGURATION +KW_CONNECTION +KW_CONSTRAINTS +KW_CONTENT +KW_CONTINUE +KW_CONVERSION +KW_COPY +KW_COST +KW_CSV +KW_CURSOR +KW_CYCLE +KW_DATA +KW_DATABASE +KW_DAY +KW_DEALLOCATE +KW_DECLARE +KW_DEFAULTS +KW_DEFERRED +KW_DEFINER +KW_DELETE +KW_DELIMITER +KW_DELIMITERS +KW_DICTIONARY +KW_DISABLE +KW_DISCARD +KW_DOCUMENT +KW_DOMAIN +KW_DOUBLE +KW_DROP +KW_EACH +KW_ENABLE +KW_ENCODING +KW_ENCRYPTED +KW_ENUM +KW_ESCAPE +KW_EVENT +KW_EXCLUDE +KW_EXCLUDING +KW_EXCLUSIVE +KW_EXECUTE +KW_EXPLAIN +KW_EXTENSION +KW_EXTERNAL +KW_FAMILY +KW_FIRST +KW_FOLLOWING +KW_FORCE +KW_FORWARD +KW_FUNCTION +KW_FUNCTIONS +KW_GLOBAL +KW_GRANTED +KW_HANDLER +KW_HEADER +KW_HOLD +KW_HOUR +KW_IDENTITY +KW_IF +KW_IMMEDIATE +KW_IMMUTABLE +KW_IMPLICIT +KW_INCLUDING +KW_INCREMENT +KW_INDEX +KW_INDEXES +KW_INHERIT +KW_NOINHERIT +KW_SUPERUSER +KW_NOSUPERUSER +KW_CREATEDB +KW_NOCREATEDB +KW_CREATEROLE +KW_NOCREATEROLE +KW_CREATEUSER +KW_NOCREATEUSER +KW_INHERITS +KW_INLINE +KW_INSENSITIVE +KW_INSERT +KW_INSTEAD +KW_INVOKER +KW_ISOLATION +KW_KEY +KW_LABEL +KW_LANGUAGE +KW_LARGE +KW_LAST +KW_LEAKPROOF +KW_LEVEL +KW_LISTEN +KW_LOAD +KW_LOCAL +KW_LOCATION +KW_LOCK +KW_MAPPING +KW_MATCH +KW_MATERIALIZED +KW_MAXVALUE +KW_MINUTE +KW_MINVALUE +KW_MODE +KW_MONTH +KW_MOVE +KW_NAME +KW_NAMES +KW_NEXT +KW_NO +KW_NOTHING +KW_NOTIFY +KW_NOWAIT +KW_NULLS +KW_OBJECT +KW_OF +KW_OFF +KW_OIDS +KW_OPERATOR +KW_OPTION +KW_OPTIONS +KW_OWNED +KW_OWNER +KW_PARSER +KW_PARTIAL +KW_PARTITION +KW_PASSING +KW_PASSWORD +KW_PLANS +KW_PRECEDING +KW_PREPARE +KW_PREPARED +KW_PRESERVE +KW_PRIOR +KW_PRIVILEGES +KW_PROCEDURAL +KW_PROCEDURE +KW_PROGRAM +KW_QUOTE +KW_RANGE +KW_READ +KW_REASSIGN +KW_RECHECK +KW_RECURSIVE +KW_REF +KW_REFRESH +KW_REINDEX +KW_RELATIVE +KW_RELEASE +KW_RENAME +KW_REPEATABLE +KW_REPLACE +KW_REPLICA +KW_RESET +KW_RESTART +KW_RESTRICT +KW_RETURNS +KW_REVOKE +KW_ROLE +KW_ROLLBACK +KW_ROWS +KW_RULE +KW_SAVEPOINT +KW_SCHEMA +KW_SCROLL +KW_SEARCH +KW_SECOND +KW_SECURITY +KW_SEQUENCE +KW_SEQUENCES +KW_SERIALIZABLE +KW_SERVER +KW_SESSION +KW_SET +KW_SHARE +KW_SHOW +KW_SIMPLE +KW_SNAPSHOT +KW_STABLE +KW_STANDALONE +KW_START +KW_STATEMENT +KW_STATISTICS +KW_STDIN +KW_STDOUT +KW_STORAGE +KW_STRICT +KW_STRIP +KW_SYSID +KW_SYSTEM +KW_TABLES +KW_TABLESPACE +KW_TEMP +KW_TEMPLATE +KW_TEMPORARY +KW_TEXT +KW_TRANSACTION +KW_TRIGGER +KW_TRUNCATE +KW_TRUSTED +KW_TYPE +KW_TYPES +KW_UNBOUNDED +KW_UNCOMMITTED +KW_UNENCRYPTED +KW_UNKNOWN +KW_UNLISTEN +KW_UNLOGGED +KW_UNTIL +KW_UPDATE +KW_VACUUM +KW_VALID +KW_VALIDATE +KW_VALIDATOR +KW_VARYING +KW_VERSION +KW_VIEW +KW_VOLATILE +KW_WHITESPACE +KW_WITHOUT +KW_WORK +KW_WRAPPER +KW_WRITE +KW_XML +KW_YEAR +KW_YES +KW_ZONE +KW_BETWEEN +KW_BIGINT +KW_BIT +KW_BOOLEAN +KW_CHAR +KW_CHARACTER +KW_COALESCE +KW_DEC +KW_DECIMAL +KW_EXISTS +KW_EXTRACT +KW_FLOAT +KW_GREATEST +KW_INOUT +KW_INT +KW_INTEGER +KW_INTERVAL +KW_LEAST +KW_NATIONAL +KW_NCHAR +KW_NONE +KW_NULLIF +KW_NUMERIC +KW_OVERLAY +KW_POSITION +KW_PRECISION +KW_REAL +KW_ROW +KW_SETOF +KW_SMALLINT +KW_SUBSTRING +KW_TIME +KW_TIMESTAMP +KW_TREAT +KW_TRIM +KW_VALUES +KW_VARCHAR +KW_XMLATTRIBUTES +KW_XMLCONCAT +KW_XMLELEMENT +KW_XMLEXISTS +KW_XMLFOREST +KW_XMLPARSE +KW_XMLPI +KW_XMLROOT +KW_XMLSERIALIZE +KW_CALL +KW_CURRENT +KW_ATTACH +KW_DETACH +KW_EXPRESSION +KW_GENERATED +KW_LOGGED +KW_STORED +KW_INCLUDE +KW_ROUTINE +KW_TRANSFORM +KW_IMPORT +KW_POLICY +KW_METHOD +KW_REFERENCING +KW_NEW +KW_OLD +KW_VALUE +KW_SUBSCRIPTION +KW_PUBLICATION +KW_OUT +KW_END +KW_ROUTINES +KW_SCHEMAS +KW_PROCEDURES +KW_INPUT +KW_SUPPORT +KW_PARALLEL +KW_SQL +KW_DEPENDS +KW_OVERRIDING +KW_CONFLICT +KW_SKIP +KW_LOCKED +KW_TIES +KW_ROLLUP +KW_CUBE +KW_GROUPING +KW_SETS +KW_TABLESAMPLE +KW_ORDINALITY +KW_XMLTABLE +KW_COLUMNS +KW_XMLNAMESPACES +KW_ROWTYPE +KW_NORMALIZED +KW_WITHIN +KW_FILTER +KW_GROUPS +KW_OTHERS +KW_NFC +KW_NFD +KW_NFKC +KW_NFKD +KW_UESCAPE +KW_VIEWS +KW_NORMALIZE +KW_DUMP +KW_PRINT_STRICT_PARAMS +KW_VARIABLE_CONFLICT +KW_ERROR +KW_USE_VARIABLE +KW_USE_COLUMN +KW_ALIAS +KW_CONSTANT +KW_PERFORM +KW_GET +KW_DIAGNOSTICS +KW_STACKED +KW_ELSIF +KW_WHILE +KW_REVERSE +KW_FOREACH +KW_SLICE +KW_EXIT +KW_RETURN +KW_QUERY +KW_RAISE +KW_SQLSTATE +KW_DEBUG +KW_LOG +KW_INFO +KW_NOTICE +KW_WARNING +KW_EXCEPTION +KW_ASSERT +KW_LOOP +KW_OPEN +KW_PEFERENCES +KW_USAGE +KW_CONNECT +KW_PUBLIC Identifier QuotedIdentifier UnterminatedQuotedIdentifier @@ -1144,488 +1170,501 @@ 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 +KW_ALL +KW_ANALYSE +KW_ANALYZE +KW_AND +KW_ANY +KW_ARRAY +KW_AS +KW_ASC +KW_ASYMMETRIC +KW_BOTH +KW_CASE +KW_CAST +KW_CHECK +KW_COLLATE +KW_COLUMN +KW_CONSTRAINT +KW_CREATE +KW_CURRENT_CATALOG +KW_CURRENT_DATE +KW_CURRENT_ROLE +KW_CURRENT_TIME +KW_CURRENT_TIMESTAMP +KW_CURRENT_USER +KW_DEFAULT +KW_DEFERRABLE +KW_DESC +KW_DISTINCT +KW_DO +KW_ELSE +KW_EXCEPT +KW_FALSE +KW_FETCH +KW_FOR +KW_FOREIGN +KW_FROM +KW_GRANT +KW_GROUP +KW_HAVING +KW_IN +KW_INITIALLY +KW_INTERSECT +KW_INTO +KW_LATERAL +KW_LEADING +KW_LIMIT +KW_LOCALTIME +KW_LOCALTIMESTAMP +KW_NOT +KW_NULL +KW_OFFSET +KW_ON +KW_ONLY +KW_OR +KW_ORDER +KW_PLACING +KW_PRIMARY +KW_REFERENCES +KW_RETURNING +KW_SELECT +KW_SESSION_USER +KW_SOME +KW_SYMMETRIC +KW_TABLE +KW_THEN +KW_TO +KW_TRAILING +KW_TRUE +KW_UNION +KW_UNIQUE +KW_USER +KW_USING +KW_VARIADIC +KW_WHEN +KW_WHERE +KW_WINDOW +KW_WITH +KW_AUTHORIZATION +KW_BINARY +KW_COLLATION +KW_CONCURRENTLY +KW_CROSS +KW_CURRENT_SCHEMA +KW_FREEZE +KW_FULL +KW_ILIKE +KW_INNER +KW_IS +KW_ISNULL +KW_JOIN +KW_LEFT +KW_LIKE +KW_NATURAL +KW_NOTNULL +KW_OUTER +KW_OVER +KW_OVERLAPS +KW_RIGHT +KW_SIMILAR +KW_VERBOSE +KW_ABORT +KW_ABSOLUTE +KW_ACCESS +KW_ACTION +KW_ADD +KW_ADMIN +KW_AFTER +KW_AGGREGATE +KW_ALSO +KW_ALTER +KW_ALWAYS +KW_ASSERTION +KW_ASSIGNMENT +KW_AT +KW_ATTRIBUTE +KW_BACKWARD +KW_BEFORE +KW_BEGIN +KW_BY +KW_CACHE +KW_CALLED +KW_CASCADE +KW_CASCADED +KW_CATALOG +KW_CHAIN +KW_CHARACTERISTICS +KW_CHECKPOINT +KW_CLASS +KW_CLOSE +KW_CLUSTER +KW_COMMENT +KW_COMMENTS +KW_COMMIT +KW_COMMITTED +KW_CONFIGURATION +KW_CONNECTION +KW_CONSTRAINTS +KW_CONTENT +KW_CONTINUE +KW_CONVERSION +KW_COPY +KW_COST +KW_CSV +KW_CURSOR +KW_CYCLE +KW_DATA +KW_DATABASE +KW_DAY +KW_DEALLOCATE +KW_DECLARE +KW_DEFAULTS +KW_DEFERRED +KW_DEFINER +KW_DELETE +KW_DELIMITER +KW_DELIMITERS +KW_DICTIONARY +KW_DISABLE +KW_DISCARD +KW_DOCUMENT +KW_DOMAIN +KW_DOUBLE +KW_DROP +KW_EACH +KW_ENABLE +KW_ENCODING +KW_ENCRYPTED +KW_ENUM +KW_ESCAPE +KW_EVENT +KW_EXCLUDE +KW_EXCLUDING +KW_EXCLUSIVE +KW_EXECUTE +KW_EXPLAIN +KW_EXTENSION +KW_EXTERNAL +KW_FAMILY +KW_FIRST +KW_FOLLOWING +KW_FORCE +KW_FORWARD +KW_FUNCTION +KW_FUNCTIONS +KW_GLOBAL +KW_GRANTED +KW_HANDLER +KW_HEADER +KW_HOLD +KW_HOUR +KW_IDENTITY +KW_IF +KW_IMMEDIATE +KW_IMMUTABLE +KW_IMPLICIT +KW_INCLUDING +KW_INCREMENT +KW_INDEX +KW_INDEXES +KW_INHERIT +KW_NOINHERIT +KW_SUPERUSER +KW_NOSUPERUSER +KW_CREATEDB +KW_NOCREATEDB +KW_CREATEROLE +KW_NOCREATEROLE +KW_CREATEUSER +KW_NOCREATEUSER +KW_INHERITS +KW_INLINE +KW_INSENSITIVE +KW_INSERT +KW_INSTEAD +KW_INVOKER +KW_ISOLATION +KW_KEY +KW_LABEL +KW_LANGUAGE +KW_LARGE +KW_LAST +KW_LEAKPROOF +KW_LEVEL +KW_LISTEN +KW_LOAD +KW_LOCAL +KW_LOCATION +KW_LOCK +KW_MAPPING +KW_MATCH +KW_MATERIALIZED +KW_MAXVALUE +KW_MINUTE +KW_MINVALUE +KW_MODE +KW_MONTH +KW_MOVE +KW_NAME +KW_NAMES +KW_NEXT +KW_NO +KW_NOTHING +KW_NOTIFY +KW_NOWAIT +KW_NULLS +KW_OBJECT +KW_OF +KW_OFF +KW_OIDS +KW_OPERATOR +KW_OPTION +KW_OPTIONS +KW_OWNED +KW_OWNER +KW_PARSER +KW_PARTIAL +KW_PARTITION +KW_PASSING +KW_PASSWORD +KW_PLANS +KW_PRECEDING +KW_PREPARE +KW_PREPARED +KW_PRESERVE +KW_PRIOR +KW_PRIVILEGES +KW_PROCEDURAL +KW_PROCEDURE +KW_PROGRAM +KW_QUOTE +KW_RANGE +KW_READ +KW_REASSIGN +KW_RECHECK +KW_RECURSIVE +KW_REF +KW_REFRESH +KW_REINDEX +KW_RELATIVE +KW_RELEASE +KW_RENAME +KW_REPEATABLE +KW_REPLACE +KW_REPLICA +KW_RESET +KW_RESTART +KW_RESTRICT +KW_RETURNS +KW_REVOKE +KW_ROLE +KW_ROLLBACK +KW_ROWS +KW_RULE +KW_SAVEPOINT +KW_SCHEMA +KW_SCROLL +KW_SEARCH +KW_SECOND +KW_SECURITY +KW_SEQUENCE +KW_SEQUENCES +KW_SERIALIZABLE +KW_SERVER +KW_SESSION +KW_SET +KW_SHARE +KW_SHOW +KW_SIMPLE +KW_SNAPSHOT +KW_STABLE +KW_STANDALONE +KW_START +KW_STATEMENT +KW_STATISTICS +KW_STDIN +KW_STDOUT +KW_STORAGE +KW_STRICT +KW_STRIP +KW_SYSID +KW_SYSTEM +KW_TABLES +KW_TABLESPACE +KW_TEMP +KW_TEMPLATE +KW_TEMPORARY +KW_TEXT +KW_TRANSACTION +KW_TRIGGER +KW_TRUNCATE +KW_TRUSTED +KW_TYPE +KW_TYPES +KW_UNBOUNDED +KW_UNCOMMITTED +KW_UNENCRYPTED +KW_UNKNOWN +KW_UNLISTEN +KW_UNLOGGED +KW_UNTIL +KW_UPDATE +KW_VACUUM +KW_VALID +KW_VALIDATE +KW_VALIDATOR +KW_VARYING +KW_VERSION +KW_VIEW +KW_VOLATILE +KW_WHITESPACE +KW_WITHOUT +KW_WORK +KW_WRAPPER +KW_WRITE +KW_XML +KW_YEAR +KW_YES +KW_ZONE +KW_BETWEEN +KW_BIGINT +KW_BIT +KW_BOOLEAN +KW_CHAR +KW_CHARACTER +KW_COALESCE +KW_DEC +KW_DECIMAL +KW_EXISTS +KW_EXTRACT +KW_FLOAT +KW_GREATEST +KW_INOUT +KW_INT +KW_INTEGER +KW_INTERVAL +KW_LEAST +KW_NATIONAL +KW_NCHAR +KW_NONE +KW_NULLIF +KW_NUMERIC +KW_OVERLAY +KW_POSITION +KW_PRECISION +KW_REAL +KW_ROW +KW_SETOF +KW_SMALLINT +KW_SUBSTRING +KW_TIME +KW_TIMESTAMP +KW_TREAT +KW_TRIM +KW_VALUES +KW_VARCHAR +KW_XMLATTRIBUTES +KW_XMLCONCAT +KW_XMLELEMENT +KW_XMLEXISTS +KW_XMLFOREST +KW_XMLPARSE +KW_XMLPI +KW_XMLROOT +KW_XMLSERIALIZE +KW_CALL +KW_CURRENT +KW_ATTACH +KW_DETACH +KW_EXPRESSION +KW_GENERATED +KW_LOGGED +KW_STORED +KW_INCLUDE +KW_ROUTINE +KW_TRANSFORM +KW_IMPORT +KW_POLICY +KW_METHOD +KW_REFERENCING +KW_NEW +KW_OLD +KW_VALUE +KW_SUBSCRIPTION +KW_PUBLICATION +KW_OUT +KW_END +KW_ROUTINES +KW_SCHEMAS +KW_PROCEDURES +KW_INPUT +KW_SUPPORT +KW_PARALLEL +KW_SQL +KW_DEPENDS +KW_OVERRIDING +KW_CONFLICT +KW_SKIP +KW_LOCKED +KW_TIES +KW_ROLLUP +KW_CUBE +KW_GROUPING +KW_SETS +KW_TABLESAMPLE +KW_ORDINALITY +KW_XMLTABLE +KW_COLUMNS +KW_XMLNAMESPACES +KW_ROWTYPE +KW_NORMALIZED +KW_WITHIN +KW_FILTER +KW_GROUPS +KW_OTHERS +KW_NFC +KW_NFD +KW_NFKC +KW_NFKD +KW_UESCAPE +KW_VIEWS +KW_NORMALIZE +KW_DUMP +KW_PRINT_STRICT_PARAMS +KW_VARIABLE_CONFLICT +KW_ERROR +KW_USE_VARIABLE +KW_USE_COLUMN +KW_ALIAS +KW_CONSTANT +KW_PERFORM +KW_GET +KW_DIAGNOSTICS +KW_STACKED +KW_ELSIF +KW_WHILE +KW_REVERSE +KW_FOREACH +KW_SLICE +KW_EXIT +KW_RETURN +KW_QUERY +KW_RAISE +KW_SQLSTATE +KW_DEBUG +KW_LOG +KW_INFO +KW_NOTICE +KW_WARNING +KW_EXCEPTION +KW_ASSERT +KW_LOOP +KW_OPEN +KW_PEFERENCES +KW_USAGE +KW_CONNECT +KW_PUBLIC Identifier IdentifierStartChar IdentifierChar @@ -1693,4 +1732,4 @@ AfterEscapeStringConstantWithNewlineMode DollarQuotedStringMode atn: -[3, 51485, 51898, 1421, 44986, 20307, 1543, 60043, 49729, 2, 555, 5392, 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, 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, 1211, 10, 29, 13, 29, 14, 29, 1212, 3, 30, 3, 30, 3, 30, 3, 30, 6, 30, 1219, 10, 30, 13, 30, 14, 30, 1220, 3, 30, 3, 30, 3, 30, 5, 30, 1226, 10, 30, 3, 30, 3, 30, 6, 30, 1230, 10, 30, 13, 30, 14, 30, 1231, 3, 30, 5, 30, 1235, 10, 30, 3, 30, 3, 30, 3, 31, 3, 31, 3, 31, 3, 31, 3, 31, 7, 31, 1244, 10, 31, 12, 31, 14, 31, 1247, 11, 31, 3, 31, 3, 31, 5, 31, 1251, 10, 31, 3, 31, 3, 31, 3, 31, 6, 31, 1256, 10, 31, 13, 31, 14, 31, 1257, 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, 4934, 10, 517, 12, 517, 14, 517, 4937, 11, 517, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 3, 518, 5, 518, 4945, 10, 518, 3, 519, 3, 519, 5, 519, 4949, 10, 519, 3, 520, 3, 520, 5, 520, 4953, 10, 520, 3, 521, 3, 521, 3, 521, 3, 522, 3, 522, 3, 522, 3, 522, 7, 522, 4962, 10, 522, 12, 522, 14, 522, 4965, 11, 522, 3, 523, 3, 523, 3, 523, 3, 524, 3, 524, 3, 524, 3, 524, 7, 524, 4974, 10, 524, 12, 524, 14, 524, 4977, 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, 5002, 10, 530, 12, 530, 14, 530, 5005, 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, 5022, 10, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 535, 3, 535, 7, 535, 5031, 10, 535, 12, 535, 14, 535, 5034, 11, 535, 3, 536, 3, 536, 3, 536, 3, 537, 3, 537, 3, 537, 7, 537, 5042, 10, 537, 12, 537, 14, 537, 5045, 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, 5059, 10, 541, 12, 541, 14, 541, 5062, 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, 5081, 10, 546, 3, 546, 3, 546, 5, 546, 5085, 10, 546, 3, 546, 5, 546, 5088, 10, 546, 3, 546, 3, 546, 3, 546, 3, 546, 5, 546, 5094, 10, 546, 3, 546, 5, 546, 5097, 10, 546, 3, 546, 3, 546, 3, 546, 5, 546, 5102, 10, 546, 3, 546, 3, 546, 5, 546, 5106, 10, 546, 3, 547, 6, 547, 5109, 10, 547, 13, 547, 14, 547, 5110, 3, 548, 3, 548, 3, 548, 7, 548, 5116, 10, 548, 12, 548, 14, 548, 5119, 11, 548, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 3, 549, 7, 549, 5129, 10, 549, 12, 549, 14, 549, 5132, 11, 549, 3, 549, 3, 549, 3, 550, 6, 550, 5137, 10, 550, 13, 550, 14, 550, 5138, 3, 550, 3, 550, 3, 551, 3, 551, 5, 551, 5145, 10, 551, 3, 551, 5, 551, 5148, 10, 551, 3, 551, 3, 551, 3, 552, 3, 552, 3, 552, 3, 552, 7, 552, 5156, 10, 552, 12, 552, 14, 552, 5159, 11, 552, 3, 552, 3, 552, 3, 553, 3, 553, 3, 553, 3, 553, 7, 553, 5167, 10, 553, 12, 553, 14, 553, 5170, 11, 553, 3, 553, 3, 553, 3, 553, 6, 553, 5175, 10, 553, 13, 553, 14, 553, 5176, 3, 553, 3, 553, 6, 553, 5181, 10, 553, 13, 553, 14, 553, 5182, 3, 553, 7, 553, 5186, 10, 553, 12, 553, 14, 553, 5189, 11, 553, 3, 553, 7, 553, 5192, 10, 553, 12, 553, 14, 553, 5195, 11, 553, 3, 553, 3, 553, 3, 553, 3, 553, 3, 553, 3, 554, 3, 554, 3, 554, 3, 554, 7, 554, 5206, 10, 554, 12, 554, 14, 554, 5209, 11, 554, 3, 554, 3, 554, 3, 554, 6, 554, 5214, 10, 554, 13, 554, 14, 554, 5215, 3, 554, 3, 554, 6, 554, 5220, 10, 554, 13, 554, 14, 554, 5221, 3, 554, 5, 554, 5225, 10, 554, 7, 554, 5227, 10, 554, 12, 554, 14, 554, 5230, 11, 554, 3, 554, 6, 554, 5233, 10, 554, 13, 554, 14, 554, 5234, 3, 554, 6, 554, 5238, 10, 554, 13, 554, 14, 554, 5239, 3, 554, 7, 554, 5243, 10, 554, 12, 554, 14, 554, 5246, 11, 554, 3, 554, 5, 554, 5249, 10, 554, 3, 554, 3, 554, 3, 555, 3, 555, 3, 555, 3, 555, 7, 555, 5257, 10, 555, 12, 555, 14, 555, 5260, 11, 555, 3, 555, 7, 555, 5263, 10, 555, 12, 555, 14, 555, 5266, 11, 555, 3, 555, 3, 555, 7, 555, 5270, 10, 555, 12, 555, 14, 555, 5273, 11, 555, 5, 555, 5275, 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, 5289, 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, 5313, 10, 560, 3, 560, 7, 560, 5316, 10, 560, 12, 560, 14, 560, 5319, 11, 560, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 3, 562, 3, 562, 5, 562, 5328, 10, 562, 3, 562, 3, 562, 3, 563, 3, 563, 3, 563, 3, 563, 3, 563, 7, 563, 5337, 10, 563, 12, 563, 14, 563, 5340, 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, 6, 569, 5369, 10, 569, 13, 569, 14, 569, 5370, 3, 569, 3, 569, 7, 569, 5375, 10, 569, 12, 569, 14, 569, 5378, 11, 569, 5, 569, 5380, 10, 569, 3, 570, 3, 570, 5, 570, 5384, 10, 570, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 3, 570, 2, 2, 2, 571, 7, 2, 3, 9, 2, 4, 11, 2, 5, 13, 2, 6, 15, 2, 7, 17, 2, 8, 19, 2, 9, 21, 2, 10, 23, 2, 11, 25, 2, 12, 27, 2, 13, 29, 2, 14, 31, 2, 15, 33, 2, 16, 35, 2, 17, 37, 2, 18, 39, 2, 19, 41, 2, 20, 43, 2, 21, 45, 2, 22, 47, 2, 23, 49, 2, 24, 51, 2, 25, 53, 2, 26, 55, 2, 27, 57, 2, 28, 59, 2, 29, 61, 2, 30, 63, 2, 31, 65, 2, 2, 67, 2, 2, 69, 2, 2, 71, 2, 2, 73, 2, 32, 75, 2, 33, 77, 2, 34, 79, 2, 35, 81, 2, 36, 83, 2, 37, 85, 2, 38, 87, 2, 39, 89, 2, 40, 91, 2, 41, 93, 2, 42, 95, 2, 43, 97, 2, 44, 99, 2, 45, 101, 2, 46, 103, 2, 47, 105, 2, 48, 107, 2, 49, 109, 2, 50, 111, 2, 51, 113, 2, 52, 115, 2, 53, 117, 2, 54, 119, 2, 55, 121, 2, 56, 123, 2, 57, 125, 2, 58, 127, 2, 59, 129, 2, 60, 131, 2, 61, 133, 2, 62, 135, 2, 63, 137, 2, 64, 139, 2, 65, 141, 2, 66, 143, 2, 67, 145, 2, 68, 147, 2, 69, 149, 2, 70, 151, 2, 71, 153, 2, 72, 155, 2, 73, 157, 2, 74, 159, 2, 75, 161, 2, 76, 163, 2, 77, 165, 2, 78, 167, 2, 79, 169, 2, 80, 171, 2, 81, 173, 2, 82, 175, 2, 83, 177, 2, 84, 179, 2, 85, 181, 2, 86, 183, 2, 87, 185, 2, 88, 187, 2, 89, 189, 2, 90, 191, 2, 91, 193, 2, 92, 195, 2, 93, 197, 2, 94, 199, 2, 95, 201, 2, 96, 203, 2, 97, 205, 2, 98, 207, 2, 99, 209, 2, 100, 211, 2, 101, 213, 2, 102, 215, 2, 103, 217, 2, 104, 219, 2, 105, 221, 2, 106, 223, 2, 107, 225, 2, 108, 227, 2, 109, 229, 2, 110, 231, 2, 111, 233, 2, 112, 235, 2, 113, 237, 2, 114, 239, 2, 115, 241, 2, 116, 243, 2, 117, 245, 2, 118, 247, 2, 119, 249, 2, 120, 251, 2, 121, 253, 2, 122, 255, 2, 123, 257, 2, 124, 259, 2, 125, 261, 2, 126, 263, 2, 127, 265, 2, 128, 267, 2, 129, 269, 2, 130, 271, 2, 131, 273, 2, 132, 275, 2, 133, 277, 2, 134, 279, 2, 135, 281, 2, 136, 283, 2, 137, 285, 2, 138, 287, 2, 139, 289, 2, 140, 291, 2, 141, 293, 2, 142, 295, 2, 143, 297, 2, 144, 299, 2, 145, 301, 2, 146, 303, 2, 147, 305, 2, 148, 307, 2, 149, 309, 2, 150, 311, 2, 151, 313, 2, 152, 315, 2, 153, 317, 2, 154, 319, 2, 155, 321, 2, 156, 323, 2, 157, 325, 2, 158, 327, 2, 159, 329, 2, 160, 331, 2, 161, 333, 2, 162, 335, 2, 163, 337, 2, 164, 339, 2, 165, 341, 2, 166, 343, 2, 167, 345, 2, 168, 347, 2, 169, 349, 2, 170, 351, 2, 171, 353, 2, 172, 355, 2, 173, 357, 2, 174, 359, 2, 175, 361, 2, 176, 363, 2, 177, 365, 2, 178, 367, 2, 179, 369, 2, 180, 371, 2, 181, 373, 2, 182, 375, 2, 183, 377, 2, 184, 379, 2, 185, 381, 2, 186, 383, 2, 187, 385, 2, 188, 387, 2, 189, 389, 2, 190, 391, 2, 191, 393, 2, 192, 395, 2, 193, 397, 2, 194, 399, 2, 195, 401, 2, 196, 403, 2, 197, 405, 2, 198, 407, 2, 199, 409, 2, 200, 411, 2, 201, 413, 2, 202, 415, 2, 203, 417, 2, 204, 419, 2, 205, 421, 2, 206, 423, 2, 207, 425, 2, 208, 427, 2, 209, 429, 2, 210, 431, 2, 211, 433, 2, 212, 435, 2, 213, 437, 2, 214, 439, 2, 215, 441, 2, 216, 443, 2, 217, 445, 2, 218, 447, 2, 219, 449, 2, 220, 451, 2, 221, 453, 2, 222, 455, 2, 223, 457, 2, 224, 459, 2, 225, 461, 2, 226, 463, 2, 227, 465, 2, 228, 467, 2, 229, 469, 2, 230, 471, 2, 231, 473, 2, 232, 475, 2, 233, 477, 2, 234, 479, 2, 235, 481, 2, 236, 483, 2, 237, 485, 2, 238, 487, 2, 239, 489, 2, 240, 491, 2, 241, 493, 2, 242, 495, 2, 243, 497, 2, 244, 499, 2, 245, 501, 2, 246, 503, 2, 247, 505, 2, 248, 507, 2, 249, 509, 2, 250, 511, 2, 251, 513, 2, 252, 515, 2, 253, 517, 2, 254, 519, 2, 255, 521, 2, 256, 523, 2, 257, 525, 2, 258, 527, 2, 259, 529, 2, 260, 531, 2, 261, 533, 2, 262, 535, 2, 263, 537, 2, 264, 539, 2, 265, 541, 2, 266, 543, 2, 267, 545, 2, 268, 547, 2, 269, 549, 2, 270, 551, 2, 271, 553, 2, 272, 555, 2, 273, 557, 2, 274, 559, 2, 275, 561, 2, 276, 563, 2, 277, 565, 2, 278, 567, 2, 279, 569, 2, 280, 571, 2, 281, 573, 2, 282, 575, 2, 283, 577, 2, 284, 579, 2, 285, 581, 2, 286, 583, 2, 287, 585, 2, 288, 587, 2, 289, 589, 2, 290, 591, 2, 291, 593, 2, 292, 595, 2, 293, 597, 2, 294, 599, 2, 295, 601, 2, 296, 603, 2, 297, 605, 2, 298, 607, 2, 299, 609, 2, 300, 611, 2, 301, 613, 2, 302, 615, 2, 303, 617, 2, 304, 619, 2, 305, 621, 2, 306, 623, 2, 307, 625, 2, 308, 627, 2, 309, 629, 2, 310, 631, 2, 311, 633, 2, 312, 635, 2, 313, 637, 2, 314, 639, 2, 315, 641, 2, 316, 643, 2, 317, 645, 2, 318, 647, 2, 319, 649, 2, 320, 651, 2, 321, 653, 2, 322, 655, 2, 323, 657, 2, 324, 659, 2, 325, 661, 2, 326, 663, 2, 327, 665, 2, 328, 667, 2, 329, 669, 2, 330, 671, 2, 331, 673, 2, 332, 675, 2, 333, 677, 2, 334, 679, 2, 335, 681, 2, 336, 683, 2, 337, 685, 2, 338, 687, 2, 339, 689, 2, 340, 691, 2, 341, 693, 2, 342, 695, 2, 343, 697, 2, 344, 699, 2, 345, 701, 2, 346, 703, 2, 347, 705, 2, 348, 707, 2, 349, 709, 2, 350, 711, 2, 351, 713, 2, 352, 715, 2, 353, 717, 2, 354, 719, 2, 355, 721, 2, 356, 723, 2, 357, 725, 2, 358, 727, 2, 359, 729, 2, 360, 731, 2, 361, 733, 2, 362, 735, 2, 363, 737, 2, 364, 739, 2, 365, 741, 2, 366, 743, 2, 367, 745, 2, 368, 747, 2, 369, 749, 2, 370, 751, 2, 371, 753, 2, 372, 755, 2, 373, 757, 2, 374, 759, 2, 375, 761, 2, 376, 763, 2, 377, 765, 2, 378, 767, 2, 379, 769, 2, 380, 771, 2, 381, 773, 2, 382, 775, 2, 383, 777, 2, 384, 779, 2, 385, 781, 2, 386, 783, 2, 387, 785, 2, 388, 787, 2, 389, 789, 2, 390, 791, 2, 391, 793, 2, 392, 795, 2, 393, 797, 2, 394, 799, 2, 395, 801, 2, 396, 803, 2, 397, 805, 2, 398, 807, 2, 399, 809, 2, 400, 811, 2, 401, 813, 2, 402, 815, 2, 403, 817, 2, 404, 819, 2, 405, 821, 2, 406, 823, 2, 407, 825, 2, 408, 827, 2, 409, 829, 2, 410, 831, 2, 411, 833, 2, 412, 835, 2, 413, 837, 2, 414, 839, 2, 415, 841, 2, 416, 843, 2, 417, 845, 2, 418, 847, 2, 419, 849, 2, 420, 851, 2, 421, 853, 2, 422, 855, 2, 423, 857, 2, 424, 859, 2, 425, 861, 2, 426, 863, 2, 427, 865, 2, 428, 867, 2, 429, 869, 2, 430, 871, 2, 431, 873, 2, 432, 875, 2, 433, 877, 2, 434, 879, 2, 435, 881, 2, 436, 883, 2, 437, 885, 2, 438, 887, 2, 439, 889, 2, 440, 891, 2, 441, 893, 2, 442, 895, 2, 443, 897, 2, 444, 899, 2, 445, 901, 2, 446, 903, 2, 447, 905, 2, 448, 907, 2, 449, 909, 2, 450, 911, 2, 451, 913, 2, 452, 915, 2, 453, 917, 2, 454, 919, 2, 455, 921, 2, 456, 923, 2, 457, 925, 2, 458, 927, 2, 459, 929, 2, 460, 931, 2, 461, 933, 2, 462, 935, 2, 463, 937, 2, 464, 939, 2, 465, 941, 2, 466, 943, 2, 467, 945, 2, 468, 947, 2, 469, 949, 2, 470, 951, 2, 471, 953, 2, 472, 955, 2, 473, 957, 2, 474, 959, 2, 475, 961, 2, 476, 963, 2, 477, 965, 2, 478, 967, 2, 479, 969, 2, 480, 971, 2, 481, 973, 2, 482, 975, 2, 483, 977, 2, 484, 979, 2, 485, 981, 2, 486, 983, 2, 487, 985, 2, 488, 987, 2, 489, 989, 2, 490, 991, 2, 491, 993, 2, 492, 995, 2, 493, 997, 2, 494, 999, 2, 495, 1001, 2, 496, 1003, 2, 497, 1005, 2, 498, 1007, 2, 499, 1009, 2, 500, 1011, 2, 501, 1013, 2, 502, 1015, 2, 503, 1017, 2, 504, 1019, 2, 505, 1021, 2, 506, 1023, 2, 507, 1025, 2, 508, 1027, 2, 509, 1029, 2, 510, 1031, 2, 511, 1033, 2, 512, 1035, 2, 513, 1037, 2, 514, 1039, 2, 2, 1041, 2, 2, 1043, 2, 2, 1045, 2, 515, 1047, 2, 516, 1049, 2, 517, 1051, 2, 518, 1053, 2, 519, 1055, 2, 520, 1057, 2, 521, 1059, 2, 522, 1061, 2, 523, 1063, 2, 524, 1065, 2, 2, 1067, 2, 525, 1069, 2, 526, 1071, 2, 527, 1073, 2, 2, 1075, 2, 528, 1077, 2, 529, 1079, 2, 530, 1081, 2, 531, 1083, 2, 532, 1085, 2, 533, 1087, 2, 534, 1089, 2, 535, 1091, 2, 536, 1093, 2, 537, 1095, 2, 538, 1097, 2, 2, 1099, 2, 539, 1101, 2, 540, 1103, 2, 541, 1105, 2, 542, 1107, 2, 543, 1109, 2, 544, 1111, 2, 545, 1113, 2, 546, 1115, 2, 547, 1117, 2, 548, 1119, 2, 549, 1121, 2, 550, 1123, 2, 2, 1125, 2, 551, 1127, 2, 552, 1129, 2, 2, 1131, 2, 2, 1133, 2, 2, 1135, 2, 2, 1137, 2, 2, 1139, 2, 555, 1141, 2, 553, 1143, 2, 554, 7, 2, 3, 4, 5, 6, 27, 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, 5, 2, 50, 59, 67, 72, 99, 104, 5, 2, 67, 92, 97, 97, 99, 124, 7, 2, 38, 38, 50, 59, 67, 92, 97, 97, 99, 124, 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, 87, 87, 119, 119, 122, 122, 4, 2, 41, 41, 94, 94, 3, 2, 38, 38, 2, 5464, 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, 5, 1135, 3, 2, 2, 2, 5, 1137, 3, 2, 2, 2, 5, 1139, 3, 2, 2, 2, 6, 1141, 3, 2, 2, 2, 6, 1143, 3, 2, 2, 2, 7, 1145, 3, 2, 2, 2, 9, 1147, 3, 2, 2, 2, 11, 1149, 3, 2, 2, 2, 13, 1151, 3, 2, 2, 2, 15, 1153, 3, 2, 2, 2, 17, 1155, 3, 2, 2, 2, 19, 1157, 3, 2, 2, 2, 21, 1159, 3, 2, 2, 2, 23, 1161, 3, 2, 2, 2, 25, 1163, 3, 2, 2, 2, 27, 1165, 3, 2, 2, 2, 29, 1167, 3, 2, 2, 2, 31, 1169, 3, 2, 2, 2, 33, 1171, 3, 2, 2, 2, 35, 1173, 3, 2, 2, 2, 37, 1175, 3, 2, 2, 2, 39, 1177, 3, 2, 2, 2, 41, 1179, 3, 2, 2, 2, 43, 1182, 3, 2, 2, 2, 45, 1185, 3, 2, 2, 2, 47, 1188, 3, 2, 2, 2, 49, 1191, 3, 2, 2, 2, 51, 1194, 3, 2, 2, 2, 53, 1197, 3, 2, 2, 2, 55, 1200, 3, 2, 2, 2, 57, 1203, 3, 2, 2, 2, 59, 1206, 3, 2, 2, 2, 61, 1208, 3, 2, 2, 2, 63, 1234, 3, 2, 2, 2, 65, 1245, 3, 2, 2, 2, 67, 1261, 3, 2, 2, 2, 69, 1263, 3, 2, 2, 2, 71, 1265, 3, 2, 2, 2, 73, 1267, 3, 2, 2, 2, 75, 1271, 3, 2, 2, 2, 77, 1279, 3, 2, 2, 2, 79, 1287, 3, 2, 2, 2, 81, 1291, 3, 2, 2, 2, 83, 1295, 3, 2, 2, 2, 85, 1301, 3, 2, 2, 2, 87, 1304, 3, 2, 2, 2, 89, 1308, 3, 2, 2, 2, 91, 1319, 3, 2, 2, 2, 93, 1324, 3, 2, 2, 2, 95, 1329, 3, 2, 2, 2, 97, 1334, 3, 2, 2, 2, 99, 1340, 3, 2, 2, 2, 101, 1348, 3, 2, 2, 2, 103, 1355, 3, 2, 2, 2, 105, 1366, 3, 2, 2, 2, 107, 1373, 3, 2, 2, 2, 109, 1389, 3, 2, 2, 2, 111, 1402, 3, 2, 2, 2, 113, 1415, 3, 2, 2, 2, 115, 1428, 3, 2, 2, 2, 117, 1446, 3, 2, 2, 2, 119, 1459, 3, 2, 2, 2, 121, 1467, 3, 2, 2, 2, 123, 1478, 3, 2, 2, 2, 125, 1483, 3, 2, 2, 2, 127, 1492, 3, 2, 2, 2, 129, 1495, 3, 2, 2, 2, 131, 1500, 3, 2, 2, 2, 133, 1507, 3, 2, 2, 2, 135, 1513, 3, 2, 2, 2, 137, 1519, 3, 2, 2, 2, 139, 1523, 3, 2, 2, 2, 141, 1531, 3, 2, 2, 2, 143, 1536, 3, 2, 2, 2, 145, 1542, 3, 2, 2, 2, 147, 1548, 3, 2, 2, 2, 149, 1555, 3, 2, 2, 2, 151, 1558, 3, 2, 2, 2, 153, 1568, 3, 2, 2, 2, 155, 1578, 3, 2, 2, 2, 157, 1583, 3, 2, 2, 2, 159, 1591, 3, 2, 2, 2, 161, 1599, 3, 2, 2, 2, 163, 1605, 3, 2, 2, 2, 165, 1615, 3, 2, 2, 2, 167, 1630, 3, 2, 2, 2, 169, 1634, 3, 2, 2, 2, 171, 1639, 3, 2, 2, 2, 173, 1646, 3, 2, 2, 2, 175, 1649, 3, 2, 2, 2, 177, 1654, 3, 2, 2, 2, 179, 1657, 3, 2, 2, 2, 181, 1663, 3, 2, 2, 2, 183, 1671, 3, 2, 2, 2, 185, 1679, 3, 2, 2, 2, 187, 1690, 3, 2, 2, 2, 189, 1700, 3, 2, 2, 2, 191, 1707, 3, 2, 2, 2, 193, 1720, 3, 2, 2, 2, 195, 1725, 3, 2, 2, 2, 197, 1735, 3, 2, 2, 2, 199, 1741, 3, 2, 2, 2, 201, 1746, 3, 2, 2, 2, 203, 1749, 3, 2, 2, 2, 205, 1758, 3, 2, 2, 2, 207, 1763, 3, 2, 2, 2, 209, 1769, 3, 2, 2, 2, 211, 1776, 3, 2, 2, 2, 213, 1781, 3, 2, 2, 2, 215, 1787, 3, 2, 2, 2, 217, 1796, 3, 2, 2, 2, 219, 1801, 3, 2, 2, 2, 221, 1807, 3, 2, 2, 2, 223, 1814, 3, 2, 2, 2, 225, 1819, 3, 2, 2, 2, 227, 1833, 3, 2, 2, 2, 229, 1840, 3, 2, 2, 2, 231, 1850, 3, 2, 2, 2, 233, 1863, 3, 2, 2, 2, 235, 1869, 3, 2, 2, 2, 237, 1884, 3, 2, 2, 2, 239, 1891, 3, 2, 2, 2, 241, 1896, 3, 2, 2, 2, 243, 1902, 3, 2, 2, 2, 245, 1908, 3, 2, 2, 2, 247, 1911, 3, 2, 2, 2, 249, 1918, 3, 2, 2, 2, 251, 1923, 3, 2, 2, 2, 253, 1928, 3, 2, 2, 2, 255, 1933, 3, 2, 2, 2, 257, 1941, 3, 2, 2, 2, 259, 1949, 3, 2, 2, 2, 261, 1955, 3, 2, 2, 2, 263, 1960, 3, 2, 2, 2, 265, 1969, 3, 2, 2, 2, 267, 1975, 3, 2, 2, 2, 269, 1983, 3, 2, 2, 2, 271, 1991, 3, 2, 2, 2, 273, 1997, 3, 2, 2, 2, 275, 2006, 3, 2, 2, 2, 277, 2013, 3, 2, 2, 2, 279, 2020, 3, 2, 2, 2, 281, 2024, 3, 2, 2, 2, 283, 2030, 3, 2, 2, 2, 285, 2036, 3, 2, 2, 2, 287, 2046, 3, 2, 2, 2, 289, 2051, 3, 2, 2, 2, 291, 2057, 3, 2, 2, 2, 293, 2064, 3, 2, 2, 2, 295, 2074, 3, 2, 2, 2, 297, 2085, 3, 2, 2, 2, 299, 2088, 3, 2, 2, 2, 301, 2098, 3, 2, 2, 2, 303, 2107, 3, 2, 2, 2, 305, 2114, 3, 2, 2, 2, 307, 2120, 3, 2, 2, 2, 309, 2123, 3, 2, 2, 2, 311, 2129, 3, 2, 2, 2, 313, 2136, 3, 2, 2, 2, 315, 2144, 3, 2, 2, 2, 317, 2153, 3, 2, 2, 2, 319, 2161, 3, 2, 2, 2, 321, 2167, 3, 2, 2, 2, 323, 2183, 3, 2, 2, 2, 325, 2194, 3, 2, 2, 2, 327, 2200, 3, 2, 2, 2, 329, 2206, 3, 2, 2, 2, 331, 2214, 3, 2, 2, 2, 333, 2222, 3, 2, 2, 2, 335, 2231, 3, 2, 2, 2, 337, 2238, 3, 2, 2, 2, 339, 2248, 3, 2, 2, 2, 341, 2262, 3, 2, 2, 2, 343, 2273, 3, 2, 2, 2, 345, 2285, 3, 2, 2, 2, 347, 2293, 3, 2, 2, 2, 349, 2302, 3, 2, 2, 2, 351, 2313, 3, 2, 2, 2, 353, 2318, 3, 2, 2, 2, 355, 2323, 3, 2, 2, 2, 357, 2327, 3, 2, 2, 2, 359, 2334, 3, 2, 2, 2, 361, 2340, 3, 2, 2, 2, 363, 2345, 3, 2, 2, 2, 365, 2354, 3, 2, 2, 2, 367, 2358, 3, 2, 2, 2, 369, 2369, 3, 2, 2, 2, 371, 2377, 3, 2, 2, 2, 373, 2386, 3, 2, 2, 2, 375, 2395, 3, 2, 2, 2, 377, 2403, 3, 2, 2, 2, 379, 2410, 3, 2, 2, 2, 381, 2420, 3, 2, 2, 2, 383, 2431, 3, 2, 2, 2, 385, 2442, 3, 2, 2, 2, 387, 2450, 3, 2, 2, 2, 389, 2458, 3, 2, 2, 2, 391, 2467, 3, 2, 2, 2, 393, 2474, 3, 2, 2, 2, 395, 2481, 3, 2, 2, 2, 397, 2486, 3, 2, 2, 2, 399, 2491, 3, 2, 2, 2, 401, 2498, 3, 2, 2, 2, 403, 2507, 3, 2, 2, 2, 405, 2517, 3, 2, 2, 2, 407, 2522, 3, 2, 2, 2, 409, 2529, 3, 2, 2, 2, 411, 2535, 3, 2, 2, 2, 413, 2543, 3, 2, 2, 2, 415, 2553, 3, 2, 2, 2, 417, 2563, 3, 2, 2, 2, 419, 2571, 3, 2, 2, 2, 421, 2579, 3, 2, 2, 2, 423, 2589, 3, 2, 2, 2, 425, 2598, 3, 2, 2, 2, 427, 2605, 3, 2, 2, 2, 429, 2611, 3, 2, 2, 2, 431, 2621, 3, 2, 2, 2, 433, 2627, 3, 2, 2, 2, 435, 2635, 3, 2, 2, 2, 437, 2644, 3, 2, 2, 2, 439, 2654, 3, 2, 2, 2, 441, 2661, 3, 2, 2, 2, 443, 2669, 3, 2, 2, 2, 445, 2677, 3, 2, 2, 2, 447, 2684, 3, 2, 2, 2, 449, 2689, 3, 2, 2, 2, 451, 2694, 3, 2, 2, 2, 453, 2703, 3, 2, 2, 2, 455, 2706, 3, 2, 2, 2, 457, 2716, 3, 2, 2, 2, 459, 2726, 3, 2, 2, 2, 461, 2735, 3, 2, 2, 2, 463, 2745, 3, 2, 2, 2, 465, 2755, 3, 2, 2, 2, 467, 2761, 3, 2, 2, 2, 469, 2769, 3, 2, 2, 2, 471, 2777, 3, 2, 2, 2, 473, 2786, 3, 2, 2, 2, 475, 2793, 3, 2, 2, 2, 477, 2805, 3, 2, 2, 2, 479, 2812, 3, 2, 2, 2, 481, 2820, 3, 2, 2, 2, 483, 2828, 3, 2, 2, 2, 485, 2838, 3, 2, 2, 2, 487, 2842, 3, 2, 2, 2, 489, 2848, 3, 2, 2, 2, 491, 2857, 3, 2, 2, 2, 493, 2863, 3, 2, 2, 2, 495, 2868, 3, 2, 2, 2, 497, 2878, 3, 2, 2, 2, 499, 2884, 3, 2, 2, 2, 501, 2891, 3, 2, 2, 2, 503, 2896, 3, 2, 2, 2, 505, 2902, 3, 2, 2, 2, 507, 2911, 3, 2, 2, 2, 509, 2916, 3, 2, 2, 2, 511, 2924, 3, 2, 2, 2, 513, 2930, 3, 2, 2, 2, 515, 2943, 3, 2, 2, 2, 517, 2952, 3, 2, 2, 2, 519, 2959, 3, 2, 2, 2, 521, 2968, 3, 2, 2, 2, 523, 2973, 3, 2, 2, 2, 525, 2979, 3, 2, 2, 2, 527, 2984, 3, 2, 2, 2, 529, 2989, 3, 2, 2, 2, 531, 2995, 3, 2, 2, 2, 533, 3000, 3, 2, 2, 2, 535, 3003, 3, 2, 2, 2, 537, 3011, 3, 2, 2, 2, 539, 3018, 3, 2, 2, 2, 541, 3025, 3, 2, 2, 2, 543, 3031, 3, 2, 2, 2, 545, 3038, 3, 2, 2, 2, 547, 3041, 3, 2, 2, 2, 549, 3045, 3, 2, 2, 2, 551, 3050, 3, 2, 2, 2, 553, 3059, 3, 2, 2, 2, 555, 3066, 3, 2, 2, 2, 557, 3074, 3, 2, 2, 2, 559, 3080, 3, 2, 2, 2, 561, 3086, 3, 2, 2, 2, 563, 3093, 3, 2, 2, 2, 565, 3101, 3, 2, 2, 2, 567, 3111, 3, 2, 2, 2, 569, 3119, 3, 2, 2, 2, 571, 3128, 3, 2, 2, 2, 573, 3134, 3, 2, 2, 2, 575, 3144, 3, 2, 2, 2, 577, 3152, 3, 2, 2, 2, 579, 3161, 3, 2, 2, 2, 581, 3170, 3, 2, 2, 2, 583, 3176, 3, 2, 2, 2, 585, 3187, 3, 2, 2, 2, 587, 3198, 3, 2, 2, 2, 589, 3208, 3, 2, 2, 2, 591, 3216, 3, 2, 2, 2, 593, 3222, 3, 2, 2, 2, 595, 3228, 3, 2, 2, 2, 597, 3233, 3, 2, 2, 2, 599, 3242, 3, 2, 2, 2, 601, 3250, 3, 2, 2, 2, 603, 3260, 3, 2, 2, 2, 605, 3264, 3, 2, 2, 2, 607, 3272, 3, 2, 2, 2, 609, 3280, 3, 2, 2, 2, 611, 3289, 3, 2, 2, 2, 613, 3297, 3, 2, 2, 2, 615, 3304, 3, 2, 2, 2, 617, 3315, 3, 2, 2, 2, 619, 3323, 3, 2, 2, 2, 621, 3331, 3, 2, 2, 2, 623, 3337, 3, 2, 2, 2, 625, 3345, 3, 2, 2, 2, 627, 3354, 3, 2, 2, 2, 629, 3362, 3, 2, 2, 2, 631, 3369, 3, 2, 2, 2, 633, 3374, 3, 2, 2, 2, 635, 3383, 3, 2, 2, 2, 637, 3388, 3, 2, 2, 2, 639, 3393, 3, 2, 2, 2, 641, 3403, 3, 2, 2, 2, 643, 3410, 3, 2, 2, 2, 645, 3417, 3, 2, 2, 2, 647, 3424, 3, 2, 2, 2, 649, 3431, 3, 2, 2, 2, 651, 3440, 3, 2, 2, 2, 653, 3449, 3, 2, 2, 2, 655, 3459, 3, 2, 2, 2, 657, 3472, 3, 2, 2, 2, 659, 3479, 3, 2, 2, 2, 661, 3487, 3, 2, 2, 2, 663, 3491, 3, 2, 2, 2, 665, 3497, 3, 2, 2, 2, 667, 3502, 3, 2, 2, 2, 669, 3509, 3, 2, 2, 2, 671, 3518, 3, 2, 2, 2, 673, 3525, 3, 2, 2, 2, 675, 3536, 3, 2, 2, 2, 677, 3542, 3, 2, 2, 2, 679, 3552, 3, 2, 2, 2, 681, 3563, 3, 2, 2, 2, 683, 3569, 3, 2, 2, 2, 685, 3576, 3, 2, 2, 2, 687, 3584, 3, 2, 2, 2, 689, 3591, 3, 2, 2, 2, 691, 3597, 3, 2, 2, 2, 693, 3603, 3, 2, 2, 2, 695, 3610, 3, 2, 2, 2, 697, 3617, 3, 2, 2, 2, 699, 3628, 3, 2, 2, 2, 701, 3633, 3, 2, 2, 2, 703, 3642, 3, 2, 2, 2, 705, 3652, 3, 2, 2, 2, 707, 3657, 3, 2, 2, 2, 709, 3669, 3, 2, 2, 2, 711, 3677, 3, 2, 2, 2, 713, 3686, 3, 2, 2, 2, 715, 3694, 3, 2, 2, 2, 717, 3699, 3, 2, 2, 2, 719, 3705, 3, 2, 2, 2, 721, 3715, 3, 2, 2, 2, 723, 3727, 3, 2, 2, 2, 725, 3739, 3, 2, 2, 2, 727, 3747, 3, 2, 2, 2, 729, 3756, 3, 2, 2, 2, 731, 3765, 3, 2, 2, 2, 733, 3771, 3, 2, 2, 2, 735, 3778, 3, 2, 2, 2, 737, 3785, 3, 2, 2, 2, 739, 3791, 3, 2, 2, 2, 741, 3800, 3, 2, 2, 2, 743, 3810, 3, 2, 2, 2, 745, 3818, 3, 2, 2, 2, 747, 3826, 3, 2, 2, 2, 749, 3831, 3, 2, 2, 2, 751, 3840, 3, 2, 2, 2, 753, 3851, 3, 2, 2, 2, 755, 3859, 3, 2, 2, 2, 757, 3864, 3, 2, 2, 2, 759, 3872, 3, 2, 2, 2, 761, 3878, 3, 2, 2, 2, 763, 3882, 3, 2, 2, 2, 765, 3887, 3, 2, 2, 2, 767, 3891, 3, 2, 2, 2, 769, 3896, 3, 2, 2, 2, 771, 3904, 3, 2, 2, 2, 773, 3911, 3, 2, 2, 2, 775, 3915, 3, 2, 2, 2, 777, 3923, 3, 2, 2, 2, 779, 3928, 3, 2, 2, 2, 781, 3938, 3, 2, 2, 2, 783, 3947, 3, 2, 2, 2, 785, 3951, 3, 2, 2, 2, 787, 3959, 3, 2, 2, 2, 789, 3966, 3, 2, 2, 2, 791, 3974, 3, 2, 2, 2, 793, 3980, 3, 2, 2, 2, 795, 3989, 3, 2, 2, 2, 797, 3995, 3, 2, 2, 2, 799, 3999, 3, 2, 2, 2, 801, 4007, 3, 2, 2, 2, 803, 4016, 3, 2, 2, 2, 805, 4022, 3, 2, 2, 2, 807, 4031, 3, 2, 2, 2, 809, 4037, 3, 2, 2, 2, 811, 4042, 3, 2, 2, 2, 813, 4049, 3, 2, 2, 2, 815, 4057, 3, 2, 2, 2, 817, 4065, 3, 2, 2, 2, 819, 4074, 3, 2, 2, 2, 821, 4084, 3, 2, 2, 2, 823, 4089, 3, 2, 2, 2, 825, 4093, 3, 2, 2, 2, 827, 4099, 3, 2, 2, 2, 829, 4108, 3, 2, 2, 2, 831, 4118, 3, 2, 2, 2, 833, 4123, 3, 2, 2, 2, 835, 4133, 3, 2, 2, 2, 837, 4139, 3, 2, 2, 2, 839, 4144, 3, 2, 2, 2, 841, 4151, 3, 2, 2, 2, 843, 4159, 3, 2, 2, 2, 845, 4173, 3, 2, 2, 2, 847, 4183, 3, 2, 2, 2, 849, 4194, 3, 2, 2, 2, 851, 4204, 3, 2, 2, 2, 853, 4214, 3, 2, 2, 2, 855, 4223, 3, 2, 2, 2, 857, 4229, 3, 2, 2, 2, 859, 4237, 3, 2, 2, 2, 861, 4250, 3, 2, 2, 2, 863, 4255, 3, 2, 2, 2, 865, 4263, 3, 2, 2, 2, 867, 4270, 3, 2, 2, 2, 869, 4277, 3, 2, 2, 2, 871, 4288, 3, 2, 2, 2, 873, 4298, 3, 2, 2, 2, 875, 4305, 3, 2, 2, 2, 877, 4312, 3, 2, 2, 2, 879, 4320, 3, 2, 2, 2, 881, 4328, 3, 2, 2, 2, 883, 4338, 3, 2, 2, 2, 885, 4345, 3, 2, 2, 2, 887, 4352, 3, 2, 2, 2, 889, 4359, 3, 2, 2, 2, 891, 4371, 3, 2, 2, 2, 893, 4375, 3, 2, 2, 2, 895, 4379, 3, 2, 2, 2, 897, 4385, 3, 2, 2, 2, 899, 4398, 3, 2, 2, 2, 901, 4410, 3, 2, 2, 2, 903, 4414, 3, 2, 2, 2, 905, 4418, 3, 2, 2, 2, 907, 4427, 3, 2, 2, 2, 909, 4435, 3, 2, 2, 2, 911, 4446, 3, 2, 2, 2, 913, 4452, 3, 2, 2, 2, 915, 4460, 3, 2, 2, 2, 917, 4469, 3, 2, 2, 2, 919, 4473, 3, 2, 2, 2, 921, 4481, 3, 2, 2, 2, 923, 4492, 3, 2, 2, 2, 925, 4501, 3, 2, 2, 2, 927, 4506, 3, 2, 2, 2, 929, 4513, 3, 2, 2, 2, 931, 4518, 3, 2, 2, 2, 933, 4525, 3, 2, 2, 2, 935, 4530, 3, 2, 2, 2, 937, 4539, 3, 2, 2, 2, 939, 4544, 3, 2, 2, 2, 941, 4556, 3, 2, 2, 2, 943, 4567, 3, 2, 2, 2, 945, 4576, 3, 2, 2, 2, 947, 4584, 3, 2, 2, 2, 949, 4598, 3, 2, 2, 2, 951, 4606, 3, 2, 2, 2, 953, 4617, 3, 2, 2, 2, 955, 4624, 3, 2, 2, 2, 957, 4631, 3, 2, 2, 2, 959, 4638, 3, 2, 2, 2, 961, 4645, 3, 2, 2, 2, 963, 4649, 3, 2, 2, 2, 965, 4653, 3, 2, 2, 2, 967, 4658, 3, 2, 2, 2, 969, 4663, 3, 2, 2, 2, 971, 4671, 3, 2, 2, 2, 973, 4677, 3, 2, 2, 2, 975, 4687, 3, 2, 2, 2, 977, 4692, 3, 2, 2, 2, 979, 4712, 3, 2, 2, 2, 981, 4730, 3, 2, 2, 2, 983, 4736, 3, 2, 2, 2, 985, 4749, 3, 2, 2, 2, 987, 4760, 3, 2, 2, 2, 989, 4766, 3, 2, 2, 2, 991, 4775, 3, 2, 2, 2, 993, 4783, 3, 2, 2, 2, 995, 4787, 3, 2, 2, 2, 997, 4799, 3, 2, 2, 2, 999, 4807, 3, 2, 2, 2, 1001, 4813, 3, 2, 2, 2, 1003, 4819, 3, 2, 2, 2, 1005, 4827, 3, 2, 2, 2, 1007, 4835, 3, 2, 2, 2, 1009, 4841, 3, 2, 2, 2, 1011, 4846, 3, 2, 2, 2, 1013, 4853, 3, 2, 2, 2, 1015, 4859, 3, 2, 2, 2, 1017, 4865, 3, 2, 2, 2, 1019, 4874, 3, 2, 2, 2, 1021, 4880, 3, 2, 2, 2, 1023, 4884, 3, 2, 2, 2, 1025, 4889, 3, 2, 2, 2, 1027, 4896, 3, 2, 2, 2, 1029, 4904, 3, 2, 2, 2, 1031, 4914, 3, 2, 2, 2, 1033, 4921, 3, 2, 2, 2, 1035, 4926, 3, 2, 2, 2, 1037, 4931, 3, 2, 2, 2, 1039, 4944, 3, 2, 2, 2, 1041, 4948, 3, 2, 2, 2, 1043, 4952, 3, 2, 2, 2, 1045, 4954, 3, 2, 2, 2, 1047, 4957, 3, 2, 2, 2, 1049, 4966, 3, 2, 2, 2, 1051, 4969, 3, 2, 2, 2, 1053, 4978, 3, 2, 2, 2, 1055, 4982, 3, 2, 2, 2, 1057, 4986, 3, 2, 2, 2, 1059, 4990, 3, 2, 2, 2, 1061, 4994, 3, 2, 2, 2, 1063, 4997, 3, 2, 2, 2, 1065, 5006, 3, 2, 2, 2, 1067, 5012, 3, 2, 2, 2, 1069, 5015, 3, 2, 2, 2, 1071, 5019, 3, 2, 2, 2, 1073, 5028, 3, 2, 2, 2, 1075, 5035, 3, 2, 2, 2, 1077, 5038, 3, 2, 2, 2, 1079, 5046, 3, 2, 2, 2, 1081, 5049, 3, 2, 2, 2, 1083, 5052, 3, 2, 2, 2, 1085, 5055, 3, 2, 2, 2, 1087, 5063, 3, 2, 2, 2, 1089, 5066, 3, 2, 2, 2, 1091, 5069, 3, 2, 2, 2, 1093, 5071, 3, 2, 2, 2, 1095, 5105, 3, 2, 2, 2, 1097, 5108, 3, 2, 2, 2, 1099, 5112, 3, 2, 2, 2, 1101, 5120, 3, 2, 2, 2, 1103, 5136, 3, 2, 2, 2, 1105, 5147, 3, 2, 2, 2, 1107, 5151, 3, 2, 2, 2, 1109, 5162, 3, 2, 2, 2, 1111, 5201, 3, 2, 2, 2, 1113, 5252, 3, 2, 2, 2, 1115, 5276, 3, 2, 2, 2, 1117, 5279, 3, 2, 2, 2, 1119, 5281, 3, 2, 2, 2, 1121, 5286, 3, 2, 2, 2, 1123, 5317, 3, 2, 2, 2, 1125, 5320, 3, 2, 2, 2, 1127, 5325, 3, 2, 2, 2, 1129, 5338, 3, 2, 2, 2, 1131, 5341, 3, 2, 2, 2, 1133, 5346, 3, 2, 2, 2, 1135, 5352, 3, 2, 2, 2, 1137, 5357, 3, 2, 2, 2, 1139, 5362, 3, 2, 2, 2, 1141, 5379, 3, 2, 2, 2, 1143, 5381, 3, 2, 2, 2, 1145, 1146, 7, 38, 2, 2, 1146, 8, 3, 2, 2, 2, 1147, 1148, 7, 42, 2, 2, 1148, 10, 3, 2, 2, 2, 1149, 1150, 7, 43, 2, 2, 1150, 12, 3, 2, 2, 2, 1151, 1152, 7, 93, 2, 2, 1152, 14, 3, 2, 2, 2, 1153, 1154, 7, 95, 2, 2, 1154, 16, 3, 2, 2, 2, 1155, 1156, 7, 46, 2, 2, 1156, 18, 3, 2, 2, 2, 1157, 1158, 7, 61, 2, 2, 1158, 20, 3, 2, 2, 2, 1159, 1160, 7, 60, 2, 2, 1160, 22, 3, 2, 2, 2, 1161, 1162, 7, 44, 2, 2, 1162, 24, 3, 2, 2, 2, 1163, 1164, 7, 63, 2, 2, 1164, 26, 3, 2, 2, 2, 1165, 1166, 7, 48, 2, 2, 1166, 28, 3, 2, 2, 2, 1167, 1168, 7, 45, 2, 2, 1168, 30, 3, 2, 2, 2, 1169, 1170, 7, 47, 2, 2, 1170, 32, 3, 2, 2, 2, 1171, 1172, 7, 49, 2, 2, 1172, 34, 3, 2, 2, 2, 1173, 1174, 7, 96, 2, 2, 1174, 36, 3, 2, 2, 2, 1175, 1176, 7, 62, 2, 2, 1176, 38, 3, 2, 2, 2, 1177, 1178, 7, 64, 2, 2, 1178, 40, 3, 2, 2, 2, 1179, 1180, 7, 62, 2, 2, 1180, 1181, 7, 62, 2, 2, 1181, 42, 3, 2, 2, 2, 1182, 1183, 7, 64, 2, 2, 1183, 1184, 7, 64, 2, 2, 1184, 44, 3, 2, 2, 2, 1185, 1186, 7, 60, 2, 2, 1186, 1187, 7, 63, 2, 2, 1187, 46, 3, 2, 2, 2, 1188, 1189, 7, 62, 2, 2, 1189, 1190, 7, 63, 2, 2, 1190, 48, 3, 2, 2, 2, 1191, 1192, 7, 63, 2, 2, 1192, 1193, 7, 64, 2, 2, 1193, 50, 3, 2, 2, 2, 1194, 1195, 7, 64, 2, 2, 1195, 1196, 7, 63, 2, 2, 1196, 52, 3, 2, 2, 2, 1197, 1198, 7, 48, 2, 2, 1198, 1199, 7, 48, 2, 2, 1199, 54, 3, 2, 2, 2, 1200, 1201, 7, 62, 2, 2, 1201, 1202, 7, 64, 2, 2, 1202, 56, 3, 2, 2, 2, 1203, 1204, 7, 60, 2, 2, 1204, 1205, 7, 60, 2, 2, 1205, 58, 3, 2, 2, 2, 1206, 1207, 7, 39, 2, 2, 1207, 60, 3, 2, 2, 2, 1208, 1210, 7, 38, 2, 2, 1209, 1211, 9, 2, 2, 2, 1210, 1209, 3, 2, 2, 2, 1211, 1212, 3, 2, 2, 2, 1212, 1210, 3, 2, 2, 2, 1212, 1213, 3, 2, 2, 2, 1213, 62, 3, 2, 2, 2, 1214, 1230, 5, 67, 32, 2, 1215, 1219, 7, 45, 2, 2, 1216, 1217, 7, 47, 2, 2, 1217, 1219, 6, 30, 2, 2, 1218, 1215, 3, 2, 2, 2, 1218, 1216, 3, 2, 2, 2, 1219, 1220, 3, 2, 2, 2, 1220, 1218, 3, 2, 2, 2, 1220, 1221, 3, 2, 2, 2, 1221, 1225, 3, 2, 2, 2, 1222, 1226, 5, 67, 32, 2, 1223, 1224, 7, 49, 2, 2, 1224, 1226, 6, 30, 3, 2, 1225, 1222, 3, 2, 2, 2, 1225, 1223, 3, 2, 2, 2, 1226, 1230, 3, 2, 2, 2, 1227, 1228, 7, 49, 2, 2, 1228, 1230, 6, 30, 4, 2, 1229, 1214, 3, 2, 2, 2, 1229, 1218, 3, 2, 2, 2, 1229, 1227, 3, 2, 2, 2, 1230, 1231, 3, 2, 2, 2, 1231, 1229, 3, 2, 2, 2, 1231, 1232, 3, 2, 2, 2, 1232, 1235, 3, 2, 2, 2, 1233, 1235, 9, 3, 2, 2, 1234, 1229, 3, 2, 2, 2, 1234, 1233, 3, 2, 2, 2, 1235, 1236, 3, 2, 2, 2, 1236, 1237, 8, 30, 2, 2, 1237, 64, 3, 2, 2, 2, 1238, 1244, 5, 69, 33, 2, 1239, 1240, 7, 47, 2, 2, 1240, 1244, 6, 31, 5, 2, 1241, 1242, 7, 49, 2, 2, 1242, 1244, 6, 31, 6, 2, 1243, 1238, 3, 2, 2, 2, 1243, 1239, 3, 2, 2, 2, 1243, 1241, 3, 2, 2, 2, 1244, 1247, 3, 2, 2, 2, 1245, 1243, 3, 2, 2, 2, 1245, 1246, 3, 2, 2, 2, 1246, 1248, 3, 2, 2, 2, 1247, 1245, 3, 2, 2, 2, 1248, 1250, 5, 71, 34, 2, 1249, 1251, 5, 63, 30, 2, 1250, 1249, 3, 2, 2, 2, 1250, 1251, 3, 2, 2, 2, 1251, 1255, 3, 2, 2, 2, 1252, 1256, 7, 45, 2, 2, 1253, 1254, 7, 47, 2, 2, 1254, 1256, 6, 31, 7, 2, 1255, 1252, 3, 2, 2, 2, 1255, 1253, 3, 2, 2, 2, 1256, 1257, 3, 2, 2, 2, 1257, 1255, 3, 2, 2, 2, 1257, 1258, 3, 2, 2, 2, 1258, 1259, 3, 2, 2, 2, 1259, 1260, 8, 31, 3, 2, 1260, 66, 3, 2, 2, 2, 1261, 1262, 9, 4, 2, 2, 1262, 68, 3, 2, 2, 2, 1263, 1264, 9, 5, 2, 2, 1264, 70, 3, 2, 2, 2, 1265, 1266, 9, 6, 2, 2, 1266, 72, 3, 2, 2, 2, 1267, 1268, 7, 67, 2, 2, 1268, 1269, 7, 78, 2, 2, 1269, 1270, 7, 78, 2, 2, 1270, 74, 3, 2, 2, 2, 1271, 1272, 7, 67, 2, 2, 1272, 1273, 7, 80, 2, 2, 1273, 1274, 7, 67, 2, 2, 1274, 1275, 7, 78, 2, 2, 1275, 1276, 7, 91, 2, 2, 1276, 1277, 7, 85, 2, 2, 1277, 1278, 7, 71, 2, 2, 1278, 76, 3, 2, 2, 2, 1279, 1280, 7, 67, 2, 2, 1280, 1281, 7, 80, 2, 2, 1281, 1282, 7, 67, 2, 2, 1282, 1283, 7, 78, 2, 2, 1283, 1284, 7, 91, 2, 2, 1284, 1285, 7, 92, 2, 2, 1285, 1286, 7, 71, 2, 2, 1286, 78, 3, 2, 2, 2, 1287, 1288, 7, 67, 2, 2, 1288, 1289, 7, 80, 2, 2, 1289, 1290, 7, 70, 2, 2, 1290, 80, 3, 2, 2, 2, 1291, 1292, 7, 67, 2, 2, 1292, 1293, 7, 80, 2, 2, 1293, 1294, 7, 91, 2, 2, 1294, 82, 3, 2, 2, 2, 1295, 1296, 7, 67, 2, 2, 1296, 1297, 7, 84, 2, 2, 1297, 1298, 7, 84, 2, 2, 1298, 1299, 7, 67, 2, 2, 1299, 1300, 7, 91, 2, 2, 1300, 84, 3, 2, 2, 2, 1301, 1302, 7, 67, 2, 2, 1302, 1303, 7, 85, 2, 2, 1303, 86, 3, 2, 2, 2, 1304, 1305, 7, 67, 2, 2, 1305, 1306, 7, 85, 2, 2, 1306, 1307, 7, 69, 2, 2, 1307, 88, 3, 2, 2, 2, 1308, 1309, 7, 67, 2, 2, 1309, 1310, 7, 85, 2, 2, 1310, 1311, 7, 91, 2, 2, 1311, 1312, 7, 79, 2, 2, 1312, 1313, 7, 79, 2, 2, 1313, 1314, 7, 71, 2, 2, 1314, 1315, 7, 86, 2, 2, 1315, 1316, 7, 84, 2, 2, 1316, 1317, 7, 75, 2, 2, 1317, 1318, 7, 69, 2, 2, 1318, 90, 3, 2, 2, 2, 1319, 1320, 7, 68, 2, 2, 1320, 1321, 7, 81, 2, 2, 1321, 1322, 7, 86, 2, 2, 1322, 1323, 7, 74, 2, 2, 1323, 92, 3, 2, 2, 2, 1324, 1325, 7, 69, 2, 2, 1325, 1326, 7, 67, 2, 2, 1326, 1327, 7, 85, 2, 2, 1327, 1328, 7, 71, 2, 2, 1328, 94, 3, 2, 2, 2, 1329, 1330, 7, 69, 2, 2, 1330, 1331, 7, 67, 2, 2, 1331, 1332, 7, 85, 2, 2, 1332, 1333, 7, 86, 2, 2, 1333, 96, 3, 2, 2, 2, 1334, 1335, 7, 69, 2, 2, 1335, 1336, 7, 74, 2, 2, 1336, 1337, 7, 71, 2, 2, 1337, 1338, 7, 69, 2, 2, 1338, 1339, 7, 77, 2, 2, 1339, 98, 3, 2, 2, 2, 1340, 1341, 7, 69, 2, 2, 1341, 1342, 7, 81, 2, 2, 1342, 1343, 7, 78, 2, 2, 1343, 1344, 7, 78, 2, 2, 1344, 1345, 7, 67, 2, 2, 1345, 1346, 7, 86, 2, 2, 1346, 1347, 7, 71, 2, 2, 1347, 100, 3, 2, 2, 2, 1348, 1349, 7, 69, 2, 2, 1349, 1350, 7, 81, 2, 2, 1350, 1351, 7, 78, 2, 2, 1351, 1352, 7, 87, 2, 2, 1352, 1353, 7, 79, 2, 2, 1353, 1354, 7, 80, 2, 2, 1354, 102, 3, 2, 2, 2, 1355, 1356, 7, 69, 2, 2, 1356, 1357, 7, 81, 2, 2, 1357, 1358, 7, 80, 2, 2, 1358, 1359, 7, 85, 2, 2, 1359, 1360, 7, 86, 2, 2, 1360, 1361, 7, 84, 2, 2, 1361, 1362, 7, 67, 2, 2, 1362, 1363, 7, 75, 2, 2, 1363, 1364, 7, 80, 2, 2, 1364, 1365, 7, 86, 2, 2, 1365, 104, 3, 2, 2, 2, 1366, 1367, 7, 69, 2, 2, 1367, 1368, 7, 84, 2, 2, 1368, 1369, 7, 71, 2, 2, 1369, 1370, 7, 67, 2, 2, 1370, 1371, 7, 86, 2, 2, 1371, 1372, 7, 71, 2, 2, 1372, 106, 3, 2, 2, 2, 1373, 1374, 7, 69, 2, 2, 1374, 1375, 7, 87, 2, 2, 1375, 1376, 7, 84, 2, 2, 1376, 1377, 7, 84, 2, 2, 1377, 1378, 7, 71, 2, 2, 1378, 1379, 7, 80, 2, 2, 1379, 1380, 7, 86, 2, 2, 1380, 1381, 7, 97, 2, 2, 1381, 1382, 7, 69, 2, 2, 1382, 1383, 7, 67, 2, 2, 1383, 1384, 7, 86, 2, 2, 1384, 1385, 7, 67, 2, 2, 1385, 1386, 7, 78, 2, 2, 1386, 1387, 7, 81, 2, 2, 1387, 1388, 7, 73, 2, 2, 1388, 108, 3, 2, 2, 2, 1389, 1390, 7, 69, 2, 2, 1390, 1391, 7, 87, 2, 2, 1391, 1392, 7, 84, 2, 2, 1392, 1393, 7, 84, 2, 2, 1393, 1394, 7, 71, 2, 2, 1394, 1395, 7, 80, 2, 2, 1395, 1396, 7, 86, 2, 2, 1396, 1397, 7, 97, 2, 2, 1397, 1398, 7, 70, 2, 2, 1398, 1399, 7, 67, 2, 2, 1399, 1400, 7, 86, 2, 2, 1400, 1401, 7, 71, 2, 2, 1401, 110, 3, 2, 2, 2, 1402, 1403, 7, 69, 2, 2, 1403, 1404, 7, 87, 2, 2, 1404, 1405, 7, 84, 2, 2, 1405, 1406, 7, 84, 2, 2, 1406, 1407, 7, 71, 2, 2, 1407, 1408, 7, 80, 2, 2, 1408, 1409, 7, 86, 2, 2, 1409, 1410, 7, 97, 2, 2, 1410, 1411, 7, 84, 2, 2, 1411, 1412, 7, 81, 2, 2, 1412, 1413, 7, 78, 2, 2, 1413, 1414, 7, 71, 2, 2, 1414, 112, 3, 2, 2, 2, 1415, 1416, 7, 69, 2, 2, 1416, 1417, 7, 87, 2, 2, 1417, 1418, 7, 84, 2, 2, 1418, 1419, 7, 84, 2, 2, 1419, 1420, 7, 71, 2, 2, 1420, 1421, 7, 80, 2, 2, 1421, 1422, 7, 86, 2, 2, 1422, 1423, 7, 97, 2, 2, 1423, 1424, 7, 86, 2, 2, 1424, 1425, 7, 75, 2, 2, 1425, 1426, 7, 79, 2, 2, 1426, 1427, 7, 71, 2, 2, 1427, 114, 3, 2, 2, 2, 1428, 1429, 7, 69, 2, 2, 1429, 1430, 7, 87, 2, 2, 1430, 1431, 7, 84, 2, 2, 1431, 1432, 7, 84, 2, 2, 1432, 1433, 7, 71, 2, 2, 1433, 1434, 7, 80, 2, 2, 1434, 1435, 7, 86, 2, 2, 1435, 1436, 7, 97, 2, 2, 1436, 1437, 7, 86, 2, 2, 1437, 1438, 7, 75, 2, 2, 1438, 1439, 7, 79, 2, 2, 1439, 1440, 7, 71, 2, 2, 1440, 1441, 7, 85, 2, 2, 1441, 1442, 7, 86, 2, 2, 1442, 1443, 7, 67, 2, 2, 1443, 1444, 7, 79, 2, 2, 1444, 1445, 7, 82, 2, 2, 1445, 116, 3, 2, 2, 2, 1446, 1447, 7, 69, 2, 2, 1447, 1448, 7, 87, 2, 2, 1448, 1449, 7, 84, 2, 2, 1449, 1450, 7, 84, 2, 2, 1450, 1451, 7, 71, 2, 2, 1451, 1452, 7, 80, 2, 2, 1452, 1453, 7, 86, 2, 2, 1453, 1454, 7, 97, 2, 2, 1454, 1455, 7, 87, 2, 2, 1455, 1456, 7, 85, 2, 2, 1456, 1457, 7, 71, 2, 2, 1457, 1458, 7, 84, 2, 2, 1458, 118, 3, 2, 2, 2, 1459, 1460, 7, 70, 2, 2, 1460, 1461, 7, 71, 2, 2, 1461, 1462, 7, 72, 2, 2, 1462, 1463, 7, 67, 2, 2, 1463, 1464, 7, 87, 2, 2, 1464, 1465, 7, 78, 2, 2, 1465, 1466, 7, 86, 2, 2, 1466, 120, 3, 2, 2, 2, 1467, 1468, 7, 70, 2, 2, 1468, 1469, 7, 71, 2, 2, 1469, 1470, 7, 72, 2, 2, 1470, 1471, 7, 71, 2, 2, 1471, 1472, 7, 84, 2, 2, 1472, 1473, 7, 84, 2, 2, 1473, 1474, 7, 67, 2, 2, 1474, 1475, 7, 68, 2, 2, 1475, 1476, 7, 78, 2, 2, 1476, 1477, 7, 71, 2, 2, 1477, 122, 3, 2, 2, 2, 1478, 1479, 7, 70, 2, 2, 1479, 1480, 7, 71, 2, 2, 1480, 1481, 7, 85, 2, 2, 1481, 1482, 7, 69, 2, 2, 1482, 124, 3, 2, 2, 2, 1483, 1484, 7, 70, 2, 2, 1484, 1485, 7, 75, 2, 2, 1485, 1486, 7, 85, 2, 2, 1486, 1487, 7, 86, 2, 2, 1487, 1488, 7, 75, 2, 2, 1488, 1489, 7, 80, 2, 2, 1489, 1490, 7, 69, 2, 2, 1490, 1491, 7, 86, 2, 2, 1491, 126, 3, 2, 2, 2, 1492, 1493, 7, 70, 2, 2, 1493, 1494, 7, 81, 2, 2, 1494, 128, 3, 2, 2, 2, 1495, 1496, 7, 71, 2, 2, 1496, 1497, 7, 78, 2, 2, 1497, 1498, 7, 85, 2, 2, 1498, 1499, 7, 71, 2, 2, 1499, 130, 3, 2, 2, 2, 1500, 1501, 7, 71, 2, 2, 1501, 1502, 7, 90, 2, 2, 1502, 1503, 7, 69, 2, 2, 1503, 1504, 7, 71, 2, 2, 1504, 1505, 7, 82, 2, 2, 1505, 1506, 7, 86, 2, 2, 1506, 132, 3, 2, 2, 2, 1507, 1508, 7, 72, 2, 2, 1508, 1509, 7, 67, 2, 2, 1509, 1510, 7, 78, 2, 2, 1510, 1511, 7, 85, 2, 2, 1511, 1512, 7, 71, 2, 2, 1512, 134, 3, 2, 2, 2, 1513, 1514, 7, 72, 2, 2, 1514, 1515, 7, 71, 2, 2, 1515, 1516, 7, 86, 2, 2, 1516, 1517, 7, 69, 2, 2, 1517, 1518, 7, 74, 2, 2, 1518, 136, 3, 2, 2, 2, 1519, 1520, 7, 72, 2, 2, 1520, 1521, 7, 81, 2, 2, 1521, 1522, 7, 84, 2, 2, 1522, 138, 3, 2, 2, 2, 1523, 1524, 7, 72, 2, 2, 1524, 1525, 7, 81, 2, 2, 1525, 1526, 7, 84, 2, 2, 1526, 1527, 7, 71, 2, 2, 1527, 1528, 7, 75, 2, 2, 1528, 1529, 7, 73, 2, 2, 1529, 1530, 7, 80, 2, 2, 1530, 140, 3, 2, 2, 2, 1531, 1532, 7, 72, 2, 2, 1532, 1533, 7, 84, 2, 2, 1533, 1534, 7, 81, 2, 2, 1534, 1535, 7, 79, 2, 2, 1535, 142, 3, 2, 2, 2, 1536, 1537, 7, 73, 2, 2, 1537, 1538, 7, 84, 2, 2, 1538, 1539, 7, 67, 2, 2, 1539, 1540, 7, 80, 2, 2, 1540, 1541, 7, 86, 2, 2, 1541, 144, 3, 2, 2, 2, 1542, 1543, 7, 73, 2, 2, 1543, 1544, 7, 84, 2, 2, 1544, 1545, 7, 81, 2, 2, 1545, 1546, 7, 87, 2, 2, 1546, 1547, 7, 82, 2, 2, 1547, 146, 3, 2, 2, 2, 1548, 1549, 7, 74, 2, 2, 1549, 1550, 7, 67, 2, 2, 1550, 1551, 7, 88, 2, 2, 1551, 1552, 7, 75, 2, 2, 1552, 1553, 7, 80, 2, 2, 1553, 1554, 7, 73, 2, 2, 1554, 148, 3, 2, 2, 2, 1555, 1556, 7, 75, 2, 2, 1556, 1557, 7, 80, 2, 2, 1557, 150, 3, 2, 2, 2, 1558, 1559, 7, 75, 2, 2, 1559, 1560, 7, 80, 2, 2, 1560, 1561, 7, 75, 2, 2, 1561, 1562, 7, 86, 2, 2, 1562, 1563, 7, 75, 2, 2, 1563, 1564, 7, 67, 2, 2, 1564, 1565, 7, 78, 2, 2, 1565, 1566, 7, 78, 2, 2, 1566, 1567, 7, 91, 2, 2, 1567, 152, 3, 2, 2, 2, 1568, 1569, 7, 75, 2, 2, 1569, 1570, 7, 80, 2, 2, 1570, 1571, 7, 86, 2, 2, 1571, 1572, 7, 71, 2, 2, 1572, 1573, 7, 84, 2, 2, 1573, 1574, 7, 85, 2, 2, 1574, 1575, 7, 71, 2, 2, 1575, 1576, 7, 69, 2, 2, 1576, 1577, 7, 86, 2, 2, 1577, 154, 3, 2, 2, 2, 1578, 1579, 7, 75, 2, 2, 1579, 1580, 7, 80, 2, 2, 1580, 1581, 7, 86, 2, 2, 1581, 1582, 7, 81, 2, 2, 1582, 156, 3, 2, 2, 2, 1583, 1584, 7, 78, 2, 2, 1584, 1585, 7, 67, 2, 2, 1585, 1586, 7, 86, 2, 2, 1586, 1587, 7, 71, 2, 2, 1587, 1588, 7, 84, 2, 2, 1588, 1589, 7, 67, 2, 2, 1589, 1590, 7, 78, 2, 2, 1590, 158, 3, 2, 2, 2, 1591, 1592, 7, 78, 2, 2, 1592, 1593, 7, 71, 2, 2, 1593, 1594, 7, 67, 2, 2, 1594, 1595, 7, 70, 2, 2, 1595, 1596, 7, 75, 2, 2, 1596, 1597, 7, 80, 2, 2, 1597, 1598, 7, 73, 2, 2, 1598, 160, 3, 2, 2, 2, 1599, 1600, 7, 78, 2, 2, 1600, 1601, 7, 75, 2, 2, 1601, 1602, 7, 79, 2, 2, 1602, 1603, 7, 75, 2, 2, 1603, 1604, 7, 86, 2, 2, 1604, 162, 3, 2, 2, 2, 1605, 1606, 7, 78, 2, 2, 1606, 1607, 7, 81, 2, 2, 1607, 1608, 7, 69, 2, 2, 1608, 1609, 7, 67, 2, 2, 1609, 1610, 7, 78, 2, 2, 1610, 1611, 7, 86, 2, 2, 1611, 1612, 7, 75, 2, 2, 1612, 1613, 7, 79, 2, 2, 1613, 1614, 7, 71, 2, 2, 1614, 164, 3, 2, 2, 2, 1615, 1616, 7, 78, 2, 2, 1616, 1617, 7, 81, 2, 2, 1617, 1618, 7, 69, 2, 2, 1618, 1619, 7, 67, 2, 2, 1619, 1620, 7, 78, 2, 2, 1620, 1621, 7, 86, 2, 2, 1621, 1622, 7, 75, 2, 2, 1622, 1623, 7, 79, 2, 2, 1623, 1624, 7, 71, 2, 2, 1624, 1625, 7, 85, 2, 2, 1625, 1626, 7, 86, 2, 2, 1626, 1627, 7, 67, 2, 2, 1627, 1628, 7, 79, 2, 2, 1628, 1629, 7, 82, 2, 2, 1629, 166, 3, 2, 2, 2, 1630, 1631, 7, 80, 2, 2, 1631, 1632, 7, 81, 2, 2, 1632, 1633, 7, 86, 2, 2, 1633, 168, 3, 2, 2, 2, 1634, 1635, 7, 80, 2, 2, 1635, 1636, 7, 87, 2, 2, 1636, 1637, 7, 78, 2, 2, 1637, 1638, 7, 78, 2, 2, 1638, 170, 3, 2, 2, 2, 1639, 1640, 7, 81, 2, 2, 1640, 1641, 7, 72, 2, 2, 1641, 1642, 7, 72, 2, 2, 1642, 1643, 7, 85, 2, 2, 1643, 1644, 7, 71, 2, 2, 1644, 1645, 7, 86, 2, 2, 1645, 172, 3, 2, 2, 2, 1646, 1647, 7, 81, 2, 2, 1647, 1648, 7, 80, 2, 2, 1648, 174, 3, 2, 2, 2, 1649, 1650, 7, 81, 2, 2, 1650, 1651, 7, 80, 2, 2, 1651, 1652, 7, 78, 2, 2, 1652, 1653, 7, 91, 2, 2, 1653, 176, 3, 2, 2, 2, 1654, 1655, 7, 81, 2, 2, 1655, 1656, 7, 84, 2, 2, 1656, 178, 3, 2, 2, 2, 1657, 1658, 7, 81, 2, 2, 1658, 1659, 7, 84, 2, 2, 1659, 1660, 7, 70, 2, 2, 1660, 1661, 7, 71, 2, 2, 1661, 1662, 7, 84, 2, 2, 1662, 180, 3, 2, 2, 2, 1663, 1664, 7, 82, 2, 2, 1664, 1665, 7, 78, 2, 2, 1665, 1666, 7, 67, 2, 2, 1666, 1667, 7, 69, 2, 2, 1667, 1668, 7, 75, 2, 2, 1668, 1669, 7, 80, 2, 2, 1669, 1670, 7, 73, 2, 2, 1670, 182, 3, 2, 2, 2, 1671, 1672, 7, 82, 2, 2, 1672, 1673, 7, 84, 2, 2, 1673, 1674, 7, 75, 2, 2, 1674, 1675, 7, 79, 2, 2, 1675, 1676, 7, 67, 2, 2, 1676, 1677, 7, 84, 2, 2, 1677, 1678, 7, 91, 2, 2, 1678, 184, 3, 2, 2, 2, 1679, 1680, 7, 84, 2, 2, 1680, 1681, 7, 71, 2, 2, 1681, 1682, 7, 72, 2, 2, 1682, 1683, 7, 71, 2, 2, 1683, 1684, 7, 84, 2, 2, 1684, 1685, 7, 71, 2, 2, 1685, 1686, 7, 80, 2, 2, 1686, 1687, 7, 69, 2, 2, 1687, 1688, 7, 71, 2, 2, 1688, 1689, 7, 85, 2, 2, 1689, 186, 3, 2, 2, 2, 1690, 1691, 7, 84, 2, 2, 1691, 1692, 7, 71, 2, 2, 1692, 1693, 7, 86, 2, 2, 1693, 1694, 7, 87, 2, 2, 1694, 1695, 7, 84, 2, 2, 1695, 1696, 7, 80, 2, 2, 1696, 1697, 7, 75, 2, 2, 1697, 1698, 7, 80, 2, 2, 1698, 1699, 7, 73, 2, 2, 1699, 188, 3, 2, 2, 2, 1700, 1701, 7, 85, 2, 2, 1701, 1702, 7, 71, 2, 2, 1702, 1703, 7, 78, 2, 2, 1703, 1704, 7, 71, 2, 2, 1704, 1705, 7, 69, 2, 2, 1705, 1706, 7, 86, 2, 2, 1706, 190, 3, 2, 2, 2, 1707, 1708, 7, 85, 2, 2, 1708, 1709, 7, 71, 2, 2, 1709, 1710, 7, 85, 2, 2, 1710, 1711, 7, 85, 2, 2, 1711, 1712, 7, 75, 2, 2, 1712, 1713, 7, 81, 2, 2, 1713, 1714, 7, 80, 2, 2, 1714, 1715, 7, 97, 2, 2, 1715, 1716, 7, 87, 2, 2, 1716, 1717, 7, 85, 2, 2, 1717, 1718, 7, 71, 2, 2, 1718, 1719, 7, 84, 2, 2, 1719, 192, 3, 2, 2, 2, 1720, 1721, 7, 85, 2, 2, 1721, 1722, 7, 81, 2, 2, 1722, 1723, 7, 79, 2, 2, 1723, 1724, 7, 71, 2, 2, 1724, 194, 3, 2, 2, 2, 1725, 1726, 7, 85, 2, 2, 1726, 1727, 7, 91, 2, 2, 1727, 1728, 7, 79, 2, 2, 1728, 1729, 7, 79, 2, 2, 1729, 1730, 7, 71, 2, 2, 1730, 1731, 7, 86, 2, 2, 1731, 1732, 7, 84, 2, 2, 1732, 1733, 7, 75, 2, 2, 1733, 1734, 7, 69, 2, 2, 1734, 196, 3, 2, 2, 2, 1735, 1736, 7, 86, 2, 2, 1736, 1737, 7, 67, 2, 2, 1737, 1738, 7, 68, 2, 2, 1738, 1739, 7, 78, 2, 2, 1739, 1740, 7, 71, 2, 2, 1740, 198, 3, 2, 2, 2, 1741, 1742, 7, 86, 2, 2, 1742, 1743, 7, 74, 2, 2, 1743, 1744, 7, 71, 2, 2, 1744, 1745, 7, 80, 2, 2, 1745, 200, 3, 2, 2, 2, 1746, 1747, 7, 86, 2, 2, 1747, 1748, 7, 81, 2, 2, 1748, 202, 3, 2, 2, 2, 1749, 1750, 7, 86, 2, 2, 1750, 1751, 7, 84, 2, 2, 1751, 1752, 7, 67, 2, 2, 1752, 1753, 7, 75, 2, 2, 1753, 1754, 7, 78, 2, 2, 1754, 1755, 7, 75, 2, 2, 1755, 1756, 7, 80, 2, 2, 1756, 1757, 7, 73, 2, 2, 1757, 204, 3, 2, 2, 2, 1758, 1759, 7, 86, 2, 2, 1759, 1760, 7, 84, 2, 2, 1760, 1761, 7, 87, 2, 2, 1761, 1762, 7, 71, 2, 2, 1762, 206, 3, 2, 2, 2, 1763, 1764, 7, 87, 2, 2, 1764, 1765, 7, 80, 2, 2, 1765, 1766, 7, 75, 2, 2, 1766, 1767, 7, 81, 2, 2, 1767, 1768, 7, 80, 2, 2, 1768, 208, 3, 2, 2, 2, 1769, 1770, 7, 87, 2, 2, 1770, 1771, 7, 80, 2, 2, 1771, 1772, 7, 75, 2, 2, 1772, 1773, 7, 83, 2, 2, 1773, 1774, 7, 87, 2, 2, 1774, 1775, 7, 71, 2, 2, 1775, 210, 3, 2, 2, 2, 1776, 1777, 7, 87, 2, 2, 1777, 1778, 7, 85, 2, 2, 1778, 1779, 7, 71, 2, 2, 1779, 1780, 7, 84, 2, 2, 1780, 212, 3, 2, 2, 2, 1781, 1782, 7, 87, 2, 2, 1782, 1783, 7, 85, 2, 2, 1783, 1784, 7, 75, 2, 2, 1784, 1785, 7, 80, 2, 2, 1785, 1786, 7, 73, 2, 2, 1786, 214, 3, 2, 2, 2, 1787, 1788, 7, 88, 2, 2, 1788, 1789, 7, 67, 2, 2, 1789, 1790, 7, 84, 2, 2, 1790, 1791, 7, 75, 2, 2, 1791, 1792, 7, 67, 2, 2, 1792, 1793, 7, 70, 2, 2, 1793, 1794, 7, 75, 2, 2, 1794, 1795, 7, 69, 2, 2, 1795, 216, 3, 2, 2, 2, 1796, 1797, 7, 89, 2, 2, 1797, 1798, 7, 74, 2, 2, 1798, 1799, 7, 71, 2, 2, 1799, 1800, 7, 80, 2, 2, 1800, 218, 3, 2, 2, 2, 1801, 1802, 7, 89, 2, 2, 1802, 1803, 7, 74, 2, 2, 1803, 1804, 7, 71, 2, 2, 1804, 1805, 7, 84, 2, 2, 1805, 1806, 7, 71, 2, 2, 1806, 220, 3, 2, 2, 2, 1807, 1808, 7, 89, 2, 2, 1808, 1809, 7, 75, 2, 2, 1809, 1810, 7, 80, 2, 2, 1810, 1811, 7, 70, 2, 2, 1811, 1812, 7, 81, 2, 2, 1812, 1813, 7, 89, 2, 2, 1813, 222, 3, 2, 2, 2, 1814, 1815, 7, 89, 2, 2, 1815, 1816, 7, 75, 2, 2, 1816, 1817, 7, 86, 2, 2, 1817, 1818, 7, 74, 2, 2, 1818, 224, 3, 2, 2, 2, 1819, 1820, 7, 67, 2, 2, 1820, 1821, 7, 87, 2, 2, 1821, 1822, 7, 86, 2, 2, 1822, 1823, 7, 74, 2, 2, 1823, 1824, 7, 81, 2, 2, 1824, 1825, 7, 84, 2, 2, 1825, 1826, 7, 75, 2, 2, 1826, 1827, 7, 92, 2, 2, 1827, 1828, 7, 67, 2, 2, 1828, 1829, 7, 86, 2, 2, 1829, 1830, 7, 75, 2, 2, 1830, 1831, 7, 81, 2, 2, 1831, 1832, 7, 80, 2, 2, 1832, 226, 3, 2, 2, 2, 1833, 1834, 7, 68, 2, 2, 1834, 1835, 7, 75, 2, 2, 1835, 1836, 7, 80, 2, 2, 1836, 1837, 7, 67, 2, 2, 1837, 1838, 7, 84, 2, 2, 1838, 1839, 7, 91, 2, 2, 1839, 228, 3, 2, 2, 2, 1840, 1841, 7, 69, 2, 2, 1841, 1842, 7, 81, 2, 2, 1842, 1843, 7, 78, 2, 2, 1843, 1844, 7, 78, 2, 2, 1844, 1845, 7, 67, 2, 2, 1845, 1846, 7, 86, 2, 2, 1846, 1847, 7, 75, 2, 2, 1847, 1848, 7, 81, 2, 2, 1848, 1849, 7, 80, 2, 2, 1849, 230, 3, 2, 2, 2, 1850, 1851, 7, 69, 2, 2, 1851, 1852, 7, 81, 2, 2, 1852, 1853, 7, 80, 2, 2, 1853, 1854, 7, 69, 2, 2, 1854, 1855, 7, 87, 2, 2, 1855, 1856, 7, 84, 2, 2, 1856, 1857, 7, 84, 2, 2, 1857, 1858, 7, 71, 2, 2, 1858, 1859, 7, 80, 2, 2, 1859, 1860, 7, 86, 2, 2, 1860, 1861, 7, 78, 2, 2, 1861, 1862, 7, 91, 2, 2, 1862, 232, 3, 2, 2, 2, 1863, 1864, 7, 69, 2, 2, 1864, 1865, 7, 84, 2, 2, 1865, 1866, 7, 81, 2, 2, 1866, 1867, 7, 85, 2, 2, 1867, 1868, 7, 85, 2, 2, 1868, 234, 3, 2, 2, 2, 1869, 1870, 7, 69, 2, 2, 1870, 1871, 7, 87, 2, 2, 1871, 1872, 7, 84, 2, 2, 1872, 1873, 7, 84, 2, 2, 1873, 1874, 7, 71, 2, 2, 1874, 1875, 7, 80, 2, 2, 1875, 1876, 7, 86, 2, 2, 1876, 1877, 7, 97, 2, 2, 1877, 1878, 7, 85, 2, 2, 1878, 1879, 7, 69, 2, 2, 1879, 1880, 7, 74, 2, 2, 1880, 1881, 7, 71, 2, 2, 1881, 1882, 7, 79, 2, 2, 1882, 1883, 7, 67, 2, 2, 1883, 236, 3, 2, 2, 2, 1884, 1885, 7, 72, 2, 2, 1885, 1886, 7, 84, 2, 2, 1886, 1887, 7, 71, 2, 2, 1887, 1888, 7, 71, 2, 2, 1888, 1889, 7, 92, 2, 2, 1889, 1890, 7, 71, 2, 2, 1890, 238, 3, 2, 2, 2, 1891, 1892, 7, 72, 2, 2, 1892, 1893, 7, 87, 2, 2, 1893, 1894, 7, 78, 2, 2, 1894, 1895, 7, 78, 2, 2, 1895, 240, 3, 2, 2, 2, 1896, 1897, 7, 75, 2, 2, 1897, 1898, 7, 78, 2, 2, 1898, 1899, 7, 75, 2, 2, 1899, 1900, 7, 77, 2, 2, 1900, 1901, 7, 71, 2, 2, 1901, 242, 3, 2, 2, 2, 1902, 1903, 7, 75, 2, 2, 1903, 1904, 7, 80, 2, 2, 1904, 1905, 7, 80, 2, 2, 1905, 1906, 7, 71, 2, 2, 1906, 1907, 7, 84, 2, 2, 1907, 244, 3, 2, 2, 2, 1908, 1909, 7, 75, 2, 2, 1909, 1910, 7, 85, 2, 2, 1910, 246, 3, 2, 2, 2, 1911, 1912, 7, 75, 2, 2, 1912, 1913, 7, 85, 2, 2, 1913, 1914, 7, 80, 2, 2, 1914, 1915, 7, 87, 2, 2, 1915, 1916, 7, 78, 2, 2, 1916, 1917, 7, 78, 2, 2, 1917, 248, 3, 2, 2, 2, 1918, 1919, 7, 76, 2, 2, 1919, 1920, 7, 81, 2, 2, 1920, 1921, 7, 75, 2, 2, 1921, 1922, 7, 80, 2, 2, 1922, 250, 3, 2, 2, 2, 1923, 1924, 7, 78, 2, 2, 1924, 1925, 7, 71, 2, 2, 1925, 1926, 7, 72, 2, 2, 1926, 1927, 7, 86, 2, 2, 1927, 252, 3, 2, 2, 2, 1928, 1929, 7, 78, 2, 2, 1929, 1930, 7, 75, 2, 2, 1930, 1931, 7, 77, 2, 2, 1931, 1932, 7, 71, 2, 2, 1932, 254, 3, 2, 2, 2, 1933, 1934, 7, 80, 2, 2, 1934, 1935, 7, 67, 2, 2, 1935, 1936, 7, 86, 2, 2, 1936, 1937, 7, 87, 2, 2, 1937, 1938, 7, 84, 2, 2, 1938, 1939, 7, 67, 2, 2, 1939, 1940, 7, 78, 2, 2, 1940, 256, 3, 2, 2, 2, 1941, 1942, 7, 80, 2, 2, 1942, 1943, 7, 81, 2, 2, 1943, 1944, 7, 86, 2, 2, 1944, 1945, 7, 80, 2, 2, 1945, 1946, 7, 87, 2, 2, 1946, 1947, 7, 78, 2, 2, 1947, 1948, 7, 78, 2, 2, 1948, 258, 3, 2, 2, 2, 1949, 1950, 7, 81, 2, 2, 1950, 1951, 7, 87, 2, 2, 1951, 1952, 7, 86, 2, 2, 1952, 1953, 7, 71, 2, 2, 1953, 1954, 7, 84, 2, 2, 1954, 260, 3, 2, 2, 2, 1955, 1956, 7, 81, 2, 2, 1956, 1957, 7, 88, 2, 2, 1957, 1958, 7, 71, 2, 2, 1958, 1959, 7, 84, 2, 2, 1959, 262, 3, 2, 2, 2, 1960, 1961, 7, 81, 2, 2, 1961, 1962, 7, 88, 2, 2, 1962, 1963, 7, 71, 2, 2, 1963, 1964, 7, 84, 2, 2, 1964, 1965, 7, 78, 2, 2, 1965, 1966, 7, 67, 2, 2, 1966, 1967, 7, 82, 2, 2, 1967, 1968, 7, 85, 2, 2, 1968, 264, 3, 2, 2, 2, 1969, 1970, 7, 84, 2, 2, 1970, 1971, 7, 75, 2, 2, 1971, 1972, 7, 73, 2, 2, 1972, 1973, 7, 74, 2, 2, 1973, 1974, 7, 86, 2, 2, 1974, 266, 3, 2, 2, 2, 1975, 1976, 7, 85, 2, 2, 1976, 1977, 7, 75, 2, 2, 1977, 1978, 7, 79, 2, 2, 1978, 1979, 7, 75, 2, 2, 1979, 1980, 7, 78, 2, 2, 1980, 1981, 7, 67, 2, 2, 1981, 1982, 7, 84, 2, 2, 1982, 268, 3, 2, 2, 2, 1983, 1984, 7, 88, 2, 2, 1984, 1985, 7, 71, 2, 2, 1985, 1986, 7, 84, 2, 2, 1986, 1987, 7, 68, 2, 2, 1987, 1988, 7, 81, 2, 2, 1988, 1989, 7, 85, 2, 2, 1989, 1990, 7, 71, 2, 2, 1990, 270, 3, 2, 2, 2, 1991, 1992, 7, 67, 2, 2, 1992, 1993, 7, 68, 2, 2, 1993, 1994, 7, 81, 2, 2, 1994, 1995, 7, 84, 2, 2, 1995, 1996, 7, 86, 2, 2, 1996, 272, 3, 2, 2, 2, 1997, 1998, 7, 67, 2, 2, 1998, 1999, 7, 68, 2, 2, 1999, 2000, 7, 85, 2, 2, 2000, 2001, 7, 81, 2, 2, 2001, 2002, 7, 78, 2, 2, 2002, 2003, 7, 87, 2, 2, 2003, 2004, 7, 86, 2, 2, 2004, 2005, 7, 71, 2, 2, 2005, 274, 3, 2, 2, 2, 2006, 2007, 7, 67, 2, 2, 2007, 2008, 7, 69, 2, 2, 2008, 2009, 7, 69, 2, 2, 2009, 2010, 7, 71, 2, 2, 2010, 2011, 7, 85, 2, 2, 2011, 2012, 7, 85, 2, 2, 2012, 276, 3, 2, 2, 2, 2013, 2014, 7, 67, 2, 2, 2014, 2015, 7, 69, 2, 2, 2015, 2016, 7, 86, 2, 2, 2016, 2017, 7, 75, 2, 2, 2017, 2018, 7, 81, 2, 2, 2018, 2019, 7, 80, 2, 2, 2019, 278, 3, 2, 2, 2, 2020, 2021, 7, 67, 2, 2, 2021, 2022, 7, 70, 2, 2, 2022, 2023, 7, 70, 2, 2, 2023, 280, 3, 2, 2, 2, 2024, 2025, 7, 67, 2, 2, 2025, 2026, 7, 70, 2, 2, 2026, 2027, 7, 79, 2, 2, 2027, 2028, 7, 75, 2, 2, 2028, 2029, 7, 80, 2, 2, 2029, 282, 3, 2, 2, 2, 2030, 2031, 7, 67, 2, 2, 2031, 2032, 7, 72, 2, 2, 2032, 2033, 7, 86, 2, 2, 2033, 2034, 7, 71, 2, 2, 2034, 2035, 7, 84, 2, 2, 2035, 284, 3, 2, 2, 2, 2036, 2037, 7, 67, 2, 2, 2037, 2038, 7, 73, 2, 2, 2038, 2039, 7, 73, 2, 2, 2039, 2040, 7, 84, 2, 2, 2040, 2041, 7, 71, 2, 2, 2041, 2042, 7, 73, 2, 2, 2042, 2043, 7, 67, 2, 2, 2043, 2044, 7, 86, 2, 2, 2044, 2045, 7, 71, 2, 2, 2045, 286, 3, 2, 2, 2, 2046, 2047, 7, 67, 2, 2, 2047, 2048, 7, 78, 2, 2, 2048, 2049, 7, 85, 2, 2, 2049, 2050, 7, 81, 2, 2, 2050, 288, 3, 2, 2, 2, 2051, 2052, 7, 67, 2, 2, 2052, 2053, 7, 78, 2, 2, 2053, 2054, 7, 86, 2, 2, 2054, 2055, 7, 71, 2, 2, 2055, 2056, 7, 84, 2, 2, 2056, 290, 3, 2, 2, 2, 2057, 2058, 7, 67, 2, 2, 2058, 2059, 7, 78, 2, 2, 2059, 2060, 7, 89, 2, 2, 2060, 2061, 7, 67, 2, 2, 2061, 2062, 7, 91, 2, 2, 2062, 2063, 7, 85, 2, 2, 2063, 292, 3, 2, 2, 2, 2064, 2065, 7, 67, 2, 2, 2065, 2066, 7, 85, 2, 2, 2066, 2067, 7, 85, 2, 2, 2067, 2068, 7, 71, 2, 2, 2068, 2069, 7, 84, 2, 2, 2069, 2070, 7, 86, 2, 2, 2070, 2071, 7, 75, 2, 2, 2071, 2072, 7, 81, 2, 2, 2072, 2073, 7, 80, 2, 2, 2073, 294, 3, 2, 2, 2, 2074, 2075, 7, 67, 2, 2, 2075, 2076, 7, 85, 2, 2, 2076, 2077, 7, 85, 2, 2, 2077, 2078, 7, 75, 2, 2, 2078, 2079, 7, 73, 2, 2, 2079, 2080, 7, 80, 2, 2, 2080, 2081, 7, 79, 2, 2, 2081, 2082, 7, 71, 2, 2, 2082, 2083, 7, 80, 2, 2, 2083, 2084, 7, 86, 2, 2, 2084, 296, 3, 2, 2, 2, 2085, 2086, 7, 67, 2, 2, 2086, 2087, 7, 86, 2, 2, 2087, 298, 3, 2, 2, 2, 2088, 2089, 7, 67, 2, 2, 2089, 2090, 7, 86, 2, 2, 2090, 2091, 7, 86, 2, 2, 2091, 2092, 7, 84, 2, 2, 2092, 2093, 7, 75, 2, 2, 2093, 2094, 7, 68, 2, 2, 2094, 2095, 7, 87, 2, 2, 2095, 2096, 7, 86, 2, 2, 2096, 2097, 7, 71, 2, 2, 2097, 300, 3, 2, 2, 2, 2098, 2099, 7, 68, 2, 2, 2099, 2100, 7, 67, 2, 2, 2100, 2101, 7, 69, 2, 2, 2101, 2102, 7, 77, 2, 2, 2102, 2103, 7, 89, 2, 2, 2103, 2104, 7, 67, 2, 2, 2104, 2105, 7, 84, 2, 2, 2105, 2106, 7, 70, 2, 2, 2106, 302, 3, 2, 2, 2, 2107, 2108, 7, 68, 2, 2, 2108, 2109, 7, 71, 2, 2, 2109, 2110, 7, 72, 2, 2, 2110, 2111, 7, 81, 2, 2, 2111, 2112, 7, 84, 2, 2, 2112, 2113, 7, 71, 2, 2, 2113, 304, 3, 2, 2, 2, 2114, 2115, 7, 68, 2, 2, 2115, 2116, 7, 71, 2, 2, 2116, 2117, 7, 73, 2, 2, 2117, 2118, 7, 75, 2, 2, 2118, 2119, 7, 80, 2, 2, 2119, 306, 3, 2, 2, 2, 2120, 2121, 7, 68, 2, 2, 2121, 2122, 7, 91, 2, 2, 2122, 308, 3, 2, 2, 2, 2123, 2124, 7, 69, 2, 2, 2124, 2125, 7, 67, 2, 2, 2125, 2126, 7, 69, 2, 2, 2126, 2127, 7, 74, 2, 2, 2127, 2128, 7, 71, 2, 2, 2128, 310, 3, 2, 2, 2, 2129, 2130, 7, 69, 2, 2, 2130, 2131, 7, 67, 2, 2, 2131, 2132, 7, 78, 2, 2, 2132, 2133, 7, 78, 2, 2, 2133, 2134, 7, 71, 2, 2, 2134, 2135, 7, 70, 2, 2, 2135, 312, 3, 2, 2, 2, 2136, 2137, 7, 69, 2, 2, 2137, 2138, 7, 67, 2, 2, 2138, 2139, 7, 85, 2, 2, 2139, 2140, 7, 69, 2, 2, 2140, 2141, 7, 67, 2, 2, 2141, 2142, 7, 70, 2, 2, 2142, 2143, 7, 71, 2, 2, 2143, 314, 3, 2, 2, 2, 2144, 2145, 7, 69, 2, 2, 2145, 2146, 7, 67, 2, 2, 2146, 2147, 7, 85, 2, 2, 2147, 2148, 7, 69, 2, 2, 2148, 2149, 7, 67, 2, 2, 2149, 2150, 7, 70, 2, 2, 2150, 2151, 7, 71, 2, 2, 2151, 2152, 7, 70, 2, 2, 2152, 316, 3, 2, 2, 2, 2153, 2154, 7, 69, 2, 2, 2154, 2155, 7, 67, 2, 2, 2155, 2156, 7, 86, 2, 2, 2156, 2157, 7, 67, 2, 2, 2157, 2158, 7, 78, 2, 2, 2158, 2159, 7, 81, 2, 2, 2159, 2160, 7, 73, 2, 2, 2160, 318, 3, 2, 2, 2, 2161, 2162, 7, 69, 2, 2, 2162, 2163, 7, 74, 2, 2, 2163, 2164, 7, 67, 2, 2, 2164, 2165, 7, 75, 2, 2, 2165, 2166, 7, 80, 2, 2, 2166, 320, 3, 2, 2, 2, 2167, 2168, 7, 69, 2, 2, 2168, 2169, 7, 74, 2, 2, 2169, 2170, 7, 67, 2, 2, 2170, 2171, 7, 84, 2, 2, 2171, 2172, 7, 67, 2, 2, 2172, 2173, 7, 69, 2, 2, 2173, 2174, 7, 86, 2, 2, 2174, 2175, 7, 71, 2, 2, 2175, 2176, 7, 84, 2, 2, 2176, 2177, 7, 75, 2, 2, 2177, 2178, 7, 85, 2, 2, 2178, 2179, 7, 86, 2, 2, 2179, 2180, 7, 75, 2, 2, 2180, 2181, 7, 69, 2, 2, 2181, 2182, 7, 85, 2, 2, 2182, 322, 3, 2, 2, 2, 2183, 2184, 7, 69, 2, 2, 2184, 2185, 7, 74, 2, 2, 2185, 2186, 7, 71, 2, 2, 2186, 2187, 7, 69, 2, 2, 2187, 2188, 7, 77, 2, 2, 2188, 2189, 7, 82, 2, 2, 2189, 2190, 7, 81, 2, 2, 2190, 2191, 7, 75, 2, 2, 2191, 2192, 7, 80, 2, 2, 2192, 2193, 7, 86, 2, 2, 2193, 324, 3, 2, 2, 2, 2194, 2195, 7, 69, 2, 2, 2195, 2196, 7, 78, 2, 2, 2196, 2197, 7, 67, 2, 2, 2197, 2198, 7, 85, 2, 2, 2198, 2199, 7, 85, 2, 2, 2199, 326, 3, 2, 2, 2, 2200, 2201, 7, 69, 2, 2, 2201, 2202, 7, 78, 2, 2, 2202, 2203, 7, 81, 2, 2, 2203, 2204, 7, 85, 2, 2, 2204, 2205, 7, 71, 2, 2, 2205, 328, 3, 2, 2, 2, 2206, 2207, 7, 69, 2, 2, 2207, 2208, 7, 78, 2, 2, 2208, 2209, 7, 87, 2, 2, 2209, 2210, 7, 85, 2, 2, 2210, 2211, 7, 86, 2, 2, 2211, 2212, 7, 71, 2, 2, 2212, 2213, 7, 84, 2, 2, 2213, 330, 3, 2, 2, 2, 2214, 2215, 7, 69, 2, 2, 2215, 2216, 7, 81, 2, 2, 2216, 2217, 7, 79, 2, 2, 2217, 2218, 7, 79, 2, 2, 2218, 2219, 7, 71, 2, 2, 2219, 2220, 7, 80, 2, 2, 2220, 2221, 7, 86, 2, 2, 2221, 332, 3, 2, 2, 2, 2222, 2223, 7, 69, 2, 2, 2223, 2224, 7, 81, 2, 2, 2224, 2225, 7, 79, 2, 2, 2225, 2226, 7, 79, 2, 2, 2226, 2227, 7, 71, 2, 2, 2227, 2228, 7, 80, 2, 2, 2228, 2229, 7, 86, 2, 2, 2229, 2230, 7, 85, 2, 2, 2230, 334, 3, 2, 2, 2, 2231, 2232, 7, 69, 2, 2, 2232, 2233, 7, 81, 2, 2, 2233, 2234, 7, 79, 2, 2, 2234, 2235, 7, 79, 2, 2, 2235, 2236, 7, 75, 2, 2, 2236, 2237, 7, 86, 2, 2, 2237, 336, 3, 2, 2, 2, 2238, 2239, 7, 69, 2, 2, 2239, 2240, 7, 81, 2, 2, 2240, 2241, 7, 79, 2, 2, 2241, 2242, 7, 79, 2, 2, 2242, 2243, 7, 75, 2, 2, 2243, 2244, 7, 86, 2, 2, 2244, 2245, 7, 86, 2, 2, 2245, 2246, 7, 71, 2, 2, 2246, 2247, 7, 70, 2, 2, 2247, 338, 3, 2, 2, 2, 2248, 2249, 7, 69, 2, 2, 2249, 2250, 7, 81, 2, 2, 2250, 2251, 7, 80, 2, 2, 2251, 2252, 7, 72, 2, 2, 2252, 2253, 7, 75, 2, 2, 2253, 2254, 7, 73, 2, 2, 2254, 2255, 7, 87, 2, 2, 2255, 2256, 7, 84, 2, 2, 2256, 2257, 7, 67, 2, 2, 2257, 2258, 7, 86, 2, 2, 2258, 2259, 7, 75, 2, 2, 2259, 2260, 7, 81, 2, 2, 2260, 2261, 7, 80, 2, 2, 2261, 340, 3, 2, 2, 2, 2262, 2263, 7, 69, 2, 2, 2263, 2264, 7, 81, 2, 2, 2264, 2265, 7, 80, 2, 2, 2265, 2266, 7, 80, 2, 2, 2266, 2267, 7, 71, 2, 2, 2267, 2268, 7, 69, 2, 2, 2268, 2269, 7, 86, 2, 2, 2269, 2270, 7, 75, 2, 2, 2270, 2271, 7, 81, 2, 2, 2271, 2272, 7, 80, 2, 2, 2272, 342, 3, 2, 2, 2, 2273, 2274, 7, 69, 2, 2, 2274, 2275, 7, 81, 2, 2, 2275, 2276, 7, 80, 2, 2, 2276, 2277, 7, 85, 2, 2, 2277, 2278, 7, 86, 2, 2, 2278, 2279, 7, 84, 2, 2, 2279, 2280, 7, 67, 2, 2, 2280, 2281, 7, 75, 2, 2, 2281, 2282, 7, 80, 2, 2, 2282, 2283, 7, 86, 2, 2, 2283, 2284, 7, 85, 2, 2, 2284, 344, 3, 2, 2, 2, 2285, 2286, 7, 69, 2, 2, 2286, 2287, 7, 81, 2, 2, 2287, 2288, 7, 80, 2, 2, 2288, 2289, 7, 86, 2, 2, 2289, 2290, 7, 71, 2, 2, 2290, 2291, 7, 80, 2, 2, 2291, 2292, 7, 86, 2, 2, 2292, 346, 3, 2, 2, 2, 2293, 2294, 7, 69, 2, 2, 2294, 2295, 7, 81, 2, 2, 2295, 2296, 7, 80, 2, 2, 2296, 2297, 7, 86, 2, 2, 2297, 2298, 7, 75, 2, 2, 2298, 2299, 7, 80, 2, 2, 2299, 2300, 7, 87, 2, 2, 2300, 2301, 7, 71, 2, 2, 2301, 348, 3, 2, 2, 2, 2302, 2303, 7, 69, 2, 2, 2303, 2304, 7, 81, 2, 2, 2304, 2305, 7, 80, 2, 2, 2305, 2306, 7, 88, 2, 2, 2306, 2307, 7, 71, 2, 2, 2307, 2308, 7, 84, 2, 2, 2308, 2309, 7, 85, 2, 2, 2309, 2310, 7, 75, 2, 2, 2310, 2311, 7, 81, 2, 2, 2311, 2312, 7, 80, 2, 2, 2312, 350, 3, 2, 2, 2, 2313, 2314, 7, 69, 2, 2, 2314, 2315, 7, 81, 2, 2, 2315, 2316, 7, 82, 2, 2, 2316, 2317, 7, 91, 2, 2, 2317, 352, 3, 2, 2, 2, 2318, 2319, 7, 69, 2, 2, 2319, 2320, 7, 81, 2, 2, 2320, 2321, 7, 85, 2, 2, 2321, 2322, 7, 86, 2, 2, 2322, 354, 3, 2, 2, 2, 2323, 2324, 7, 69, 2, 2, 2324, 2325, 7, 85, 2, 2, 2325, 2326, 7, 88, 2, 2, 2326, 356, 3, 2, 2, 2, 2327, 2328, 7, 69, 2, 2, 2328, 2329, 7, 87, 2, 2, 2329, 2330, 7, 84, 2, 2, 2330, 2331, 7, 85, 2, 2, 2331, 2332, 7, 81, 2, 2, 2332, 2333, 7, 84, 2, 2, 2333, 358, 3, 2, 2, 2, 2334, 2335, 7, 69, 2, 2, 2335, 2336, 7, 91, 2, 2, 2336, 2337, 7, 69, 2, 2, 2337, 2338, 7, 78, 2, 2, 2338, 2339, 7, 71, 2, 2, 2339, 360, 3, 2, 2, 2, 2340, 2341, 7, 70, 2, 2, 2341, 2342, 7, 67, 2, 2, 2342, 2343, 7, 86, 2, 2, 2343, 2344, 7, 67, 2, 2, 2344, 362, 3, 2, 2, 2, 2345, 2346, 7, 70, 2, 2, 2346, 2347, 7, 67, 2, 2, 2347, 2348, 7, 86, 2, 2, 2348, 2349, 7, 67, 2, 2, 2349, 2350, 7, 68, 2, 2, 2350, 2351, 7, 67, 2, 2, 2351, 2352, 7, 85, 2, 2, 2352, 2353, 7, 71, 2, 2, 2353, 364, 3, 2, 2, 2, 2354, 2355, 7, 70, 2, 2, 2355, 2356, 7, 67, 2, 2, 2356, 2357, 7, 91, 2, 2, 2357, 366, 3, 2, 2, 2, 2358, 2359, 7, 70, 2, 2, 2359, 2360, 7, 71, 2, 2, 2360, 2361, 7, 67, 2, 2, 2361, 2362, 7, 78, 2, 2, 2362, 2363, 7, 78, 2, 2, 2363, 2364, 7, 81, 2, 2, 2364, 2365, 7, 69, 2, 2, 2365, 2366, 7, 67, 2, 2, 2366, 2367, 7, 86, 2, 2, 2367, 2368, 7, 71, 2, 2, 2368, 368, 3, 2, 2, 2, 2369, 2370, 7, 70, 2, 2, 2370, 2371, 7, 71, 2, 2, 2371, 2372, 7, 69, 2, 2, 2372, 2373, 7, 78, 2, 2, 2373, 2374, 7, 67, 2, 2, 2374, 2375, 7, 84, 2, 2, 2375, 2376, 7, 71, 2, 2, 2376, 370, 3, 2, 2, 2, 2377, 2378, 7, 70, 2, 2, 2378, 2379, 7, 71, 2, 2, 2379, 2380, 7, 72, 2, 2, 2380, 2381, 7, 67, 2, 2, 2381, 2382, 7, 87, 2, 2, 2382, 2383, 7, 78, 2, 2, 2383, 2384, 7, 86, 2, 2, 2384, 2385, 7, 85, 2, 2, 2385, 372, 3, 2, 2, 2, 2386, 2387, 7, 70, 2, 2, 2387, 2388, 7, 71, 2, 2, 2388, 2389, 7, 72, 2, 2, 2389, 2390, 7, 71, 2, 2, 2390, 2391, 7, 84, 2, 2, 2391, 2392, 7, 84, 2, 2, 2392, 2393, 7, 71, 2, 2, 2393, 2394, 7, 70, 2, 2, 2394, 374, 3, 2, 2, 2, 2395, 2396, 7, 70, 2, 2, 2396, 2397, 7, 71, 2, 2, 2397, 2398, 7, 72, 2, 2, 2398, 2399, 7, 75, 2, 2, 2399, 2400, 7, 80, 2, 2, 2400, 2401, 7, 71, 2, 2, 2401, 2402, 7, 84, 2, 2, 2402, 376, 3, 2, 2, 2, 2403, 2404, 7, 70, 2, 2, 2404, 2405, 7, 71, 2, 2, 2405, 2406, 7, 78, 2, 2, 2406, 2407, 7, 71, 2, 2, 2407, 2408, 7, 86, 2, 2, 2408, 2409, 7, 71, 2, 2, 2409, 378, 3, 2, 2, 2, 2410, 2411, 7, 70, 2, 2, 2411, 2412, 7, 71, 2, 2, 2412, 2413, 7, 78, 2, 2, 2413, 2414, 7, 75, 2, 2, 2414, 2415, 7, 79, 2, 2, 2415, 2416, 7, 75, 2, 2, 2416, 2417, 7, 86, 2, 2, 2417, 2418, 7, 71, 2, 2, 2418, 2419, 7, 84, 2, 2, 2419, 380, 3, 2, 2, 2, 2420, 2421, 7, 70, 2, 2, 2421, 2422, 7, 71, 2, 2, 2422, 2423, 7, 78, 2, 2, 2423, 2424, 7, 75, 2, 2, 2424, 2425, 7, 79, 2, 2, 2425, 2426, 7, 75, 2, 2, 2426, 2427, 7, 86, 2, 2, 2427, 2428, 7, 71, 2, 2, 2428, 2429, 7, 84, 2, 2, 2429, 2430, 7, 85, 2, 2, 2430, 382, 3, 2, 2, 2, 2431, 2432, 7, 70, 2, 2, 2432, 2433, 7, 75, 2, 2, 2433, 2434, 7, 69, 2, 2, 2434, 2435, 7, 86, 2, 2, 2435, 2436, 7, 75, 2, 2, 2436, 2437, 7, 81, 2, 2, 2437, 2438, 7, 80, 2, 2, 2438, 2439, 7, 67, 2, 2, 2439, 2440, 7, 84, 2, 2, 2440, 2441, 7, 91, 2, 2, 2441, 384, 3, 2, 2, 2, 2442, 2443, 7, 70, 2, 2, 2443, 2444, 7, 75, 2, 2, 2444, 2445, 7, 85, 2, 2, 2445, 2446, 7, 67, 2, 2, 2446, 2447, 7, 68, 2, 2, 2447, 2448, 7, 78, 2, 2, 2448, 2449, 7, 71, 2, 2, 2449, 386, 3, 2, 2, 2, 2450, 2451, 7, 70, 2, 2, 2451, 2452, 7, 75, 2, 2, 2452, 2453, 7, 85, 2, 2, 2453, 2454, 7, 69, 2, 2, 2454, 2455, 7, 67, 2, 2, 2455, 2456, 7, 84, 2, 2, 2456, 2457, 7, 70, 2, 2, 2457, 388, 3, 2, 2, 2, 2458, 2459, 7, 70, 2, 2, 2459, 2460, 7, 81, 2, 2, 2460, 2461, 7, 69, 2, 2, 2461, 2462, 7, 87, 2, 2, 2462, 2463, 7, 79, 2, 2, 2463, 2464, 7, 71, 2, 2, 2464, 2465, 7, 80, 2, 2, 2465, 2466, 7, 86, 2, 2, 2466, 390, 3, 2, 2, 2, 2467, 2468, 7, 70, 2, 2, 2468, 2469, 7, 81, 2, 2, 2469, 2470, 7, 79, 2, 2, 2470, 2471, 7, 67, 2, 2, 2471, 2472, 7, 75, 2, 2, 2472, 2473, 7, 80, 2, 2, 2473, 392, 3, 2, 2, 2, 2474, 2475, 7, 70, 2, 2, 2475, 2476, 7, 81, 2, 2, 2476, 2477, 7, 87, 2, 2, 2477, 2478, 7, 68, 2, 2, 2478, 2479, 7, 78, 2, 2, 2479, 2480, 7, 71, 2, 2, 2480, 394, 3, 2, 2, 2, 2481, 2482, 7, 70, 2, 2, 2482, 2483, 7, 84, 2, 2, 2483, 2484, 7, 81, 2, 2, 2484, 2485, 7, 82, 2, 2, 2485, 396, 3, 2, 2, 2, 2486, 2487, 7, 71, 2, 2, 2487, 2488, 7, 67, 2, 2, 2488, 2489, 7, 69, 2, 2, 2489, 2490, 7, 74, 2, 2, 2490, 398, 3, 2, 2, 2, 2491, 2492, 7, 71, 2, 2, 2492, 2493, 7, 80, 2, 2, 2493, 2494, 7, 67, 2, 2, 2494, 2495, 7, 68, 2, 2, 2495, 2496, 7, 78, 2, 2, 2496, 2497, 7, 71, 2, 2, 2497, 400, 3, 2, 2, 2, 2498, 2499, 7, 71, 2, 2, 2499, 2500, 7, 80, 2, 2, 2500, 2501, 7, 69, 2, 2, 2501, 2502, 7, 81, 2, 2, 2502, 2503, 7, 70, 2, 2, 2503, 2504, 7, 75, 2, 2, 2504, 2505, 7, 80, 2, 2, 2505, 2506, 7, 73, 2, 2, 2506, 402, 3, 2, 2, 2, 2507, 2508, 7, 71, 2, 2, 2508, 2509, 7, 80, 2, 2, 2509, 2510, 7, 69, 2, 2, 2510, 2511, 7, 84, 2, 2, 2511, 2512, 7, 91, 2, 2, 2512, 2513, 7, 82, 2, 2, 2513, 2514, 7, 86, 2, 2, 2514, 2515, 7, 71, 2, 2, 2515, 2516, 7, 70, 2, 2, 2516, 404, 3, 2, 2, 2, 2517, 2518, 7, 71, 2, 2, 2518, 2519, 7, 80, 2, 2, 2519, 2520, 7, 87, 2, 2, 2520, 2521, 7, 79, 2, 2, 2521, 406, 3, 2, 2, 2, 2522, 2523, 7, 71, 2, 2, 2523, 2524, 7, 85, 2, 2, 2524, 2525, 7, 69, 2, 2, 2525, 2526, 7, 67, 2, 2, 2526, 2527, 7, 82, 2, 2, 2527, 2528, 7, 71, 2, 2, 2528, 408, 3, 2, 2, 2, 2529, 2530, 7, 71, 2, 2, 2530, 2531, 7, 88, 2, 2, 2531, 2532, 7, 71, 2, 2, 2532, 2533, 7, 80, 2, 2, 2533, 2534, 7, 86, 2, 2, 2534, 410, 3, 2, 2, 2, 2535, 2536, 7, 71, 2, 2, 2536, 2537, 7, 90, 2, 2, 2537, 2538, 7, 69, 2, 2, 2538, 2539, 7, 78, 2, 2, 2539, 2540, 7, 87, 2, 2, 2540, 2541, 7, 70, 2, 2, 2541, 2542, 7, 71, 2, 2, 2542, 412, 3, 2, 2, 2, 2543, 2544, 7, 71, 2, 2, 2544, 2545, 7, 90, 2, 2, 2545, 2546, 7, 69, 2, 2, 2546, 2547, 7, 78, 2, 2, 2547, 2548, 7, 87, 2, 2, 2548, 2549, 7, 70, 2, 2, 2549, 2550, 7, 75, 2, 2, 2550, 2551, 7, 80, 2, 2, 2551, 2552, 7, 73, 2, 2, 2552, 414, 3, 2, 2, 2, 2553, 2554, 7, 71, 2, 2, 2554, 2555, 7, 90, 2, 2, 2555, 2556, 7, 69, 2, 2, 2556, 2557, 7, 78, 2, 2, 2557, 2558, 7, 87, 2, 2, 2558, 2559, 7, 85, 2, 2, 2559, 2560, 7, 75, 2, 2, 2560, 2561, 7, 88, 2, 2, 2561, 2562, 7, 71, 2, 2, 2562, 416, 3, 2, 2, 2, 2563, 2564, 7, 71, 2, 2, 2564, 2565, 7, 90, 2, 2, 2565, 2566, 7, 71, 2, 2, 2566, 2567, 7, 69, 2, 2, 2567, 2568, 7, 87, 2, 2, 2568, 2569, 7, 86, 2, 2, 2569, 2570, 7, 71, 2, 2, 2570, 418, 3, 2, 2, 2, 2571, 2572, 7, 71, 2, 2, 2572, 2573, 7, 90, 2, 2, 2573, 2574, 7, 82, 2, 2, 2574, 2575, 7, 78, 2, 2, 2575, 2576, 7, 67, 2, 2, 2576, 2577, 7, 75, 2, 2, 2577, 2578, 7, 80, 2, 2, 2578, 420, 3, 2, 2, 2, 2579, 2580, 7, 71, 2, 2, 2580, 2581, 7, 90, 2, 2, 2581, 2582, 7, 86, 2, 2, 2582, 2583, 7, 71, 2, 2, 2583, 2584, 7, 80, 2, 2, 2584, 2585, 7, 85, 2, 2, 2585, 2586, 7, 75, 2, 2, 2586, 2587, 7, 81, 2, 2, 2587, 2588, 7, 80, 2, 2, 2588, 422, 3, 2, 2, 2, 2589, 2590, 7, 71, 2, 2, 2590, 2591, 7, 90, 2, 2, 2591, 2592, 7, 86, 2, 2, 2592, 2593, 7, 71, 2, 2, 2593, 2594, 7, 84, 2, 2, 2594, 2595, 7, 80, 2, 2, 2595, 2596, 7, 67, 2, 2, 2596, 2597, 7, 78, 2, 2, 2597, 424, 3, 2, 2, 2, 2598, 2599, 7, 72, 2, 2, 2599, 2600, 7, 67, 2, 2, 2600, 2601, 7, 79, 2, 2, 2601, 2602, 7, 75, 2, 2, 2602, 2603, 7, 78, 2, 2, 2603, 2604, 7, 91, 2, 2, 2604, 426, 3, 2, 2, 2, 2605, 2606, 7, 72, 2, 2, 2606, 2607, 7, 75, 2, 2, 2607, 2608, 7, 84, 2, 2, 2608, 2609, 7, 85, 2, 2, 2609, 2610, 7, 86, 2, 2, 2610, 428, 3, 2, 2, 2, 2611, 2612, 7, 72, 2, 2, 2612, 2613, 7, 81, 2, 2, 2613, 2614, 7, 78, 2, 2, 2614, 2615, 7, 78, 2, 2, 2615, 2616, 7, 81, 2, 2, 2616, 2617, 7, 89, 2, 2, 2617, 2618, 7, 75, 2, 2, 2618, 2619, 7, 80, 2, 2, 2619, 2620, 7, 73, 2, 2, 2620, 430, 3, 2, 2, 2, 2621, 2622, 7, 72, 2, 2, 2622, 2623, 7, 81, 2, 2, 2623, 2624, 7, 84, 2, 2, 2624, 2625, 7, 69, 2, 2, 2625, 2626, 7, 71, 2, 2, 2626, 432, 3, 2, 2, 2, 2627, 2628, 7, 72, 2, 2, 2628, 2629, 7, 81, 2, 2, 2629, 2630, 7, 84, 2, 2, 2630, 2631, 7, 89, 2, 2, 2631, 2632, 7, 67, 2, 2, 2632, 2633, 7, 84, 2, 2, 2633, 2634, 7, 70, 2, 2, 2634, 434, 3, 2, 2, 2, 2635, 2636, 7, 72, 2, 2, 2636, 2637, 7, 87, 2, 2, 2637, 2638, 7, 80, 2, 2, 2638, 2639, 7, 69, 2, 2, 2639, 2640, 7, 86, 2, 2, 2640, 2641, 7, 75, 2, 2, 2641, 2642, 7, 81, 2, 2, 2642, 2643, 7, 80, 2, 2, 2643, 436, 3, 2, 2, 2, 2644, 2645, 7, 72, 2, 2, 2645, 2646, 7, 87, 2, 2, 2646, 2647, 7, 80, 2, 2, 2647, 2648, 7, 69, 2, 2, 2648, 2649, 7, 86, 2, 2, 2649, 2650, 7, 75, 2, 2, 2650, 2651, 7, 81, 2, 2, 2651, 2652, 7, 80, 2, 2, 2652, 2653, 7, 85, 2, 2, 2653, 438, 3, 2, 2, 2, 2654, 2655, 7, 73, 2, 2, 2655, 2656, 7, 78, 2, 2, 2656, 2657, 7, 81, 2, 2, 2657, 2658, 7, 68, 2, 2, 2658, 2659, 7, 67, 2, 2, 2659, 2660, 7, 78, 2, 2, 2660, 440, 3, 2, 2, 2, 2661, 2662, 7, 73, 2, 2, 2662, 2663, 7, 84, 2, 2, 2663, 2664, 7, 67, 2, 2, 2664, 2665, 7, 80, 2, 2, 2665, 2666, 7, 86, 2, 2, 2666, 2667, 7, 71, 2, 2, 2667, 2668, 7, 70, 2, 2, 2668, 442, 3, 2, 2, 2, 2669, 2670, 7, 74, 2, 2, 2670, 2671, 7, 67, 2, 2, 2671, 2672, 7, 80, 2, 2, 2672, 2673, 7, 70, 2, 2, 2673, 2674, 7, 78, 2, 2, 2674, 2675, 7, 71, 2, 2, 2675, 2676, 7, 84, 2, 2, 2676, 444, 3, 2, 2, 2, 2677, 2678, 7, 74, 2, 2, 2678, 2679, 7, 71, 2, 2, 2679, 2680, 7, 67, 2, 2, 2680, 2681, 7, 70, 2, 2, 2681, 2682, 7, 71, 2, 2, 2682, 2683, 7, 84, 2, 2, 2683, 446, 3, 2, 2, 2, 2684, 2685, 7, 74, 2, 2, 2685, 2686, 7, 81, 2, 2, 2686, 2687, 7, 78, 2, 2, 2687, 2688, 7, 70, 2, 2, 2688, 448, 3, 2, 2, 2, 2689, 2690, 7, 74, 2, 2, 2690, 2691, 7, 81, 2, 2, 2691, 2692, 7, 87, 2, 2, 2692, 2693, 7, 84, 2, 2, 2693, 450, 3, 2, 2, 2, 2694, 2695, 7, 75, 2, 2, 2695, 2696, 7, 70, 2, 2, 2696, 2697, 7, 71, 2, 2, 2697, 2698, 7, 80, 2, 2, 2698, 2699, 7, 86, 2, 2, 2699, 2700, 7, 75, 2, 2, 2700, 2701, 7, 86, 2, 2, 2701, 2702, 7, 91, 2, 2, 2702, 452, 3, 2, 2, 2, 2703, 2704, 7, 75, 2, 2, 2704, 2705, 7, 72, 2, 2, 2705, 454, 3, 2, 2, 2, 2706, 2707, 7, 75, 2, 2, 2707, 2708, 7, 79, 2, 2, 2708, 2709, 7, 79, 2, 2, 2709, 2710, 7, 71, 2, 2, 2710, 2711, 7, 70, 2, 2, 2711, 2712, 7, 75, 2, 2, 2712, 2713, 7, 67, 2, 2, 2713, 2714, 7, 86, 2, 2, 2714, 2715, 7, 71, 2, 2, 2715, 456, 3, 2, 2, 2, 2716, 2717, 7, 75, 2, 2, 2717, 2718, 7, 79, 2, 2, 2718, 2719, 7, 79, 2, 2, 2719, 2720, 7, 87, 2, 2, 2720, 2721, 7, 86, 2, 2, 2721, 2722, 7, 67, 2, 2, 2722, 2723, 7, 68, 2, 2, 2723, 2724, 7, 78, 2, 2, 2724, 2725, 7, 71, 2, 2, 2725, 458, 3, 2, 2, 2, 2726, 2727, 7, 75, 2, 2, 2727, 2728, 7, 79, 2, 2, 2728, 2729, 7, 82, 2, 2, 2729, 2730, 7, 78, 2, 2, 2730, 2731, 7, 75, 2, 2, 2731, 2732, 7, 69, 2, 2, 2732, 2733, 7, 75, 2, 2, 2733, 2734, 7, 86, 2, 2, 2734, 460, 3, 2, 2, 2, 2735, 2736, 7, 75, 2, 2, 2736, 2737, 7, 80, 2, 2, 2737, 2738, 7, 69, 2, 2, 2738, 2739, 7, 78, 2, 2, 2739, 2740, 7, 87, 2, 2, 2740, 2741, 7, 70, 2, 2, 2741, 2742, 7, 75, 2, 2, 2742, 2743, 7, 80, 2, 2, 2743, 2744, 7, 73, 2, 2, 2744, 462, 3, 2, 2, 2, 2745, 2746, 7, 75, 2, 2, 2746, 2747, 7, 80, 2, 2, 2747, 2748, 7, 69, 2, 2, 2748, 2749, 7, 84, 2, 2, 2749, 2750, 7, 71, 2, 2, 2750, 2751, 7, 79, 2, 2, 2751, 2752, 7, 71, 2, 2, 2752, 2753, 7, 80, 2, 2, 2753, 2754, 7, 86, 2, 2, 2754, 464, 3, 2, 2, 2, 2755, 2756, 7, 75, 2, 2, 2756, 2757, 7, 80, 2, 2, 2757, 2758, 7, 70, 2, 2, 2758, 2759, 7, 71, 2, 2, 2759, 2760, 7, 90, 2, 2, 2760, 466, 3, 2, 2, 2, 2761, 2762, 7, 75, 2, 2, 2762, 2763, 7, 80, 2, 2, 2763, 2764, 7, 70, 2, 2, 2764, 2765, 7, 71, 2, 2, 2765, 2766, 7, 90, 2, 2, 2766, 2767, 7, 71, 2, 2, 2767, 2768, 7, 85, 2, 2, 2768, 468, 3, 2, 2, 2, 2769, 2770, 7, 75, 2, 2, 2770, 2771, 7, 80, 2, 2, 2771, 2772, 7, 74, 2, 2, 2772, 2773, 7, 71, 2, 2, 2773, 2774, 7, 84, 2, 2, 2774, 2775, 7, 75, 2, 2, 2775, 2776, 7, 86, 2, 2, 2776, 470, 3, 2, 2, 2, 2777, 2778, 7, 75, 2, 2, 2778, 2779, 7, 80, 2, 2, 2779, 2780, 7, 74, 2, 2, 2780, 2781, 7, 71, 2, 2, 2781, 2782, 7, 84, 2, 2, 2782, 2783, 7, 75, 2, 2, 2783, 2784, 7, 86, 2, 2, 2784, 2785, 7, 85, 2, 2, 2785, 472, 3, 2, 2, 2, 2786, 2787, 7, 75, 2, 2, 2787, 2788, 7, 80, 2, 2, 2788, 2789, 7, 78, 2, 2, 2789, 2790, 7, 75, 2, 2, 2790, 2791, 7, 80, 2, 2, 2791, 2792, 7, 71, 2, 2, 2792, 474, 3, 2, 2, 2, 2793, 2794, 7, 75, 2, 2, 2794, 2795, 7, 80, 2, 2, 2795, 2796, 7, 85, 2, 2, 2796, 2797, 7, 71, 2, 2, 2797, 2798, 7, 80, 2, 2, 2798, 2799, 7, 85, 2, 2, 2799, 2800, 7, 75, 2, 2, 2800, 2801, 7, 86, 2, 2, 2801, 2802, 7, 75, 2, 2, 2802, 2803, 7, 88, 2, 2, 2803, 2804, 7, 71, 2, 2, 2804, 476, 3, 2, 2, 2, 2805, 2806, 7, 75, 2, 2, 2806, 2807, 7, 80, 2, 2, 2807, 2808, 7, 85, 2, 2, 2808, 2809, 7, 71, 2, 2, 2809, 2810, 7, 84, 2, 2, 2810, 2811, 7, 86, 2, 2, 2811, 478, 3, 2, 2, 2, 2812, 2813, 7, 75, 2, 2, 2813, 2814, 7, 80, 2, 2, 2814, 2815, 7, 85, 2, 2, 2815, 2816, 7, 86, 2, 2, 2816, 2817, 7, 71, 2, 2, 2817, 2818, 7, 67, 2, 2, 2818, 2819, 7, 70, 2, 2, 2819, 480, 3, 2, 2, 2, 2820, 2821, 7, 75, 2, 2, 2821, 2822, 7, 80, 2, 2, 2822, 2823, 7, 88, 2, 2, 2823, 2824, 7, 81, 2, 2, 2824, 2825, 7, 77, 2, 2, 2825, 2826, 7, 71, 2, 2, 2826, 2827, 7, 84, 2, 2, 2827, 482, 3, 2, 2, 2, 2828, 2829, 7, 75, 2, 2, 2829, 2830, 7, 85, 2, 2, 2830, 2831, 7, 81, 2, 2, 2831, 2832, 7, 78, 2, 2, 2832, 2833, 7, 67, 2, 2, 2833, 2834, 7, 86, 2, 2, 2834, 2835, 7, 75, 2, 2, 2835, 2836, 7, 81, 2, 2, 2836, 2837, 7, 80, 2, 2, 2837, 484, 3, 2, 2, 2, 2838, 2839, 7, 77, 2, 2, 2839, 2840, 7, 71, 2, 2, 2840, 2841, 7, 91, 2, 2, 2841, 486, 3, 2, 2, 2, 2842, 2843, 7, 78, 2, 2, 2843, 2844, 7, 67, 2, 2, 2844, 2845, 7, 68, 2, 2, 2845, 2846, 7, 71, 2, 2, 2846, 2847, 7, 78, 2, 2, 2847, 488, 3, 2, 2, 2, 2848, 2849, 7, 78, 2, 2, 2849, 2850, 7, 67, 2, 2, 2850, 2851, 7, 80, 2, 2, 2851, 2852, 7, 73, 2, 2, 2852, 2853, 7, 87, 2, 2, 2853, 2854, 7, 67, 2, 2, 2854, 2855, 7, 73, 2, 2, 2855, 2856, 7, 71, 2, 2, 2856, 490, 3, 2, 2, 2, 2857, 2858, 7, 78, 2, 2, 2858, 2859, 7, 67, 2, 2, 2859, 2860, 7, 84, 2, 2, 2860, 2861, 7, 73, 2, 2, 2861, 2862, 7, 71, 2, 2, 2862, 492, 3, 2, 2, 2, 2863, 2864, 7, 78, 2, 2, 2864, 2865, 7, 67, 2, 2, 2865, 2866, 7, 85, 2, 2, 2866, 2867, 7, 86, 2, 2, 2867, 494, 3, 2, 2, 2, 2868, 2869, 7, 78, 2, 2, 2869, 2870, 7, 71, 2, 2, 2870, 2871, 7, 67, 2, 2, 2871, 2872, 7, 77, 2, 2, 2872, 2873, 7, 82, 2, 2, 2873, 2874, 7, 84, 2, 2, 2874, 2875, 7, 81, 2, 2, 2875, 2876, 7, 81, 2, 2, 2876, 2877, 7, 72, 2, 2, 2877, 496, 3, 2, 2, 2, 2878, 2879, 7, 78, 2, 2, 2879, 2880, 7, 71, 2, 2, 2880, 2881, 7, 88, 2, 2, 2881, 2882, 7, 71, 2, 2, 2882, 2883, 7, 78, 2, 2, 2883, 498, 3, 2, 2, 2, 2884, 2885, 7, 78, 2, 2, 2885, 2886, 7, 75, 2, 2, 2886, 2887, 7, 85, 2, 2, 2887, 2888, 7, 86, 2, 2, 2888, 2889, 7, 71, 2, 2, 2889, 2890, 7, 80, 2, 2, 2890, 500, 3, 2, 2, 2, 2891, 2892, 7, 78, 2, 2, 2892, 2893, 7, 81, 2, 2, 2893, 2894, 7, 67, 2, 2, 2894, 2895, 7, 70, 2, 2, 2895, 502, 3, 2, 2, 2, 2896, 2897, 7, 78, 2, 2, 2897, 2898, 7, 81, 2, 2, 2898, 2899, 7, 69, 2, 2, 2899, 2900, 7, 67, 2, 2, 2900, 2901, 7, 78, 2, 2, 2901, 504, 3, 2, 2, 2, 2902, 2903, 7, 78, 2, 2, 2903, 2904, 7, 81, 2, 2, 2904, 2905, 7, 69, 2, 2, 2905, 2906, 7, 67, 2, 2, 2906, 2907, 7, 86, 2, 2, 2907, 2908, 7, 75, 2, 2, 2908, 2909, 7, 81, 2, 2, 2909, 2910, 7, 80, 2, 2, 2910, 506, 3, 2, 2, 2, 2911, 2912, 7, 78, 2, 2, 2912, 2913, 7, 81, 2, 2, 2913, 2914, 7, 69, 2, 2, 2914, 2915, 7, 77, 2, 2, 2915, 508, 3, 2, 2, 2, 2916, 2917, 7, 79, 2, 2, 2917, 2918, 7, 67, 2, 2, 2918, 2919, 7, 82, 2, 2, 2919, 2920, 7, 82, 2, 2, 2920, 2921, 7, 75, 2, 2, 2921, 2922, 7, 80, 2, 2, 2922, 2923, 7, 73, 2, 2, 2923, 510, 3, 2, 2, 2, 2924, 2925, 7, 79, 2, 2, 2925, 2926, 7, 67, 2, 2, 2926, 2927, 7, 86, 2, 2, 2927, 2928, 7, 69, 2, 2, 2928, 2929, 7, 74, 2, 2, 2929, 512, 3, 2, 2, 2, 2930, 2931, 7, 79, 2, 2, 2931, 2932, 7, 67, 2, 2, 2932, 2933, 7, 86, 2, 2, 2933, 2934, 7, 71, 2, 2, 2934, 2935, 7, 84, 2, 2, 2935, 2936, 7, 75, 2, 2, 2936, 2937, 7, 67, 2, 2, 2937, 2938, 7, 78, 2, 2, 2938, 2939, 7, 75, 2, 2, 2939, 2940, 7, 92, 2, 2, 2940, 2941, 7, 71, 2, 2, 2941, 2942, 7, 70, 2, 2, 2942, 514, 3, 2, 2, 2, 2943, 2944, 7, 79, 2, 2, 2944, 2945, 7, 67, 2, 2, 2945, 2946, 7, 90, 2, 2, 2946, 2947, 7, 88, 2, 2, 2947, 2948, 7, 67, 2, 2, 2948, 2949, 7, 78, 2, 2, 2949, 2950, 7, 87, 2, 2, 2950, 2951, 7, 71, 2, 2, 2951, 516, 3, 2, 2, 2, 2952, 2953, 7, 79, 2, 2, 2953, 2954, 7, 75, 2, 2, 2954, 2955, 7, 80, 2, 2, 2955, 2956, 7, 87, 2, 2, 2956, 2957, 7, 86, 2, 2, 2957, 2958, 7, 71, 2, 2, 2958, 518, 3, 2, 2, 2, 2959, 2960, 7, 79, 2, 2, 2960, 2961, 7, 75, 2, 2, 2961, 2962, 7, 80, 2, 2, 2962, 2963, 7, 88, 2, 2, 2963, 2964, 7, 67, 2, 2, 2964, 2965, 7, 78, 2, 2, 2965, 2966, 7, 87, 2, 2, 2966, 2967, 7, 71, 2, 2, 2967, 520, 3, 2, 2, 2, 2968, 2969, 7, 79, 2, 2, 2969, 2970, 7, 81, 2, 2, 2970, 2971, 7, 70, 2, 2, 2971, 2972, 7, 71, 2, 2, 2972, 522, 3, 2, 2, 2, 2973, 2974, 7, 79, 2, 2, 2974, 2975, 7, 81, 2, 2, 2975, 2976, 7, 80, 2, 2, 2976, 2977, 7, 86, 2, 2, 2977, 2978, 7, 74, 2, 2, 2978, 524, 3, 2, 2, 2, 2979, 2980, 7, 79, 2, 2, 2980, 2981, 7, 81, 2, 2, 2981, 2982, 7, 88, 2, 2, 2982, 2983, 7, 71, 2, 2, 2983, 526, 3, 2, 2, 2, 2984, 2985, 7, 80, 2, 2, 2985, 2986, 7, 67, 2, 2, 2986, 2987, 7, 79, 2, 2, 2987, 2988, 7, 71, 2, 2, 2988, 528, 3, 2, 2, 2, 2989, 2990, 7, 80, 2, 2, 2990, 2991, 7, 67, 2, 2, 2991, 2992, 7, 79, 2, 2, 2992, 2993, 7, 71, 2, 2, 2993, 2994, 7, 85, 2, 2, 2994, 530, 3, 2, 2, 2, 2995, 2996, 7, 80, 2, 2, 2996, 2997, 7, 71, 2, 2, 2997, 2998, 7, 90, 2, 2, 2998, 2999, 7, 86, 2, 2, 2999, 532, 3, 2, 2, 2, 3000, 3001, 7, 80, 2, 2, 3001, 3002, 7, 81, 2, 2, 3002, 534, 3, 2, 2, 2, 3003, 3004, 7, 80, 2, 2, 3004, 3005, 7, 81, 2, 2, 3005, 3006, 7, 86, 2, 2, 3006, 3007, 7, 74, 2, 2, 3007, 3008, 7, 75, 2, 2, 3008, 3009, 7, 80, 2, 2, 3009, 3010, 7, 73, 2, 2, 3010, 536, 3, 2, 2, 2, 3011, 3012, 7, 80, 2, 2, 3012, 3013, 7, 81, 2, 2, 3013, 3014, 7, 86, 2, 2, 3014, 3015, 7, 75, 2, 2, 3015, 3016, 7, 72, 2, 2, 3016, 3017, 7, 91, 2, 2, 3017, 538, 3, 2, 2, 2, 3018, 3019, 7, 80, 2, 2, 3019, 3020, 7, 81, 2, 2, 3020, 3021, 7, 89, 2, 2, 3021, 3022, 7, 67, 2, 2, 3022, 3023, 7, 75, 2, 2, 3023, 3024, 7, 86, 2, 2, 3024, 540, 3, 2, 2, 2, 3025, 3026, 7, 80, 2, 2, 3026, 3027, 7, 87, 2, 2, 3027, 3028, 7, 78, 2, 2, 3028, 3029, 7, 78, 2, 2, 3029, 3030, 7, 85, 2, 2, 3030, 542, 3, 2, 2, 2, 3031, 3032, 7, 81, 2, 2, 3032, 3033, 7, 68, 2, 2, 3033, 3034, 7, 76, 2, 2, 3034, 3035, 7, 71, 2, 2, 3035, 3036, 7, 69, 2, 2, 3036, 3037, 7, 86, 2, 2, 3037, 544, 3, 2, 2, 2, 3038, 3039, 7, 81, 2, 2, 3039, 3040, 7, 72, 2, 2, 3040, 546, 3, 2, 2, 2, 3041, 3042, 7, 81, 2, 2, 3042, 3043, 7, 72, 2, 2, 3043, 3044, 7, 72, 2, 2, 3044, 548, 3, 2, 2, 2, 3045, 3046, 7, 81, 2, 2, 3046, 3047, 7, 75, 2, 2, 3047, 3048, 7, 70, 2, 2, 3048, 3049, 7, 85, 2, 2, 3049, 550, 3, 2, 2, 2, 3050, 3051, 7, 81, 2, 2, 3051, 3052, 7, 82, 2, 2, 3052, 3053, 7, 71, 2, 2, 3053, 3054, 7, 84, 2, 2, 3054, 3055, 7, 67, 2, 2, 3055, 3056, 7, 86, 2, 2, 3056, 3057, 7, 81, 2, 2, 3057, 3058, 7, 84, 2, 2, 3058, 552, 3, 2, 2, 2, 3059, 3060, 7, 81, 2, 2, 3060, 3061, 7, 82, 2, 2, 3061, 3062, 7, 86, 2, 2, 3062, 3063, 7, 75, 2, 2, 3063, 3064, 7, 81, 2, 2, 3064, 3065, 7, 80, 2, 2, 3065, 554, 3, 2, 2, 2, 3066, 3067, 7, 81, 2, 2, 3067, 3068, 7, 82, 2, 2, 3068, 3069, 7, 86, 2, 2, 3069, 3070, 7, 75, 2, 2, 3070, 3071, 7, 81, 2, 2, 3071, 3072, 7, 80, 2, 2, 3072, 3073, 7, 85, 2, 2, 3073, 556, 3, 2, 2, 2, 3074, 3075, 7, 81, 2, 2, 3075, 3076, 7, 89, 2, 2, 3076, 3077, 7, 80, 2, 2, 3077, 3078, 7, 71, 2, 2, 3078, 3079, 7, 70, 2, 2, 3079, 558, 3, 2, 2, 2, 3080, 3081, 7, 81, 2, 2, 3081, 3082, 7, 89, 2, 2, 3082, 3083, 7, 80, 2, 2, 3083, 3084, 7, 71, 2, 2, 3084, 3085, 7, 84, 2, 2, 3085, 560, 3, 2, 2, 2, 3086, 3087, 7, 82, 2, 2, 3087, 3088, 7, 67, 2, 2, 3088, 3089, 7, 84, 2, 2, 3089, 3090, 7, 85, 2, 2, 3090, 3091, 7, 71, 2, 2, 3091, 3092, 7, 84, 2, 2, 3092, 562, 3, 2, 2, 2, 3093, 3094, 7, 82, 2, 2, 3094, 3095, 7, 67, 2, 2, 3095, 3096, 7, 84, 2, 2, 3096, 3097, 7, 86, 2, 2, 3097, 3098, 7, 75, 2, 2, 3098, 3099, 7, 67, 2, 2, 3099, 3100, 7, 78, 2, 2, 3100, 564, 3, 2, 2, 2, 3101, 3102, 7, 82, 2, 2, 3102, 3103, 7, 67, 2, 2, 3103, 3104, 7, 84, 2, 2, 3104, 3105, 7, 86, 2, 2, 3105, 3106, 7, 75, 2, 2, 3106, 3107, 7, 86, 2, 2, 3107, 3108, 7, 75, 2, 2, 3108, 3109, 7, 81, 2, 2, 3109, 3110, 7, 80, 2, 2, 3110, 566, 3, 2, 2, 2, 3111, 3112, 7, 82, 2, 2, 3112, 3113, 7, 67, 2, 2, 3113, 3114, 7, 85, 2, 2, 3114, 3115, 7, 85, 2, 2, 3115, 3116, 7, 75, 2, 2, 3116, 3117, 7, 80, 2, 2, 3117, 3118, 7, 73, 2, 2, 3118, 568, 3, 2, 2, 2, 3119, 3120, 7, 82, 2, 2, 3120, 3121, 7, 67, 2, 2, 3121, 3122, 7, 85, 2, 2, 3122, 3123, 7, 85, 2, 2, 3123, 3124, 7, 89, 2, 2, 3124, 3125, 7, 81, 2, 2, 3125, 3126, 7, 84, 2, 2, 3126, 3127, 7, 70, 2, 2, 3127, 570, 3, 2, 2, 2, 3128, 3129, 7, 82, 2, 2, 3129, 3130, 7, 78, 2, 2, 3130, 3131, 7, 67, 2, 2, 3131, 3132, 7, 80, 2, 2, 3132, 3133, 7, 85, 2, 2, 3133, 572, 3, 2, 2, 2, 3134, 3135, 7, 82, 2, 2, 3135, 3136, 7, 84, 2, 2, 3136, 3137, 7, 71, 2, 2, 3137, 3138, 7, 69, 2, 2, 3138, 3139, 7, 71, 2, 2, 3139, 3140, 7, 70, 2, 2, 3140, 3141, 7, 75, 2, 2, 3141, 3142, 7, 80, 2, 2, 3142, 3143, 7, 73, 2, 2, 3143, 574, 3, 2, 2, 2, 3144, 3145, 7, 82, 2, 2, 3145, 3146, 7, 84, 2, 2, 3146, 3147, 7, 71, 2, 2, 3147, 3148, 7, 82, 2, 2, 3148, 3149, 7, 67, 2, 2, 3149, 3150, 7, 84, 2, 2, 3150, 3151, 7, 71, 2, 2, 3151, 576, 3, 2, 2, 2, 3152, 3153, 7, 82, 2, 2, 3153, 3154, 7, 84, 2, 2, 3154, 3155, 7, 71, 2, 2, 3155, 3156, 7, 82, 2, 2, 3156, 3157, 7, 67, 2, 2, 3157, 3158, 7, 84, 2, 2, 3158, 3159, 7, 71, 2, 2, 3159, 3160, 7, 70, 2, 2, 3160, 578, 3, 2, 2, 2, 3161, 3162, 7, 82, 2, 2, 3162, 3163, 7, 84, 2, 2, 3163, 3164, 7, 71, 2, 2, 3164, 3165, 7, 85, 2, 2, 3165, 3166, 7, 71, 2, 2, 3166, 3167, 7, 84, 2, 2, 3167, 3168, 7, 88, 2, 2, 3168, 3169, 7, 71, 2, 2, 3169, 580, 3, 2, 2, 2, 3170, 3171, 7, 82, 2, 2, 3171, 3172, 7, 84, 2, 2, 3172, 3173, 7, 75, 2, 2, 3173, 3174, 7, 81, 2, 2, 3174, 3175, 7, 84, 2, 2, 3175, 582, 3, 2, 2, 2, 3176, 3177, 7, 82, 2, 2, 3177, 3178, 7, 84, 2, 2, 3178, 3179, 7, 75, 2, 2, 3179, 3180, 7, 88, 2, 2, 3180, 3181, 7, 75, 2, 2, 3181, 3182, 7, 78, 2, 2, 3182, 3183, 7, 71, 2, 2, 3183, 3184, 7, 73, 2, 2, 3184, 3185, 7, 71, 2, 2, 3185, 3186, 7, 85, 2, 2, 3186, 584, 3, 2, 2, 2, 3187, 3188, 7, 82, 2, 2, 3188, 3189, 7, 84, 2, 2, 3189, 3190, 7, 81, 2, 2, 3190, 3191, 7, 69, 2, 2, 3191, 3192, 7, 71, 2, 2, 3192, 3193, 7, 70, 2, 2, 3193, 3194, 7, 87, 2, 2, 3194, 3195, 7, 84, 2, 2, 3195, 3196, 7, 67, 2, 2, 3196, 3197, 7, 78, 2, 2, 3197, 586, 3, 2, 2, 2, 3198, 3199, 7, 82, 2, 2, 3199, 3200, 7, 84, 2, 2, 3200, 3201, 7, 81, 2, 2, 3201, 3202, 7, 69, 2, 2, 3202, 3203, 7, 71, 2, 2, 3203, 3204, 7, 70, 2, 2, 3204, 3205, 7, 87, 2, 2, 3205, 3206, 7, 84, 2, 2, 3206, 3207, 7, 71, 2, 2, 3207, 588, 3, 2, 2, 2, 3208, 3209, 7, 82, 2, 2, 3209, 3210, 7, 84, 2, 2, 3210, 3211, 7, 81, 2, 2, 3211, 3212, 7, 73, 2, 2, 3212, 3213, 7, 84, 2, 2, 3213, 3214, 7, 67, 2, 2, 3214, 3215, 7, 79, 2, 2, 3215, 590, 3, 2, 2, 2, 3216, 3217, 7, 83, 2, 2, 3217, 3218, 7, 87, 2, 2, 3218, 3219, 7, 81, 2, 2, 3219, 3220, 7, 86, 2, 2, 3220, 3221, 7, 71, 2, 2, 3221, 592, 3, 2, 2, 2, 3222, 3223, 7, 84, 2, 2, 3223, 3224, 7, 67, 2, 2, 3224, 3225, 7, 80, 2, 2, 3225, 3226, 7, 73, 2, 2, 3226, 3227, 7, 71, 2, 2, 3227, 594, 3, 2, 2, 2, 3228, 3229, 7, 84, 2, 2, 3229, 3230, 7, 71, 2, 2, 3230, 3231, 7, 67, 2, 2, 3231, 3232, 7, 70, 2, 2, 3232, 596, 3, 2, 2, 2, 3233, 3234, 7, 84, 2, 2, 3234, 3235, 7, 71, 2, 2, 3235, 3236, 7, 67, 2, 2, 3236, 3237, 7, 85, 2, 2, 3237, 3238, 7, 85, 2, 2, 3238, 3239, 7, 75, 2, 2, 3239, 3240, 7, 73, 2, 2, 3240, 3241, 7, 80, 2, 2, 3241, 598, 3, 2, 2, 2, 3242, 3243, 7, 84, 2, 2, 3243, 3244, 7, 71, 2, 2, 3244, 3245, 7, 69, 2, 2, 3245, 3246, 7, 74, 2, 2, 3246, 3247, 7, 71, 2, 2, 3247, 3248, 7, 69, 2, 2, 3248, 3249, 7, 77, 2, 2, 3249, 600, 3, 2, 2, 2, 3250, 3251, 7, 84, 2, 2, 3251, 3252, 7, 71, 2, 2, 3252, 3253, 7, 69, 2, 2, 3253, 3254, 7, 87, 2, 2, 3254, 3255, 7, 84, 2, 2, 3255, 3256, 7, 85, 2, 2, 3256, 3257, 7, 75, 2, 2, 3257, 3258, 7, 88, 2, 2, 3258, 3259, 7, 71, 2, 2, 3259, 602, 3, 2, 2, 2, 3260, 3261, 7, 84, 2, 2, 3261, 3262, 7, 71, 2, 2, 3262, 3263, 7, 72, 2, 2, 3263, 604, 3, 2, 2, 2, 3264, 3265, 7, 84, 2, 2, 3265, 3266, 7, 71, 2, 2, 3266, 3267, 7, 72, 2, 2, 3267, 3268, 7, 84, 2, 2, 3268, 3269, 7, 71, 2, 2, 3269, 3270, 7, 85, 2, 2, 3270, 3271, 7, 74, 2, 2, 3271, 606, 3, 2, 2, 2, 3272, 3273, 7, 84, 2, 2, 3273, 3274, 7, 71, 2, 2, 3274, 3275, 7, 75, 2, 2, 3275, 3276, 7, 80, 2, 2, 3276, 3277, 7, 70, 2, 2, 3277, 3278, 7, 71, 2, 2, 3278, 3279, 7, 90, 2, 2, 3279, 608, 3, 2, 2, 2, 3280, 3281, 7, 84, 2, 2, 3281, 3282, 7, 71, 2, 2, 3282, 3283, 7, 78, 2, 2, 3283, 3284, 7, 67, 2, 2, 3284, 3285, 7, 86, 2, 2, 3285, 3286, 7, 75, 2, 2, 3286, 3287, 7, 88, 2, 2, 3287, 3288, 7, 71, 2, 2, 3288, 610, 3, 2, 2, 2, 3289, 3290, 7, 84, 2, 2, 3290, 3291, 7, 71, 2, 2, 3291, 3292, 7, 78, 2, 2, 3292, 3293, 7, 71, 2, 2, 3293, 3294, 7, 67, 2, 2, 3294, 3295, 7, 85, 2, 2, 3295, 3296, 7, 71, 2, 2, 3296, 612, 3, 2, 2, 2, 3297, 3298, 7, 84, 2, 2, 3298, 3299, 7, 71, 2, 2, 3299, 3300, 7, 80, 2, 2, 3300, 3301, 7, 67, 2, 2, 3301, 3302, 7, 79, 2, 2, 3302, 3303, 7, 71, 2, 2, 3303, 614, 3, 2, 2, 2, 3304, 3305, 7, 84, 2, 2, 3305, 3306, 7, 71, 2, 2, 3306, 3307, 7, 82, 2, 2, 3307, 3308, 7, 71, 2, 2, 3308, 3309, 7, 67, 2, 2, 3309, 3310, 7, 86, 2, 2, 3310, 3311, 7, 67, 2, 2, 3311, 3312, 7, 68, 2, 2, 3312, 3313, 7, 78, 2, 2, 3313, 3314, 7, 71, 2, 2, 3314, 616, 3, 2, 2, 2, 3315, 3316, 7, 84, 2, 2, 3316, 3317, 7, 71, 2, 2, 3317, 3318, 7, 82, 2, 2, 3318, 3319, 7, 78, 2, 2, 3319, 3320, 7, 67, 2, 2, 3320, 3321, 7, 69, 2, 2, 3321, 3322, 7, 71, 2, 2, 3322, 618, 3, 2, 2, 2, 3323, 3324, 7, 84, 2, 2, 3324, 3325, 7, 71, 2, 2, 3325, 3326, 7, 82, 2, 2, 3326, 3327, 7, 78, 2, 2, 3327, 3328, 7, 75, 2, 2, 3328, 3329, 7, 69, 2, 2, 3329, 3330, 7, 67, 2, 2, 3330, 620, 3, 2, 2, 2, 3331, 3332, 7, 84, 2, 2, 3332, 3333, 7, 71, 2, 2, 3333, 3334, 7, 85, 2, 2, 3334, 3335, 7, 71, 2, 2, 3335, 3336, 7, 86, 2, 2, 3336, 622, 3, 2, 2, 2, 3337, 3338, 7, 84, 2, 2, 3338, 3339, 7, 71, 2, 2, 3339, 3340, 7, 85, 2, 2, 3340, 3341, 7, 86, 2, 2, 3341, 3342, 7, 67, 2, 2, 3342, 3343, 7, 84, 2, 2, 3343, 3344, 7, 86, 2, 2, 3344, 624, 3, 2, 2, 2, 3345, 3346, 7, 84, 2, 2, 3346, 3347, 7, 71, 2, 2, 3347, 3348, 7, 85, 2, 2, 3348, 3349, 7, 86, 2, 2, 3349, 3350, 7, 84, 2, 2, 3350, 3351, 7, 75, 2, 2, 3351, 3352, 7, 69, 2, 2, 3352, 3353, 7, 86, 2, 2, 3353, 626, 3, 2, 2, 2, 3354, 3355, 7, 84, 2, 2, 3355, 3356, 7, 71, 2, 2, 3356, 3357, 7, 86, 2, 2, 3357, 3358, 7, 87, 2, 2, 3358, 3359, 7, 84, 2, 2, 3359, 3360, 7, 80, 2, 2, 3360, 3361, 7, 85, 2, 2, 3361, 628, 3, 2, 2, 2, 3362, 3363, 7, 84, 2, 2, 3363, 3364, 7, 71, 2, 2, 3364, 3365, 7, 88, 2, 2, 3365, 3366, 7, 81, 2, 2, 3366, 3367, 7, 77, 2, 2, 3367, 3368, 7, 71, 2, 2, 3368, 630, 3, 2, 2, 2, 3369, 3370, 7, 84, 2, 2, 3370, 3371, 7, 81, 2, 2, 3371, 3372, 7, 78, 2, 2, 3372, 3373, 7, 71, 2, 2, 3373, 632, 3, 2, 2, 2, 3374, 3375, 7, 84, 2, 2, 3375, 3376, 7, 81, 2, 2, 3376, 3377, 7, 78, 2, 2, 3377, 3378, 7, 78, 2, 2, 3378, 3379, 7, 68, 2, 2, 3379, 3380, 7, 67, 2, 2, 3380, 3381, 7, 69, 2, 2, 3381, 3382, 7, 77, 2, 2, 3382, 634, 3, 2, 2, 2, 3383, 3384, 7, 84, 2, 2, 3384, 3385, 7, 81, 2, 2, 3385, 3386, 7, 89, 2, 2, 3386, 3387, 7, 85, 2, 2, 3387, 636, 3, 2, 2, 2, 3388, 3389, 7, 84, 2, 2, 3389, 3390, 7, 87, 2, 2, 3390, 3391, 7, 78, 2, 2, 3391, 3392, 7, 71, 2, 2, 3392, 638, 3, 2, 2, 2, 3393, 3394, 7, 85, 2, 2, 3394, 3395, 7, 67, 2, 2, 3395, 3396, 7, 88, 2, 2, 3396, 3397, 7, 71, 2, 2, 3397, 3398, 7, 82, 2, 2, 3398, 3399, 7, 81, 2, 2, 3399, 3400, 7, 75, 2, 2, 3400, 3401, 7, 80, 2, 2, 3401, 3402, 7, 86, 2, 2, 3402, 640, 3, 2, 2, 2, 3403, 3404, 7, 85, 2, 2, 3404, 3405, 7, 69, 2, 2, 3405, 3406, 7, 74, 2, 2, 3406, 3407, 7, 71, 2, 2, 3407, 3408, 7, 79, 2, 2, 3408, 3409, 7, 67, 2, 2, 3409, 642, 3, 2, 2, 2, 3410, 3411, 7, 85, 2, 2, 3411, 3412, 7, 69, 2, 2, 3412, 3413, 7, 84, 2, 2, 3413, 3414, 7, 81, 2, 2, 3414, 3415, 7, 78, 2, 2, 3415, 3416, 7, 78, 2, 2, 3416, 644, 3, 2, 2, 2, 3417, 3418, 7, 85, 2, 2, 3418, 3419, 7, 71, 2, 2, 3419, 3420, 7, 67, 2, 2, 3420, 3421, 7, 84, 2, 2, 3421, 3422, 7, 69, 2, 2, 3422, 3423, 7, 74, 2, 2, 3423, 646, 3, 2, 2, 2, 3424, 3425, 7, 85, 2, 2, 3425, 3426, 7, 71, 2, 2, 3426, 3427, 7, 69, 2, 2, 3427, 3428, 7, 81, 2, 2, 3428, 3429, 7, 80, 2, 2, 3429, 3430, 7, 70, 2, 2, 3430, 648, 3, 2, 2, 2, 3431, 3432, 7, 85, 2, 2, 3432, 3433, 7, 71, 2, 2, 3433, 3434, 7, 69, 2, 2, 3434, 3435, 7, 87, 2, 2, 3435, 3436, 7, 84, 2, 2, 3436, 3437, 7, 75, 2, 2, 3437, 3438, 7, 86, 2, 2, 3438, 3439, 7, 91, 2, 2, 3439, 650, 3, 2, 2, 2, 3440, 3441, 7, 85, 2, 2, 3441, 3442, 7, 71, 2, 2, 3442, 3443, 7, 83, 2, 2, 3443, 3444, 7, 87, 2, 2, 3444, 3445, 7, 71, 2, 2, 3445, 3446, 7, 80, 2, 2, 3446, 3447, 7, 69, 2, 2, 3447, 3448, 7, 71, 2, 2, 3448, 652, 3, 2, 2, 2, 3449, 3450, 7, 85, 2, 2, 3450, 3451, 7, 71, 2, 2, 3451, 3452, 7, 83, 2, 2, 3452, 3453, 7, 87, 2, 2, 3453, 3454, 7, 71, 2, 2, 3454, 3455, 7, 80, 2, 2, 3455, 3456, 7, 69, 2, 2, 3456, 3457, 7, 71, 2, 2, 3457, 3458, 7, 85, 2, 2, 3458, 654, 3, 2, 2, 2, 3459, 3460, 7, 85, 2, 2, 3460, 3461, 7, 71, 2, 2, 3461, 3462, 7, 84, 2, 2, 3462, 3463, 7, 75, 2, 2, 3463, 3464, 7, 67, 2, 2, 3464, 3465, 7, 78, 2, 2, 3465, 3466, 7, 75, 2, 2, 3466, 3467, 7, 92, 2, 2, 3467, 3468, 7, 67, 2, 2, 3468, 3469, 7, 68, 2, 2, 3469, 3470, 7, 78, 2, 2, 3470, 3471, 7, 71, 2, 2, 3471, 656, 3, 2, 2, 2, 3472, 3473, 7, 85, 2, 2, 3473, 3474, 7, 71, 2, 2, 3474, 3475, 7, 84, 2, 2, 3475, 3476, 7, 88, 2, 2, 3476, 3477, 7, 71, 2, 2, 3477, 3478, 7, 84, 2, 2, 3478, 658, 3, 2, 2, 2, 3479, 3480, 7, 85, 2, 2, 3480, 3481, 7, 71, 2, 2, 3481, 3482, 7, 85, 2, 2, 3482, 3483, 7, 85, 2, 2, 3483, 3484, 7, 75, 2, 2, 3484, 3485, 7, 81, 2, 2, 3485, 3486, 7, 80, 2, 2, 3486, 660, 3, 2, 2, 2, 3487, 3488, 7, 85, 2, 2, 3488, 3489, 7, 71, 2, 2, 3489, 3490, 7, 86, 2, 2, 3490, 662, 3, 2, 2, 2, 3491, 3492, 7, 85, 2, 2, 3492, 3493, 7, 74, 2, 2, 3493, 3494, 7, 67, 2, 2, 3494, 3495, 7, 84, 2, 2, 3495, 3496, 7, 71, 2, 2, 3496, 664, 3, 2, 2, 2, 3497, 3498, 7, 85, 2, 2, 3498, 3499, 7, 74, 2, 2, 3499, 3500, 7, 81, 2, 2, 3500, 3501, 7, 89, 2, 2, 3501, 666, 3, 2, 2, 2, 3502, 3503, 7, 85, 2, 2, 3503, 3504, 7, 75, 2, 2, 3504, 3505, 7, 79, 2, 2, 3505, 3506, 7, 82, 2, 2, 3506, 3507, 7, 78, 2, 2, 3507, 3508, 7, 71, 2, 2, 3508, 668, 3, 2, 2, 2, 3509, 3510, 7, 85, 2, 2, 3510, 3511, 7, 80, 2, 2, 3511, 3512, 7, 67, 2, 2, 3512, 3513, 7, 82, 2, 2, 3513, 3514, 7, 85, 2, 2, 3514, 3515, 7, 74, 2, 2, 3515, 3516, 7, 81, 2, 2, 3516, 3517, 7, 86, 2, 2, 3517, 670, 3, 2, 2, 2, 3518, 3519, 7, 85, 2, 2, 3519, 3520, 7, 86, 2, 2, 3520, 3521, 7, 67, 2, 2, 3521, 3522, 7, 68, 2, 2, 3522, 3523, 7, 78, 2, 2, 3523, 3524, 7, 71, 2, 2, 3524, 672, 3, 2, 2, 2, 3525, 3526, 7, 85, 2, 2, 3526, 3527, 7, 86, 2, 2, 3527, 3528, 7, 67, 2, 2, 3528, 3529, 7, 80, 2, 2, 3529, 3530, 7, 70, 2, 2, 3530, 3531, 7, 67, 2, 2, 3531, 3532, 7, 78, 2, 2, 3532, 3533, 7, 81, 2, 2, 3533, 3534, 7, 80, 2, 2, 3534, 3535, 7, 71, 2, 2, 3535, 674, 3, 2, 2, 2, 3536, 3537, 7, 85, 2, 2, 3537, 3538, 7, 86, 2, 2, 3538, 3539, 7, 67, 2, 2, 3539, 3540, 7, 84, 2, 2, 3540, 3541, 7, 86, 2, 2, 3541, 676, 3, 2, 2, 2, 3542, 3543, 7, 85, 2, 2, 3543, 3544, 7, 86, 2, 2, 3544, 3545, 7, 67, 2, 2, 3545, 3546, 7, 86, 2, 2, 3546, 3547, 7, 71, 2, 2, 3547, 3548, 7, 79, 2, 2, 3548, 3549, 7, 71, 2, 2, 3549, 3550, 7, 80, 2, 2, 3550, 3551, 7, 86, 2, 2, 3551, 678, 3, 2, 2, 2, 3552, 3553, 7, 85, 2, 2, 3553, 3554, 7, 86, 2, 2, 3554, 3555, 7, 67, 2, 2, 3555, 3556, 7, 86, 2, 2, 3556, 3557, 7, 75, 2, 2, 3557, 3558, 7, 85, 2, 2, 3558, 3559, 7, 86, 2, 2, 3559, 3560, 7, 75, 2, 2, 3560, 3561, 7, 69, 2, 2, 3561, 3562, 7, 85, 2, 2, 3562, 680, 3, 2, 2, 2, 3563, 3564, 7, 85, 2, 2, 3564, 3565, 7, 86, 2, 2, 3565, 3566, 7, 70, 2, 2, 3566, 3567, 7, 75, 2, 2, 3567, 3568, 7, 80, 2, 2, 3568, 682, 3, 2, 2, 2, 3569, 3570, 7, 85, 2, 2, 3570, 3571, 7, 86, 2, 2, 3571, 3572, 7, 70, 2, 2, 3572, 3573, 7, 81, 2, 2, 3573, 3574, 7, 87, 2, 2, 3574, 3575, 7, 86, 2, 2, 3575, 684, 3, 2, 2, 2, 3576, 3577, 7, 85, 2, 2, 3577, 3578, 7, 86, 2, 2, 3578, 3579, 7, 81, 2, 2, 3579, 3580, 7, 84, 2, 2, 3580, 3581, 7, 67, 2, 2, 3581, 3582, 7, 73, 2, 2, 3582, 3583, 7, 71, 2, 2, 3583, 686, 3, 2, 2, 2, 3584, 3585, 7, 85, 2, 2, 3585, 3586, 7, 86, 2, 2, 3586, 3587, 7, 84, 2, 2, 3587, 3588, 7, 75, 2, 2, 3588, 3589, 7, 69, 2, 2, 3589, 3590, 7, 86, 2, 2, 3590, 688, 3, 2, 2, 2, 3591, 3592, 7, 85, 2, 2, 3592, 3593, 7, 86, 2, 2, 3593, 3594, 7, 84, 2, 2, 3594, 3595, 7, 75, 2, 2, 3595, 3596, 7, 82, 2, 2, 3596, 690, 3, 2, 2, 2, 3597, 3598, 7, 85, 2, 2, 3598, 3599, 7, 91, 2, 2, 3599, 3600, 7, 85, 2, 2, 3600, 3601, 7, 75, 2, 2, 3601, 3602, 7, 70, 2, 2, 3602, 692, 3, 2, 2, 2, 3603, 3604, 7, 85, 2, 2, 3604, 3605, 7, 91, 2, 2, 3605, 3606, 7, 85, 2, 2, 3606, 3607, 7, 86, 2, 2, 3607, 3608, 7, 71, 2, 2, 3608, 3609, 7, 79, 2, 2, 3609, 694, 3, 2, 2, 2, 3610, 3611, 7, 86, 2, 2, 3611, 3612, 7, 67, 2, 2, 3612, 3613, 7, 68, 2, 2, 3613, 3614, 7, 78, 2, 2, 3614, 3615, 7, 71, 2, 2, 3615, 3616, 7, 85, 2, 2, 3616, 696, 3, 2, 2, 2, 3617, 3618, 7, 86, 2, 2, 3618, 3619, 7, 67, 2, 2, 3619, 3620, 7, 68, 2, 2, 3620, 3621, 7, 78, 2, 2, 3621, 3622, 7, 71, 2, 2, 3622, 3623, 7, 85, 2, 2, 3623, 3624, 7, 82, 2, 2, 3624, 3625, 7, 67, 2, 2, 3625, 3626, 7, 69, 2, 2, 3626, 3627, 7, 71, 2, 2, 3627, 698, 3, 2, 2, 2, 3628, 3629, 7, 86, 2, 2, 3629, 3630, 7, 71, 2, 2, 3630, 3631, 7, 79, 2, 2, 3631, 3632, 7, 82, 2, 2, 3632, 700, 3, 2, 2, 2, 3633, 3634, 7, 86, 2, 2, 3634, 3635, 7, 71, 2, 2, 3635, 3636, 7, 79, 2, 2, 3636, 3637, 7, 82, 2, 2, 3637, 3638, 7, 78, 2, 2, 3638, 3639, 7, 67, 2, 2, 3639, 3640, 7, 86, 2, 2, 3640, 3641, 7, 71, 2, 2, 3641, 702, 3, 2, 2, 2, 3642, 3643, 7, 86, 2, 2, 3643, 3644, 7, 71, 2, 2, 3644, 3645, 7, 79, 2, 2, 3645, 3646, 7, 82, 2, 2, 3646, 3647, 7, 81, 2, 2, 3647, 3648, 7, 84, 2, 2, 3648, 3649, 7, 67, 2, 2, 3649, 3650, 7, 84, 2, 2, 3650, 3651, 7, 91, 2, 2, 3651, 704, 3, 2, 2, 2, 3652, 3653, 7, 86, 2, 2, 3653, 3654, 7, 71, 2, 2, 3654, 3655, 7, 90, 2, 2, 3655, 3656, 7, 86, 2, 2, 3656, 706, 3, 2, 2, 2, 3657, 3658, 7, 86, 2, 2, 3658, 3659, 7, 84, 2, 2, 3659, 3660, 7, 67, 2, 2, 3660, 3661, 7, 80, 2, 2, 3661, 3662, 7, 85, 2, 2, 3662, 3663, 7, 67, 2, 2, 3663, 3664, 7, 69, 2, 2, 3664, 3665, 7, 86, 2, 2, 3665, 3666, 7, 75, 2, 2, 3666, 3667, 7, 81, 2, 2, 3667, 3668, 7, 80, 2, 2, 3668, 708, 3, 2, 2, 2, 3669, 3670, 7, 86, 2, 2, 3670, 3671, 7, 84, 2, 2, 3671, 3672, 7, 75, 2, 2, 3672, 3673, 7, 73, 2, 2, 3673, 3674, 7, 73, 2, 2, 3674, 3675, 7, 71, 2, 2, 3675, 3676, 7, 84, 2, 2, 3676, 710, 3, 2, 2, 2, 3677, 3678, 7, 86, 2, 2, 3678, 3679, 7, 84, 2, 2, 3679, 3680, 7, 87, 2, 2, 3680, 3681, 7, 80, 2, 2, 3681, 3682, 7, 69, 2, 2, 3682, 3683, 7, 67, 2, 2, 3683, 3684, 7, 86, 2, 2, 3684, 3685, 7, 71, 2, 2, 3685, 712, 3, 2, 2, 2, 3686, 3687, 7, 86, 2, 2, 3687, 3688, 7, 84, 2, 2, 3688, 3689, 7, 87, 2, 2, 3689, 3690, 7, 85, 2, 2, 3690, 3691, 7, 86, 2, 2, 3691, 3692, 7, 71, 2, 2, 3692, 3693, 7, 70, 2, 2, 3693, 714, 3, 2, 2, 2, 3694, 3695, 7, 86, 2, 2, 3695, 3696, 7, 91, 2, 2, 3696, 3697, 7, 82, 2, 2, 3697, 3698, 7, 71, 2, 2, 3698, 716, 3, 2, 2, 2, 3699, 3700, 7, 86, 2, 2, 3700, 3701, 7, 91, 2, 2, 3701, 3702, 7, 82, 2, 2, 3702, 3703, 7, 71, 2, 2, 3703, 3704, 7, 85, 2, 2, 3704, 718, 3, 2, 2, 2, 3705, 3706, 7, 87, 2, 2, 3706, 3707, 7, 80, 2, 2, 3707, 3708, 7, 68, 2, 2, 3708, 3709, 7, 81, 2, 2, 3709, 3710, 7, 87, 2, 2, 3710, 3711, 7, 80, 2, 2, 3711, 3712, 7, 70, 2, 2, 3712, 3713, 7, 71, 2, 2, 3713, 3714, 7, 70, 2, 2, 3714, 720, 3, 2, 2, 2, 3715, 3716, 7, 87, 2, 2, 3716, 3717, 7, 80, 2, 2, 3717, 3718, 7, 69, 2, 2, 3718, 3719, 7, 81, 2, 2, 3719, 3720, 7, 79, 2, 2, 3720, 3721, 7, 79, 2, 2, 3721, 3722, 7, 75, 2, 2, 3722, 3723, 7, 86, 2, 2, 3723, 3724, 7, 86, 2, 2, 3724, 3725, 7, 71, 2, 2, 3725, 3726, 7, 70, 2, 2, 3726, 722, 3, 2, 2, 2, 3727, 3728, 7, 87, 2, 2, 3728, 3729, 7, 80, 2, 2, 3729, 3730, 7, 71, 2, 2, 3730, 3731, 7, 80, 2, 2, 3731, 3732, 7, 69, 2, 2, 3732, 3733, 7, 84, 2, 2, 3733, 3734, 7, 91, 2, 2, 3734, 3735, 7, 82, 2, 2, 3735, 3736, 7, 86, 2, 2, 3736, 3737, 7, 71, 2, 2, 3737, 3738, 7, 70, 2, 2, 3738, 724, 3, 2, 2, 2, 3739, 3740, 7, 87, 2, 2, 3740, 3741, 7, 80, 2, 2, 3741, 3742, 7, 77, 2, 2, 3742, 3743, 7, 80, 2, 2, 3743, 3744, 7, 81, 2, 2, 3744, 3745, 7, 89, 2, 2, 3745, 3746, 7, 80, 2, 2, 3746, 726, 3, 2, 2, 2, 3747, 3748, 7, 87, 2, 2, 3748, 3749, 7, 80, 2, 2, 3749, 3750, 7, 78, 2, 2, 3750, 3751, 7, 75, 2, 2, 3751, 3752, 7, 85, 2, 2, 3752, 3753, 7, 86, 2, 2, 3753, 3754, 7, 71, 2, 2, 3754, 3755, 7, 80, 2, 2, 3755, 728, 3, 2, 2, 2, 3756, 3757, 7, 87, 2, 2, 3757, 3758, 7, 80, 2, 2, 3758, 3759, 7, 78, 2, 2, 3759, 3760, 7, 81, 2, 2, 3760, 3761, 7, 73, 2, 2, 3761, 3762, 7, 73, 2, 2, 3762, 3763, 7, 71, 2, 2, 3763, 3764, 7, 70, 2, 2, 3764, 730, 3, 2, 2, 2, 3765, 3766, 7, 87, 2, 2, 3766, 3767, 7, 80, 2, 2, 3767, 3768, 7, 86, 2, 2, 3768, 3769, 7, 75, 2, 2, 3769, 3770, 7, 78, 2, 2, 3770, 732, 3, 2, 2, 2, 3771, 3772, 7, 87, 2, 2, 3772, 3773, 7, 82, 2, 2, 3773, 3774, 7, 70, 2, 2, 3774, 3775, 7, 67, 2, 2, 3775, 3776, 7, 86, 2, 2, 3776, 3777, 7, 71, 2, 2, 3777, 734, 3, 2, 2, 2, 3778, 3779, 7, 88, 2, 2, 3779, 3780, 7, 67, 2, 2, 3780, 3781, 7, 69, 2, 2, 3781, 3782, 7, 87, 2, 2, 3782, 3783, 7, 87, 2, 2, 3783, 3784, 7, 79, 2, 2, 3784, 736, 3, 2, 2, 2, 3785, 3786, 7, 88, 2, 2, 3786, 3787, 7, 67, 2, 2, 3787, 3788, 7, 78, 2, 2, 3788, 3789, 7, 75, 2, 2, 3789, 3790, 7, 70, 2, 2, 3790, 738, 3, 2, 2, 2, 3791, 3792, 7, 88, 2, 2, 3792, 3793, 7, 67, 2, 2, 3793, 3794, 7, 78, 2, 2, 3794, 3795, 7, 75, 2, 2, 3795, 3796, 7, 70, 2, 2, 3796, 3797, 7, 67, 2, 2, 3797, 3798, 7, 86, 2, 2, 3798, 3799, 7, 71, 2, 2, 3799, 740, 3, 2, 2, 2, 3800, 3801, 7, 88, 2, 2, 3801, 3802, 7, 67, 2, 2, 3802, 3803, 7, 78, 2, 2, 3803, 3804, 7, 75, 2, 2, 3804, 3805, 7, 70, 2, 2, 3805, 3806, 7, 67, 2, 2, 3806, 3807, 7, 86, 2, 2, 3807, 3808, 7, 81, 2, 2, 3808, 3809, 7, 84, 2, 2, 3809, 742, 3, 2, 2, 2, 3810, 3811, 7, 88, 2, 2, 3811, 3812, 7, 67, 2, 2, 3812, 3813, 7, 84, 2, 2, 3813, 3814, 7, 91, 2, 2, 3814, 3815, 7, 75, 2, 2, 3815, 3816, 7, 80, 2, 2, 3816, 3817, 7, 73, 2, 2, 3817, 744, 3, 2, 2, 2, 3818, 3819, 7, 88, 2, 2, 3819, 3820, 7, 71, 2, 2, 3820, 3821, 7, 84, 2, 2, 3821, 3822, 7, 85, 2, 2, 3822, 3823, 7, 75, 2, 2, 3823, 3824, 7, 81, 2, 2, 3824, 3825, 7, 80, 2, 2, 3825, 746, 3, 2, 2, 2, 3826, 3827, 7, 88, 2, 2, 3827, 3828, 7, 75, 2, 2, 3828, 3829, 7, 71, 2, 2, 3829, 3830, 7, 89, 2, 2, 3830, 748, 3, 2, 2, 2, 3831, 3832, 7, 88, 2, 2, 3832, 3833, 7, 81, 2, 2, 3833, 3834, 7, 78, 2, 2, 3834, 3835, 7, 67, 2, 2, 3835, 3836, 7, 86, 2, 2, 3836, 3837, 7, 75, 2, 2, 3837, 3838, 7, 78, 2, 2, 3838, 3839, 7, 71, 2, 2, 3839, 750, 3, 2, 2, 2, 3840, 3841, 7, 89, 2, 2, 3841, 3842, 7, 74, 2, 2, 3842, 3843, 7, 75, 2, 2, 3843, 3844, 7, 86, 2, 2, 3844, 3845, 7, 71, 2, 2, 3845, 3846, 7, 85, 2, 2, 3846, 3847, 7, 82, 2, 2, 3847, 3848, 7, 67, 2, 2, 3848, 3849, 7, 69, 2, 2, 3849, 3850, 7, 71, 2, 2, 3850, 752, 3, 2, 2, 2, 3851, 3852, 7, 89, 2, 2, 3852, 3853, 7, 75, 2, 2, 3853, 3854, 7, 86, 2, 2, 3854, 3855, 7, 74, 2, 2, 3855, 3856, 7, 81, 2, 2, 3856, 3857, 7, 87, 2, 2, 3857, 3858, 7, 86, 2, 2, 3858, 754, 3, 2, 2, 2, 3859, 3860, 7, 89, 2, 2, 3860, 3861, 7, 81, 2, 2, 3861, 3862, 7, 84, 2, 2, 3862, 3863, 7, 77, 2, 2, 3863, 756, 3, 2, 2, 2, 3864, 3865, 7, 89, 2, 2, 3865, 3866, 7, 84, 2, 2, 3866, 3867, 7, 67, 2, 2, 3867, 3868, 7, 82, 2, 2, 3868, 3869, 7, 82, 2, 2, 3869, 3870, 7, 71, 2, 2, 3870, 3871, 7, 84, 2, 2, 3871, 758, 3, 2, 2, 2, 3872, 3873, 7, 89, 2, 2, 3873, 3874, 7, 84, 2, 2, 3874, 3875, 7, 75, 2, 2, 3875, 3876, 7, 86, 2, 2, 3876, 3877, 7, 71, 2, 2, 3877, 760, 3, 2, 2, 2, 3878, 3879, 7, 90, 2, 2, 3879, 3880, 7, 79, 2, 2, 3880, 3881, 7, 78, 2, 2, 3881, 762, 3, 2, 2, 2, 3882, 3883, 7, 91, 2, 2, 3883, 3884, 7, 71, 2, 2, 3884, 3885, 7, 67, 2, 2, 3885, 3886, 7, 84, 2, 2, 3886, 764, 3, 2, 2, 2, 3887, 3888, 7, 91, 2, 2, 3888, 3889, 7, 71, 2, 2, 3889, 3890, 7, 85, 2, 2, 3890, 766, 3, 2, 2, 2, 3891, 3892, 7, 92, 2, 2, 3892, 3893, 7, 81, 2, 2, 3893, 3894, 7, 80, 2, 2, 3894, 3895, 7, 71, 2, 2, 3895, 768, 3, 2, 2, 2, 3896, 3897, 7, 68, 2, 2, 3897, 3898, 7, 71, 2, 2, 3898, 3899, 7, 86, 2, 2, 3899, 3900, 7, 89, 2, 2, 3900, 3901, 7, 71, 2, 2, 3901, 3902, 7, 71, 2, 2, 3902, 3903, 7, 80, 2, 2, 3903, 770, 3, 2, 2, 2, 3904, 3905, 7, 68, 2, 2, 3905, 3906, 7, 75, 2, 2, 3906, 3907, 7, 73, 2, 2, 3907, 3908, 7, 75, 2, 2, 3908, 3909, 7, 80, 2, 2, 3909, 3910, 7, 86, 2, 2, 3910, 772, 3, 2, 2, 2, 3911, 3912, 7, 68, 2, 2, 3912, 3913, 7, 75, 2, 2, 3913, 3914, 7, 86, 2, 2, 3914, 774, 3, 2, 2, 2, 3915, 3916, 7, 68, 2, 2, 3916, 3917, 7, 81, 2, 2, 3917, 3918, 7, 81, 2, 2, 3918, 3919, 7, 78, 2, 2, 3919, 3920, 7, 71, 2, 2, 3920, 3921, 7, 67, 2, 2, 3921, 3922, 7, 80, 2, 2, 3922, 776, 3, 2, 2, 2, 3923, 3924, 7, 69, 2, 2, 3924, 3925, 7, 74, 2, 2, 3925, 3926, 7, 67, 2, 2, 3926, 3927, 7, 84, 2, 2, 3927, 778, 3, 2, 2, 2, 3928, 3929, 7, 69, 2, 2, 3929, 3930, 7, 74, 2, 2, 3930, 3931, 7, 67, 2, 2, 3931, 3932, 7, 84, 2, 2, 3932, 3933, 7, 67, 2, 2, 3933, 3934, 7, 69, 2, 2, 3934, 3935, 7, 86, 2, 2, 3935, 3936, 7, 71, 2, 2, 3936, 3937, 7, 84, 2, 2, 3937, 780, 3, 2, 2, 2, 3938, 3939, 7, 69, 2, 2, 3939, 3940, 7, 81, 2, 2, 3940, 3941, 7, 67, 2, 2, 3941, 3942, 7, 78, 2, 2, 3942, 3943, 7, 71, 2, 2, 3943, 3944, 7, 85, 2, 2, 3944, 3945, 7, 69, 2, 2, 3945, 3946, 7, 71, 2, 2, 3946, 782, 3, 2, 2, 2, 3947, 3948, 7, 70, 2, 2, 3948, 3949, 7, 71, 2, 2, 3949, 3950, 7, 69, 2, 2, 3950, 784, 3, 2, 2, 2, 3951, 3952, 7, 70, 2, 2, 3952, 3953, 7, 71, 2, 2, 3953, 3954, 7, 69, 2, 2, 3954, 3955, 7, 75, 2, 2, 3955, 3956, 7, 79, 2, 2, 3956, 3957, 7, 67, 2, 2, 3957, 3958, 7, 78, 2, 2, 3958, 786, 3, 2, 2, 2, 3959, 3960, 7, 71, 2, 2, 3960, 3961, 7, 90, 2, 2, 3961, 3962, 7, 75, 2, 2, 3962, 3963, 7, 85, 2, 2, 3963, 3964, 7, 86, 2, 2, 3964, 3965, 7, 85, 2, 2, 3965, 788, 3, 2, 2, 2, 3966, 3967, 7, 71, 2, 2, 3967, 3968, 7, 90, 2, 2, 3968, 3969, 7, 86, 2, 2, 3969, 3970, 7, 84, 2, 2, 3970, 3971, 7, 67, 2, 2, 3971, 3972, 7, 69, 2, 2, 3972, 3973, 7, 86, 2, 2, 3973, 790, 3, 2, 2, 2, 3974, 3975, 7, 72, 2, 2, 3975, 3976, 7, 78, 2, 2, 3976, 3977, 7, 81, 2, 2, 3977, 3978, 7, 67, 2, 2, 3978, 3979, 7, 86, 2, 2, 3979, 792, 3, 2, 2, 2, 3980, 3981, 7, 73, 2, 2, 3981, 3982, 7, 84, 2, 2, 3982, 3983, 7, 71, 2, 2, 3983, 3984, 7, 67, 2, 2, 3984, 3985, 7, 86, 2, 2, 3985, 3986, 7, 71, 2, 2, 3986, 3987, 7, 85, 2, 2, 3987, 3988, 7, 86, 2, 2, 3988, 794, 3, 2, 2, 2, 3989, 3990, 7, 75, 2, 2, 3990, 3991, 7, 80, 2, 2, 3991, 3992, 7, 81, 2, 2, 3992, 3993, 7, 87, 2, 2, 3993, 3994, 7, 86, 2, 2, 3994, 796, 3, 2, 2, 2, 3995, 3996, 7, 75, 2, 2, 3996, 3997, 7, 80, 2, 2, 3997, 3998, 7, 86, 2, 2, 3998, 798, 3, 2, 2, 2, 3999, 4000, 7, 75, 2, 2, 4000, 4001, 7, 80, 2, 2, 4001, 4002, 7, 86, 2, 2, 4002, 4003, 7, 71, 2, 2, 4003, 4004, 7, 73, 2, 2, 4004, 4005, 7, 71, 2, 2, 4005, 4006, 7, 84, 2, 2, 4006, 800, 3, 2, 2, 2, 4007, 4008, 7, 75, 2, 2, 4008, 4009, 7, 80, 2, 2, 4009, 4010, 7, 86, 2, 2, 4010, 4011, 7, 71, 2, 2, 4011, 4012, 7, 84, 2, 2, 4012, 4013, 7, 88, 2, 2, 4013, 4014, 7, 67, 2, 2, 4014, 4015, 7, 78, 2, 2, 4015, 802, 3, 2, 2, 2, 4016, 4017, 7, 78, 2, 2, 4017, 4018, 7, 71, 2, 2, 4018, 4019, 7, 67, 2, 2, 4019, 4020, 7, 85, 2, 2, 4020, 4021, 7, 86, 2, 2, 4021, 804, 3, 2, 2, 2, 4022, 4023, 7, 80, 2, 2, 4023, 4024, 7, 67, 2, 2, 4024, 4025, 7, 86, 2, 2, 4025, 4026, 7, 75, 2, 2, 4026, 4027, 7, 81, 2, 2, 4027, 4028, 7, 80, 2, 2, 4028, 4029, 7, 67, 2, 2, 4029, 4030, 7, 78, 2, 2, 4030, 806, 3, 2, 2, 2, 4031, 4032, 7, 80, 2, 2, 4032, 4033, 7, 69, 2, 2, 4033, 4034, 7, 74, 2, 2, 4034, 4035, 7, 67, 2, 2, 4035, 4036, 7, 84, 2, 2, 4036, 808, 3, 2, 2, 2, 4037, 4038, 7, 80, 2, 2, 4038, 4039, 7, 81, 2, 2, 4039, 4040, 7, 80, 2, 2, 4040, 4041, 7, 71, 2, 2, 4041, 810, 3, 2, 2, 2, 4042, 4043, 7, 80, 2, 2, 4043, 4044, 7, 87, 2, 2, 4044, 4045, 7, 78, 2, 2, 4045, 4046, 7, 78, 2, 2, 4046, 4047, 7, 75, 2, 2, 4047, 4048, 7, 72, 2, 2, 4048, 812, 3, 2, 2, 2, 4049, 4050, 7, 80, 2, 2, 4050, 4051, 7, 87, 2, 2, 4051, 4052, 7, 79, 2, 2, 4052, 4053, 7, 71, 2, 2, 4053, 4054, 7, 84, 2, 2, 4054, 4055, 7, 75, 2, 2, 4055, 4056, 7, 69, 2, 2, 4056, 814, 3, 2, 2, 2, 4057, 4058, 7, 81, 2, 2, 4058, 4059, 7, 88, 2, 2, 4059, 4060, 7, 71, 2, 2, 4060, 4061, 7, 84, 2, 2, 4061, 4062, 7, 78, 2, 2, 4062, 4063, 7, 67, 2, 2, 4063, 4064, 7, 91, 2, 2, 4064, 816, 3, 2, 2, 2, 4065, 4066, 7, 82, 2, 2, 4066, 4067, 7, 81, 2, 2, 4067, 4068, 7, 85, 2, 2, 4068, 4069, 7, 75, 2, 2, 4069, 4070, 7, 86, 2, 2, 4070, 4071, 7, 75, 2, 2, 4071, 4072, 7, 81, 2, 2, 4072, 4073, 7, 80, 2, 2, 4073, 818, 3, 2, 2, 2, 4074, 4075, 7, 82, 2, 2, 4075, 4076, 7, 84, 2, 2, 4076, 4077, 7, 71, 2, 2, 4077, 4078, 7, 69, 2, 2, 4078, 4079, 7, 75, 2, 2, 4079, 4080, 7, 85, 2, 2, 4080, 4081, 7, 75, 2, 2, 4081, 4082, 7, 81, 2, 2, 4082, 4083, 7, 80, 2, 2, 4083, 820, 3, 2, 2, 2, 4084, 4085, 7, 84, 2, 2, 4085, 4086, 7, 71, 2, 2, 4086, 4087, 7, 67, 2, 2, 4087, 4088, 7, 78, 2, 2, 4088, 822, 3, 2, 2, 2, 4089, 4090, 7, 84, 2, 2, 4090, 4091, 7, 81, 2, 2, 4091, 4092, 7, 89, 2, 2, 4092, 824, 3, 2, 2, 2, 4093, 4094, 7, 85, 2, 2, 4094, 4095, 7, 71, 2, 2, 4095, 4096, 7, 86, 2, 2, 4096, 4097, 7, 81, 2, 2, 4097, 4098, 7, 72, 2, 2, 4098, 826, 3, 2, 2, 2, 4099, 4100, 7, 85, 2, 2, 4100, 4101, 7, 79, 2, 2, 4101, 4102, 7, 67, 2, 2, 4102, 4103, 7, 78, 2, 2, 4103, 4104, 7, 78, 2, 2, 4104, 4105, 7, 75, 2, 2, 4105, 4106, 7, 80, 2, 2, 4106, 4107, 7, 86, 2, 2, 4107, 828, 3, 2, 2, 2, 4108, 4109, 7, 85, 2, 2, 4109, 4110, 7, 87, 2, 2, 4110, 4111, 7, 68, 2, 2, 4111, 4112, 7, 85, 2, 2, 4112, 4113, 7, 86, 2, 2, 4113, 4114, 7, 84, 2, 2, 4114, 4115, 7, 75, 2, 2, 4115, 4116, 7, 80, 2, 2, 4116, 4117, 7, 73, 2, 2, 4117, 830, 3, 2, 2, 2, 4118, 4119, 7, 86, 2, 2, 4119, 4120, 7, 75, 2, 2, 4120, 4121, 7, 79, 2, 2, 4121, 4122, 7, 71, 2, 2, 4122, 832, 3, 2, 2, 2, 4123, 4124, 7, 86, 2, 2, 4124, 4125, 7, 75, 2, 2, 4125, 4126, 7, 79, 2, 2, 4126, 4127, 7, 71, 2, 2, 4127, 4128, 7, 85, 2, 2, 4128, 4129, 7, 86, 2, 2, 4129, 4130, 7, 67, 2, 2, 4130, 4131, 7, 79, 2, 2, 4131, 4132, 7, 82, 2, 2, 4132, 834, 3, 2, 2, 2, 4133, 4134, 7, 86, 2, 2, 4134, 4135, 7, 84, 2, 2, 4135, 4136, 7, 71, 2, 2, 4136, 4137, 7, 67, 2, 2, 4137, 4138, 7, 86, 2, 2, 4138, 836, 3, 2, 2, 2, 4139, 4140, 7, 86, 2, 2, 4140, 4141, 7, 84, 2, 2, 4141, 4142, 7, 75, 2, 2, 4142, 4143, 7, 79, 2, 2, 4143, 838, 3, 2, 2, 2, 4144, 4145, 7, 88, 2, 2, 4145, 4146, 7, 67, 2, 2, 4146, 4147, 7, 78, 2, 2, 4147, 4148, 7, 87, 2, 2, 4148, 4149, 7, 71, 2, 2, 4149, 4150, 7, 85, 2, 2, 4150, 840, 3, 2, 2, 2, 4151, 4152, 7, 88, 2, 2, 4152, 4153, 7, 67, 2, 2, 4153, 4154, 7, 84, 2, 2, 4154, 4155, 7, 69, 2, 2, 4155, 4156, 7, 74, 2, 2, 4156, 4157, 7, 67, 2, 2, 4157, 4158, 7, 84, 2, 2, 4158, 842, 3, 2, 2, 2, 4159, 4160, 7, 90, 2, 2, 4160, 4161, 7, 79, 2, 2, 4161, 4162, 7, 78, 2, 2, 4162, 4163, 7, 67, 2, 2, 4163, 4164, 7, 86, 2, 2, 4164, 4165, 7, 86, 2, 2, 4165, 4166, 7, 84, 2, 2, 4166, 4167, 7, 75, 2, 2, 4167, 4168, 7, 68, 2, 2, 4168, 4169, 7, 87, 2, 2, 4169, 4170, 7, 86, 2, 2, 4170, 4171, 7, 71, 2, 2, 4171, 4172, 7, 85, 2, 2, 4172, 844, 3, 2, 2, 2, 4173, 4174, 7, 90, 2, 2, 4174, 4175, 7, 79, 2, 2, 4175, 4176, 7, 78, 2, 2, 4176, 4177, 7, 69, 2, 2, 4177, 4178, 7, 81, 2, 2, 4178, 4179, 7, 80, 2, 2, 4179, 4180, 7, 69, 2, 2, 4180, 4181, 7, 67, 2, 2, 4181, 4182, 7, 86, 2, 2, 4182, 846, 3, 2, 2, 2, 4183, 4184, 7, 90, 2, 2, 4184, 4185, 7, 79, 2, 2, 4185, 4186, 7, 78, 2, 2, 4186, 4187, 7, 71, 2, 2, 4187, 4188, 7, 78, 2, 2, 4188, 4189, 7, 71, 2, 2, 4189, 4190, 7, 79, 2, 2, 4190, 4191, 7, 71, 2, 2, 4191, 4192, 7, 80, 2, 2, 4192, 4193, 7, 86, 2, 2, 4193, 848, 3, 2, 2, 2, 4194, 4195, 7, 90, 2, 2, 4195, 4196, 7, 79, 2, 2, 4196, 4197, 7, 78, 2, 2, 4197, 4198, 7, 71, 2, 2, 4198, 4199, 7, 90, 2, 2, 4199, 4200, 7, 75, 2, 2, 4200, 4201, 7, 85, 2, 2, 4201, 4202, 7, 86, 2, 2, 4202, 4203, 7, 85, 2, 2, 4203, 850, 3, 2, 2, 2, 4204, 4205, 7, 90, 2, 2, 4205, 4206, 7, 79, 2, 2, 4206, 4207, 7, 78, 2, 2, 4207, 4208, 7, 72, 2, 2, 4208, 4209, 7, 81, 2, 2, 4209, 4210, 7, 84, 2, 2, 4210, 4211, 7, 71, 2, 2, 4211, 4212, 7, 85, 2, 2, 4212, 4213, 7, 86, 2, 2, 4213, 852, 3, 2, 2, 2, 4214, 4215, 7, 90, 2, 2, 4215, 4216, 7, 79, 2, 2, 4216, 4217, 7, 78, 2, 2, 4217, 4218, 7, 82, 2, 2, 4218, 4219, 7, 67, 2, 2, 4219, 4220, 7, 84, 2, 2, 4220, 4221, 7, 85, 2, 2, 4221, 4222, 7, 71, 2, 2, 4222, 854, 3, 2, 2, 2, 4223, 4224, 7, 90, 2, 2, 4224, 4225, 7, 79, 2, 2, 4225, 4226, 7, 78, 2, 2, 4226, 4227, 7, 82, 2, 2, 4227, 4228, 7, 75, 2, 2, 4228, 856, 3, 2, 2, 2, 4229, 4230, 7, 90, 2, 2, 4230, 4231, 7, 79, 2, 2, 4231, 4232, 7, 78, 2, 2, 4232, 4233, 7, 84, 2, 2, 4233, 4234, 7, 81, 2, 2, 4234, 4235, 7, 81, 2, 2, 4235, 4236, 7, 86, 2, 2, 4236, 858, 3, 2, 2, 2, 4237, 4238, 7, 90, 2, 2, 4238, 4239, 7, 79, 2, 2, 4239, 4240, 7, 78, 2, 2, 4240, 4241, 7, 85, 2, 2, 4241, 4242, 7, 71, 2, 2, 4242, 4243, 7, 84, 2, 2, 4243, 4244, 7, 75, 2, 2, 4244, 4245, 7, 67, 2, 2, 4245, 4246, 7, 78, 2, 2, 4246, 4247, 7, 75, 2, 2, 4247, 4248, 7, 92, 2, 2, 4248, 4249, 7, 71, 2, 2, 4249, 860, 3, 2, 2, 2, 4250, 4251, 7, 69, 2, 2, 4251, 4252, 7, 67, 2, 2, 4252, 4253, 7, 78, 2, 2, 4253, 4254, 7, 78, 2, 2, 4254, 862, 3, 2, 2, 2, 4255, 4256, 7, 69, 2, 2, 4256, 4257, 7, 87, 2, 2, 4257, 4258, 7, 84, 2, 2, 4258, 4259, 7, 84, 2, 2, 4259, 4260, 7, 71, 2, 2, 4260, 4261, 7, 80, 2, 2, 4261, 4262, 7, 86, 2, 2, 4262, 864, 3, 2, 2, 2, 4263, 4264, 7, 67, 2, 2, 4264, 4265, 7, 86, 2, 2, 4265, 4266, 7, 86, 2, 2, 4266, 4267, 7, 67, 2, 2, 4267, 4268, 7, 69, 2, 2, 4268, 4269, 7, 74, 2, 2, 4269, 866, 3, 2, 2, 2, 4270, 4271, 7, 70, 2, 2, 4271, 4272, 7, 71, 2, 2, 4272, 4273, 7, 86, 2, 2, 4273, 4274, 7, 67, 2, 2, 4274, 4275, 7, 69, 2, 2, 4275, 4276, 7, 74, 2, 2, 4276, 868, 3, 2, 2, 2, 4277, 4278, 7, 71, 2, 2, 4278, 4279, 7, 90, 2, 2, 4279, 4280, 7, 82, 2, 2, 4280, 4281, 7, 84, 2, 2, 4281, 4282, 7, 71, 2, 2, 4282, 4283, 7, 85, 2, 2, 4283, 4284, 7, 85, 2, 2, 4284, 4285, 7, 75, 2, 2, 4285, 4286, 7, 81, 2, 2, 4286, 4287, 7, 80, 2, 2, 4287, 870, 3, 2, 2, 2, 4288, 4289, 7, 73, 2, 2, 4289, 4290, 7, 71, 2, 2, 4290, 4291, 7, 80, 2, 2, 4291, 4292, 7, 71, 2, 2, 4292, 4293, 7, 84, 2, 2, 4293, 4294, 7, 67, 2, 2, 4294, 4295, 7, 86, 2, 2, 4295, 4296, 7, 71, 2, 2, 4296, 4297, 7, 70, 2, 2, 4297, 872, 3, 2, 2, 2, 4298, 4299, 7, 78, 2, 2, 4299, 4300, 7, 81, 2, 2, 4300, 4301, 7, 73, 2, 2, 4301, 4302, 7, 73, 2, 2, 4302, 4303, 7, 71, 2, 2, 4303, 4304, 7, 70, 2, 2, 4304, 874, 3, 2, 2, 2, 4305, 4306, 7, 85, 2, 2, 4306, 4307, 7, 86, 2, 2, 4307, 4308, 7, 81, 2, 2, 4308, 4309, 7, 84, 2, 2, 4309, 4310, 7, 71, 2, 2, 4310, 4311, 7, 70, 2, 2, 4311, 876, 3, 2, 2, 2, 4312, 4313, 7, 75, 2, 2, 4313, 4314, 7, 80, 2, 2, 4314, 4315, 7, 69, 2, 2, 4315, 4316, 7, 78, 2, 2, 4316, 4317, 7, 87, 2, 2, 4317, 4318, 7, 70, 2, 2, 4318, 4319, 7, 71, 2, 2, 4319, 878, 3, 2, 2, 2, 4320, 4321, 7, 84, 2, 2, 4321, 4322, 7, 81, 2, 2, 4322, 4323, 7, 87, 2, 2, 4323, 4324, 7, 86, 2, 2, 4324, 4325, 7, 75, 2, 2, 4325, 4326, 7, 80, 2, 2, 4326, 4327, 7, 71, 2, 2, 4327, 880, 3, 2, 2, 2, 4328, 4329, 7, 86, 2, 2, 4329, 4330, 7, 84, 2, 2, 4330, 4331, 7, 67, 2, 2, 4331, 4332, 7, 80, 2, 2, 4332, 4333, 7, 85, 2, 2, 4333, 4334, 7, 72, 2, 2, 4334, 4335, 7, 81, 2, 2, 4335, 4336, 7, 84, 2, 2, 4336, 4337, 7, 79, 2, 2, 4337, 882, 3, 2, 2, 2, 4338, 4339, 7, 75, 2, 2, 4339, 4340, 7, 79, 2, 2, 4340, 4341, 7, 82, 2, 2, 4341, 4342, 7, 81, 2, 2, 4342, 4343, 7, 84, 2, 2, 4343, 4344, 7, 86, 2, 2, 4344, 884, 3, 2, 2, 2, 4345, 4346, 7, 82, 2, 2, 4346, 4347, 7, 81, 2, 2, 4347, 4348, 7, 78, 2, 2, 4348, 4349, 7, 75, 2, 2, 4349, 4350, 7, 69, 2, 2, 4350, 4351, 7, 91, 2, 2, 4351, 886, 3, 2, 2, 2, 4352, 4353, 7, 79, 2, 2, 4353, 4354, 7, 71, 2, 2, 4354, 4355, 7, 86, 2, 2, 4355, 4356, 7, 74, 2, 2, 4356, 4357, 7, 81, 2, 2, 4357, 4358, 7, 70, 2, 2, 4358, 888, 3, 2, 2, 2, 4359, 4360, 7, 84, 2, 2, 4360, 4361, 7, 71, 2, 2, 4361, 4362, 7, 72, 2, 2, 4362, 4363, 7, 71, 2, 2, 4363, 4364, 7, 84, 2, 2, 4364, 4365, 7, 71, 2, 2, 4365, 4366, 7, 80, 2, 2, 4366, 4367, 7, 69, 2, 2, 4367, 4368, 7, 75, 2, 2, 4368, 4369, 7, 80, 2, 2, 4369, 4370, 7, 73, 2, 2, 4370, 890, 3, 2, 2, 2, 4371, 4372, 7, 80, 2, 2, 4372, 4373, 7, 71, 2, 2, 4373, 4374, 7, 89, 2, 2, 4374, 892, 3, 2, 2, 2, 4375, 4376, 7, 81, 2, 2, 4376, 4377, 7, 78, 2, 2, 4377, 4378, 7, 70, 2, 2, 4378, 894, 3, 2, 2, 2, 4379, 4380, 7, 88, 2, 2, 4380, 4381, 7, 67, 2, 2, 4381, 4382, 7, 78, 2, 2, 4382, 4383, 7, 87, 2, 2, 4383, 4384, 7, 71, 2, 2, 4384, 896, 3, 2, 2, 2, 4385, 4386, 7, 85, 2, 2, 4386, 4387, 7, 87, 2, 2, 4387, 4388, 7, 68, 2, 2, 4388, 4389, 7, 85, 2, 2, 4389, 4390, 7, 69, 2, 2, 4390, 4391, 7, 84, 2, 2, 4391, 4392, 7, 75, 2, 2, 4392, 4393, 7, 82, 2, 2, 4393, 4394, 7, 86, 2, 2, 4394, 4395, 7, 75, 2, 2, 4395, 4396, 7, 81, 2, 2, 4396, 4397, 7, 80, 2, 2, 4397, 898, 3, 2, 2, 2, 4398, 4399, 7, 82, 2, 2, 4399, 4400, 7, 87, 2, 2, 4400, 4401, 7, 68, 2, 2, 4401, 4402, 7, 78, 2, 2, 4402, 4403, 7, 75, 2, 2, 4403, 4404, 7, 69, 2, 2, 4404, 4405, 7, 67, 2, 2, 4405, 4406, 7, 86, 2, 2, 4406, 4407, 7, 75, 2, 2, 4407, 4408, 7, 81, 2, 2, 4408, 4409, 7, 80, 2, 2, 4409, 900, 3, 2, 2, 2, 4410, 4411, 7, 81, 2, 2, 4411, 4412, 7, 87, 2, 2, 4412, 4413, 7, 86, 2, 2, 4413, 902, 3, 2, 2, 2, 4414, 4415, 7, 71, 2, 2, 4415, 4416, 7, 80, 2, 2, 4416, 4417, 7, 70, 2, 2, 4417, 904, 3, 2, 2, 2, 4418, 4419, 7, 84, 2, 2, 4419, 4420, 7, 81, 2, 2, 4420, 4421, 7, 87, 2, 2, 4421, 4422, 7, 86, 2, 2, 4422, 4423, 7, 75, 2, 2, 4423, 4424, 7, 80, 2, 2, 4424, 4425, 7, 71, 2, 2, 4425, 4426, 7, 85, 2, 2, 4426, 906, 3, 2, 2, 2, 4427, 4428, 7, 85, 2, 2, 4428, 4429, 7, 69, 2, 2, 4429, 4430, 7, 74, 2, 2, 4430, 4431, 7, 71, 2, 2, 4431, 4432, 7, 79, 2, 2, 4432, 4433, 7, 67, 2, 2, 4433, 4434, 7, 85, 2, 2, 4434, 908, 3, 2, 2, 2, 4435, 4436, 7, 82, 2, 2, 4436, 4437, 7, 84, 2, 2, 4437, 4438, 7, 81, 2, 2, 4438, 4439, 7, 69, 2, 2, 4439, 4440, 7, 71, 2, 2, 4440, 4441, 7, 70, 2, 2, 4441, 4442, 7, 87, 2, 2, 4442, 4443, 7, 84, 2, 2, 4443, 4444, 7, 71, 2, 2, 4444, 4445, 7, 85, 2, 2, 4445, 910, 3, 2, 2, 2, 4446, 4447, 7, 75, 2, 2, 4447, 4448, 7, 80, 2, 2, 4448, 4449, 7, 82, 2, 2, 4449, 4450, 7, 87, 2, 2, 4450, 4451, 7, 86, 2, 2, 4451, 912, 3, 2, 2, 2, 4452, 4453, 7, 85, 2, 2, 4453, 4454, 7, 87, 2, 2, 4454, 4455, 7, 82, 2, 2, 4455, 4456, 7, 82, 2, 2, 4456, 4457, 7, 81, 2, 2, 4457, 4458, 7, 84, 2, 2, 4458, 4459, 7, 86, 2, 2, 4459, 914, 3, 2, 2, 2, 4460, 4461, 7, 82, 2, 2, 4461, 4462, 7, 67, 2, 2, 4462, 4463, 7, 84, 2, 2, 4463, 4464, 7, 67, 2, 2, 4464, 4465, 7, 78, 2, 2, 4465, 4466, 7, 78, 2, 2, 4466, 4467, 7, 71, 2, 2, 4467, 4468, 7, 78, 2, 2, 4468, 916, 3, 2, 2, 2, 4469, 4470, 7, 85, 2, 2, 4470, 4471, 7, 83, 2, 2, 4471, 4472, 7, 78, 2, 2, 4472, 918, 3, 2, 2, 2, 4473, 4474, 7, 70, 2, 2, 4474, 4475, 7, 71, 2, 2, 4475, 4476, 7, 82, 2, 2, 4476, 4477, 7, 71, 2, 2, 4477, 4478, 7, 80, 2, 2, 4478, 4479, 7, 70, 2, 2, 4479, 4480, 7, 85, 2, 2, 4480, 920, 3, 2, 2, 2, 4481, 4482, 7, 81, 2, 2, 4482, 4483, 7, 88, 2, 2, 4483, 4484, 7, 71, 2, 2, 4484, 4485, 7, 84, 2, 2, 4485, 4486, 7, 84, 2, 2, 4486, 4487, 7, 75, 2, 2, 4487, 4488, 7, 70, 2, 2, 4488, 4489, 7, 75, 2, 2, 4489, 4490, 7, 80, 2, 2, 4490, 4491, 7, 73, 2, 2, 4491, 922, 3, 2, 2, 2, 4492, 4493, 7, 69, 2, 2, 4493, 4494, 7, 81, 2, 2, 4494, 4495, 7, 80, 2, 2, 4495, 4496, 7, 72, 2, 2, 4496, 4497, 7, 78, 2, 2, 4497, 4498, 7, 75, 2, 2, 4498, 4499, 7, 69, 2, 2, 4499, 4500, 7, 86, 2, 2, 4500, 924, 3, 2, 2, 2, 4501, 4502, 7, 85, 2, 2, 4502, 4503, 7, 77, 2, 2, 4503, 4504, 7, 75, 2, 2, 4504, 4505, 7, 82, 2, 2, 4505, 926, 3, 2, 2, 2, 4506, 4507, 7, 78, 2, 2, 4507, 4508, 7, 81, 2, 2, 4508, 4509, 7, 69, 2, 2, 4509, 4510, 7, 77, 2, 2, 4510, 4511, 7, 71, 2, 2, 4511, 4512, 7, 70, 2, 2, 4512, 928, 3, 2, 2, 2, 4513, 4514, 7, 86, 2, 2, 4514, 4515, 7, 75, 2, 2, 4515, 4516, 7, 71, 2, 2, 4516, 4517, 7, 85, 2, 2, 4517, 930, 3, 2, 2, 2, 4518, 4519, 7, 84, 2, 2, 4519, 4520, 7, 81, 2, 2, 4520, 4521, 7, 78, 2, 2, 4521, 4522, 7, 78, 2, 2, 4522, 4523, 7, 87, 2, 2, 4523, 4524, 7, 82, 2, 2, 4524, 932, 3, 2, 2, 2, 4525, 4526, 7, 69, 2, 2, 4526, 4527, 7, 87, 2, 2, 4527, 4528, 7, 68, 2, 2, 4528, 4529, 7, 71, 2, 2, 4529, 934, 3, 2, 2, 2, 4530, 4531, 7, 73, 2, 2, 4531, 4532, 7, 84, 2, 2, 4532, 4533, 7, 81, 2, 2, 4533, 4534, 7, 87, 2, 2, 4534, 4535, 7, 82, 2, 2, 4535, 4536, 7, 75, 2, 2, 4536, 4537, 7, 80, 2, 2, 4537, 4538, 7, 73, 2, 2, 4538, 936, 3, 2, 2, 2, 4539, 4540, 7, 85, 2, 2, 4540, 4541, 7, 71, 2, 2, 4541, 4542, 7, 86, 2, 2, 4542, 4543, 7, 85, 2, 2, 4543, 938, 3, 2, 2, 2, 4544, 4545, 7, 86, 2, 2, 4545, 4546, 7, 67, 2, 2, 4546, 4547, 7, 68, 2, 2, 4547, 4548, 7, 78, 2, 2, 4548, 4549, 7, 71, 2, 2, 4549, 4550, 7, 85, 2, 2, 4550, 4551, 7, 67, 2, 2, 4551, 4552, 7, 79, 2, 2, 4552, 4553, 7, 82, 2, 2, 4553, 4554, 7, 78, 2, 2, 4554, 4555, 7, 71, 2, 2, 4555, 940, 3, 2, 2, 2, 4556, 4557, 7, 81, 2, 2, 4557, 4558, 7, 84, 2, 2, 4558, 4559, 7, 70, 2, 2, 4559, 4560, 7, 75, 2, 2, 4560, 4561, 7, 80, 2, 2, 4561, 4562, 7, 67, 2, 2, 4562, 4563, 7, 78, 2, 2, 4563, 4564, 7, 75, 2, 2, 4564, 4565, 7, 86, 2, 2, 4565, 4566, 7, 91, 2, 2, 4566, 942, 3, 2, 2, 2, 4567, 4568, 7, 90, 2, 2, 4568, 4569, 7, 79, 2, 2, 4569, 4570, 7, 78, 2, 2, 4570, 4571, 7, 86, 2, 2, 4571, 4572, 7, 67, 2, 2, 4572, 4573, 7, 68, 2, 2, 4573, 4574, 7, 78, 2, 2, 4574, 4575, 7, 71, 2, 2, 4575, 944, 3, 2, 2, 2, 4576, 4577, 7, 69, 2, 2, 4577, 4578, 7, 81, 2, 2, 4578, 4579, 7, 78, 2, 2, 4579, 4580, 7, 87, 2, 2, 4580, 4581, 7, 79, 2, 2, 4581, 4582, 7, 80, 2, 2, 4582, 4583, 7, 85, 2, 2, 4583, 946, 3, 2, 2, 2, 4584, 4585, 7, 90, 2, 2, 4585, 4586, 7, 79, 2, 2, 4586, 4587, 7, 78, 2, 2, 4587, 4588, 7, 80, 2, 2, 4588, 4589, 7, 67, 2, 2, 4589, 4590, 7, 79, 2, 2, 4590, 4591, 7, 71, 2, 2, 4591, 4592, 7, 85, 2, 2, 4592, 4593, 7, 82, 2, 2, 4593, 4594, 7, 67, 2, 2, 4594, 4595, 7, 69, 2, 2, 4595, 4596, 7, 71, 2, 2, 4596, 4597, 7, 85, 2, 2, 4597, 948, 3, 2, 2, 2, 4598, 4599, 7, 84, 2, 2, 4599, 4600, 7, 81, 2, 2, 4600, 4601, 7, 89, 2, 2, 4601, 4602, 7, 86, 2, 2, 4602, 4603, 7, 91, 2, 2, 4603, 4604, 7, 82, 2, 2, 4604, 4605, 7, 71, 2, 2, 4605, 950, 3, 2, 2, 2, 4606, 4607, 7, 80, 2, 2, 4607, 4608, 7, 81, 2, 2, 4608, 4609, 7, 84, 2, 2, 4609, 4610, 7, 79, 2, 2, 4610, 4611, 7, 67, 2, 2, 4611, 4612, 7, 78, 2, 2, 4612, 4613, 7, 75, 2, 2, 4613, 4614, 7, 92, 2, 2, 4614, 4615, 7, 71, 2, 2, 4615, 4616, 7, 70, 2, 2, 4616, 952, 3, 2, 2, 2, 4617, 4618, 7, 89, 2, 2, 4618, 4619, 7, 75, 2, 2, 4619, 4620, 7, 86, 2, 2, 4620, 4621, 7, 74, 2, 2, 4621, 4622, 7, 75, 2, 2, 4622, 4623, 7, 80, 2, 2, 4623, 954, 3, 2, 2, 2, 4624, 4625, 7, 72, 2, 2, 4625, 4626, 7, 75, 2, 2, 4626, 4627, 7, 78, 2, 2, 4627, 4628, 7, 86, 2, 2, 4628, 4629, 7, 71, 2, 2, 4629, 4630, 7, 84, 2, 2, 4630, 956, 3, 2, 2, 2, 4631, 4632, 7, 73, 2, 2, 4632, 4633, 7, 84, 2, 2, 4633, 4634, 7, 81, 2, 2, 4634, 4635, 7, 87, 2, 2, 4635, 4636, 7, 82, 2, 2, 4636, 4637, 7, 85, 2, 2, 4637, 958, 3, 2, 2, 2, 4638, 4639, 7, 81, 2, 2, 4639, 4640, 7, 86, 2, 2, 4640, 4641, 7, 74, 2, 2, 4641, 4642, 7, 71, 2, 2, 4642, 4643, 7, 84, 2, 2, 4643, 4644, 7, 85, 2, 2, 4644, 960, 3, 2, 2, 2, 4645, 4646, 7, 80, 2, 2, 4646, 4647, 7, 72, 2, 2, 4647, 4648, 7, 69, 2, 2, 4648, 962, 3, 2, 2, 2, 4649, 4650, 7, 80, 2, 2, 4650, 4651, 7, 72, 2, 2, 4651, 4652, 7, 70, 2, 2, 4652, 964, 3, 2, 2, 2, 4653, 4654, 7, 80, 2, 2, 4654, 4655, 7, 72, 2, 2, 4655, 4656, 7, 77, 2, 2, 4656, 4657, 7, 69, 2, 2, 4657, 966, 3, 2, 2, 2, 4658, 4659, 7, 80, 2, 2, 4659, 4660, 7, 72, 2, 2, 4660, 4661, 7, 77, 2, 2, 4661, 4662, 7, 70, 2, 2, 4662, 968, 3, 2, 2, 2, 4663, 4664, 7, 87, 2, 2, 4664, 4665, 7, 71, 2, 2, 4665, 4666, 7, 85, 2, 2, 4666, 4667, 7, 69, 2, 2, 4667, 4668, 7, 67, 2, 2, 4668, 4669, 7, 82, 2, 2, 4669, 4670, 7, 71, 2, 2, 4670, 970, 3, 2, 2, 2, 4671, 4672, 7, 88, 2, 2, 4672, 4673, 7, 75, 2, 2, 4673, 4674, 7, 71, 2, 2, 4674, 4675, 7, 89, 2, 2, 4675, 4676, 7, 85, 2, 2, 4676, 972, 3, 2, 2, 2, 4677, 4678, 7, 80, 2, 2, 4678, 4679, 7, 81, 2, 2, 4679, 4680, 7, 84, 2, 2, 4680, 4681, 7, 79, 2, 2, 4681, 4682, 7, 67, 2, 2, 4682, 4683, 7, 78, 2, 2, 4683, 4684, 7, 75, 2, 2, 4684, 4685, 7, 92, 2, 2, 4685, 4686, 7, 71, 2, 2, 4686, 974, 3, 2, 2, 2, 4687, 4688, 7, 70, 2, 2, 4688, 4689, 7, 87, 2, 2, 4689, 4690, 7, 79, 2, 2, 4690, 4691, 7, 82, 2, 2, 4691, 976, 3, 2, 2, 2, 4692, 4693, 7, 82, 2, 2, 4693, 4694, 7, 84, 2, 2, 4694, 4695, 7, 75, 2, 2, 4695, 4696, 7, 80, 2, 2, 4696, 4697, 7, 86, 2, 2, 4697, 4698, 7, 97, 2, 2, 4698, 4699, 7, 85, 2, 2, 4699, 4700, 7, 86, 2, 2, 4700, 4701, 7, 84, 2, 2, 4701, 4702, 7, 75, 2, 2, 4702, 4703, 7, 69, 2, 2, 4703, 4704, 7, 86, 2, 2, 4704, 4705, 7, 97, 2, 2, 4705, 4706, 7, 82, 2, 2, 4706, 4707, 7, 67, 2, 2, 4707, 4708, 7, 84, 2, 2, 4708, 4709, 7, 67, 2, 2, 4709, 4710, 7, 79, 2, 2, 4710, 4711, 7, 85, 2, 2, 4711, 978, 3, 2, 2, 2, 4712, 4713, 7, 88, 2, 2, 4713, 4714, 7, 67, 2, 2, 4714, 4715, 7, 84, 2, 2, 4715, 4716, 7, 75, 2, 2, 4716, 4717, 7, 67, 2, 2, 4717, 4718, 7, 68, 2, 2, 4718, 4719, 7, 78, 2, 2, 4719, 4720, 7, 71, 2, 2, 4720, 4721, 7, 97, 2, 2, 4721, 4722, 7, 69, 2, 2, 4722, 4723, 7, 81, 2, 2, 4723, 4724, 7, 80, 2, 2, 4724, 4725, 7, 72, 2, 2, 4725, 4726, 7, 78, 2, 2, 4726, 4727, 7, 75, 2, 2, 4727, 4728, 7, 69, 2, 2, 4728, 4729, 7, 86, 2, 2, 4729, 980, 3, 2, 2, 2, 4730, 4731, 7, 71, 2, 2, 4731, 4732, 7, 84, 2, 2, 4732, 4733, 7, 84, 2, 2, 4733, 4734, 7, 81, 2, 2, 4734, 4735, 7, 84, 2, 2, 4735, 982, 3, 2, 2, 2, 4736, 4737, 7, 87, 2, 2, 4737, 4738, 7, 85, 2, 2, 4738, 4739, 7, 71, 2, 2, 4739, 4740, 7, 97, 2, 2, 4740, 4741, 7, 88, 2, 2, 4741, 4742, 7, 67, 2, 2, 4742, 4743, 7, 84, 2, 2, 4743, 4744, 7, 75, 2, 2, 4744, 4745, 7, 67, 2, 2, 4745, 4746, 7, 68, 2, 2, 4746, 4747, 7, 78, 2, 2, 4747, 4748, 7, 71, 2, 2, 4748, 984, 3, 2, 2, 2, 4749, 4750, 7, 87, 2, 2, 4750, 4751, 7, 85, 2, 2, 4751, 4752, 7, 71, 2, 2, 4752, 4753, 7, 97, 2, 2, 4753, 4754, 7, 69, 2, 2, 4754, 4755, 7, 81, 2, 2, 4755, 4756, 7, 78, 2, 2, 4756, 4757, 7, 87, 2, 2, 4757, 4758, 7, 79, 2, 2, 4758, 4759, 7, 80, 2, 2, 4759, 986, 3, 2, 2, 2, 4760, 4761, 7, 67, 2, 2, 4761, 4762, 7, 78, 2, 2, 4762, 4763, 7, 75, 2, 2, 4763, 4764, 7, 67, 2, 2, 4764, 4765, 7, 85, 2, 2, 4765, 988, 3, 2, 2, 2, 4766, 4767, 7, 69, 2, 2, 4767, 4768, 7, 81, 2, 2, 4768, 4769, 7, 80, 2, 2, 4769, 4770, 7, 85, 2, 2, 4770, 4771, 7, 86, 2, 2, 4771, 4772, 7, 67, 2, 2, 4772, 4773, 7, 80, 2, 2, 4773, 4774, 7, 86, 2, 2, 4774, 990, 3, 2, 2, 2, 4775, 4776, 7, 82, 2, 2, 4776, 4777, 7, 71, 2, 2, 4777, 4778, 7, 84, 2, 2, 4778, 4779, 7, 72, 2, 2, 4779, 4780, 7, 81, 2, 2, 4780, 4781, 7, 84, 2, 2, 4781, 4782, 7, 79, 2, 2, 4782, 992, 3, 2, 2, 2, 4783, 4784, 7, 73, 2, 2, 4784, 4785, 7, 71, 2, 2, 4785, 4786, 7, 86, 2, 2, 4786, 994, 3, 2, 2, 2, 4787, 4788, 7, 70, 2, 2, 4788, 4789, 7, 75, 2, 2, 4789, 4790, 7, 67, 2, 2, 4790, 4791, 7, 73, 2, 2, 4791, 4792, 7, 80, 2, 2, 4792, 4793, 7, 81, 2, 2, 4793, 4794, 7, 85, 2, 2, 4794, 4795, 7, 86, 2, 2, 4795, 4796, 7, 75, 2, 2, 4796, 4797, 7, 69, 2, 2, 4797, 4798, 7, 85, 2, 2, 4798, 996, 3, 2, 2, 2, 4799, 4800, 7, 85, 2, 2, 4800, 4801, 7, 86, 2, 2, 4801, 4802, 7, 67, 2, 2, 4802, 4803, 7, 69, 2, 2, 4803, 4804, 7, 77, 2, 2, 4804, 4805, 7, 71, 2, 2, 4805, 4806, 7, 70, 2, 2, 4806, 998, 3, 2, 2, 2, 4807, 4808, 7, 71, 2, 2, 4808, 4809, 7, 78, 2, 2, 4809, 4810, 7, 85, 2, 2, 4810, 4811, 7, 75, 2, 2, 4811, 4812, 7, 72, 2, 2, 4812, 1000, 3, 2, 2, 2, 4813, 4814, 7, 89, 2, 2, 4814, 4815, 7, 74, 2, 2, 4815, 4816, 7, 75, 2, 2, 4816, 4817, 7, 78, 2, 2, 4817, 4818, 7, 71, 2, 2, 4818, 1002, 3, 2, 2, 2, 4819, 4820, 7, 84, 2, 2, 4820, 4821, 7, 71, 2, 2, 4821, 4822, 7, 88, 2, 2, 4822, 4823, 7, 71, 2, 2, 4823, 4824, 7, 84, 2, 2, 4824, 4825, 7, 85, 2, 2, 4825, 4826, 7, 71, 2, 2, 4826, 1004, 3, 2, 2, 2, 4827, 4828, 7, 72, 2, 2, 4828, 4829, 7, 81, 2, 2, 4829, 4830, 7, 84, 2, 2, 4830, 4831, 7, 71, 2, 2, 4831, 4832, 7, 67, 2, 2, 4832, 4833, 7, 69, 2, 2, 4833, 4834, 7, 74, 2, 2, 4834, 1006, 3, 2, 2, 2, 4835, 4836, 7, 85, 2, 2, 4836, 4837, 7, 78, 2, 2, 4837, 4838, 7, 75, 2, 2, 4838, 4839, 7, 69, 2, 2, 4839, 4840, 7, 71, 2, 2, 4840, 1008, 3, 2, 2, 2, 4841, 4842, 7, 71, 2, 2, 4842, 4843, 7, 90, 2, 2, 4843, 4844, 7, 75, 2, 2, 4844, 4845, 7, 86, 2, 2, 4845, 1010, 3, 2, 2, 2, 4846, 4847, 7, 84, 2, 2, 4847, 4848, 7, 71, 2, 2, 4848, 4849, 7, 86, 2, 2, 4849, 4850, 7, 87, 2, 2, 4850, 4851, 7, 84, 2, 2, 4851, 4852, 7, 80, 2, 2, 4852, 1012, 3, 2, 2, 2, 4853, 4854, 7, 83, 2, 2, 4854, 4855, 7, 87, 2, 2, 4855, 4856, 7, 71, 2, 2, 4856, 4857, 7, 84, 2, 2, 4857, 4858, 7, 91, 2, 2, 4858, 1014, 3, 2, 2, 2, 4859, 4860, 7, 84, 2, 2, 4860, 4861, 7, 67, 2, 2, 4861, 4862, 7, 75, 2, 2, 4862, 4863, 7, 85, 2, 2, 4863, 4864, 7, 71, 2, 2, 4864, 1016, 3, 2, 2, 2, 4865, 4866, 7, 85, 2, 2, 4866, 4867, 7, 83, 2, 2, 4867, 4868, 7, 78, 2, 2, 4868, 4869, 7, 85, 2, 2, 4869, 4870, 7, 86, 2, 2, 4870, 4871, 7, 67, 2, 2, 4871, 4872, 7, 86, 2, 2, 4872, 4873, 7, 71, 2, 2, 4873, 1018, 3, 2, 2, 2, 4874, 4875, 7, 70, 2, 2, 4875, 4876, 7, 71, 2, 2, 4876, 4877, 7, 68, 2, 2, 4877, 4878, 7, 87, 2, 2, 4878, 4879, 7, 73, 2, 2, 4879, 1020, 3, 2, 2, 2, 4880, 4881, 7, 78, 2, 2, 4881, 4882, 7, 81, 2, 2, 4882, 4883, 7, 73, 2, 2, 4883, 1022, 3, 2, 2, 2, 4884, 4885, 7, 75, 2, 2, 4885, 4886, 7, 80, 2, 2, 4886, 4887, 7, 72, 2, 2, 4887, 4888, 7, 81, 2, 2, 4888, 1024, 3, 2, 2, 2, 4889, 4890, 7, 80, 2, 2, 4890, 4891, 7, 81, 2, 2, 4891, 4892, 7, 86, 2, 2, 4892, 4893, 7, 75, 2, 2, 4893, 4894, 7, 69, 2, 2, 4894, 4895, 7, 71, 2, 2, 4895, 1026, 3, 2, 2, 2, 4896, 4897, 7, 89, 2, 2, 4897, 4898, 7, 67, 2, 2, 4898, 4899, 7, 84, 2, 2, 4899, 4900, 7, 80, 2, 2, 4900, 4901, 7, 75, 2, 2, 4901, 4902, 7, 80, 2, 2, 4902, 4903, 7, 73, 2, 2, 4903, 1028, 3, 2, 2, 2, 4904, 4905, 7, 71, 2, 2, 4905, 4906, 7, 90, 2, 2, 4906, 4907, 7, 69, 2, 2, 4907, 4908, 7, 71, 2, 2, 4908, 4909, 7, 82, 2, 2, 4909, 4910, 7, 86, 2, 2, 4910, 4911, 7, 75, 2, 2, 4911, 4912, 7, 81, 2, 2, 4912, 4913, 7, 80, 2, 2, 4913, 1030, 3, 2, 2, 2, 4914, 4915, 7, 67, 2, 2, 4915, 4916, 7, 85, 2, 2, 4916, 4917, 7, 85, 2, 2, 4917, 4918, 7, 71, 2, 2, 4918, 4919, 7, 84, 2, 2, 4919, 4920, 7, 86, 2, 2, 4920, 1032, 3, 2, 2, 2, 4921, 4922, 7, 78, 2, 2, 4922, 4923, 7, 81, 2, 2, 4923, 4924, 7, 81, 2, 2, 4924, 4925, 7, 82, 2, 2, 4925, 1034, 3, 2, 2, 2, 4926, 4927, 7, 81, 2, 2, 4927, 4928, 7, 82, 2, 2, 4928, 4929, 7, 71, 2, 2, 4929, 4930, 7, 80, 2, 2, 4930, 1036, 3, 2, 2, 2, 4931, 4935, 5, 1039, 518, 2, 4932, 4934, 5, 1041, 519, 2, 4933, 4932, 3, 2, 2, 2, 4934, 4937, 3, 2, 2, 2, 4935, 4933, 3, 2, 2, 2, 4935, 4936, 3, 2, 2, 2, 4936, 1038, 3, 2, 2, 2, 4937, 4935, 3, 2, 2, 2, 4938, 4945, 9, 7, 2, 2, 4939, 4940, 9, 8, 2, 2, 4940, 4945, 6, 518, 8, 2, 4941, 4942, 9, 9, 2, 2, 4942, 4943, 9, 10, 2, 2, 4943, 4945, 6, 518, 9, 2, 4944, 4938, 3, 2, 2, 2, 4944, 4939, 3, 2, 2, 2, 4944, 4941, 3, 2, 2, 2, 4945, 1040, 3, 2, 2, 2, 4946, 4949, 5, 1043, 520, 2, 4947, 4949, 7, 38, 2, 2, 4948, 4946, 3, 2, 2, 2, 4948, 4947, 3, 2, 2, 2, 4949, 1042, 3, 2, 2, 2, 4950, 4953, 5, 1039, 518, 2, 4951, 4953, 9, 2, 2, 2, 4952, 4950, 3, 2, 2, 2, 4952, 4951, 3, 2, 2, 2, 4953, 1044, 3, 2, 2, 2, 4954, 4955, 5, 1047, 522, 2, 4955, 4956, 7, 36, 2, 2, 4956, 1046, 3, 2, 2, 2, 4957, 4963, 7, 36, 2, 2, 4958, 4959, 7, 36, 2, 2, 4959, 4962, 7, 36, 2, 2, 4960, 4962, 10, 11, 2, 2, 4961, 4958, 3, 2, 2, 2, 4961, 4960, 3, 2, 2, 2, 4962, 4965, 3, 2, 2, 2, 4963, 4961, 3, 2, 2, 2, 4963, 4964, 3, 2, 2, 2, 4964, 1048, 3, 2, 2, 2, 4965, 4963, 3, 2, 2, 2, 4966, 4967, 5, 1051, 524, 2, 4967, 4968, 7, 36, 2, 2, 4968, 1050, 3, 2, 2, 2, 4969, 4975, 7, 36, 2, 2, 4970, 4971, 7, 36, 2, 2, 4971, 4974, 7, 36, 2, 2, 4972, 4974, 10, 12, 2, 2, 4973, 4970, 3, 2, 2, 2, 4973, 4972, 3, 2, 2, 2, 4974, 4977, 3, 2, 2, 2, 4975, 4973, 3, 2, 2, 2, 4975, 4976, 3, 2, 2, 2, 4976, 1052, 3, 2, 2, 2, 4977, 4975, 3, 2, 2, 2, 4978, 4979, 7, 87, 2, 2, 4979, 4980, 7, 40, 2, 2, 4980, 4981, 5, 1045, 521, 2, 4981, 1054, 3, 2, 2, 2, 4982, 4983, 7, 87, 2, 2, 4983, 4984, 7, 40, 2, 2, 4984, 4985, 5, 1047, 522, 2, 4985, 1056, 3, 2, 2, 2, 4986, 4987, 7, 87, 2, 2, 4987, 4988, 7, 40, 2, 2, 4988, 4989, 5, 1049, 523, 2, 4989, 1058, 3, 2, 2, 2, 4990, 4991, 7, 87, 2, 2, 4991, 4992, 7, 40, 2, 2, 4992, 4993, 5, 1051, 524, 2, 4993, 1060, 3, 2, 2, 2, 4994, 4995, 5, 1063, 530, 2, 4995, 4996, 7, 41, 2, 2, 4996, 1062, 3, 2, 2, 2, 4997, 5003, 7, 41, 2, 2, 4998, 4999, 7, 41, 2, 2, 4999, 5002, 7, 41, 2, 2, 5000, 5002, 10, 13, 2, 2, 5001, 4998, 3, 2, 2, 2, 5001, 5000, 3, 2, 2, 2, 5002, 5005, 3, 2, 2, 2, 5003, 5001, 3, 2, 2, 2, 5003, 5004, 3, 2, 2, 2, 5004, 1064, 3, 2, 2, 2, 5005, 5003, 3, 2, 2, 2, 5006, 5007, 7, 71, 2, 2, 5007, 5008, 7, 41, 2, 2, 5008, 5009, 3, 2, 2, 2, 5009, 5010, 8, 531, 4, 2, 5010, 5011, 8, 531, 5, 2, 5011, 1066, 3, 2, 2, 2, 5012, 5013, 5, 1069, 533, 2, 5013, 5014, 7, 41, 2, 2, 5014, 1068, 3, 2, 2, 2, 5015, 5016, 7, 87, 2, 2, 5016, 5017, 7, 40, 2, 2, 5017, 5018, 5, 1063, 530, 2, 5018, 1070, 3, 2, 2, 2, 5019, 5021, 7, 38, 2, 2, 5020, 5022, 5, 1073, 535, 2, 5021, 5020, 3, 2, 2, 2, 5021, 5022, 3, 2, 2, 2, 5022, 5023, 3, 2, 2, 2, 5023, 5024, 7, 38, 2, 2, 5024, 5025, 8, 534, 6, 2, 5025, 5026, 3, 2, 2, 2, 5026, 5027, 8, 534, 7, 2, 5027, 1072, 3, 2, 2, 2, 5028, 5032, 5, 1039, 518, 2, 5029, 5031, 5, 1043, 520, 2, 5030, 5029, 3, 2, 2, 2, 5031, 5034, 3, 2, 2, 2, 5032, 5030, 3, 2, 2, 2, 5032, 5033, 3, 2, 2, 2, 5033, 1074, 3, 2, 2, 2, 5034, 5032, 3, 2, 2, 2, 5035, 5036, 5, 1077, 537, 2, 5036, 5037, 7, 41, 2, 2, 5037, 1076, 3, 2, 2, 2, 5038, 5039, 7, 68, 2, 2, 5039, 5043, 7, 41, 2, 2, 5040, 5042, 9, 14, 2, 2, 5041, 5040, 3, 2, 2, 2, 5042, 5045, 3, 2, 2, 2, 5043, 5041, 3, 2, 2, 2, 5043, 5044, 3, 2, 2, 2, 5044, 1078, 3, 2, 2, 2, 5045, 5043, 3, 2, 2, 2, 5046, 5047, 5, 1081, 539, 2, 5047, 5048, 7, 41, 2, 2, 5048, 1080, 3, 2, 2, 2, 5049, 5050, 7, 68, 2, 2, 5050, 5051, 5, 1063, 530, 2, 5051, 1082, 3, 2, 2, 2, 5052, 5053, 5, 1085, 541, 2, 5053, 5054, 7, 41, 2, 2, 5054, 1084, 3, 2, 2, 2, 5055, 5056, 7, 90, 2, 2, 5056, 5060, 7, 41, 2, 2, 5057, 5059, 9, 15, 2, 2, 5058, 5057, 3, 2, 2, 2, 5059, 5062, 3, 2, 2, 2, 5060, 5058, 3, 2, 2, 2, 5060, 5061, 3, 2, 2, 2, 5061, 1086, 3, 2, 2, 2, 5062, 5060, 3, 2, 2, 2, 5063, 5064, 5, 1089, 543, 2, 5064, 5065, 7, 41, 2, 2, 5065, 1088, 3, 2, 2, 2, 5066, 5067, 7, 90, 2, 2, 5067, 5068, 5, 1063, 530, 2, 5068, 1090, 3, 2, 2, 2, 5069, 5070, 5, 1097, 547, 2, 5070, 1092, 3, 2, 2, 2, 5071, 5072, 5, 1097, 547, 2, 5072, 5073, 7, 48, 2, 2, 5073, 5074, 7, 48, 2, 2, 5074, 5075, 3, 2, 2, 2, 5075, 5076, 8, 545, 8, 2, 5076, 1094, 3, 2, 2, 2, 5077, 5078, 5, 1097, 547, 2, 5078, 5080, 7, 48, 2, 2, 5079, 5081, 5, 1097, 547, 2, 5080, 5079, 3, 2, 2, 2, 5080, 5081, 3, 2, 2, 2, 5081, 5087, 3, 2, 2, 2, 5082, 5084, 7, 71, 2, 2, 5083, 5085, 9, 3, 2, 2, 5084, 5083, 3, 2, 2, 2, 5084, 5085, 3, 2, 2, 2, 5085, 5086, 3, 2, 2, 2, 5086, 5088, 5, 1097, 547, 2, 5087, 5082, 3, 2, 2, 2, 5087, 5088, 3, 2, 2, 2, 5088, 5106, 3, 2, 2, 2, 5089, 5090, 7, 48, 2, 2, 5090, 5096, 5, 1097, 547, 2, 5091, 5093, 7, 71, 2, 2, 5092, 5094, 9, 3, 2, 2, 5093, 5092, 3, 2, 2, 2, 5093, 5094, 3, 2, 2, 2, 5094, 5095, 3, 2, 2, 2, 5095, 5097, 5, 1097, 547, 2, 5096, 5091, 3, 2, 2, 2, 5096, 5097, 3, 2, 2, 2, 5097, 5106, 3, 2, 2, 2, 5098, 5099, 5, 1097, 547, 2, 5099, 5101, 7, 71, 2, 2, 5100, 5102, 9, 3, 2, 2, 5101, 5100, 3, 2, 2, 2, 5101, 5102, 3, 2, 2, 2, 5102, 5103, 3, 2, 2, 2, 5103, 5104, 5, 1097, 547, 2, 5104, 5106, 3, 2, 2, 2, 5105, 5077, 3, 2, 2, 2, 5105, 5089, 3, 2, 2, 2, 5105, 5098, 3, 2, 2, 2, 5106, 1096, 3, 2, 2, 2, 5107, 5109, 9, 2, 2, 2, 5108, 5107, 3, 2, 2, 2, 5109, 5110, 3, 2, 2, 2, 5110, 5108, 3, 2, 2, 2, 5110, 5111, 3, 2, 2, 2, 5111, 1098, 3, 2, 2, 2, 5112, 5113, 7, 60, 2, 2, 5113, 5117, 9, 16, 2, 2, 5114, 5116, 9, 17, 2, 2, 5115, 5114, 3, 2, 2, 2, 5116, 5119, 3, 2, 2, 2, 5117, 5115, 3, 2, 2, 2, 5117, 5118, 3, 2, 2, 2, 5118, 1100, 3, 2, 2, 2, 5119, 5117, 3, 2, 2, 2, 5120, 5121, 7, 60, 2, 2, 5121, 5122, 7, 36, 2, 2, 5122, 5130, 3, 2, 2, 2, 5123, 5124, 7, 94, 2, 2, 5124, 5129, 11, 2, 2, 2, 5125, 5126, 7, 36, 2, 2, 5126, 5129, 7, 36, 2, 2, 5127, 5129, 10, 18, 2, 2, 5128, 5123, 3, 2, 2, 2, 5128, 5125, 3, 2, 2, 2, 5128, 5127, 3, 2, 2, 2, 5129, 5132, 3, 2, 2, 2, 5130, 5128, 3, 2, 2, 2, 5130, 5131, 3, 2, 2, 2, 5131, 5133, 3, 2, 2, 2, 5132, 5130, 3, 2, 2, 2, 5133, 5134, 7, 36, 2, 2, 5134, 1102, 3, 2, 2, 2, 5135, 5137, 9, 19, 2, 2, 5136, 5135, 3, 2, 2, 2, 5137, 5138, 3, 2, 2, 2, 5138, 5136, 3, 2, 2, 2, 5138, 5139, 3, 2, 2, 2, 5139, 5140, 3, 2, 2, 2, 5140, 5141, 8, 550, 9, 2, 5141, 1104, 3, 2, 2, 2, 5142, 5144, 7, 15, 2, 2, 5143, 5145, 7, 12, 2, 2, 5144, 5143, 3, 2, 2, 2, 5144, 5145, 3, 2, 2, 2, 5145, 5148, 3, 2, 2, 2, 5146, 5148, 7, 12, 2, 2, 5147, 5142, 3, 2, 2, 2, 5147, 5146, 3, 2, 2, 2, 5148, 5149, 3, 2, 2, 2, 5149, 5150, 8, 551, 9, 2, 5150, 1106, 3, 2, 2, 2, 5151, 5152, 7, 47, 2, 2, 5152, 5153, 7, 47, 2, 2, 5153, 5157, 3, 2, 2, 2, 5154, 5156, 10, 20, 2, 2, 5155, 5154, 3, 2, 2, 2, 5156, 5159, 3, 2, 2, 2, 5157, 5155, 3, 2, 2, 2, 5157, 5158, 3, 2, 2, 2, 5158, 5160, 3, 2, 2, 2, 5159, 5157, 3, 2, 2, 2, 5160, 5161, 8, 552, 9, 2, 5161, 1108, 3, 2, 2, 2, 5162, 5163, 7, 49, 2, 2, 5163, 5164, 7, 44, 2, 2, 5164, 5187, 3, 2, 2, 2, 5165, 5167, 7, 49, 2, 2, 5166, 5165, 3, 2, 2, 2, 5167, 5170, 3, 2, 2, 2, 5168, 5166, 3, 2, 2, 2, 5168, 5169, 3, 2, 2, 2, 5169, 5171, 3, 2, 2, 2, 5170, 5168, 3, 2, 2, 2, 5171, 5186, 5, 1109, 553, 2, 5172, 5186, 10, 21, 2, 2, 5173, 5175, 7, 49, 2, 2, 5174, 5173, 3, 2, 2, 2, 5175, 5176, 3, 2, 2, 2, 5176, 5174, 3, 2, 2, 2, 5176, 5177, 3, 2, 2, 2, 5177, 5178, 3, 2, 2, 2, 5178, 5186, 10, 21, 2, 2, 5179, 5181, 7, 44, 2, 2, 5180, 5179, 3, 2, 2, 2, 5181, 5182, 3, 2, 2, 2, 5182, 5180, 3, 2, 2, 2, 5182, 5183, 3, 2, 2, 2, 5183, 5184, 3, 2, 2, 2, 5184, 5186, 10, 21, 2, 2, 5185, 5168, 3, 2, 2, 2, 5185, 5172, 3, 2, 2, 2, 5185, 5174, 3, 2, 2, 2, 5185, 5180, 3, 2, 2, 2, 5186, 5189, 3, 2, 2, 2, 5187, 5185, 3, 2, 2, 2, 5187, 5188, 3, 2, 2, 2, 5188, 5193, 3, 2, 2, 2, 5189, 5187, 3, 2, 2, 2, 5190, 5192, 7, 44, 2, 2, 5191, 5190, 3, 2, 2, 2, 5192, 5195, 3, 2, 2, 2, 5193, 5191, 3, 2, 2, 2, 5193, 5194, 3, 2, 2, 2, 5194, 5196, 3, 2, 2, 2, 5195, 5193, 3, 2, 2, 2, 5196, 5197, 7, 44, 2, 2, 5197, 5198, 7, 49, 2, 2, 5198, 5199, 3, 2, 2, 2, 5199, 5200, 8, 553, 9, 2, 5200, 1110, 3, 2, 2, 2, 5201, 5202, 7, 49, 2, 2, 5202, 5203, 7, 44, 2, 2, 5203, 5228, 3, 2, 2, 2, 5204, 5206, 7, 49, 2, 2, 5205, 5204, 3, 2, 2, 2, 5206, 5209, 3, 2, 2, 2, 5207, 5205, 3, 2, 2, 2, 5207, 5208, 3, 2, 2, 2, 5208, 5210, 3, 2, 2, 2, 5209, 5207, 3, 2, 2, 2, 5210, 5227, 5, 1109, 553, 2, 5211, 5227, 10, 21, 2, 2, 5212, 5214, 7, 49, 2, 2, 5213, 5212, 3, 2, 2, 2, 5214, 5215, 3, 2, 2, 2, 5215, 5213, 3, 2, 2, 2, 5215, 5216, 3, 2, 2, 2, 5216, 5217, 3, 2, 2, 2, 5217, 5225, 10, 21, 2, 2, 5218, 5220, 7, 44, 2, 2, 5219, 5218, 3, 2, 2, 2, 5220, 5221, 3, 2, 2, 2, 5221, 5219, 3, 2, 2, 2, 5221, 5222, 3, 2, 2, 2, 5222, 5223, 3, 2, 2, 2, 5223, 5225, 10, 21, 2, 2, 5224, 5213, 3, 2, 2, 2, 5224, 5219, 3, 2, 2, 2, 5225, 5227, 3, 2, 2, 2, 5226, 5207, 3, 2, 2, 2, 5226, 5211, 3, 2, 2, 2, 5226, 5224, 3, 2, 2, 2, 5227, 5230, 3, 2, 2, 2, 5228, 5226, 3, 2, 2, 2, 5228, 5229, 3, 2, 2, 2, 5229, 5248, 3, 2, 2, 2, 5230, 5228, 3, 2, 2, 2, 5231, 5233, 7, 49, 2, 2, 5232, 5231, 3, 2, 2, 2, 5233, 5234, 3, 2, 2, 2, 5234, 5232, 3, 2, 2, 2, 5234, 5235, 3, 2, 2, 2, 5235, 5249, 3, 2, 2, 2, 5236, 5238, 7, 44, 2, 2, 5237, 5236, 3, 2, 2, 2, 5238, 5239, 3, 2, 2, 2, 5239, 5237, 3, 2, 2, 2, 5239, 5240, 3, 2, 2, 2, 5240, 5249, 3, 2, 2, 2, 5241, 5243, 7, 49, 2, 2, 5242, 5241, 3, 2, 2, 2, 5243, 5246, 3, 2, 2, 2, 5244, 5242, 3, 2, 2, 2, 5244, 5245, 3, 2, 2, 2, 5245, 5247, 3, 2, 2, 2, 5246, 5244, 3, 2, 2, 2, 5247, 5249, 5, 1111, 554, 2, 5248, 5232, 3, 2, 2, 2, 5248, 5237, 3, 2, 2, 2, 5248, 5244, 3, 2, 2, 2, 5248, 5249, 3, 2, 2, 2, 5249, 5250, 3, 2, 2, 2, 5250, 5251, 8, 554, 10, 2, 5251, 1112, 3, 2, 2, 2, 5252, 5264, 7, 94, 2, 2, 5253, 5263, 10, 22, 2, 2, 5254, 5258, 7, 36, 2, 2, 5255, 5257, 10, 23, 2, 2, 5256, 5255, 3, 2, 2, 2, 5257, 5260, 3, 2, 2, 2, 5258, 5256, 3, 2, 2, 2, 5258, 5259, 3, 2, 2, 2, 5259, 5261, 3, 2, 2, 2, 5260, 5258, 3, 2, 2, 2, 5261, 5263, 7, 36, 2, 2, 5262, 5253, 3, 2, 2, 2, 5262, 5254, 3, 2, 2, 2, 5263, 5266, 3, 2, 2, 2, 5264, 5262, 3, 2, 2, 2, 5264, 5265, 3, 2, 2, 2, 5265, 5274, 3, 2, 2, 2, 5266, 5264, 3, 2, 2, 2, 5267, 5271, 7, 36, 2, 2, 5268, 5270, 10, 23, 2, 2, 5269, 5268, 3, 2, 2, 2, 5270, 5273, 3, 2, 2, 2, 5271, 5269, 3, 2, 2, 2, 5271, 5272, 3, 2, 2, 2, 5272, 5275, 3, 2, 2, 2, 5273, 5271, 3, 2, 2, 2, 5274, 5267, 3, 2, 2, 2, 5274, 5275, 3, 2, 2, 2, 5275, 1114, 3, 2, 2, 2, 5276, 5277, 7, 94, 2, 2, 5277, 5278, 7, 94, 2, 2, 5278, 1116, 3, 2, 2, 2, 5279, 5280, 11, 2, 2, 2, 5280, 1118, 3, 2, 2, 2, 5281, 5282, 5, 1123, 560, 2, 5282, 5283, 7, 41, 2, 2, 5283, 5284, 3, 2, 2, 2, 5284, 5285, 8, 558, 11, 2, 5285, 1120, 3, 2, 2, 2, 5286, 5288, 5, 1123, 560, 2, 5287, 5289, 7, 94, 2, 2, 5288, 5287, 3, 2, 2, 2, 5288, 5289, 3, 2, 2, 2, 5289, 5290, 3, 2, 2, 2, 5290, 5291, 7, 2, 2, 3, 5291, 1122, 3, 2, 2, 2, 5292, 5293, 7, 41, 2, 2, 5293, 5316, 7, 41, 2, 2, 5294, 5312, 7, 94, 2, 2, 5295, 5296, 7, 122, 2, 2, 5296, 5313, 9, 15, 2, 2, 5297, 5298, 7, 119, 2, 2, 5298, 5299, 9, 15, 2, 2, 5299, 5300, 9, 15, 2, 2, 5300, 5301, 9, 15, 2, 2, 5301, 5313, 9, 15, 2, 2, 5302, 5303, 7, 87, 2, 2, 5303, 5304, 9, 15, 2, 2, 5304, 5305, 9, 15, 2, 2, 5305, 5306, 9, 15, 2, 2, 5306, 5307, 9, 15, 2, 2, 5307, 5308, 9, 15, 2, 2, 5308, 5309, 9, 15, 2, 2, 5309, 5310, 9, 15, 2, 2, 5310, 5313, 9, 15, 2, 2, 5311, 5313, 10, 24, 2, 2, 5312, 5295, 3, 2, 2, 2, 5312, 5297, 3, 2, 2, 2, 5312, 5302, 3, 2, 2, 2, 5312, 5311, 3, 2, 2, 2, 5313, 5316, 3, 2, 2, 2, 5314, 5316, 10, 25, 2, 2, 5315, 5292, 3, 2, 2, 2, 5315, 5294, 3, 2, 2, 2, 5315, 5314, 3, 2, 2, 2, 5316, 5319, 3, 2, 2, 2, 5317, 5315, 3, 2, 2, 2, 5317, 5318, 3, 2, 2, 2, 5318, 1124, 3, 2, 2, 2, 5319, 5317, 3, 2, 2, 2, 5320, 5321, 5, 1129, 563, 2, 5321, 5322, 7, 41, 2, 2, 5322, 5323, 3, 2, 2, 2, 5323, 5324, 8, 561, 11, 2, 5324, 1126, 3, 2, 2, 2, 5325, 5327, 5, 1129, 563, 2, 5326, 5328, 7, 94, 2, 2, 5327, 5326, 3, 2, 2, 2, 5327, 5328, 3, 2, 2, 2, 5328, 5329, 3, 2, 2, 2, 5329, 5330, 7, 2, 2, 3, 5330, 1128, 3, 2, 2, 2, 5331, 5332, 7, 41, 2, 2, 5332, 5337, 7, 41, 2, 2, 5333, 5334, 7, 94, 2, 2, 5334, 5337, 11, 2, 2, 2, 5335, 5337, 10, 25, 2, 2, 5336, 5331, 3, 2, 2, 2, 5336, 5333, 3, 2, 2, 2, 5336, 5335, 3, 2, 2, 2, 5337, 5340, 3, 2, 2, 2, 5338, 5336, 3, 2, 2, 2, 5338, 5339, 3, 2, 2, 2, 5339, 1130, 3, 2, 2, 2, 5340, 5338, 3, 2, 2, 2, 5341, 5342, 5, 1103, 550, 2, 5342, 5343, 3, 2, 2, 2, 5343, 5344, 8, 564, 12, 2, 5344, 5345, 8, 564, 9, 2, 5345, 1132, 3, 2, 2, 2, 5346, 5347, 5, 1105, 551, 2, 5347, 5348, 3, 2, 2, 2, 5348, 5349, 8, 565, 13, 2, 5349, 5350, 8, 565, 9, 2, 5350, 5351, 8, 565, 14, 2, 5351, 1134, 3, 2, 2, 2, 5352, 5353, 5, 1103, 550, 2, 5353, 5354, 3, 2, 2, 2, 5354, 5355, 8, 566, 12, 2, 5355, 5356, 8, 566, 9, 2, 5356, 1136, 3, 2, 2, 2, 5357, 5358, 5, 1105, 551, 2, 5358, 5359, 3, 2, 2, 2, 5359, 5360, 8, 567, 13, 2, 5360, 5361, 8, 567, 9, 2, 5361, 1138, 3, 2, 2, 2, 5362, 5363, 7, 41, 2, 2, 5363, 5364, 3, 2, 2, 2, 5364, 5365, 8, 568, 4, 2, 5365, 5366, 8, 568, 15, 2, 5366, 1140, 3, 2, 2, 2, 5367, 5369, 10, 26, 2, 2, 5368, 5367, 3, 2, 2, 2, 5369, 5370, 3, 2, 2, 2, 5370, 5368, 3, 2, 2, 2, 5370, 5371, 3, 2, 2, 2, 5371, 5380, 3, 2, 2, 2, 5372, 5376, 7, 38, 2, 2, 5373, 5375, 10, 26, 2, 2, 5374, 5373, 3, 2, 2, 2, 5375, 5378, 3, 2, 2, 2, 5376, 5374, 3, 2, 2, 2, 5376, 5377, 3, 2, 2, 2, 5377, 5380, 3, 2, 2, 2, 5378, 5376, 3, 2, 2, 2, 5379, 5368, 3, 2, 2, 2, 5379, 5372, 3, 2, 2, 2, 5380, 1142, 3, 2, 2, 2, 5381, 5383, 7, 38, 2, 2, 5382, 5384, 5, 1073, 535, 2, 5383, 5382, 3, 2, 2, 2, 5383, 5384, 3, 2, 2, 2, 5384, 5385, 3, 2, 2, 2, 5385, 5386, 7, 38, 2, 2, 5386, 5387, 3, 2, 2, 2, 5387, 5388, 6, 570, 10, 2, 5388, 5389, 8, 570, 16, 2, 5389, 5390, 3, 2, 2, 2, 5390, 5391, 8, 570, 17, 2, 5391, 1144, 3, 2, 2, 2, 80, 2, 3, 4, 5, 6, 1212, 1218, 1220, 1225, 1229, 1231, 1234, 1243, 1245, 1250, 1255, 1257, 4935, 4944, 4948, 4952, 4961, 4963, 4973, 4975, 5001, 5003, 5021, 5032, 5043, 5060, 5080, 5084, 5087, 5093, 5096, 5101, 5105, 5110, 5117, 5128, 5130, 5138, 5144, 5147, 5157, 5168, 5176, 5182, 5185, 5187, 5193, 5207, 5215, 5221, 5224, 5226, 5228, 5234, 5239, 5244, 5248, 5258, 5262, 5264, 5271, 5274, 5288, 5312, 5315, 5317, 5327, 5336, 5338, 5370, 5376, 5379, 5383, 18, 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, 4, 3, 2, 3, 570, 6, 6, 2, 2] \ No newline at end of file +[3, 51485, 51898, 1421, 44986, 20307, 1543, 60043, 49729, 2, 568, 5530, 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, 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, 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, 1237, 10, 29, 13, 29, 14, 29, 1238, 3, 30, 3, 30, 6, 30, 1243, 10, 30, 13, 30, 14, 30, 1244, 3, 30, 3, 30, 5, 30, 1249, 10, 30, 5, 30, 1251, 10, 30, 3, 30, 6, 30, 1254, 10, 30, 13, 30, 14, 30, 1255, 3, 30, 5, 30, 1259, 10, 30, 3, 31, 3, 31, 7, 31, 1263, 10, 31, 12, 31, 14, 31, 1266, 11, 31, 3, 31, 3, 31, 5, 31, 1270, 10, 31, 3, 31, 6, 31, 1273, 10, 31, 13, 31, 14, 31, 1274, 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, 234, 3, 235, 3, 235, 3, 235, 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, 237, 3, 237, 3, 238, 3, 238, 3, 238, 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, 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, 240, 3, 240, 3, 240, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 241, 3, 242, 3, 242, 3, 242, 3, 242, 3, 242, 3, 242, 3, 242, 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, 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, 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, 247, 3, 247, 3, 248, 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, 249, 3, 249, 3, 249, 3, 249, 3, 249, 3, 250, 3, 250, 3, 250, 3, 250, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 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, 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, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 3, 260, 3, 260, 3, 260, 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, 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, 264, 3, 264, 3, 264, 3, 264, 3, 264, 3, 264, 3, 264, 3, 264, 3, 265, 3, 265, 3, 265, 3, 265, 3, 265, 3, 265, 3, 265, 3, 265, 3, 265, 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, 267, 3, 267, 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, 271, 3, 271, 3, 271, 3, 271, 3, 271, 3, 272, 3, 272, 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, 275, 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, 277, 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, 281, 3, 281, 3, 281, 3, 281, 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, 284, 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, 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, 289, 3, 289, 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, 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, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 294, 3, 294, 3, 294, 3, 294, 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, 295, 3, 295, 3, 296, 3, 296, 3, 296, 3, 296, 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, 299, 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, 300, 3, 300, 3, 300, 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, 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, 304, 3, 304, 3, 304, 3, 304, 3, 304, 3, 304, 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, 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, 308, 3, 308, 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, 312, 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, 313, 3, 314, 3, 314, 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, 315, 3, 315, 3, 316, 3, 316, 3, 316, 3, 316, 3, 316, 3, 316, 3, 316, 3, 316, 3, 317, 3, 317, 3, 317, 3, 317, 3, 317, 3, 317, 3, 317, 3, 317, 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, 319, 3, 320, 3, 320, 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, 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, 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, 326, 3, 326, 3, 326, 3, 326, 3, 326, 3, 327, 3, 327, 3, 327, 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, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 331, 3, 331, 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, 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, 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, 335, 3, 335, 3, 336, 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, 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, 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, 342, 3, 342, 3, 343, 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, 344, 3, 344, 3, 344, 3, 344, 3, 344, 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, 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, 348, 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, 351, 3, 351, 3, 351, 3, 351, 3, 351, 3, 351, 3, 351, 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, 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, 356, 3, 356, 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, 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, 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, 361, 3, 361, 3, 361, 3, 361, 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, 364, 3, 364, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 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, 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, 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, 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, 371, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 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, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 376, 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, 377, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 382, 3, 382, 3, 382, 3, 382, 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, 383, 3, 383, 3, 383, 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, 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, 387, 3, 388, 3, 388, 3, 388, 3, 388, 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, 392, 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, 394, 3, 394, 3, 394, 3, 394, 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, 397, 3, 397, 3, 397, 3, 397, 3, 397, 3, 397, 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, 398, 3, 399, 3, 399, 3, 399, 3, 399, 3, 400, 3, 400, 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, 402, 3, 402, 3, 402, 3, 402, 3, 402, 3, 402, 3, 402, 3, 402, 3, 403, 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, 404, 3, 404, 3, 405, 3, 405, 3, 405, 3, 405, 3, 405, 3, 405, 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, 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, 409, 3, 410, 3, 410, 3, 410, 3, 410, 3, 410, 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, 413, 3, 413, 3, 413, 3, 413, 3, 413, 3, 413, 3, 413, 3, 414, 3, 414, 3, 414, 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, 416, 3, 416, 3, 416, 3, 416, 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, 417, 3, 417, 3, 417, 3, 418, 3, 418, 3, 418, 3, 418, 3, 418, 3, 419, 3, 419, 3, 419, 3, 419, 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, 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, 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, 426, 3, 426, 3, 426, 3, 426, 3, 426, 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, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 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, 430, 3, 430, 3, 431, 3, 431, 3, 431, 3, 431, 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, 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, 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, 436, 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, 437, 3, 437, 3, 437, 3, 437, 3, 437, 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, 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, 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, 444, 3, 444, 3, 444, 3, 444, 3, 444, 3, 444, 3, 444, 3, 445, 3, 445, 3, 445, 3, 445, 3, 445, 3, 445, 3, 445, 3, 446, 3, 446, 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, 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, 449, 3, 449, 3, 449, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 3, 450, 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, 452, 3, 452, 3, 452, 3, 452, 3, 453, 3, 453, 3, 453, 3, 453, 3, 454, 3, 454, 3, 454, 3, 454, 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, 456, 3, 456, 3, 456, 3, 456, 3, 457, 3, 457, 3, 457, 3, 457, 3, 457, 3, 457, 3, 457, 3, 457, 3, 457, 3, 457, 3, 457, 3, 457, 3, 458, 3, 458, 3, 458, 3, 458, 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, 461, 3, 461, 3, 461, 3, 462, 3, 462, 3, 462, 3, 462, 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, 463, 3, 464, 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, 465, 3, 465, 3, 465, 3, 465, 3, 466, 3, 466, 3, 466, 3, 466, 3, 467, 3, 467, 3, 467, 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, 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, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 3, 471, 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, 474, 3, 474, 3, 474, 3, 474, 3, 474, 3, 475, 3, 475, 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, 477, 3, 477, 3, 477, 3, 477, 3, 477, 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, 478, 3, 478, 3, 478, 3, 478, 3, 479, 3, 479, 3, 479, 3, 479, 3, 479, 3, 479, 3, 479, 3, 479, 3, 479, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 482, 3, 482, 3, 482, 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, 483, 3, 483, 3, 483, 3, 484, 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, 486, 3, 486, 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, 488, 3, 488, 3, 488, 3, 488, 3, 489, 3, 489, 3, 489, 3, 489, 3, 490, 3, 490, 3, 490, 3, 490, 3, 490, 3, 491, 3, 491, 3, 491, 3, 491, 3, 491, 3, 492, 3, 492, 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, 494, 3, 494, 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, 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, 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, 497, 3, 497, 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, 499, 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, 500, 3, 500, 3, 500, 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, 502, 3, 502, 3, 502, 3, 503, 3, 503, 3, 503, 3, 503, 3, 503, 3, 503, 3, 503, 3, 503, 3, 504, 3, 504, 3, 504, 3, 504, 3, 505, 3, 505, 3, 505, 3, 505, 3, 505, 3, 505, 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, 506, 3, 506, 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, 509, 3, 509, 3, 509, 3, 509, 3, 510, 3, 510, 3, 510, 3, 510, 3, 510, 3, 510, 3, 510, 3, 510, 3, 511, 3, 511, 3, 511, 3, 511, 3, 511, 3, 511, 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, 514, 3, 514, 3, 514, 3, 514, 3, 514, 3, 514, 3, 515, 3, 515, 3, 515, 3, 515, 3, 515, 3, 515, 3, 516, 3, 516, 3, 516, 3, 516, 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, 3, 518, 3, 519, 3, 519, 3, 519, 3, 519, 3, 519, 3, 520, 3, 520, 3, 520, 3, 520, 3, 520, 3, 520, 3, 520, 3, 521, 3, 521, 3, 521, 3, 521, 3, 521, 3, 521, 3, 521, 3, 521, 3, 522, 3, 522, 3, 522, 3, 522, 3, 522, 3, 522, 3, 522, 3, 522, 3, 522, 3, 522, 3, 523, 3, 523, 3, 523, 3, 523, 3, 523, 3, 523, 3, 523, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 525, 3, 525, 3, 525, 3, 525, 3, 525, 3, 526, 3, 526, 3, 526, 3, 526, 3, 526, 3, 526, 3, 526, 3, 526, 3, 526, 3, 526, 3, 526, 3, 527, 3, 527, 3, 527, 3, 527, 3, 527, 3, 527, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 529, 3, 529, 3, 529, 3, 529, 3, 529, 3, 529, 3, 529, 3, 530, 3, 530, 7, 530, 5083, 10, 530, 12, 530, 14, 530, 5086, 11, 530, 3, 531, 3, 531, 3, 531, 5, 531, 5091, 10, 531, 3, 532, 3, 532, 5, 532, 5095, 10, 532, 3, 533, 3, 533, 5, 533, 5099, 10, 533, 3, 534, 3, 534, 3, 534, 3, 535, 3, 535, 3, 535, 3, 535, 7, 535, 5108, 10, 535, 12, 535, 14, 535, 5111, 11, 535, 3, 536, 3, 536, 3, 536, 3, 537, 3, 537, 3, 537, 3, 537, 7, 537, 5120, 10, 537, 12, 537, 14, 537, 5123, 11, 537, 3, 538, 3, 538, 3, 538, 3, 538, 3, 539, 3, 539, 3, 539, 3, 539, 3, 540, 3, 540, 3, 540, 3, 540, 3, 541, 3, 541, 3, 541, 3, 541, 3, 542, 3, 542, 3, 542, 3, 543, 3, 543, 3, 543, 3, 543, 7, 543, 5148, 10, 543, 12, 543, 14, 543, 5151, 11, 543, 3, 544, 3, 544, 3, 544, 3, 544, 3, 544, 3, 544, 3, 545, 3, 545, 3, 545, 3, 546, 3, 546, 3, 546, 3, 546, 3, 547, 3, 547, 5, 547, 5168, 10, 547, 3, 547, 3, 547, 3, 547, 3, 547, 3, 548, 3, 548, 7, 548, 5176, 10, 548, 12, 548, 14, 548, 5179, 11, 548, 3, 549, 3, 549, 3, 549, 3, 550, 3, 550, 3, 550, 7, 550, 5187, 10, 550, 12, 550, 14, 550, 5190, 11, 550, 3, 551, 3, 551, 3, 551, 3, 552, 3, 552, 3, 552, 3, 553, 3, 553, 3, 553, 3, 554, 3, 554, 3, 554, 7, 554, 5204, 10, 554, 12, 554, 14, 554, 5207, 11, 554, 3, 555, 3, 555, 3, 555, 3, 556, 3, 556, 3, 556, 3, 557, 3, 557, 3, 558, 3, 558, 3, 558, 3, 558, 3, 559, 3, 559, 3, 559, 5, 559, 5224, 10, 559, 3, 559, 3, 559, 5, 559, 5228, 10, 559, 3, 559, 5, 559, 5231, 10, 559, 3, 559, 3, 559, 3, 559, 3, 559, 5, 559, 5237, 10, 559, 3, 559, 5, 559, 5240, 10, 559, 3, 559, 3, 559, 3, 559, 5, 559, 5245, 10, 559, 3, 559, 3, 559, 5, 559, 5249, 10, 559, 3, 560, 6, 560, 5252, 10, 560, 13, 560, 14, 560, 5253, 3, 561, 3, 561, 3, 561, 7, 561, 5259, 10, 561, 12, 561, 14, 561, 5262, 11, 561, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 7, 562, 5272, 10, 562, 12, 562, 14, 562, 5275, 11, 562, 3, 562, 3, 562, 3, 563, 6, 563, 5280, 10, 563, 13, 563, 14, 563, 5281, 3, 563, 3, 563, 3, 564, 3, 564, 5, 564, 5288, 10, 564, 3, 564, 5, 564, 5291, 10, 564, 3, 564, 3, 564, 3, 565, 3, 565, 3, 565, 3, 565, 7, 565, 5299, 10, 565, 12, 565, 14, 565, 5302, 11, 565, 3, 565, 3, 565, 3, 566, 3, 566, 3, 566, 3, 566, 7, 566, 5310, 10, 566, 12, 566, 14, 566, 5313, 11, 566, 3, 566, 3, 566, 3, 566, 6, 566, 5318, 10, 566, 13, 566, 14, 566, 5319, 3, 566, 3, 566, 6, 566, 5324, 10, 566, 13, 566, 14, 566, 5325, 3, 566, 7, 566, 5329, 10, 566, 12, 566, 14, 566, 5332, 11, 566, 3, 566, 7, 566, 5335, 10, 566, 12, 566, 14, 566, 5338, 11, 566, 3, 566, 3, 566, 3, 566, 3, 566, 3, 566, 3, 567, 3, 567, 3, 567, 3, 567, 7, 567, 5349, 10, 567, 12, 567, 14, 567, 5352, 11, 567, 3, 567, 3, 567, 3, 567, 6, 567, 5357, 10, 567, 13, 567, 14, 567, 5358, 3, 567, 3, 567, 6, 567, 5363, 10, 567, 13, 567, 14, 567, 5364, 3, 567, 5, 567, 5368, 10, 567, 7, 567, 5370, 10, 567, 12, 567, 14, 567, 5373, 11, 567, 3, 567, 6, 567, 5376, 10, 567, 13, 567, 14, 567, 5377, 3, 567, 6, 567, 5381, 10, 567, 13, 567, 14, 567, 5382, 3, 567, 7, 567, 5386, 10, 567, 12, 567, 14, 567, 5389, 11, 567, 3, 567, 5, 567, 5392, 10, 567, 3, 568, 3, 568, 3, 568, 3, 568, 7, 568, 5398, 10, 568, 12, 568, 14, 568, 5401, 11, 568, 3, 568, 7, 568, 5404, 10, 568, 12, 568, 14, 568, 5407, 11, 568, 3, 568, 3, 568, 7, 568, 5411, 10, 568, 12, 568, 14, 568, 5414, 11, 568, 5, 568, 5416, 10, 568, 3, 569, 3, 569, 3, 569, 3, 570, 3, 570, 3, 571, 3, 571, 3, 571, 3, 571, 3, 571, 3, 572, 3, 572, 5, 572, 5430, 10, 572, 3, 572, 3, 572, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 5, 573, 5454, 10, 573, 3, 573, 7, 573, 5457, 10, 573, 12, 573, 14, 573, 5460, 11, 573, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 575, 3, 575, 5, 575, 5469, 10, 575, 3, 575, 3, 575, 3, 576, 3, 576, 3, 576, 3, 576, 3, 576, 7, 576, 5478, 10, 576, 12, 576, 14, 576, 5481, 11, 576, 3, 577, 3, 577, 3, 577, 3, 577, 3, 577, 3, 578, 3, 578, 3, 578, 3, 578, 3, 578, 3, 578, 3, 579, 3, 579, 3, 579, 3, 579, 3, 579, 3, 580, 3, 580, 3, 580, 3, 580, 3, 580, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 582, 6, 582, 5510, 10, 582, 13, 582, 14, 582, 5511, 3, 582, 3, 582, 7, 582, 5516, 10, 582, 12, 582, 14, 582, 5519, 11, 582, 5, 582, 5521, 10, 582, 3, 583, 3, 583, 5, 583, 5525, 10, 583, 3, 583, 3, 583, 3, 583, 3, 583, 2, 2, 2, 584, 7, 2, 3, 9, 2, 4, 11, 2, 5, 13, 2, 6, 15, 2, 7, 17, 2, 8, 19, 2, 9, 21, 2, 10, 23, 2, 11, 25, 2, 12, 27, 2, 13, 29, 2, 14, 31, 2, 15, 33, 2, 16, 35, 2, 17, 37, 2, 18, 39, 2, 19, 41, 2, 20, 43, 2, 21, 45, 2, 22, 47, 2, 23, 49, 2, 24, 51, 2, 25, 53, 2, 26, 55, 2, 27, 57, 2, 28, 59, 2, 29, 61, 2, 30, 63, 2, 31, 65, 2, 2, 67, 2, 2, 69, 2, 2, 71, 2, 2, 73, 2, 32, 75, 2, 33, 77, 2, 34, 79, 2, 35, 81, 2, 36, 83, 2, 37, 85, 2, 38, 87, 2, 39, 89, 2, 40, 91, 2, 41, 93, 2, 42, 95, 2, 43, 97, 2, 44, 99, 2, 45, 101, 2, 46, 103, 2, 47, 105, 2, 48, 107, 2, 49, 109, 2, 50, 111, 2, 51, 113, 2, 52, 115, 2, 53, 117, 2, 54, 119, 2, 55, 121, 2, 56, 123, 2, 57, 125, 2, 58, 127, 2, 59, 129, 2, 60, 131, 2, 61, 133, 2, 62, 135, 2, 63, 137, 2, 64, 139, 2, 65, 141, 2, 66, 143, 2, 67, 145, 2, 68, 147, 2, 69, 149, 2, 70, 151, 2, 71, 153, 2, 72, 155, 2, 73, 157, 2, 74, 159, 2, 75, 161, 2, 76, 163, 2, 77, 165, 2, 78, 167, 2, 79, 169, 2, 80, 171, 2, 81, 173, 2, 82, 175, 2, 83, 177, 2, 84, 179, 2, 85, 181, 2, 86, 183, 2, 87, 185, 2, 88, 187, 2, 89, 189, 2, 90, 191, 2, 91, 193, 2, 92, 195, 2, 93, 197, 2, 94, 199, 2, 95, 201, 2, 96, 203, 2, 97, 205, 2, 98, 207, 2, 99, 209, 2, 100, 211, 2, 101, 213, 2, 102, 215, 2, 103, 217, 2, 104, 219, 2, 105, 221, 2, 106, 223, 2, 107, 225, 2, 108, 227, 2, 109, 229, 2, 110, 231, 2, 111, 233, 2, 112, 235, 2, 113, 237, 2, 114, 239, 2, 115, 241, 2, 116, 243, 2, 117, 245, 2, 118, 247, 2, 119, 249, 2, 120, 251, 2, 121, 253, 2, 122, 255, 2, 123, 257, 2, 124, 259, 2, 125, 261, 2, 126, 263, 2, 127, 265, 2, 128, 267, 2, 129, 269, 2, 130, 271, 2, 131, 273, 2, 132, 275, 2, 133, 277, 2, 134, 279, 2, 135, 281, 2, 136, 283, 2, 137, 285, 2, 138, 287, 2, 139, 289, 2, 140, 291, 2, 141, 293, 2, 142, 295, 2, 143, 297, 2, 144, 299, 2, 145, 301, 2, 146, 303, 2, 147, 305, 2, 148, 307, 2, 149, 309, 2, 150, 311, 2, 151, 313, 2, 152, 315, 2, 153, 317, 2, 154, 319, 2, 155, 321, 2, 156, 323, 2, 157, 325, 2, 158, 327, 2, 159, 329, 2, 160, 331, 2, 161, 333, 2, 162, 335, 2, 163, 337, 2, 164, 339, 2, 165, 341, 2, 166, 343, 2, 167, 345, 2, 168, 347, 2, 169, 349, 2, 170, 351, 2, 171, 353, 2, 172, 355, 2, 173, 357, 2, 174, 359, 2, 175, 361, 2, 176, 363, 2, 177, 365, 2, 178, 367, 2, 179, 369, 2, 180, 371, 2, 181, 373, 2, 182, 375, 2, 183, 377, 2, 184, 379, 2, 185, 381, 2, 186, 383, 2, 187, 385, 2, 188, 387, 2, 189, 389, 2, 190, 391, 2, 191, 393, 2, 192, 395, 2, 193, 397, 2, 194, 399, 2, 195, 401, 2, 196, 403, 2, 197, 405, 2, 198, 407, 2, 199, 409, 2, 200, 411, 2, 201, 413, 2, 202, 415, 2, 203, 417, 2, 204, 419, 2, 205, 421, 2, 206, 423, 2, 207, 425, 2, 208, 427, 2, 209, 429, 2, 210, 431, 2, 211, 433, 2, 212, 435, 2, 213, 437, 2, 214, 439, 2, 215, 441, 2, 216, 443, 2, 217, 445, 2, 218, 447, 2, 219, 449, 2, 220, 451, 2, 221, 453, 2, 222, 455, 2, 223, 457, 2, 224, 459, 2, 225, 461, 2, 226, 463, 2, 227, 465, 2, 228, 467, 2, 229, 469, 2, 230, 471, 2, 231, 473, 2, 232, 475, 2, 233, 477, 2, 234, 479, 2, 235, 481, 2, 236, 483, 2, 237, 485, 2, 238, 487, 2, 239, 489, 2, 240, 491, 2, 241, 493, 2, 242, 495, 2, 243, 497, 2, 244, 499, 2, 245, 501, 2, 246, 503, 2, 247, 505, 2, 248, 507, 2, 249, 509, 2, 250, 511, 2, 251, 513, 2, 252, 515, 2, 253, 517, 2, 254, 519, 2, 255, 521, 2, 256, 523, 2, 257, 525, 2, 258, 527, 2, 259, 529, 2, 260, 531, 2, 261, 533, 2, 262, 535, 2, 263, 537, 2, 264, 539, 2, 265, 541, 2, 266, 543, 2, 267, 545, 2, 268, 547, 2, 269, 549, 2, 270, 551, 2, 271, 553, 2, 272, 555, 2, 273, 557, 2, 274, 559, 2, 275, 561, 2, 276, 563, 2, 277, 565, 2, 278, 567, 2, 279, 569, 2, 280, 571, 2, 281, 573, 2, 282, 575, 2, 283, 577, 2, 284, 579, 2, 285, 581, 2, 286, 583, 2, 287, 585, 2, 288, 587, 2, 289, 589, 2, 290, 591, 2, 291, 593, 2, 292, 595, 2, 293, 597, 2, 294, 599, 2, 295, 601, 2, 296, 603, 2, 297, 605, 2, 298, 607, 2, 299, 609, 2, 300, 611, 2, 301, 613, 2, 302, 615, 2, 303, 617, 2, 304, 619, 2, 305, 621, 2, 306, 623, 2, 307, 625, 2, 308, 627, 2, 309, 629, 2, 310, 631, 2, 311, 633, 2, 312, 635, 2, 313, 637, 2, 314, 639, 2, 315, 641, 2, 316, 643, 2, 317, 645, 2, 318, 647, 2, 319, 649, 2, 320, 651, 2, 321, 653, 2, 322, 655, 2, 323, 657, 2, 324, 659, 2, 325, 661, 2, 326, 663, 2, 327, 665, 2, 328, 667, 2, 329, 669, 2, 330, 671, 2, 331, 673, 2, 332, 675, 2, 333, 677, 2, 334, 679, 2, 335, 681, 2, 336, 683, 2, 337, 685, 2, 338, 687, 2, 339, 689, 2, 340, 691, 2, 341, 693, 2, 342, 695, 2, 343, 697, 2, 344, 699, 2, 345, 701, 2, 346, 703, 2, 347, 705, 2, 348, 707, 2, 349, 709, 2, 350, 711, 2, 351, 713, 2, 352, 715, 2, 353, 717, 2, 354, 719, 2, 355, 721, 2, 356, 723, 2, 357, 725, 2, 358, 727, 2, 359, 729, 2, 360, 731, 2, 361, 733, 2, 362, 735, 2, 363, 737, 2, 364, 739, 2, 365, 741, 2, 366, 743, 2, 367, 745, 2, 368, 747, 2, 369, 749, 2, 370, 751, 2, 371, 753, 2, 372, 755, 2, 373, 757, 2, 374, 759, 2, 375, 761, 2, 376, 763, 2, 377, 765, 2, 378, 767, 2, 379, 769, 2, 380, 771, 2, 381, 773, 2, 382, 775, 2, 383, 777, 2, 384, 779, 2, 385, 781, 2, 386, 783, 2, 387, 785, 2, 388, 787, 2, 389, 789, 2, 390, 791, 2, 391, 793, 2, 392, 795, 2, 393, 797, 2, 394, 799, 2, 395, 801, 2, 396, 803, 2, 397, 805, 2, 398, 807, 2, 399, 809, 2, 400, 811, 2, 401, 813, 2, 402, 815, 2, 403, 817, 2, 404, 819, 2, 405, 821, 2, 406, 823, 2, 407, 825, 2, 408, 827, 2, 409, 829, 2, 410, 831, 2, 411, 833, 2, 412, 835, 2, 413, 837, 2, 414, 839, 2, 415, 841, 2, 416, 843, 2, 417, 845, 2, 418, 847, 2, 419, 849, 2, 420, 851, 2, 421, 853, 2, 422, 855, 2, 423, 857, 2, 424, 859, 2, 425, 861, 2, 426, 863, 2, 427, 865, 2, 428, 867, 2, 429, 869, 2, 430, 871, 2, 431, 873, 2, 432, 875, 2, 433, 877, 2, 434, 879, 2, 435, 881, 2, 436, 883, 2, 437, 885, 2, 438, 887, 2, 439, 889, 2, 440, 891, 2, 441, 893, 2, 442, 895, 2, 443, 897, 2, 444, 899, 2, 445, 901, 2, 446, 903, 2, 447, 905, 2, 448, 907, 2, 449, 909, 2, 450, 911, 2, 451, 913, 2, 452, 915, 2, 453, 917, 2, 454, 919, 2, 455, 921, 2, 456, 923, 2, 457, 925, 2, 458, 927, 2, 459, 929, 2, 460, 931, 2, 461, 933, 2, 462, 935, 2, 463, 937, 2, 464, 939, 2, 465, 941, 2, 466, 943, 2, 467, 945, 2, 468, 947, 2, 469, 949, 2, 470, 951, 2, 471, 953, 2, 472, 955, 2, 473, 957, 2, 474, 959, 2, 475, 961, 2, 476, 963, 2, 477, 965, 2, 478, 967, 2, 479, 969, 2, 480, 971, 2, 481, 973, 2, 482, 975, 2, 483, 977, 2, 484, 979, 2, 485, 981, 2, 486, 983, 2, 487, 985, 2, 488, 987, 2, 489, 989, 2, 490, 991, 2, 491, 993, 2, 492, 995, 2, 493, 997, 2, 494, 999, 2, 495, 1001, 2, 496, 1003, 2, 497, 1005, 2, 498, 1007, 2, 499, 1009, 2, 500, 1011, 2, 501, 1013, 2, 502, 1015, 2, 503, 1017, 2, 504, 1019, 2, 505, 1021, 2, 506, 1023, 2, 507, 1025, 2, 508, 1027, 2, 509, 1029, 2, 510, 1031, 2, 511, 1033, 2, 512, 1035, 2, 513, 1037, 2, 514, 1039, 2, 515, 1041, 2, 516, 1043, 2, 517, 1045, 2, 518, 1047, 2, 519, 1049, 2, 520, 1051, 2, 521, 1053, 2, 522, 1055, 2, 523, 1057, 2, 524, 1059, 2, 525, 1061, 2, 526, 1063, 2, 527, 1065, 2, 2, 1067, 2, 2, 1069, 2, 2, 1071, 2, 528, 1073, 2, 529, 1075, 2, 530, 1077, 2, 531, 1079, 2, 532, 1081, 2, 533, 1083, 2, 534, 1085, 2, 535, 1087, 2, 536, 1089, 2, 537, 1091, 2, 2, 1093, 2, 538, 1095, 2, 539, 1097, 2, 540, 1099, 2, 2, 1101, 2, 541, 1103, 2, 542, 1105, 2, 543, 1107, 2, 544, 1109, 2, 545, 1111, 2, 546, 1113, 2, 547, 1115, 2, 548, 1117, 2, 549, 1119, 2, 550, 1121, 2, 551, 1123, 2, 2, 1125, 2, 552, 1127, 2, 553, 1129, 2, 554, 1131, 2, 555, 1133, 2, 556, 1135, 2, 557, 1137, 2, 558, 1139, 2, 559, 1141, 2, 560, 1143, 2, 561, 1145, 2, 562, 1147, 2, 563, 1149, 2, 2, 1151, 2, 564, 1153, 2, 565, 1155, 2, 2, 1157, 2, 2, 1159, 2, 2, 1161, 2, 2, 1163, 2, 2, 1165, 2, 568, 1167, 2, 566, 1169, 2, 567, 7, 2, 3, 4, 5, 6, 27, 3, 2, 50, 59, 4, 2, 45, 45, 47, 47, 4, 2, 47, 47, 49, 49, 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, 12, 2, 67, 92, 97, 97, 99, 124, 172, 172, 183, 183, 188, 188, 194, 216, 218, 248, 250, 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, 5, 2, 50, 59, 67, 72, 99, 104, 5, 2, 67, 92, 97, 97, 99, 124, 7, 2, 38, 38, 50, 59, 67, 92, 97, 97, 99, 124, 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, 87, 87, 119, 119, 122, 122, 4, 2, 41, 41, 94, 94, 3, 2, 38, 38, 2, 5599, 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, 1039, 3, 2, 2, 2, 2, 1041, 3, 2, 2, 2, 2, 1043, 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, 1071, 3, 2, 2, 2, 2, 1073, 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, 1097, 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, 2, 1119, 3, 2, 2, 2, 2, 1121, 3, 2, 2, 2, 2, 1125, 3, 2, 2, 2, 2, 1127, 3, 2, 2, 2, 2, 1129, 3, 2, 2, 2, 2, 1131, 3, 2, 2, 2, 2, 1133, 3, 2, 2, 2, 2, 1135, 3, 2, 2, 2, 2, 1137, 3, 2, 2, 2, 2, 1139, 3, 2, 2, 2, 2, 1141, 3, 2, 2, 2, 2, 1143, 3, 2, 2, 2, 3, 1145, 3, 2, 2, 2, 3, 1147, 3, 2, 2, 2, 3, 1151, 3, 2, 2, 2, 3, 1153, 3, 2, 2, 2, 4, 1157, 3, 2, 2, 2, 4, 1159, 3, 2, 2, 2, 5, 1161, 3, 2, 2, 2, 5, 1163, 3, 2, 2, 2, 5, 1165, 3, 2, 2, 2, 6, 1167, 3, 2, 2, 2, 6, 1169, 3, 2, 2, 2, 7, 1171, 3, 2, 2, 2, 9, 1173, 3, 2, 2, 2, 11, 1175, 3, 2, 2, 2, 13, 1177, 3, 2, 2, 2, 15, 1179, 3, 2, 2, 2, 17, 1181, 3, 2, 2, 2, 19, 1183, 3, 2, 2, 2, 21, 1185, 3, 2, 2, 2, 23, 1187, 3, 2, 2, 2, 25, 1189, 3, 2, 2, 2, 27, 1191, 3, 2, 2, 2, 29, 1193, 3, 2, 2, 2, 31, 1195, 3, 2, 2, 2, 33, 1197, 3, 2, 2, 2, 35, 1199, 3, 2, 2, 2, 37, 1201, 3, 2, 2, 2, 39, 1203, 3, 2, 2, 2, 41, 1205, 3, 2, 2, 2, 43, 1208, 3, 2, 2, 2, 45, 1211, 3, 2, 2, 2, 47, 1214, 3, 2, 2, 2, 49, 1217, 3, 2, 2, 2, 51, 1220, 3, 2, 2, 2, 53, 1223, 3, 2, 2, 2, 55, 1226, 3, 2, 2, 2, 57, 1229, 3, 2, 2, 2, 59, 1232, 3, 2, 2, 2, 61, 1234, 3, 2, 2, 2, 63, 1258, 3, 2, 2, 2, 65, 1264, 3, 2, 2, 2, 67, 1278, 3, 2, 2, 2, 69, 1280, 3, 2, 2, 2, 71, 1282, 3, 2, 2, 2, 73, 1284, 3, 2, 2, 2, 75, 1288, 3, 2, 2, 2, 77, 1296, 3, 2, 2, 2, 79, 1304, 3, 2, 2, 2, 81, 1308, 3, 2, 2, 2, 83, 1312, 3, 2, 2, 2, 85, 1318, 3, 2, 2, 2, 87, 1321, 3, 2, 2, 2, 89, 1325, 3, 2, 2, 2, 91, 1336, 3, 2, 2, 2, 93, 1341, 3, 2, 2, 2, 95, 1346, 3, 2, 2, 2, 97, 1351, 3, 2, 2, 2, 99, 1357, 3, 2, 2, 2, 101, 1365, 3, 2, 2, 2, 103, 1372, 3, 2, 2, 2, 105, 1383, 3, 2, 2, 2, 107, 1390, 3, 2, 2, 2, 109, 1406, 3, 2, 2, 2, 111, 1419, 3, 2, 2, 2, 113, 1432, 3, 2, 2, 2, 115, 1445, 3, 2, 2, 2, 117, 1463, 3, 2, 2, 2, 119, 1476, 3, 2, 2, 2, 121, 1484, 3, 2, 2, 2, 123, 1495, 3, 2, 2, 2, 125, 1500, 3, 2, 2, 2, 127, 1509, 3, 2, 2, 2, 129, 1512, 3, 2, 2, 2, 131, 1517, 3, 2, 2, 2, 133, 1524, 3, 2, 2, 2, 135, 1530, 3, 2, 2, 2, 137, 1536, 3, 2, 2, 2, 139, 1540, 3, 2, 2, 2, 141, 1548, 3, 2, 2, 2, 143, 1553, 3, 2, 2, 2, 145, 1559, 3, 2, 2, 2, 147, 1565, 3, 2, 2, 2, 149, 1572, 3, 2, 2, 2, 151, 1575, 3, 2, 2, 2, 153, 1585, 3, 2, 2, 2, 155, 1595, 3, 2, 2, 2, 157, 1600, 3, 2, 2, 2, 159, 1608, 3, 2, 2, 2, 161, 1616, 3, 2, 2, 2, 163, 1622, 3, 2, 2, 2, 165, 1632, 3, 2, 2, 2, 167, 1647, 3, 2, 2, 2, 169, 1651, 3, 2, 2, 2, 171, 1656, 3, 2, 2, 2, 173, 1663, 3, 2, 2, 2, 175, 1666, 3, 2, 2, 2, 177, 1671, 3, 2, 2, 2, 179, 1674, 3, 2, 2, 2, 181, 1680, 3, 2, 2, 2, 183, 1688, 3, 2, 2, 2, 185, 1696, 3, 2, 2, 2, 187, 1707, 3, 2, 2, 2, 189, 1717, 3, 2, 2, 2, 191, 1724, 3, 2, 2, 2, 193, 1737, 3, 2, 2, 2, 195, 1742, 3, 2, 2, 2, 197, 1752, 3, 2, 2, 2, 199, 1758, 3, 2, 2, 2, 201, 1763, 3, 2, 2, 2, 203, 1766, 3, 2, 2, 2, 205, 1775, 3, 2, 2, 2, 207, 1780, 3, 2, 2, 2, 209, 1786, 3, 2, 2, 2, 211, 1793, 3, 2, 2, 2, 213, 1798, 3, 2, 2, 2, 215, 1804, 3, 2, 2, 2, 217, 1813, 3, 2, 2, 2, 219, 1818, 3, 2, 2, 2, 221, 1824, 3, 2, 2, 2, 223, 1831, 3, 2, 2, 2, 225, 1836, 3, 2, 2, 2, 227, 1850, 3, 2, 2, 2, 229, 1857, 3, 2, 2, 2, 231, 1867, 3, 2, 2, 2, 233, 1880, 3, 2, 2, 2, 235, 1886, 3, 2, 2, 2, 237, 1901, 3, 2, 2, 2, 239, 1908, 3, 2, 2, 2, 241, 1913, 3, 2, 2, 2, 243, 1919, 3, 2, 2, 2, 245, 1925, 3, 2, 2, 2, 247, 1928, 3, 2, 2, 2, 249, 1935, 3, 2, 2, 2, 251, 1940, 3, 2, 2, 2, 253, 1945, 3, 2, 2, 2, 255, 1950, 3, 2, 2, 2, 257, 1958, 3, 2, 2, 2, 259, 1966, 3, 2, 2, 2, 261, 1972, 3, 2, 2, 2, 263, 1977, 3, 2, 2, 2, 265, 1986, 3, 2, 2, 2, 267, 1992, 3, 2, 2, 2, 269, 2000, 3, 2, 2, 2, 271, 2008, 3, 2, 2, 2, 273, 2014, 3, 2, 2, 2, 275, 2023, 3, 2, 2, 2, 277, 2030, 3, 2, 2, 2, 279, 2037, 3, 2, 2, 2, 281, 2041, 3, 2, 2, 2, 283, 2047, 3, 2, 2, 2, 285, 2053, 3, 2, 2, 2, 287, 2063, 3, 2, 2, 2, 289, 2068, 3, 2, 2, 2, 291, 2074, 3, 2, 2, 2, 293, 2081, 3, 2, 2, 2, 295, 2091, 3, 2, 2, 2, 297, 2102, 3, 2, 2, 2, 299, 2105, 3, 2, 2, 2, 301, 2115, 3, 2, 2, 2, 303, 2124, 3, 2, 2, 2, 305, 2131, 3, 2, 2, 2, 307, 2137, 3, 2, 2, 2, 309, 2140, 3, 2, 2, 2, 311, 2146, 3, 2, 2, 2, 313, 2153, 3, 2, 2, 2, 315, 2161, 3, 2, 2, 2, 317, 2170, 3, 2, 2, 2, 319, 2178, 3, 2, 2, 2, 321, 2184, 3, 2, 2, 2, 323, 2200, 3, 2, 2, 2, 325, 2211, 3, 2, 2, 2, 327, 2217, 3, 2, 2, 2, 329, 2223, 3, 2, 2, 2, 331, 2231, 3, 2, 2, 2, 333, 2239, 3, 2, 2, 2, 335, 2248, 3, 2, 2, 2, 337, 2255, 3, 2, 2, 2, 339, 2265, 3, 2, 2, 2, 341, 2279, 3, 2, 2, 2, 343, 2290, 3, 2, 2, 2, 345, 2302, 3, 2, 2, 2, 347, 2310, 3, 2, 2, 2, 349, 2319, 3, 2, 2, 2, 351, 2330, 3, 2, 2, 2, 353, 2335, 3, 2, 2, 2, 355, 2340, 3, 2, 2, 2, 357, 2344, 3, 2, 2, 2, 359, 2351, 3, 2, 2, 2, 361, 2357, 3, 2, 2, 2, 363, 2362, 3, 2, 2, 2, 365, 2371, 3, 2, 2, 2, 367, 2375, 3, 2, 2, 2, 369, 2386, 3, 2, 2, 2, 371, 2394, 3, 2, 2, 2, 373, 2403, 3, 2, 2, 2, 375, 2412, 3, 2, 2, 2, 377, 2420, 3, 2, 2, 2, 379, 2427, 3, 2, 2, 2, 381, 2437, 3, 2, 2, 2, 383, 2448, 3, 2, 2, 2, 385, 2459, 3, 2, 2, 2, 387, 2467, 3, 2, 2, 2, 389, 2475, 3, 2, 2, 2, 391, 2484, 3, 2, 2, 2, 393, 2491, 3, 2, 2, 2, 395, 2498, 3, 2, 2, 2, 397, 2503, 3, 2, 2, 2, 399, 2508, 3, 2, 2, 2, 401, 2515, 3, 2, 2, 2, 403, 2524, 3, 2, 2, 2, 405, 2534, 3, 2, 2, 2, 407, 2539, 3, 2, 2, 2, 409, 2546, 3, 2, 2, 2, 411, 2552, 3, 2, 2, 2, 413, 2560, 3, 2, 2, 2, 415, 2570, 3, 2, 2, 2, 417, 2580, 3, 2, 2, 2, 419, 2588, 3, 2, 2, 2, 421, 2596, 3, 2, 2, 2, 423, 2606, 3, 2, 2, 2, 425, 2615, 3, 2, 2, 2, 427, 2622, 3, 2, 2, 2, 429, 2628, 3, 2, 2, 2, 431, 2638, 3, 2, 2, 2, 433, 2644, 3, 2, 2, 2, 435, 2652, 3, 2, 2, 2, 437, 2661, 3, 2, 2, 2, 439, 2671, 3, 2, 2, 2, 441, 2678, 3, 2, 2, 2, 443, 2686, 3, 2, 2, 2, 445, 2694, 3, 2, 2, 2, 447, 2701, 3, 2, 2, 2, 449, 2706, 3, 2, 2, 2, 451, 2711, 3, 2, 2, 2, 453, 2720, 3, 2, 2, 2, 455, 2723, 3, 2, 2, 2, 457, 2733, 3, 2, 2, 2, 459, 2743, 3, 2, 2, 2, 461, 2752, 3, 2, 2, 2, 463, 2762, 3, 2, 2, 2, 465, 2772, 3, 2, 2, 2, 467, 2778, 3, 2, 2, 2, 469, 2786, 3, 2, 2, 2, 471, 2794, 3, 2, 2, 2, 473, 2804, 3, 2, 2, 2, 475, 2814, 3, 2, 2, 2, 477, 2826, 3, 2, 2, 2, 479, 2835, 3, 2, 2, 2, 481, 2846, 3, 2, 2, 2, 483, 2857, 3, 2, 2, 2, 485, 2870, 3, 2, 2, 2, 487, 2881, 3, 2, 2, 2, 489, 2894, 3, 2, 2, 2, 491, 2903, 3, 2, 2, 2, 493, 2910, 3, 2, 2, 2, 495, 2922, 3, 2, 2, 2, 497, 2929, 3, 2, 2, 2, 499, 2937, 3, 2, 2, 2, 501, 2945, 3, 2, 2, 2, 503, 2955, 3, 2, 2, 2, 505, 2959, 3, 2, 2, 2, 507, 2965, 3, 2, 2, 2, 509, 2974, 3, 2, 2, 2, 511, 2980, 3, 2, 2, 2, 513, 2985, 3, 2, 2, 2, 515, 2995, 3, 2, 2, 2, 517, 3001, 3, 2, 2, 2, 519, 3008, 3, 2, 2, 2, 521, 3013, 3, 2, 2, 2, 523, 3019, 3, 2, 2, 2, 525, 3028, 3, 2, 2, 2, 527, 3033, 3, 2, 2, 2, 529, 3041, 3, 2, 2, 2, 531, 3047, 3, 2, 2, 2, 533, 3060, 3, 2, 2, 2, 535, 3069, 3, 2, 2, 2, 537, 3076, 3, 2, 2, 2, 539, 3085, 3, 2, 2, 2, 541, 3090, 3, 2, 2, 2, 543, 3096, 3, 2, 2, 2, 545, 3101, 3, 2, 2, 2, 547, 3106, 3, 2, 2, 2, 549, 3112, 3, 2, 2, 2, 551, 3117, 3, 2, 2, 2, 553, 3120, 3, 2, 2, 2, 555, 3128, 3, 2, 2, 2, 557, 3135, 3, 2, 2, 2, 559, 3142, 3, 2, 2, 2, 561, 3148, 3, 2, 2, 2, 563, 3155, 3, 2, 2, 2, 565, 3158, 3, 2, 2, 2, 567, 3162, 3, 2, 2, 2, 569, 3167, 3, 2, 2, 2, 571, 3176, 3, 2, 2, 2, 573, 3183, 3, 2, 2, 2, 575, 3191, 3, 2, 2, 2, 577, 3197, 3, 2, 2, 2, 579, 3203, 3, 2, 2, 2, 581, 3210, 3, 2, 2, 2, 583, 3218, 3, 2, 2, 2, 585, 3228, 3, 2, 2, 2, 587, 3236, 3, 2, 2, 2, 589, 3245, 3, 2, 2, 2, 591, 3251, 3, 2, 2, 2, 593, 3261, 3, 2, 2, 2, 595, 3269, 3, 2, 2, 2, 597, 3278, 3, 2, 2, 2, 599, 3287, 3, 2, 2, 2, 601, 3293, 3, 2, 2, 2, 603, 3304, 3, 2, 2, 2, 605, 3315, 3, 2, 2, 2, 607, 3325, 3, 2, 2, 2, 609, 3333, 3, 2, 2, 2, 611, 3339, 3, 2, 2, 2, 613, 3345, 3, 2, 2, 2, 615, 3350, 3, 2, 2, 2, 617, 3359, 3, 2, 2, 2, 619, 3367, 3, 2, 2, 2, 621, 3377, 3, 2, 2, 2, 623, 3381, 3, 2, 2, 2, 625, 3389, 3, 2, 2, 2, 627, 3397, 3, 2, 2, 2, 629, 3406, 3, 2, 2, 2, 631, 3414, 3, 2, 2, 2, 633, 3421, 3, 2, 2, 2, 635, 3432, 3, 2, 2, 2, 637, 3440, 3, 2, 2, 2, 639, 3448, 3, 2, 2, 2, 641, 3454, 3, 2, 2, 2, 643, 3462, 3, 2, 2, 2, 645, 3471, 3, 2, 2, 2, 647, 3479, 3, 2, 2, 2, 649, 3486, 3, 2, 2, 2, 651, 3491, 3, 2, 2, 2, 653, 3500, 3, 2, 2, 2, 655, 3505, 3, 2, 2, 2, 657, 3510, 3, 2, 2, 2, 659, 3520, 3, 2, 2, 2, 661, 3527, 3, 2, 2, 2, 663, 3534, 3, 2, 2, 2, 665, 3541, 3, 2, 2, 2, 667, 3548, 3, 2, 2, 2, 669, 3557, 3, 2, 2, 2, 671, 3566, 3, 2, 2, 2, 673, 3576, 3, 2, 2, 2, 675, 3589, 3, 2, 2, 2, 677, 3596, 3, 2, 2, 2, 679, 3604, 3, 2, 2, 2, 681, 3608, 3, 2, 2, 2, 683, 3614, 3, 2, 2, 2, 685, 3619, 3, 2, 2, 2, 687, 3626, 3, 2, 2, 2, 689, 3635, 3, 2, 2, 2, 691, 3642, 3, 2, 2, 2, 693, 3653, 3, 2, 2, 2, 695, 3659, 3, 2, 2, 2, 697, 3669, 3, 2, 2, 2, 699, 3680, 3, 2, 2, 2, 701, 3686, 3, 2, 2, 2, 703, 3693, 3, 2, 2, 2, 705, 3701, 3, 2, 2, 2, 707, 3708, 3, 2, 2, 2, 709, 3714, 3, 2, 2, 2, 711, 3720, 3, 2, 2, 2, 713, 3727, 3, 2, 2, 2, 715, 3734, 3, 2, 2, 2, 717, 3745, 3, 2, 2, 2, 719, 3750, 3, 2, 2, 2, 721, 3759, 3, 2, 2, 2, 723, 3769, 3, 2, 2, 2, 725, 3774, 3, 2, 2, 2, 727, 3786, 3, 2, 2, 2, 729, 3794, 3, 2, 2, 2, 731, 3803, 3, 2, 2, 2, 733, 3811, 3, 2, 2, 2, 735, 3816, 3, 2, 2, 2, 737, 3822, 3, 2, 2, 2, 739, 3832, 3, 2, 2, 2, 741, 3844, 3, 2, 2, 2, 743, 3856, 3, 2, 2, 2, 745, 3864, 3, 2, 2, 2, 747, 3873, 3, 2, 2, 2, 749, 3882, 3, 2, 2, 2, 751, 3888, 3, 2, 2, 2, 753, 3895, 3, 2, 2, 2, 755, 3902, 3, 2, 2, 2, 757, 3908, 3, 2, 2, 2, 759, 3917, 3, 2, 2, 2, 761, 3927, 3, 2, 2, 2, 763, 3935, 3, 2, 2, 2, 765, 3943, 3, 2, 2, 2, 767, 3948, 3, 2, 2, 2, 769, 3957, 3, 2, 2, 2, 771, 3968, 3, 2, 2, 2, 773, 3976, 3, 2, 2, 2, 775, 3981, 3, 2, 2, 2, 777, 3989, 3, 2, 2, 2, 779, 3995, 3, 2, 2, 2, 781, 3999, 3, 2, 2, 2, 783, 4004, 3, 2, 2, 2, 785, 4008, 3, 2, 2, 2, 787, 4013, 3, 2, 2, 2, 789, 4021, 3, 2, 2, 2, 791, 4028, 3, 2, 2, 2, 793, 4032, 3, 2, 2, 2, 795, 4040, 3, 2, 2, 2, 797, 4045, 3, 2, 2, 2, 799, 4055, 3, 2, 2, 2, 801, 4064, 3, 2, 2, 2, 803, 4068, 3, 2, 2, 2, 805, 4076, 3, 2, 2, 2, 807, 4083, 3, 2, 2, 2, 809, 4091, 3, 2, 2, 2, 811, 4097, 3, 2, 2, 2, 813, 4106, 3, 2, 2, 2, 815, 4112, 3, 2, 2, 2, 817, 4116, 3, 2, 2, 2, 819, 4124, 3, 2, 2, 2, 821, 4133, 3, 2, 2, 2, 823, 4139, 3, 2, 2, 2, 825, 4148, 3, 2, 2, 2, 827, 4154, 3, 2, 2, 2, 829, 4159, 3, 2, 2, 2, 831, 4166, 3, 2, 2, 2, 833, 4174, 3, 2, 2, 2, 835, 4182, 3, 2, 2, 2, 837, 4191, 3, 2, 2, 2, 839, 4201, 3, 2, 2, 2, 841, 4206, 3, 2, 2, 2, 843, 4210, 3, 2, 2, 2, 845, 4216, 3, 2, 2, 2, 847, 4225, 3, 2, 2, 2, 849, 4235, 3, 2, 2, 2, 851, 4240, 3, 2, 2, 2, 853, 4250, 3, 2, 2, 2, 855, 4256, 3, 2, 2, 2, 857, 4261, 3, 2, 2, 2, 859, 4268, 3, 2, 2, 2, 861, 4276, 3, 2, 2, 2, 863, 4290, 3, 2, 2, 2, 865, 4300, 3, 2, 2, 2, 867, 4311, 3, 2, 2, 2, 869, 4321, 3, 2, 2, 2, 871, 4331, 3, 2, 2, 2, 873, 4340, 3, 2, 2, 2, 875, 4346, 3, 2, 2, 2, 877, 4354, 3, 2, 2, 2, 879, 4367, 3, 2, 2, 2, 881, 4372, 3, 2, 2, 2, 883, 4380, 3, 2, 2, 2, 885, 4387, 3, 2, 2, 2, 887, 4394, 3, 2, 2, 2, 889, 4405, 3, 2, 2, 2, 891, 4415, 3, 2, 2, 2, 893, 4422, 3, 2, 2, 2, 895, 4429, 3, 2, 2, 2, 897, 4437, 3, 2, 2, 2, 899, 4445, 3, 2, 2, 2, 901, 4455, 3, 2, 2, 2, 903, 4462, 3, 2, 2, 2, 905, 4469, 3, 2, 2, 2, 907, 4476, 3, 2, 2, 2, 909, 4488, 3, 2, 2, 2, 911, 4492, 3, 2, 2, 2, 913, 4496, 3, 2, 2, 2, 915, 4502, 3, 2, 2, 2, 917, 4515, 3, 2, 2, 2, 919, 4527, 3, 2, 2, 2, 921, 4531, 3, 2, 2, 2, 923, 4535, 3, 2, 2, 2, 925, 4544, 3, 2, 2, 2, 927, 4552, 3, 2, 2, 2, 929, 4563, 3, 2, 2, 2, 931, 4569, 3, 2, 2, 2, 933, 4577, 3, 2, 2, 2, 935, 4586, 3, 2, 2, 2, 937, 4590, 3, 2, 2, 2, 939, 4598, 3, 2, 2, 2, 941, 4609, 3, 2, 2, 2, 943, 4618, 3, 2, 2, 2, 945, 4623, 3, 2, 2, 2, 947, 4630, 3, 2, 2, 2, 949, 4635, 3, 2, 2, 2, 951, 4642, 3, 2, 2, 2, 953, 4647, 3, 2, 2, 2, 955, 4656, 3, 2, 2, 2, 957, 4661, 3, 2, 2, 2, 959, 4673, 3, 2, 2, 2, 961, 4684, 3, 2, 2, 2, 963, 4693, 3, 2, 2, 2, 965, 4701, 3, 2, 2, 2, 967, 4715, 3, 2, 2, 2, 969, 4723, 3, 2, 2, 2, 971, 4734, 3, 2, 2, 2, 973, 4741, 3, 2, 2, 2, 975, 4748, 3, 2, 2, 2, 977, 4755, 3, 2, 2, 2, 979, 4762, 3, 2, 2, 2, 981, 4766, 3, 2, 2, 2, 983, 4770, 3, 2, 2, 2, 985, 4775, 3, 2, 2, 2, 987, 4780, 3, 2, 2, 2, 989, 4788, 3, 2, 2, 2, 991, 4794, 3, 2, 2, 2, 993, 4804, 3, 2, 2, 2, 995, 4809, 3, 2, 2, 2, 997, 4829, 3, 2, 2, 2, 999, 4847, 3, 2, 2, 2, 1001, 4853, 3, 2, 2, 2, 1003, 4866, 3, 2, 2, 2, 1005, 4877, 3, 2, 2, 2, 1007, 4883, 3, 2, 2, 2, 1009, 4892, 3, 2, 2, 2, 1011, 4900, 3, 2, 2, 2, 1013, 4904, 3, 2, 2, 2, 1015, 4916, 3, 2, 2, 2, 1017, 4924, 3, 2, 2, 2, 1019, 4930, 3, 2, 2, 2, 1021, 4936, 3, 2, 2, 2, 1023, 4944, 3, 2, 2, 2, 1025, 4952, 3, 2, 2, 2, 1027, 4958, 3, 2, 2, 2, 1029, 4963, 3, 2, 2, 2, 1031, 4970, 3, 2, 2, 2, 1033, 4976, 3, 2, 2, 2, 1035, 4982, 3, 2, 2, 2, 1037, 4991, 3, 2, 2, 2, 1039, 4997, 3, 2, 2, 2, 1041, 5001, 3, 2, 2, 2, 1043, 5006, 3, 2, 2, 2, 1045, 5013, 3, 2, 2, 2, 1047, 5021, 3, 2, 2, 2, 1049, 5031, 3, 2, 2, 2, 1051, 5038, 3, 2, 2, 2, 1053, 5043, 3, 2, 2, 2, 1055, 5048, 3, 2, 2, 2, 1057, 5059, 3, 2, 2, 2, 1059, 5065, 3, 2, 2, 2, 1061, 5073, 3, 2, 2, 2, 1063, 5080, 3, 2, 2, 2, 1065, 5090, 3, 2, 2, 2, 1067, 5094, 3, 2, 2, 2, 1069, 5098, 3, 2, 2, 2, 1071, 5100, 3, 2, 2, 2, 1073, 5103, 3, 2, 2, 2, 1075, 5112, 3, 2, 2, 2, 1077, 5115, 3, 2, 2, 2, 1079, 5124, 3, 2, 2, 2, 1081, 5128, 3, 2, 2, 2, 1083, 5132, 3, 2, 2, 2, 1085, 5136, 3, 2, 2, 2, 1087, 5140, 3, 2, 2, 2, 1089, 5143, 3, 2, 2, 2, 1091, 5152, 3, 2, 2, 2, 1093, 5158, 3, 2, 2, 2, 1095, 5161, 3, 2, 2, 2, 1097, 5165, 3, 2, 2, 2, 1099, 5173, 3, 2, 2, 2, 1101, 5180, 3, 2, 2, 2, 1103, 5183, 3, 2, 2, 2, 1105, 5191, 3, 2, 2, 2, 1107, 5194, 3, 2, 2, 2, 1109, 5197, 3, 2, 2, 2, 1111, 5200, 3, 2, 2, 2, 1113, 5208, 3, 2, 2, 2, 1115, 5211, 3, 2, 2, 2, 1117, 5214, 3, 2, 2, 2, 1119, 5216, 3, 2, 2, 2, 1121, 5248, 3, 2, 2, 2, 1123, 5251, 3, 2, 2, 2, 1125, 5255, 3, 2, 2, 2, 1127, 5263, 3, 2, 2, 2, 1129, 5279, 3, 2, 2, 2, 1131, 5290, 3, 2, 2, 2, 1133, 5294, 3, 2, 2, 2, 1135, 5305, 3, 2, 2, 2, 1137, 5344, 3, 2, 2, 2, 1139, 5393, 3, 2, 2, 2, 1141, 5417, 3, 2, 2, 2, 1143, 5420, 3, 2, 2, 2, 1145, 5422, 3, 2, 2, 2, 1147, 5427, 3, 2, 2, 2, 1149, 5458, 3, 2, 2, 2, 1151, 5461, 3, 2, 2, 2, 1153, 5466, 3, 2, 2, 2, 1155, 5479, 3, 2, 2, 2, 1157, 5482, 3, 2, 2, 2, 1159, 5487, 3, 2, 2, 2, 1161, 5493, 3, 2, 2, 2, 1163, 5498, 3, 2, 2, 2, 1165, 5503, 3, 2, 2, 2, 1167, 5520, 3, 2, 2, 2, 1169, 5522, 3, 2, 2, 2, 1171, 1172, 7, 38, 2, 2, 1172, 8, 3, 2, 2, 2, 1173, 1174, 7, 42, 2, 2, 1174, 10, 3, 2, 2, 2, 1175, 1176, 7, 43, 2, 2, 1176, 12, 3, 2, 2, 2, 1177, 1178, 7, 93, 2, 2, 1178, 14, 3, 2, 2, 2, 1179, 1180, 7, 95, 2, 2, 1180, 16, 3, 2, 2, 2, 1181, 1182, 7, 46, 2, 2, 1182, 18, 3, 2, 2, 2, 1183, 1184, 7, 61, 2, 2, 1184, 20, 3, 2, 2, 2, 1185, 1186, 7, 60, 2, 2, 1186, 22, 3, 2, 2, 2, 1187, 1188, 7, 44, 2, 2, 1188, 24, 3, 2, 2, 2, 1189, 1190, 7, 63, 2, 2, 1190, 26, 3, 2, 2, 2, 1191, 1192, 7, 48, 2, 2, 1192, 28, 3, 2, 2, 2, 1193, 1194, 7, 45, 2, 2, 1194, 30, 3, 2, 2, 2, 1195, 1196, 7, 47, 2, 2, 1196, 32, 3, 2, 2, 2, 1197, 1198, 7, 49, 2, 2, 1198, 34, 3, 2, 2, 2, 1199, 1200, 7, 96, 2, 2, 1200, 36, 3, 2, 2, 2, 1201, 1202, 7, 62, 2, 2, 1202, 38, 3, 2, 2, 2, 1203, 1204, 7, 64, 2, 2, 1204, 40, 3, 2, 2, 2, 1205, 1206, 7, 62, 2, 2, 1206, 1207, 7, 62, 2, 2, 1207, 42, 3, 2, 2, 2, 1208, 1209, 7, 64, 2, 2, 1209, 1210, 7, 64, 2, 2, 1210, 44, 3, 2, 2, 2, 1211, 1212, 7, 60, 2, 2, 1212, 1213, 7, 63, 2, 2, 1213, 46, 3, 2, 2, 2, 1214, 1215, 7, 62, 2, 2, 1215, 1216, 7, 63, 2, 2, 1216, 48, 3, 2, 2, 2, 1217, 1218, 7, 63, 2, 2, 1218, 1219, 7, 64, 2, 2, 1219, 50, 3, 2, 2, 2, 1220, 1221, 7, 64, 2, 2, 1221, 1222, 7, 63, 2, 2, 1222, 52, 3, 2, 2, 2, 1223, 1224, 7, 48, 2, 2, 1224, 1225, 7, 48, 2, 2, 1225, 54, 3, 2, 2, 2, 1226, 1227, 7, 62, 2, 2, 1227, 1228, 7, 64, 2, 2, 1228, 56, 3, 2, 2, 2, 1229, 1230, 7, 60, 2, 2, 1230, 1231, 7, 60, 2, 2, 1231, 58, 3, 2, 2, 2, 1232, 1233, 7, 39, 2, 2, 1233, 60, 3, 2, 2, 2, 1234, 1236, 7, 38, 2, 2, 1235, 1237, 9, 2, 2, 2, 1236, 1235, 3, 2, 2, 2, 1237, 1238, 3, 2, 2, 2, 1238, 1236, 3, 2, 2, 2, 1238, 1239, 3, 2, 2, 2, 1239, 62, 3, 2, 2, 2, 1240, 1254, 5, 67, 32, 2, 1241, 1243, 9, 3, 2, 2, 1242, 1241, 3, 2, 2, 2, 1243, 1244, 3, 2, 2, 2, 1244, 1242, 3, 2, 2, 2, 1244, 1245, 3, 2, 2, 2, 1245, 1250, 3, 2, 2, 2, 1246, 1251, 5, 67, 32, 2, 1247, 1249, 7, 49, 2, 2, 1248, 1247, 3, 2, 2, 2, 1248, 1249, 3, 2, 2, 2, 1249, 1251, 3, 2, 2, 2, 1250, 1246, 3, 2, 2, 2, 1250, 1248, 3, 2, 2, 2, 1251, 1254, 3, 2, 2, 2, 1252, 1254, 7, 49, 2, 2, 1253, 1240, 3, 2, 2, 2, 1253, 1242, 3, 2, 2, 2, 1253, 1252, 3, 2, 2, 2, 1254, 1255, 3, 2, 2, 2, 1255, 1253, 3, 2, 2, 2, 1255, 1256, 3, 2, 2, 2, 1256, 1259, 3, 2, 2, 2, 1257, 1259, 9, 3, 2, 2, 1258, 1253, 3, 2, 2, 2, 1258, 1257, 3, 2, 2, 2, 1259, 64, 3, 2, 2, 2, 1260, 1263, 5, 69, 33, 2, 1261, 1263, 9, 4, 2, 2, 1262, 1260, 3, 2, 2, 2, 1262, 1261, 3, 2, 2, 2, 1263, 1266, 3, 2, 2, 2, 1264, 1262, 3, 2, 2, 2, 1264, 1265, 3, 2, 2, 2, 1265, 1267, 3, 2, 2, 2, 1266, 1264, 3, 2, 2, 2, 1267, 1269, 5, 71, 34, 2, 1268, 1270, 5, 63, 30, 2, 1269, 1268, 3, 2, 2, 2, 1269, 1270, 3, 2, 2, 2, 1270, 1272, 3, 2, 2, 2, 1271, 1273, 9, 3, 2, 2, 1272, 1271, 3, 2, 2, 2, 1273, 1274, 3, 2, 2, 2, 1274, 1272, 3, 2, 2, 2, 1274, 1275, 3, 2, 2, 2, 1275, 1276, 3, 2, 2, 2, 1276, 1277, 8, 31, 2, 2, 1277, 66, 3, 2, 2, 2, 1278, 1279, 9, 5, 2, 2, 1279, 68, 3, 2, 2, 2, 1280, 1281, 9, 6, 2, 2, 1281, 70, 3, 2, 2, 2, 1282, 1283, 9, 7, 2, 2, 1283, 72, 3, 2, 2, 2, 1284, 1285, 7, 67, 2, 2, 1285, 1286, 7, 78, 2, 2, 1286, 1287, 7, 78, 2, 2, 1287, 74, 3, 2, 2, 2, 1288, 1289, 7, 67, 2, 2, 1289, 1290, 7, 80, 2, 2, 1290, 1291, 7, 67, 2, 2, 1291, 1292, 7, 78, 2, 2, 1292, 1293, 7, 91, 2, 2, 1293, 1294, 7, 85, 2, 2, 1294, 1295, 7, 71, 2, 2, 1295, 76, 3, 2, 2, 2, 1296, 1297, 7, 67, 2, 2, 1297, 1298, 7, 80, 2, 2, 1298, 1299, 7, 67, 2, 2, 1299, 1300, 7, 78, 2, 2, 1300, 1301, 7, 91, 2, 2, 1301, 1302, 7, 92, 2, 2, 1302, 1303, 7, 71, 2, 2, 1303, 78, 3, 2, 2, 2, 1304, 1305, 7, 67, 2, 2, 1305, 1306, 7, 80, 2, 2, 1306, 1307, 7, 70, 2, 2, 1307, 80, 3, 2, 2, 2, 1308, 1309, 7, 67, 2, 2, 1309, 1310, 7, 80, 2, 2, 1310, 1311, 7, 91, 2, 2, 1311, 82, 3, 2, 2, 2, 1312, 1313, 7, 67, 2, 2, 1313, 1314, 7, 84, 2, 2, 1314, 1315, 7, 84, 2, 2, 1315, 1316, 7, 67, 2, 2, 1316, 1317, 7, 91, 2, 2, 1317, 84, 3, 2, 2, 2, 1318, 1319, 7, 67, 2, 2, 1319, 1320, 7, 85, 2, 2, 1320, 86, 3, 2, 2, 2, 1321, 1322, 7, 67, 2, 2, 1322, 1323, 7, 85, 2, 2, 1323, 1324, 7, 69, 2, 2, 1324, 88, 3, 2, 2, 2, 1325, 1326, 7, 67, 2, 2, 1326, 1327, 7, 85, 2, 2, 1327, 1328, 7, 91, 2, 2, 1328, 1329, 7, 79, 2, 2, 1329, 1330, 7, 79, 2, 2, 1330, 1331, 7, 71, 2, 2, 1331, 1332, 7, 86, 2, 2, 1332, 1333, 7, 84, 2, 2, 1333, 1334, 7, 75, 2, 2, 1334, 1335, 7, 69, 2, 2, 1335, 90, 3, 2, 2, 2, 1336, 1337, 7, 68, 2, 2, 1337, 1338, 7, 81, 2, 2, 1338, 1339, 7, 86, 2, 2, 1339, 1340, 7, 74, 2, 2, 1340, 92, 3, 2, 2, 2, 1341, 1342, 7, 69, 2, 2, 1342, 1343, 7, 67, 2, 2, 1343, 1344, 7, 85, 2, 2, 1344, 1345, 7, 71, 2, 2, 1345, 94, 3, 2, 2, 2, 1346, 1347, 7, 69, 2, 2, 1347, 1348, 7, 67, 2, 2, 1348, 1349, 7, 85, 2, 2, 1349, 1350, 7, 86, 2, 2, 1350, 96, 3, 2, 2, 2, 1351, 1352, 7, 69, 2, 2, 1352, 1353, 7, 74, 2, 2, 1353, 1354, 7, 71, 2, 2, 1354, 1355, 7, 69, 2, 2, 1355, 1356, 7, 77, 2, 2, 1356, 98, 3, 2, 2, 2, 1357, 1358, 7, 69, 2, 2, 1358, 1359, 7, 81, 2, 2, 1359, 1360, 7, 78, 2, 2, 1360, 1361, 7, 78, 2, 2, 1361, 1362, 7, 67, 2, 2, 1362, 1363, 7, 86, 2, 2, 1363, 1364, 7, 71, 2, 2, 1364, 100, 3, 2, 2, 2, 1365, 1366, 7, 69, 2, 2, 1366, 1367, 7, 81, 2, 2, 1367, 1368, 7, 78, 2, 2, 1368, 1369, 7, 87, 2, 2, 1369, 1370, 7, 79, 2, 2, 1370, 1371, 7, 80, 2, 2, 1371, 102, 3, 2, 2, 2, 1372, 1373, 7, 69, 2, 2, 1373, 1374, 7, 81, 2, 2, 1374, 1375, 7, 80, 2, 2, 1375, 1376, 7, 85, 2, 2, 1376, 1377, 7, 86, 2, 2, 1377, 1378, 7, 84, 2, 2, 1378, 1379, 7, 67, 2, 2, 1379, 1380, 7, 75, 2, 2, 1380, 1381, 7, 80, 2, 2, 1381, 1382, 7, 86, 2, 2, 1382, 104, 3, 2, 2, 2, 1383, 1384, 7, 69, 2, 2, 1384, 1385, 7, 84, 2, 2, 1385, 1386, 7, 71, 2, 2, 1386, 1387, 7, 67, 2, 2, 1387, 1388, 7, 86, 2, 2, 1388, 1389, 7, 71, 2, 2, 1389, 106, 3, 2, 2, 2, 1390, 1391, 7, 69, 2, 2, 1391, 1392, 7, 87, 2, 2, 1392, 1393, 7, 84, 2, 2, 1393, 1394, 7, 84, 2, 2, 1394, 1395, 7, 71, 2, 2, 1395, 1396, 7, 80, 2, 2, 1396, 1397, 7, 86, 2, 2, 1397, 1398, 7, 97, 2, 2, 1398, 1399, 7, 69, 2, 2, 1399, 1400, 7, 67, 2, 2, 1400, 1401, 7, 86, 2, 2, 1401, 1402, 7, 67, 2, 2, 1402, 1403, 7, 78, 2, 2, 1403, 1404, 7, 81, 2, 2, 1404, 1405, 7, 73, 2, 2, 1405, 108, 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, 70, 2, 2, 1415, 1416, 7, 67, 2, 2, 1416, 1417, 7, 86, 2, 2, 1417, 1418, 7, 71, 2, 2, 1418, 110, 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, 84, 2, 2, 1428, 1429, 7, 81, 2, 2, 1429, 1430, 7, 78, 2, 2, 1430, 1431, 7, 71, 2, 2, 1431, 112, 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, 114, 3, 2, 2, 2, 1445, 1446, 7, 69, 2, 2, 1446, 1447, 7, 87, 2, 2, 1447, 1448, 7, 84, 2, 2, 1448, 1449, 7, 84, 2, 2, 1449, 1450, 7, 71, 2, 2, 1450, 1451, 7, 80, 2, 2, 1451, 1452, 7, 86, 2, 2, 1452, 1453, 7, 97, 2, 2, 1453, 1454, 7, 86, 2, 2, 1454, 1455, 7, 75, 2, 2, 1455, 1456, 7, 79, 2, 2, 1456, 1457, 7, 71, 2, 2, 1457, 1458, 7, 85, 2, 2, 1458, 1459, 7, 86, 2, 2, 1459, 1460, 7, 67, 2, 2, 1460, 1461, 7, 79, 2, 2, 1461, 1462, 7, 82, 2, 2, 1462, 116, 3, 2, 2, 2, 1463, 1464, 7, 69, 2, 2, 1464, 1465, 7, 87, 2, 2, 1465, 1466, 7, 84, 2, 2, 1466, 1467, 7, 84, 2, 2, 1467, 1468, 7, 71, 2, 2, 1468, 1469, 7, 80, 2, 2, 1469, 1470, 7, 86, 2, 2, 1470, 1471, 7, 97, 2, 2, 1471, 1472, 7, 87, 2, 2, 1472, 1473, 7, 85, 2, 2, 1473, 1474, 7, 71, 2, 2, 1474, 1475, 7, 84, 2, 2, 1475, 118, 3, 2, 2, 2, 1476, 1477, 7, 70, 2, 2, 1477, 1478, 7, 71, 2, 2, 1478, 1479, 7, 72, 2, 2, 1479, 1480, 7, 67, 2, 2, 1480, 1481, 7, 87, 2, 2, 1481, 1482, 7, 78, 2, 2, 1482, 1483, 7, 86, 2, 2, 1483, 120, 3, 2, 2, 2, 1484, 1485, 7, 70, 2, 2, 1485, 1486, 7, 71, 2, 2, 1486, 1487, 7, 72, 2, 2, 1487, 1488, 7, 71, 2, 2, 1488, 1489, 7, 84, 2, 2, 1489, 1490, 7, 84, 2, 2, 1490, 1491, 7, 67, 2, 2, 1491, 1492, 7, 68, 2, 2, 1492, 1493, 7, 78, 2, 2, 1493, 1494, 7, 71, 2, 2, 1494, 122, 3, 2, 2, 2, 1495, 1496, 7, 70, 2, 2, 1496, 1497, 7, 71, 2, 2, 1497, 1498, 7, 85, 2, 2, 1498, 1499, 7, 69, 2, 2, 1499, 124, 3, 2, 2, 2, 1500, 1501, 7, 70, 2, 2, 1501, 1502, 7, 75, 2, 2, 1502, 1503, 7, 85, 2, 2, 1503, 1504, 7, 86, 2, 2, 1504, 1505, 7, 75, 2, 2, 1505, 1506, 7, 80, 2, 2, 1506, 1507, 7, 69, 2, 2, 1507, 1508, 7, 86, 2, 2, 1508, 126, 3, 2, 2, 2, 1509, 1510, 7, 70, 2, 2, 1510, 1511, 7, 81, 2, 2, 1511, 128, 3, 2, 2, 2, 1512, 1513, 7, 71, 2, 2, 1513, 1514, 7, 78, 2, 2, 1514, 1515, 7, 85, 2, 2, 1515, 1516, 7, 71, 2, 2, 1516, 130, 3, 2, 2, 2, 1517, 1518, 7, 71, 2, 2, 1518, 1519, 7, 90, 2, 2, 1519, 1520, 7, 69, 2, 2, 1520, 1521, 7, 71, 2, 2, 1521, 1522, 7, 82, 2, 2, 1522, 1523, 7, 86, 2, 2, 1523, 132, 3, 2, 2, 2, 1524, 1525, 7, 72, 2, 2, 1525, 1526, 7, 67, 2, 2, 1526, 1527, 7, 78, 2, 2, 1527, 1528, 7, 85, 2, 2, 1528, 1529, 7, 71, 2, 2, 1529, 134, 3, 2, 2, 2, 1530, 1531, 7, 72, 2, 2, 1531, 1532, 7, 71, 2, 2, 1532, 1533, 7, 86, 2, 2, 1533, 1534, 7, 69, 2, 2, 1534, 1535, 7, 74, 2, 2, 1535, 136, 3, 2, 2, 2, 1536, 1537, 7, 72, 2, 2, 1537, 1538, 7, 81, 2, 2, 1538, 1539, 7, 84, 2, 2, 1539, 138, 3, 2, 2, 2, 1540, 1541, 7, 72, 2, 2, 1541, 1542, 7, 81, 2, 2, 1542, 1543, 7, 84, 2, 2, 1543, 1544, 7, 71, 2, 2, 1544, 1545, 7, 75, 2, 2, 1545, 1546, 7, 73, 2, 2, 1546, 1547, 7, 80, 2, 2, 1547, 140, 3, 2, 2, 2, 1548, 1549, 7, 72, 2, 2, 1549, 1550, 7, 84, 2, 2, 1550, 1551, 7, 81, 2, 2, 1551, 1552, 7, 79, 2, 2, 1552, 142, 3, 2, 2, 2, 1553, 1554, 7, 73, 2, 2, 1554, 1555, 7, 84, 2, 2, 1555, 1556, 7, 67, 2, 2, 1556, 1557, 7, 80, 2, 2, 1557, 1558, 7, 86, 2, 2, 1558, 144, 3, 2, 2, 2, 1559, 1560, 7, 73, 2, 2, 1560, 1561, 7, 84, 2, 2, 1561, 1562, 7, 81, 2, 2, 1562, 1563, 7, 87, 2, 2, 1563, 1564, 7, 82, 2, 2, 1564, 146, 3, 2, 2, 2, 1565, 1566, 7, 74, 2, 2, 1566, 1567, 7, 67, 2, 2, 1567, 1568, 7, 88, 2, 2, 1568, 1569, 7, 75, 2, 2, 1569, 1570, 7, 80, 2, 2, 1570, 1571, 7, 73, 2, 2, 1571, 148, 3, 2, 2, 2, 1572, 1573, 7, 75, 2, 2, 1573, 1574, 7, 80, 2, 2, 1574, 150, 3, 2, 2, 2, 1575, 1576, 7, 75, 2, 2, 1576, 1577, 7, 80, 2, 2, 1577, 1578, 7, 75, 2, 2, 1578, 1579, 7, 86, 2, 2, 1579, 1580, 7, 75, 2, 2, 1580, 1581, 7, 67, 2, 2, 1581, 1582, 7, 78, 2, 2, 1582, 1583, 7, 78, 2, 2, 1583, 1584, 7, 91, 2, 2, 1584, 152, 3, 2, 2, 2, 1585, 1586, 7, 75, 2, 2, 1586, 1587, 7, 80, 2, 2, 1587, 1588, 7, 86, 2, 2, 1588, 1589, 7, 71, 2, 2, 1589, 1590, 7, 84, 2, 2, 1590, 1591, 7, 85, 2, 2, 1591, 1592, 7, 71, 2, 2, 1592, 1593, 7, 69, 2, 2, 1593, 1594, 7, 86, 2, 2, 1594, 154, 3, 2, 2, 2, 1595, 1596, 7, 75, 2, 2, 1596, 1597, 7, 80, 2, 2, 1597, 1598, 7, 86, 2, 2, 1598, 1599, 7, 81, 2, 2, 1599, 156, 3, 2, 2, 2, 1600, 1601, 7, 78, 2, 2, 1601, 1602, 7, 67, 2, 2, 1602, 1603, 7, 86, 2, 2, 1603, 1604, 7, 71, 2, 2, 1604, 1605, 7, 84, 2, 2, 1605, 1606, 7, 67, 2, 2, 1606, 1607, 7, 78, 2, 2, 1607, 158, 3, 2, 2, 2, 1608, 1609, 7, 78, 2, 2, 1609, 1610, 7, 71, 2, 2, 1610, 1611, 7, 67, 2, 2, 1611, 1612, 7, 70, 2, 2, 1612, 1613, 7, 75, 2, 2, 1613, 1614, 7, 80, 2, 2, 1614, 1615, 7, 73, 2, 2, 1615, 160, 3, 2, 2, 2, 1616, 1617, 7, 78, 2, 2, 1617, 1618, 7, 75, 2, 2, 1618, 1619, 7, 79, 2, 2, 1619, 1620, 7, 75, 2, 2, 1620, 1621, 7, 86, 2, 2, 1621, 162, 3, 2, 2, 2, 1622, 1623, 7, 78, 2, 2, 1623, 1624, 7, 81, 2, 2, 1624, 1625, 7, 69, 2, 2, 1625, 1626, 7, 67, 2, 2, 1626, 1627, 7, 78, 2, 2, 1627, 1628, 7, 86, 2, 2, 1628, 1629, 7, 75, 2, 2, 1629, 1630, 7, 79, 2, 2, 1630, 1631, 7, 71, 2, 2, 1631, 164, 3, 2, 2, 2, 1632, 1633, 7, 78, 2, 2, 1633, 1634, 7, 81, 2, 2, 1634, 1635, 7, 69, 2, 2, 1635, 1636, 7, 67, 2, 2, 1636, 1637, 7, 78, 2, 2, 1637, 1638, 7, 86, 2, 2, 1638, 1639, 7, 75, 2, 2, 1639, 1640, 7, 79, 2, 2, 1640, 1641, 7, 71, 2, 2, 1641, 1642, 7, 85, 2, 2, 1642, 1643, 7, 86, 2, 2, 1643, 1644, 7, 67, 2, 2, 1644, 1645, 7, 79, 2, 2, 1645, 1646, 7, 82, 2, 2, 1646, 166, 3, 2, 2, 2, 1647, 1648, 7, 80, 2, 2, 1648, 1649, 7, 81, 2, 2, 1649, 1650, 7, 86, 2, 2, 1650, 168, 3, 2, 2, 2, 1651, 1652, 7, 80, 2, 2, 1652, 1653, 7, 87, 2, 2, 1653, 1654, 7, 78, 2, 2, 1654, 1655, 7, 78, 2, 2, 1655, 170, 3, 2, 2, 2, 1656, 1657, 7, 81, 2, 2, 1657, 1658, 7, 72, 2, 2, 1658, 1659, 7, 72, 2, 2, 1659, 1660, 7, 85, 2, 2, 1660, 1661, 7, 71, 2, 2, 1661, 1662, 7, 86, 2, 2, 1662, 172, 3, 2, 2, 2, 1663, 1664, 7, 81, 2, 2, 1664, 1665, 7, 80, 2, 2, 1665, 174, 3, 2, 2, 2, 1666, 1667, 7, 81, 2, 2, 1667, 1668, 7, 80, 2, 2, 1668, 1669, 7, 78, 2, 2, 1669, 1670, 7, 91, 2, 2, 1670, 176, 3, 2, 2, 2, 1671, 1672, 7, 81, 2, 2, 1672, 1673, 7, 84, 2, 2, 1673, 178, 3, 2, 2, 2, 1674, 1675, 7, 81, 2, 2, 1675, 1676, 7, 84, 2, 2, 1676, 1677, 7, 70, 2, 2, 1677, 1678, 7, 71, 2, 2, 1678, 1679, 7, 84, 2, 2, 1679, 180, 3, 2, 2, 2, 1680, 1681, 7, 82, 2, 2, 1681, 1682, 7, 78, 2, 2, 1682, 1683, 7, 67, 2, 2, 1683, 1684, 7, 69, 2, 2, 1684, 1685, 7, 75, 2, 2, 1685, 1686, 7, 80, 2, 2, 1686, 1687, 7, 73, 2, 2, 1687, 182, 3, 2, 2, 2, 1688, 1689, 7, 82, 2, 2, 1689, 1690, 7, 84, 2, 2, 1690, 1691, 7, 75, 2, 2, 1691, 1692, 7, 79, 2, 2, 1692, 1693, 7, 67, 2, 2, 1693, 1694, 7, 84, 2, 2, 1694, 1695, 7, 91, 2, 2, 1695, 184, 3, 2, 2, 2, 1696, 1697, 7, 84, 2, 2, 1697, 1698, 7, 71, 2, 2, 1698, 1699, 7, 72, 2, 2, 1699, 1700, 7, 71, 2, 2, 1700, 1701, 7, 84, 2, 2, 1701, 1702, 7, 71, 2, 2, 1702, 1703, 7, 80, 2, 2, 1703, 1704, 7, 69, 2, 2, 1704, 1705, 7, 71, 2, 2, 1705, 1706, 7, 85, 2, 2, 1706, 186, 3, 2, 2, 2, 1707, 1708, 7, 84, 2, 2, 1708, 1709, 7, 71, 2, 2, 1709, 1710, 7, 86, 2, 2, 1710, 1711, 7, 87, 2, 2, 1711, 1712, 7, 84, 2, 2, 1712, 1713, 7, 80, 2, 2, 1713, 1714, 7, 75, 2, 2, 1714, 1715, 7, 80, 2, 2, 1715, 1716, 7, 73, 2, 2, 1716, 188, 3, 2, 2, 2, 1717, 1718, 7, 85, 2, 2, 1718, 1719, 7, 71, 2, 2, 1719, 1720, 7, 78, 2, 2, 1720, 1721, 7, 71, 2, 2, 1721, 1722, 7, 69, 2, 2, 1722, 1723, 7, 86, 2, 2, 1723, 190, 3, 2, 2, 2, 1724, 1725, 7, 85, 2, 2, 1725, 1726, 7, 71, 2, 2, 1726, 1727, 7, 85, 2, 2, 1727, 1728, 7, 85, 2, 2, 1728, 1729, 7, 75, 2, 2, 1729, 1730, 7, 81, 2, 2, 1730, 1731, 7, 80, 2, 2, 1731, 1732, 7, 97, 2, 2, 1732, 1733, 7, 87, 2, 2, 1733, 1734, 7, 85, 2, 2, 1734, 1735, 7, 71, 2, 2, 1735, 1736, 7, 84, 2, 2, 1736, 192, 3, 2, 2, 2, 1737, 1738, 7, 85, 2, 2, 1738, 1739, 7, 81, 2, 2, 1739, 1740, 7, 79, 2, 2, 1740, 1741, 7, 71, 2, 2, 1741, 194, 3, 2, 2, 2, 1742, 1743, 7, 85, 2, 2, 1743, 1744, 7, 91, 2, 2, 1744, 1745, 7, 79, 2, 2, 1745, 1746, 7, 79, 2, 2, 1746, 1747, 7, 71, 2, 2, 1747, 1748, 7, 86, 2, 2, 1748, 1749, 7, 84, 2, 2, 1749, 1750, 7, 75, 2, 2, 1750, 1751, 7, 69, 2, 2, 1751, 196, 3, 2, 2, 2, 1752, 1753, 7, 86, 2, 2, 1753, 1754, 7, 67, 2, 2, 1754, 1755, 7, 68, 2, 2, 1755, 1756, 7, 78, 2, 2, 1756, 1757, 7, 71, 2, 2, 1757, 198, 3, 2, 2, 2, 1758, 1759, 7, 86, 2, 2, 1759, 1760, 7, 74, 2, 2, 1760, 1761, 7, 71, 2, 2, 1761, 1762, 7, 80, 2, 2, 1762, 200, 3, 2, 2, 2, 1763, 1764, 7, 86, 2, 2, 1764, 1765, 7, 81, 2, 2, 1765, 202, 3, 2, 2, 2, 1766, 1767, 7, 86, 2, 2, 1767, 1768, 7, 84, 2, 2, 1768, 1769, 7, 67, 2, 2, 1769, 1770, 7, 75, 2, 2, 1770, 1771, 7, 78, 2, 2, 1771, 1772, 7, 75, 2, 2, 1772, 1773, 7, 80, 2, 2, 1773, 1774, 7, 73, 2, 2, 1774, 204, 3, 2, 2, 2, 1775, 1776, 7, 86, 2, 2, 1776, 1777, 7, 84, 2, 2, 1777, 1778, 7, 87, 2, 2, 1778, 1779, 7, 71, 2, 2, 1779, 206, 3, 2, 2, 2, 1780, 1781, 7, 87, 2, 2, 1781, 1782, 7, 80, 2, 2, 1782, 1783, 7, 75, 2, 2, 1783, 1784, 7, 81, 2, 2, 1784, 1785, 7, 80, 2, 2, 1785, 208, 3, 2, 2, 2, 1786, 1787, 7, 87, 2, 2, 1787, 1788, 7, 80, 2, 2, 1788, 1789, 7, 75, 2, 2, 1789, 1790, 7, 83, 2, 2, 1790, 1791, 7, 87, 2, 2, 1791, 1792, 7, 71, 2, 2, 1792, 210, 3, 2, 2, 2, 1793, 1794, 7, 87, 2, 2, 1794, 1795, 7, 85, 2, 2, 1795, 1796, 7, 71, 2, 2, 1796, 1797, 7, 84, 2, 2, 1797, 212, 3, 2, 2, 2, 1798, 1799, 7, 87, 2, 2, 1799, 1800, 7, 85, 2, 2, 1800, 1801, 7, 75, 2, 2, 1801, 1802, 7, 80, 2, 2, 1802, 1803, 7, 73, 2, 2, 1803, 214, 3, 2, 2, 2, 1804, 1805, 7, 88, 2, 2, 1805, 1806, 7, 67, 2, 2, 1806, 1807, 7, 84, 2, 2, 1807, 1808, 7, 75, 2, 2, 1808, 1809, 7, 67, 2, 2, 1809, 1810, 7, 70, 2, 2, 1810, 1811, 7, 75, 2, 2, 1811, 1812, 7, 69, 2, 2, 1812, 216, 3, 2, 2, 2, 1813, 1814, 7, 89, 2, 2, 1814, 1815, 7, 74, 2, 2, 1815, 1816, 7, 71, 2, 2, 1816, 1817, 7, 80, 2, 2, 1817, 218, 3, 2, 2, 2, 1818, 1819, 7, 89, 2, 2, 1819, 1820, 7, 74, 2, 2, 1820, 1821, 7, 71, 2, 2, 1821, 1822, 7, 84, 2, 2, 1822, 1823, 7, 71, 2, 2, 1823, 220, 3, 2, 2, 2, 1824, 1825, 7, 89, 2, 2, 1825, 1826, 7, 75, 2, 2, 1826, 1827, 7, 80, 2, 2, 1827, 1828, 7, 70, 2, 2, 1828, 1829, 7, 81, 2, 2, 1829, 1830, 7, 89, 2, 2, 1830, 222, 3, 2, 2, 2, 1831, 1832, 7, 89, 2, 2, 1832, 1833, 7, 75, 2, 2, 1833, 1834, 7, 86, 2, 2, 1834, 1835, 7, 74, 2, 2, 1835, 224, 3, 2, 2, 2, 1836, 1837, 7, 67, 2, 2, 1837, 1838, 7, 87, 2, 2, 1838, 1839, 7, 86, 2, 2, 1839, 1840, 7, 74, 2, 2, 1840, 1841, 7, 81, 2, 2, 1841, 1842, 7, 84, 2, 2, 1842, 1843, 7, 75, 2, 2, 1843, 1844, 7, 92, 2, 2, 1844, 1845, 7, 67, 2, 2, 1845, 1846, 7, 86, 2, 2, 1846, 1847, 7, 75, 2, 2, 1847, 1848, 7, 81, 2, 2, 1848, 1849, 7, 80, 2, 2, 1849, 226, 3, 2, 2, 2, 1850, 1851, 7, 68, 2, 2, 1851, 1852, 7, 75, 2, 2, 1852, 1853, 7, 80, 2, 2, 1853, 1854, 7, 67, 2, 2, 1854, 1855, 7, 84, 2, 2, 1855, 1856, 7, 91, 2, 2, 1856, 228, 3, 2, 2, 2, 1857, 1858, 7, 69, 2, 2, 1858, 1859, 7, 81, 2, 2, 1859, 1860, 7, 78, 2, 2, 1860, 1861, 7, 78, 2, 2, 1861, 1862, 7, 67, 2, 2, 1862, 1863, 7, 86, 2, 2, 1863, 1864, 7, 75, 2, 2, 1864, 1865, 7, 81, 2, 2, 1865, 1866, 7, 80, 2, 2, 1866, 230, 3, 2, 2, 2, 1867, 1868, 7, 69, 2, 2, 1868, 1869, 7, 81, 2, 2, 1869, 1870, 7, 80, 2, 2, 1870, 1871, 7, 69, 2, 2, 1871, 1872, 7, 87, 2, 2, 1872, 1873, 7, 84, 2, 2, 1873, 1874, 7, 84, 2, 2, 1874, 1875, 7, 71, 2, 2, 1875, 1876, 7, 80, 2, 2, 1876, 1877, 7, 86, 2, 2, 1877, 1878, 7, 78, 2, 2, 1878, 1879, 7, 91, 2, 2, 1879, 232, 3, 2, 2, 2, 1880, 1881, 7, 69, 2, 2, 1881, 1882, 7, 84, 2, 2, 1882, 1883, 7, 81, 2, 2, 1883, 1884, 7, 85, 2, 2, 1884, 1885, 7, 85, 2, 2, 1885, 234, 3, 2, 2, 2, 1886, 1887, 7, 69, 2, 2, 1887, 1888, 7, 87, 2, 2, 1888, 1889, 7, 84, 2, 2, 1889, 1890, 7, 84, 2, 2, 1890, 1891, 7, 71, 2, 2, 1891, 1892, 7, 80, 2, 2, 1892, 1893, 7, 86, 2, 2, 1893, 1894, 7, 97, 2, 2, 1894, 1895, 7, 85, 2, 2, 1895, 1896, 7, 69, 2, 2, 1896, 1897, 7, 74, 2, 2, 1897, 1898, 7, 71, 2, 2, 1898, 1899, 7, 79, 2, 2, 1899, 1900, 7, 67, 2, 2, 1900, 236, 3, 2, 2, 2, 1901, 1902, 7, 72, 2, 2, 1902, 1903, 7, 84, 2, 2, 1903, 1904, 7, 71, 2, 2, 1904, 1905, 7, 71, 2, 2, 1905, 1906, 7, 92, 2, 2, 1906, 1907, 7, 71, 2, 2, 1907, 238, 3, 2, 2, 2, 1908, 1909, 7, 72, 2, 2, 1909, 1910, 7, 87, 2, 2, 1910, 1911, 7, 78, 2, 2, 1911, 1912, 7, 78, 2, 2, 1912, 240, 3, 2, 2, 2, 1913, 1914, 7, 75, 2, 2, 1914, 1915, 7, 78, 2, 2, 1915, 1916, 7, 75, 2, 2, 1916, 1917, 7, 77, 2, 2, 1917, 1918, 7, 71, 2, 2, 1918, 242, 3, 2, 2, 2, 1919, 1920, 7, 75, 2, 2, 1920, 1921, 7, 80, 2, 2, 1921, 1922, 7, 80, 2, 2, 1922, 1923, 7, 71, 2, 2, 1923, 1924, 7, 84, 2, 2, 1924, 244, 3, 2, 2, 2, 1925, 1926, 7, 75, 2, 2, 1926, 1927, 7, 85, 2, 2, 1927, 246, 3, 2, 2, 2, 1928, 1929, 7, 75, 2, 2, 1929, 1930, 7, 85, 2, 2, 1930, 1931, 7, 80, 2, 2, 1931, 1932, 7, 87, 2, 2, 1932, 1933, 7, 78, 2, 2, 1933, 1934, 7, 78, 2, 2, 1934, 248, 3, 2, 2, 2, 1935, 1936, 7, 76, 2, 2, 1936, 1937, 7, 81, 2, 2, 1937, 1938, 7, 75, 2, 2, 1938, 1939, 7, 80, 2, 2, 1939, 250, 3, 2, 2, 2, 1940, 1941, 7, 78, 2, 2, 1941, 1942, 7, 71, 2, 2, 1942, 1943, 7, 72, 2, 2, 1943, 1944, 7, 86, 2, 2, 1944, 252, 3, 2, 2, 2, 1945, 1946, 7, 78, 2, 2, 1946, 1947, 7, 75, 2, 2, 1947, 1948, 7, 77, 2, 2, 1948, 1949, 7, 71, 2, 2, 1949, 254, 3, 2, 2, 2, 1950, 1951, 7, 80, 2, 2, 1951, 1952, 7, 67, 2, 2, 1952, 1953, 7, 86, 2, 2, 1953, 1954, 7, 87, 2, 2, 1954, 1955, 7, 84, 2, 2, 1955, 1956, 7, 67, 2, 2, 1956, 1957, 7, 78, 2, 2, 1957, 256, 3, 2, 2, 2, 1958, 1959, 7, 80, 2, 2, 1959, 1960, 7, 81, 2, 2, 1960, 1961, 7, 86, 2, 2, 1961, 1962, 7, 80, 2, 2, 1962, 1963, 7, 87, 2, 2, 1963, 1964, 7, 78, 2, 2, 1964, 1965, 7, 78, 2, 2, 1965, 258, 3, 2, 2, 2, 1966, 1967, 7, 81, 2, 2, 1967, 1968, 7, 87, 2, 2, 1968, 1969, 7, 86, 2, 2, 1969, 1970, 7, 71, 2, 2, 1970, 1971, 7, 84, 2, 2, 1971, 260, 3, 2, 2, 2, 1972, 1973, 7, 81, 2, 2, 1973, 1974, 7, 88, 2, 2, 1974, 1975, 7, 71, 2, 2, 1975, 1976, 7, 84, 2, 2, 1976, 262, 3, 2, 2, 2, 1977, 1978, 7, 81, 2, 2, 1978, 1979, 7, 88, 2, 2, 1979, 1980, 7, 71, 2, 2, 1980, 1981, 7, 84, 2, 2, 1981, 1982, 7, 78, 2, 2, 1982, 1983, 7, 67, 2, 2, 1983, 1984, 7, 82, 2, 2, 1984, 1985, 7, 85, 2, 2, 1985, 264, 3, 2, 2, 2, 1986, 1987, 7, 84, 2, 2, 1987, 1988, 7, 75, 2, 2, 1988, 1989, 7, 73, 2, 2, 1989, 1990, 7, 74, 2, 2, 1990, 1991, 7, 86, 2, 2, 1991, 266, 3, 2, 2, 2, 1992, 1993, 7, 85, 2, 2, 1993, 1994, 7, 75, 2, 2, 1994, 1995, 7, 79, 2, 2, 1995, 1996, 7, 75, 2, 2, 1996, 1997, 7, 78, 2, 2, 1997, 1998, 7, 67, 2, 2, 1998, 1999, 7, 84, 2, 2, 1999, 268, 3, 2, 2, 2, 2000, 2001, 7, 88, 2, 2, 2001, 2002, 7, 71, 2, 2, 2002, 2003, 7, 84, 2, 2, 2003, 2004, 7, 68, 2, 2, 2004, 2005, 7, 81, 2, 2, 2005, 2006, 7, 85, 2, 2, 2006, 2007, 7, 71, 2, 2, 2007, 270, 3, 2, 2, 2, 2008, 2009, 7, 67, 2, 2, 2009, 2010, 7, 68, 2, 2, 2010, 2011, 7, 81, 2, 2, 2011, 2012, 7, 84, 2, 2, 2012, 2013, 7, 86, 2, 2, 2013, 272, 3, 2, 2, 2, 2014, 2015, 7, 67, 2, 2, 2015, 2016, 7, 68, 2, 2, 2016, 2017, 7, 85, 2, 2, 2017, 2018, 7, 81, 2, 2, 2018, 2019, 7, 78, 2, 2, 2019, 2020, 7, 87, 2, 2, 2020, 2021, 7, 86, 2, 2, 2021, 2022, 7, 71, 2, 2, 2022, 274, 3, 2, 2, 2, 2023, 2024, 7, 67, 2, 2, 2024, 2025, 7, 69, 2, 2, 2025, 2026, 7, 69, 2, 2, 2026, 2027, 7, 71, 2, 2, 2027, 2028, 7, 85, 2, 2, 2028, 2029, 7, 85, 2, 2, 2029, 276, 3, 2, 2, 2, 2030, 2031, 7, 67, 2, 2, 2031, 2032, 7, 69, 2, 2, 2032, 2033, 7, 86, 2, 2, 2033, 2034, 7, 75, 2, 2, 2034, 2035, 7, 81, 2, 2, 2035, 2036, 7, 80, 2, 2, 2036, 278, 3, 2, 2, 2, 2037, 2038, 7, 67, 2, 2, 2038, 2039, 7, 70, 2, 2, 2039, 2040, 7, 70, 2, 2, 2040, 280, 3, 2, 2, 2, 2041, 2042, 7, 67, 2, 2, 2042, 2043, 7, 70, 2, 2, 2043, 2044, 7, 79, 2, 2, 2044, 2045, 7, 75, 2, 2, 2045, 2046, 7, 80, 2, 2, 2046, 282, 3, 2, 2, 2, 2047, 2048, 7, 67, 2, 2, 2048, 2049, 7, 72, 2, 2, 2049, 2050, 7, 86, 2, 2, 2050, 2051, 7, 71, 2, 2, 2051, 2052, 7, 84, 2, 2, 2052, 284, 3, 2, 2, 2, 2053, 2054, 7, 67, 2, 2, 2054, 2055, 7, 73, 2, 2, 2055, 2056, 7, 73, 2, 2, 2056, 2057, 7, 84, 2, 2, 2057, 2058, 7, 71, 2, 2, 2058, 2059, 7, 73, 2, 2, 2059, 2060, 7, 67, 2, 2, 2060, 2061, 7, 86, 2, 2, 2061, 2062, 7, 71, 2, 2, 2062, 286, 3, 2, 2, 2, 2063, 2064, 7, 67, 2, 2, 2064, 2065, 7, 78, 2, 2, 2065, 2066, 7, 85, 2, 2, 2066, 2067, 7, 81, 2, 2, 2067, 288, 3, 2, 2, 2, 2068, 2069, 7, 67, 2, 2, 2069, 2070, 7, 78, 2, 2, 2070, 2071, 7, 86, 2, 2, 2071, 2072, 7, 71, 2, 2, 2072, 2073, 7, 84, 2, 2, 2073, 290, 3, 2, 2, 2, 2074, 2075, 7, 67, 2, 2, 2075, 2076, 7, 78, 2, 2, 2076, 2077, 7, 89, 2, 2, 2077, 2078, 7, 67, 2, 2, 2078, 2079, 7, 91, 2, 2, 2079, 2080, 7, 85, 2, 2, 2080, 292, 3, 2, 2, 2, 2081, 2082, 7, 67, 2, 2, 2082, 2083, 7, 85, 2, 2, 2083, 2084, 7, 85, 2, 2, 2084, 2085, 7, 71, 2, 2, 2085, 2086, 7, 84, 2, 2, 2086, 2087, 7, 86, 2, 2, 2087, 2088, 7, 75, 2, 2, 2088, 2089, 7, 81, 2, 2, 2089, 2090, 7, 80, 2, 2, 2090, 294, 3, 2, 2, 2, 2091, 2092, 7, 67, 2, 2, 2092, 2093, 7, 85, 2, 2, 2093, 2094, 7, 85, 2, 2, 2094, 2095, 7, 75, 2, 2, 2095, 2096, 7, 73, 2, 2, 2096, 2097, 7, 80, 2, 2, 2097, 2098, 7, 79, 2, 2, 2098, 2099, 7, 71, 2, 2, 2099, 2100, 7, 80, 2, 2, 2100, 2101, 7, 86, 2, 2, 2101, 296, 3, 2, 2, 2, 2102, 2103, 7, 67, 2, 2, 2103, 2104, 7, 86, 2, 2, 2104, 298, 3, 2, 2, 2, 2105, 2106, 7, 67, 2, 2, 2106, 2107, 7, 86, 2, 2, 2107, 2108, 7, 86, 2, 2, 2108, 2109, 7, 84, 2, 2, 2109, 2110, 7, 75, 2, 2, 2110, 2111, 7, 68, 2, 2, 2111, 2112, 7, 87, 2, 2, 2112, 2113, 7, 86, 2, 2, 2113, 2114, 7, 71, 2, 2, 2114, 300, 3, 2, 2, 2, 2115, 2116, 7, 68, 2, 2, 2116, 2117, 7, 67, 2, 2, 2117, 2118, 7, 69, 2, 2, 2118, 2119, 7, 77, 2, 2, 2119, 2120, 7, 89, 2, 2, 2120, 2121, 7, 67, 2, 2, 2121, 2122, 7, 84, 2, 2, 2122, 2123, 7, 70, 2, 2, 2123, 302, 3, 2, 2, 2, 2124, 2125, 7, 68, 2, 2, 2125, 2126, 7, 71, 2, 2, 2126, 2127, 7, 72, 2, 2, 2127, 2128, 7, 81, 2, 2, 2128, 2129, 7, 84, 2, 2, 2129, 2130, 7, 71, 2, 2, 2130, 304, 3, 2, 2, 2, 2131, 2132, 7, 68, 2, 2, 2132, 2133, 7, 71, 2, 2, 2133, 2134, 7, 73, 2, 2, 2134, 2135, 7, 75, 2, 2, 2135, 2136, 7, 80, 2, 2, 2136, 306, 3, 2, 2, 2, 2137, 2138, 7, 68, 2, 2, 2138, 2139, 7, 91, 2, 2, 2139, 308, 3, 2, 2, 2, 2140, 2141, 7, 69, 2, 2, 2141, 2142, 7, 67, 2, 2, 2142, 2143, 7, 69, 2, 2, 2143, 2144, 7, 74, 2, 2, 2144, 2145, 7, 71, 2, 2, 2145, 310, 3, 2, 2, 2, 2146, 2147, 7, 69, 2, 2, 2147, 2148, 7, 67, 2, 2, 2148, 2149, 7, 78, 2, 2, 2149, 2150, 7, 78, 2, 2, 2150, 2151, 7, 71, 2, 2, 2151, 2152, 7, 70, 2, 2, 2152, 312, 3, 2, 2, 2, 2153, 2154, 7, 69, 2, 2, 2154, 2155, 7, 67, 2, 2, 2155, 2156, 7, 85, 2, 2, 2156, 2157, 7, 69, 2, 2, 2157, 2158, 7, 67, 2, 2, 2158, 2159, 7, 70, 2, 2, 2159, 2160, 7, 71, 2, 2, 2160, 314, 3, 2, 2, 2, 2161, 2162, 7, 69, 2, 2, 2162, 2163, 7, 67, 2, 2, 2163, 2164, 7, 85, 2, 2, 2164, 2165, 7, 69, 2, 2, 2165, 2166, 7, 67, 2, 2, 2166, 2167, 7, 70, 2, 2, 2167, 2168, 7, 71, 2, 2, 2168, 2169, 7, 70, 2, 2, 2169, 316, 3, 2, 2, 2, 2170, 2171, 7, 69, 2, 2, 2171, 2172, 7, 67, 2, 2, 2172, 2173, 7, 86, 2, 2, 2173, 2174, 7, 67, 2, 2, 2174, 2175, 7, 78, 2, 2, 2175, 2176, 7, 81, 2, 2, 2176, 2177, 7, 73, 2, 2, 2177, 318, 3, 2, 2, 2, 2178, 2179, 7, 69, 2, 2, 2179, 2180, 7, 74, 2, 2, 2180, 2181, 7, 67, 2, 2, 2181, 2182, 7, 75, 2, 2, 2182, 2183, 7, 80, 2, 2, 2183, 320, 3, 2, 2, 2, 2184, 2185, 7, 69, 2, 2, 2185, 2186, 7, 74, 2, 2, 2186, 2187, 7, 67, 2, 2, 2187, 2188, 7, 84, 2, 2, 2188, 2189, 7, 67, 2, 2, 2189, 2190, 7, 69, 2, 2, 2190, 2191, 7, 86, 2, 2, 2191, 2192, 7, 71, 2, 2, 2192, 2193, 7, 84, 2, 2, 2193, 2194, 7, 75, 2, 2, 2194, 2195, 7, 85, 2, 2, 2195, 2196, 7, 86, 2, 2, 2196, 2197, 7, 75, 2, 2, 2197, 2198, 7, 69, 2, 2, 2198, 2199, 7, 85, 2, 2, 2199, 322, 3, 2, 2, 2, 2200, 2201, 7, 69, 2, 2, 2201, 2202, 7, 74, 2, 2, 2202, 2203, 7, 71, 2, 2, 2203, 2204, 7, 69, 2, 2, 2204, 2205, 7, 77, 2, 2, 2205, 2206, 7, 82, 2, 2, 2206, 2207, 7, 81, 2, 2, 2207, 2208, 7, 75, 2, 2, 2208, 2209, 7, 80, 2, 2, 2209, 2210, 7, 86, 2, 2, 2210, 324, 3, 2, 2, 2, 2211, 2212, 7, 69, 2, 2, 2212, 2213, 7, 78, 2, 2, 2213, 2214, 7, 67, 2, 2, 2214, 2215, 7, 85, 2, 2, 2215, 2216, 7, 85, 2, 2, 2216, 326, 3, 2, 2, 2, 2217, 2218, 7, 69, 2, 2, 2218, 2219, 7, 78, 2, 2, 2219, 2220, 7, 81, 2, 2, 2220, 2221, 7, 85, 2, 2, 2221, 2222, 7, 71, 2, 2, 2222, 328, 3, 2, 2, 2, 2223, 2224, 7, 69, 2, 2, 2224, 2225, 7, 78, 2, 2, 2225, 2226, 7, 87, 2, 2, 2226, 2227, 7, 85, 2, 2, 2227, 2228, 7, 86, 2, 2, 2228, 2229, 7, 71, 2, 2, 2229, 2230, 7, 84, 2, 2, 2230, 330, 3, 2, 2, 2, 2231, 2232, 7, 69, 2, 2, 2232, 2233, 7, 81, 2, 2, 2233, 2234, 7, 79, 2, 2, 2234, 2235, 7, 79, 2, 2, 2235, 2236, 7, 71, 2, 2, 2236, 2237, 7, 80, 2, 2, 2237, 2238, 7, 86, 2, 2, 2238, 332, 3, 2, 2, 2, 2239, 2240, 7, 69, 2, 2, 2240, 2241, 7, 81, 2, 2, 2241, 2242, 7, 79, 2, 2, 2242, 2243, 7, 79, 2, 2, 2243, 2244, 7, 71, 2, 2, 2244, 2245, 7, 80, 2, 2, 2245, 2246, 7, 86, 2, 2, 2246, 2247, 7, 85, 2, 2, 2247, 334, 3, 2, 2, 2, 2248, 2249, 7, 69, 2, 2, 2249, 2250, 7, 81, 2, 2, 2250, 2251, 7, 79, 2, 2, 2251, 2252, 7, 79, 2, 2, 2252, 2253, 7, 75, 2, 2, 2253, 2254, 7, 86, 2, 2, 2254, 336, 3, 2, 2, 2, 2255, 2256, 7, 69, 2, 2, 2256, 2257, 7, 81, 2, 2, 2257, 2258, 7, 79, 2, 2, 2258, 2259, 7, 79, 2, 2, 2259, 2260, 7, 75, 2, 2, 2260, 2261, 7, 86, 2, 2, 2261, 2262, 7, 86, 2, 2, 2262, 2263, 7, 71, 2, 2, 2263, 2264, 7, 70, 2, 2, 2264, 338, 3, 2, 2, 2, 2265, 2266, 7, 69, 2, 2, 2266, 2267, 7, 81, 2, 2, 2267, 2268, 7, 80, 2, 2, 2268, 2269, 7, 72, 2, 2, 2269, 2270, 7, 75, 2, 2, 2270, 2271, 7, 73, 2, 2, 2271, 2272, 7, 87, 2, 2, 2272, 2273, 7, 84, 2, 2, 2273, 2274, 7, 67, 2, 2, 2274, 2275, 7, 86, 2, 2, 2275, 2276, 7, 75, 2, 2, 2276, 2277, 7, 81, 2, 2, 2277, 2278, 7, 80, 2, 2, 2278, 340, 3, 2, 2, 2, 2279, 2280, 7, 69, 2, 2, 2280, 2281, 7, 81, 2, 2, 2281, 2282, 7, 80, 2, 2, 2282, 2283, 7, 80, 2, 2, 2283, 2284, 7, 71, 2, 2, 2284, 2285, 7, 69, 2, 2, 2285, 2286, 7, 86, 2, 2, 2286, 2287, 7, 75, 2, 2, 2287, 2288, 7, 81, 2, 2, 2288, 2289, 7, 80, 2, 2, 2289, 342, 3, 2, 2, 2, 2290, 2291, 7, 69, 2, 2, 2291, 2292, 7, 81, 2, 2, 2292, 2293, 7, 80, 2, 2, 2293, 2294, 7, 85, 2, 2, 2294, 2295, 7, 86, 2, 2, 2295, 2296, 7, 84, 2, 2, 2296, 2297, 7, 67, 2, 2, 2297, 2298, 7, 75, 2, 2, 2298, 2299, 7, 80, 2, 2, 2299, 2300, 7, 86, 2, 2, 2300, 2301, 7, 85, 2, 2, 2301, 344, 3, 2, 2, 2, 2302, 2303, 7, 69, 2, 2, 2303, 2304, 7, 81, 2, 2, 2304, 2305, 7, 80, 2, 2, 2305, 2306, 7, 86, 2, 2, 2306, 2307, 7, 71, 2, 2, 2307, 2308, 7, 80, 2, 2, 2308, 2309, 7, 86, 2, 2, 2309, 346, 3, 2, 2, 2, 2310, 2311, 7, 69, 2, 2, 2311, 2312, 7, 81, 2, 2, 2312, 2313, 7, 80, 2, 2, 2313, 2314, 7, 86, 2, 2, 2314, 2315, 7, 75, 2, 2, 2315, 2316, 7, 80, 2, 2, 2316, 2317, 7, 87, 2, 2, 2317, 2318, 7, 71, 2, 2, 2318, 348, 3, 2, 2, 2, 2319, 2320, 7, 69, 2, 2, 2320, 2321, 7, 81, 2, 2, 2321, 2322, 7, 80, 2, 2, 2322, 2323, 7, 88, 2, 2, 2323, 2324, 7, 71, 2, 2, 2324, 2325, 7, 84, 2, 2, 2325, 2326, 7, 85, 2, 2, 2326, 2327, 7, 75, 2, 2, 2327, 2328, 7, 81, 2, 2, 2328, 2329, 7, 80, 2, 2, 2329, 350, 3, 2, 2, 2, 2330, 2331, 7, 69, 2, 2, 2331, 2332, 7, 81, 2, 2, 2332, 2333, 7, 82, 2, 2, 2333, 2334, 7, 91, 2, 2, 2334, 352, 3, 2, 2, 2, 2335, 2336, 7, 69, 2, 2, 2336, 2337, 7, 81, 2, 2, 2337, 2338, 7, 85, 2, 2, 2338, 2339, 7, 86, 2, 2, 2339, 354, 3, 2, 2, 2, 2340, 2341, 7, 69, 2, 2, 2341, 2342, 7, 85, 2, 2, 2342, 2343, 7, 88, 2, 2, 2343, 356, 3, 2, 2, 2, 2344, 2345, 7, 69, 2, 2, 2345, 2346, 7, 87, 2, 2, 2346, 2347, 7, 84, 2, 2, 2347, 2348, 7, 85, 2, 2, 2348, 2349, 7, 81, 2, 2, 2349, 2350, 7, 84, 2, 2, 2350, 358, 3, 2, 2, 2, 2351, 2352, 7, 69, 2, 2, 2352, 2353, 7, 91, 2, 2, 2353, 2354, 7, 69, 2, 2, 2354, 2355, 7, 78, 2, 2, 2355, 2356, 7, 71, 2, 2, 2356, 360, 3, 2, 2, 2, 2357, 2358, 7, 70, 2, 2, 2358, 2359, 7, 67, 2, 2, 2359, 2360, 7, 86, 2, 2, 2360, 2361, 7, 67, 2, 2, 2361, 362, 3, 2, 2, 2, 2362, 2363, 7, 70, 2, 2, 2363, 2364, 7, 67, 2, 2, 2364, 2365, 7, 86, 2, 2, 2365, 2366, 7, 67, 2, 2, 2366, 2367, 7, 68, 2, 2, 2367, 2368, 7, 67, 2, 2, 2368, 2369, 7, 85, 2, 2, 2369, 2370, 7, 71, 2, 2, 2370, 364, 3, 2, 2, 2, 2371, 2372, 7, 70, 2, 2, 2372, 2373, 7, 67, 2, 2, 2373, 2374, 7, 91, 2, 2, 2374, 366, 3, 2, 2, 2, 2375, 2376, 7, 70, 2, 2, 2376, 2377, 7, 71, 2, 2, 2377, 2378, 7, 67, 2, 2, 2378, 2379, 7, 78, 2, 2, 2379, 2380, 7, 78, 2, 2, 2380, 2381, 7, 81, 2, 2, 2381, 2382, 7, 69, 2, 2, 2382, 2383, 7, 67, 2, 2, 2383, 2384, 7, 86, 2, 2, 2384, 2385, 7, 71, 2, 2, 2385, 368, 3, 2, 2, 2, 2386, 2387, 7, 70, 2, 2, 2387, 2388, 7, 71, 2, 2, 2388, 2389, 7, 69, 2, 2, 2389, 2390, 7, 78, 2, 2, 2390, 2391, 7, 67, 2, 2, 2391, 2392, 7, 84, 2, 2, 2392, 2393, 7, 71, 2, 2, 2393, 370, 3, 2, 2, 2, 2394, 2395, 7, 70, 2, 2, 2395, 2396, 7, 71, 2, 2, 2396, 2397, 7, 72, 2, 2, 2397, 2398, 7, 67, 2, 2, 2398, 2399, 7, 87, 2, 2, 2399, 2400, 7, 78, 2, 2, 2400, 2401, 7, 86, 2, 2, 2401, 2402, 7, 85, 2, 2, 2402, 372, 3, 2, 2, 2, 2403, 2404, 7, 70, 2, 2, 2404, 2405, 7, 71, 2, 2, 2405, 2406, 7, 72, 2, 2, 2406, 2407, 7, 71, 2, 2, 2407, 2408, 7, 84, 2, 2, 2408, 2409, 7, 84, 2, 2, 2409, 2410, 7, 71, 2, 2, 2410, 2411, 7, 70, 2, 2, 2411, 374, 3, 2, 2, 2, 2412, 2413, 7, 70, 2, 2, 2413, 2414, 7, 71, 2, 2, 2414, 2415, 7, 72, 2, 2, 2415, 2416, 7, 75, 2, 2, 2416, 2417, 7, 80, 2, 2, 2417, 2418, 7, 71, 2, 2, 2418, 2419, 7, 84, 2, 2, 2419, 376, 3, 2, 2, 2, 2420, 2421, 7, 70, 2, 2, 2421, 2422, 7, 71, 2, 2, 2422, 2423, 7, 78, 2, 2, 2423, 2424, 7, 71, 2, 2, 2424, 2425, 7, 86, 2, 2, 2425, 2426, 7, 71, 2, 2, 2426, 378, 3, 2, 2, 2, 2427, 2428, 7, 70, 2, 2, 2428, 2429, 7, 71, 2, 2, 2429, 2430, 7, 78, 2, 2, 2430, 2431, 7, 75, 2, 2, 2431, 2432, 7, 79, 2, 2, 2432, 2433, 7, 75, 2, 2, 2433, 2434, 7, 86, 2, 2, 2434, 2435, 7, 71, 2, 2, 2435, 2436, 7, 84, 2, 2, 2436, 380, 3, 2, 2, 2, 2437, 2438, 7, 70, 2, 2, 2438, 2439, 7, 71, 2, 2, 2439, 2440, 7, 78, 2, 2, 2440, 2441, 7, 75, 2, 2, 2441, 2442, 7, 79, 2, 2, 2442, 2443, 7, 75, 2, 2, 2443, 2444, 7, 86, 2, 2, 2444, 2445, 7, 71, 2, 2, 2445, 2446, 7, 84, 2, 2, 2446, 2447, 7, 85, 2, 2, 2447, 382, 3, 2, 2, 2, 2448, 2449, 7, 70, 2, 2, 2449, 2450, 7, 75, 2, 2, 2450, 2451, 7, 69, 2, 2, 2451, 2452, 7, 86, 2, 2, 2452, 2453, 7, 75, 2, 2, 2453, 2454, 7, 81, 2, 2, 2454, 2455, 7, 80, 2, 2, 2455, 2456, 7, 67, 2, 2, 2456, 2457, 7, 84, 2, 2, 2457, 2458, 7, 91, 2, 2, 2458, 384, 3, 2, 2, 2, 2459, 2460, 7, 70, 2, 2, 2460, 2461, 7, 75, 2, 2, 2461, 2462, 7, 85, 2, 2, 2462, 2463, 7, 67, 2, 2, 2463, 2464, 7, 68, 2, 2, 2464, 2465, 7, 78, 2, 2, 2465, 2466, 7, 71, 2, 2, 2466, 386, 3, 2, 2, 2, 2467, 2468, 7, 70, 2, 2, 2468, 2469, 7, 75, 2, 2, 2469, 2470, 7, 85, 2, 2, 2470, 2471, 7, 69, 2, 2, 2471, 2472, 7, 67, 2, 2, 2472, 2473, 7, 84, 2, 2, 2473, 2474, 7, 70, 2, 2, 2474, 388, 3, 2, 2, 2, 2475, 2476, 7, 70, 2, 2, 2476, 2477, 7, 81, 2, 2, 2477, 2478, 7, 69, 2, 2, 2478, 2479, 7, 87, 2, 2, 2479, 2480, 7, 79, 2, 2, 2480, 2481, 7, 71, 2, 2, 2481, 2482, 7, 80, 2, 2, 2482, 2483, 7, 86, 2, 2, 2483, 390, 3, 2, 2, 2, 2484, 2485, 7, 70, 2, 2, 2485, 2486, 7, 81, 2, 2, 2486, 2487, 7, 79, 2, 2, 2487, 2488, 7, 67, 2, 2, 2488, 2489, 7, 75, 2, 2, 2489, 2490, 7, 80, 2, 2, 2490, 392, 3, 2, 2, 2, 2491, 2492, 7, 70, 2, 2, 2492, 2493, 7, 81, 2, 2, 2493, 2494, 7, 87, 2, 2, 2494, 2495, 7, 68, 2, 2, 2495, 2496, 7, 78, 2, 2, 2496, 2497, 7, 71, 2, 2, 2497, 394, 3, 2, 2, 2, 2498, 2499, 7, 70, 2, 2, 2499, 2500, 7, 84, 2, 2, 2500, 2501, 7, 81, 2, 2, 2501, 2502, 7, 82, 2, 2, 2502, 396, 3, 2, 2, 2, 2503, 2504, 7, 71, 2, 2, 2504, 2505, 7, 67, 2, 2, 2505, 2506, 7, 69, 2, 2, 2506, 2507, 7, 74, 2, 2, 2507, 398, 3, 2, 2, 2, 2508, 2509, 7, 71, 2, 2, 2509, 2510, 7, 80, 2, 2, 2510, 2511, 7, 67, 2, 2, 2511, 2512, 7, 68, 2, 2, 2512, 2513, 7, 78, 2, 2, 2513, 2514, 7, 71, 2, 2, 2514, 400, 3, 2, 2, 2, 2515, 2516, 7, 71, 2, 2, 2516, 2517, 7, 80, 2, 2, 2517, 2518, 7, 69, 2, 2, 2518, 2519, 7, 81, 2, 2, 2519, 2520, 7, 70, 2, 2, 2520, 2521, 7, 75, 2, 2, 2521, 2522, 7, 80, 2, 2, 2522, 2523, 7, 73, 2, 2, 2523, 402, 3, 2, 2, 2, 2524, 2525, 7, 71, 2, 2, 2525, 2526, 7, 80, 2, 2, 2526, 2527, 7, 69, 2, 2, 2527, 2528, 7, 84, 2, 2, 2528, 2529, 7, 91, 2, 2, 2529, 2530, 7, 82, 2, 2, 2530, 2531, 7, 86, 2, 2, 2531, 2532, 7, 71, 2, 2, 2532, 2533, 7, 70, 2, 2, 2533, 404, 3, 2, 2, 2, 2534, 2535, 7, 71, 2, 2, 2535, 2536, 7, 80, 2, 2, 2536, 2537, 7, 87, 2, 2, 2537, 2538, 7, 79, 2, 2, 2538, 406, 3, 2, 2, 2, 2539, 2540, 7, 71, 2, 2, 2540, 2541, 7, 85, 2, 2, 2541, 2542, 7, 69, 2, 2, 2542, 2543, 7, 67, 2, 2, 2543, 2544, 7, 82, 2, 2, 2544, 2545, 7, 71, 2, 2, 2545, 408, 3, 2, 2, 2, 2546, 2547, 7, 71, 2, 2, 2547, 2548, 7, 88, 2, 2, 2548, 2549, 7, 71, 2, 2, 2549, 2550, 7, 80, 2, 2, 2550, 2551, 7, 86, 2, 2, 2551, 410, 3, 2, 2, 2, 2552, 2553, 7, 71, 2, 2, 2553, 2554, 7, 90, 2, 2, 2554, 2555, 7, 69, 2, 2, 2555, 2556, 7, 78, 2, 2, 2556, 2557, 7, 87, 2, 2, 2557, 2558, 7, 70, 2, 2, 2558, 2559, 7, 71, 2, 2, 2559, 412, 3, 2, 2, 2, 2560, 2561, 7, 71, 2, 2, 2561, 2562, 7, 90, 2, 2, 2562, 2563, 7, 69, 2, 2, 2563, 2564, 7, 78, 2, 2, 2564, 2565, 7, 87, 2, 2, 2565, 2566, 7, 70, 2, 2, 2566, 2567, 7, 75, 2, 2, 2567, 2568, 7, 80, 2, 2, 2568, 2569, 7, 73, 2, 2, 2569, 414, 3, 2, 2, 2, 2570, 2571, 7, 71, 2, 2, 2571, 2572, 7, 90, 2, 2, 2572, 2573, 7, 69, 2, 2, 2573, 2574, 7, 78, 2, 2, 2574, 2575, 7, 87, 2, 2, 2575, 2576, 7, 85, 2, 2, 2576, 2577, 7, 75, 2, 2, 2577, 2578, 7, 88, 2, 2, 2578, 2579, 7, 71, 2, 2, 2579, 416, 3, 2, 2, 2, 2580, 2581, 7, 71, 2, 2, 2581, 2582, 7, 90, 2, 2, 2582, 2583, 7, 71, 2, 2, 2583, 2584, 7, 69, 2, 2, 2584, 2585, 7, 87, 2, 2, 2585, 2586, 7, 86, 2, 2, 2586, 2587, 7, 71, 2, 2, 2587, 418, 3, 2, 2, 2, 2588, 2589, 7, 71, 2, 2, 2589, 2590, 7, 90, 2, 2, 2590, 2591, 7, 82, 2, 2, 2591, 2592, 7, 78, 2, 2, 2592, 2593, 7, 67, 2, 2, 2593, 2594, 7, 75, 2, 2, 2594, 2595, 7, 80, 2, 2, 2595, 420, 3, 2, 2, 2, 2596, 2597, 7, 71, 2, 2, 2597, 2598, 7, 90, 2, 2, 2598, 2599, 7, 86, 2, 2, 2599, 2600, 7, 71, 2, 2, 2600, 2601, 7, 80, 2, 2, 2601, 2602, 7, 85, 2, 2, 2602, 2603, 7, 75, 2, 2, 2603, 2604, 7, 81, 2, 2, 2604, 2605, 7, 80, 2, 2, 2605, 422, 3, 2, 2, 2, 2606, 2607, 7, 71, 2, 2, 2607, 2608, 7, 90, 2, 2, 2608, 2609, 7, 86, 2, 2, 2609, 2610, 7, 71, 2, 2, 2610, 2611, 7, 84, 2, 2, 2611, 2612, 7, 80, 2, 2, 2612, 2613, 7, 67, 2, 2, 2613, 2614, 7, 78, 2, 2, 2614, 424, 3, 2, 2, 2, 2615, 2616, 7, 72, 2, 2, 2616, 2617, 7, 67, 2, 2, 2617, 2618, 7, 79, 2, 2, 2618, 2619, 7, 75, 2, 2, 2619, 2620, 7, 78, 2, 2, 2620, 2621, 7, 91, 2, 2, 2621, 426, 3, 2, 2, 2, 2622, 2623, 7, 72, 2, 2, 2623, 2624, 7, 75, 2, 2, 2624, 2625, 7, 84, 2, 2, 2625, 2626, 7, 85, 2, 2, 2626, 2627, 7, 86, 2, 2, 2627, 428, 3, 2, 2, 2, 2628, 2629, 7, 72, 2, 2, 2629, 2630, 7, 81, 2, 2, 2630, 2631, 7, 78, 2, 2, 2631, 2632, 7, 78, 2, 2, 2632, 2633, 7, 81, 2, 2, 2633, 2634, 7, 89, 2, 2, 2634, 2635, 7, 75, 2, 2, 2635, 2636, 7, 80, 2, 2, 2636, 2637, 7, 73, 2, 2, 2637, 430, 3, 2, 2, 2, 2638, 2639, 7, 72, 2, 2, 2639, 2640, 7, 81, 2, 2, 2640, 2641, 7, 84, 2, 2, 2641, 2642, 7, 69, 2, 2, 2642, 2643, 7, 71, 2, 2, 2643, 432, 3, 2, 2, 2, 2644, 2645, 7, 72, 2, 2, 2645, 2646, 7, 81, 2, 2, 2646, 2647, 7, 84, 2, 2, 2647, 2648, 7, 89, 2, 2, 2648, 2649, 7, 67, 2, 2, 2649, 2650, 7, 84, 2, 2, 2650, 2651, 7, 70, 2, 2, 2651, 434, 3, 2, 2, 2, 2652, 2653, 7, 72, 2, 2, 2653, 2654, 7, 87, 2, 2, 2654, 2655, 7, 80, 2, 2, 2655, 2656, 7, 69, 2, 2, 2656, 2657, 7, 86, 2, 2, 2657, 2658, 7, 75, 2, 2, 2658, 2659, 7, 81, 2, 2, 2659, 2660, 7, 80, 2, 2, 2660, 436, 3, 2, 2, 2, 2661, 2662, 7, 72, 2, 2, 2662, 2663, 7, 87, 2, 2, 2663, 2664, 7, 80, 2, 2, 2664, 2665, 7, 69, 2, 2, 2665, 2666, 7, 86, 2, 2, 2666, 2667, 7, 75, 2, 2, 2667, 2668, 7, 81, 2, 2, 2668, 2669, 7, 80, 2, 2, 2669, 2670, 7, 85, 2, 2, 2670, 438, 3, 2, 2, 2, 2671, 2672, 7, 73, 2, 2, 2672, 2673, 7, 78, 2, 2, 2673, 2674, 7, 81, 2, 2, 2674, 2675, 7, 68, 2, 2, 2675, 2676, 7, 67, 2, 2, 2676, 2677, 7, 78, 2, 2, 2677, 440, 3, 2, 2, 2, 2678, 2679, 7, 73, 2, 2, 2679, 2680, 7, 84, 2, 2, 2680, 2681, 7, 67, 2, 2, 2681, 2682, 7, 80, 2, 2, 2682, 2683, 7, 86, 2, 2, 2683, 2684, 7, 71, 2, 2, 2684, 2685, 7, 70, 2, 2, 2685, 442, 3, 2, 2, 2, 2686, 2687, 7, 74, 2, 2, 2687, 2688, 7, 67, 2, 2, 2688, 2689, 7, 80, 2, 2, 2689, 2690, 7, 70, 2, 2, 2690, 2691, 7, 78, 2, 2, 2691, 2692, 7, 71, 2, 2, 2692, 2693, 7, 84, 2, 2, 2693, 444, 3, 2, 2, 2, 2694, 2695, 7, 74, 2, 2, 2695, 2696, 7, 71, 2, 2, 2696, 2697, 7, 67, 2, 2, 2697, 2698, 7, 70, 2, 2, 2698, 2699, 7, 71, 2, 2, 2699, 2700, 7, 84, 2, 2, 2700, 446, 3, 2, 2, 2, 2701, 2702, 7, 74, 2, 2, 2702, 2703, 7, 81, 2, 2, 2703, 2704, 7, 78, 2, 2, 2704, 2705, 7, 70, 2, 2, 2705, 448, 3, 2, 2, 2, 2706, 2707, 7, 74, 2, 2, 2707, 2708, 7, 81, 2, 2, 2708, 2709, 7, 87, 2, 2, 2709, 2710, 7, 84, 2, 2, 2710, 450, 3, 2, 2, 2, 2711, 2712, 7, 75, 2, 2, 2712, 2713, 7, 70, 2, 2, 2713, 2714, 7, 71, 2, 2, 2714, 2715, 7, 80, 2, 2, 2715, 2716, 7, 86, 2, 2, 2716, 2717, 7, 75, 2, 2, 2717, 2718, 7, 86, 2, 2, 2718, 2719, 7, 91, 2, 2, 2719, 452, 3, 2, 2, 2, 2720, 2721, 7, 75, 2, 2, 2721, 2722, 7, 72, 2, 2, 2722, 454, 3, 2, 2, 2, 2723, 2724, 7, 75, 2, 2, 2724, 2725, 7, 79, 2, 2, 2725, 2726, 7, 79, 2, 2, 2726, 2727, 7, 71, 2, 2, 2727, 2728, 7, 70, 2, 2, 2728, 2729, 7, 75, 2, 2, 2729, 2730, 7, 67, 2, 2, 2730, 2731, 7, 86, 2, 2, 2731, 2732, 7, 71, 2, 2, 2732, 456, 3, 2, 2, 2, 2733, 2734, 7, 75, 2, 2, 2734, 2735, 7, 79, 2, 2, 2735, 2736, 7, 79, 2, 2, 2736, 2737, 7, 87, 2, 2, 2737, 2738, 7, 86, 2, 2, 2738, 2739, 7, 67, 2, 2, 2739, 2740, 7, 68, 2, 2, 2740, 2741, 7, 78, 2, 2, 2741, 2742, 7, 71, 2, 2, 2742, 458, 3, 2, 2, 2, 2743, 2744, 7, 75, 2, 2, 2744, 2745, 7, 79, 2, 2, 2745, 2746, 7, 82, 2, 2, 2746, 2747, 7, 78, 2, 2, 2747, 2748, 7, 75, 2, 2, 2748, 2749, 7, 69, 2, 2, 2749, 2750, 7, 75, 2, 2, 2750, 2751, 7, 86, 2, 2, 2751, 460, 3, 2, 2, 2, 2752, 2753, 7, 75, 2, 2, 2753, 2754, 7, 80, 2, 2, 2754, 2755, 7, 69, 2, 2, 2755, 2756, 7, 78, 2, 2, 2756, 2757, 7, 87, 2, 2, 2757, 2758, 7, 70, 2, 2, 2758, 2759, 7, 75, 2, 2, 2759, 2760, 7, 80, 2, 2, 2760, 2761, 7, 73, 2, 2, 2761, 462, 3, 2, 2, 2, 2762, 2763, 7, 75, 2, 2, 2763, 2764, 7, 80, 2, 2, 2764, 2765, 7, 69, 2, 2, 2765, 2766, 7, 84, 2, 2, 2766, 2767, 7, 71, 2, 2, 2767, 2768, 7, 79, 2, 2, 2768, 2769, 7, 71, 2, 2, 2769, 2770, 7, 80, 2, 2, 2770, 2771, 7, 86, 2, 2, 2771, 464, 3, 2, 2, 2, 2772, 2773, 7, 75, 2, 2, 2773, 2774, 7, 80, 2, 2, 2774, 2775, 7, 70, 2, 2, 2775, 2776, 7, 71, 2, 2, 2776, 2777, 7, 90, 2, 2, 2777, 466, 3, 2, 2, 2, 2778, 2779, 7, 75, 2, 2, 2779, 2780, 7, 80, 2, 2, 2780, 2781, 7, 70, 2, 2, 2781, 2782, 7, 71, 2, 2, 2782, 2783, 7, 90, 2, 2, 2783, 2784, 7, 71, 2, 2, 2784, 2785, 7, 85, 2, 2, 2785, 468, 3, 2, 2, 2, 2786, 2787, 7, 75, 2, 2, 2787, 2788, 7, 80, 2, 2, 2788, 2789, 7, 74, 2, 2, 2789, 2790, 7, 71, 2, 2, 2790, 2791, 7, 84, 2, 2, 2791, 2792, 7, 75, 2, 2, 2792, 2793, 7, 86, 2, 2, 2793, 470, 3, 2, 2, 2, 2794, 2795, 7, 80, 2, 2, 2795, 2796, 7, 81, 2, 2, 2796, 2797, 7, 75, 2, 2, 2797, 2798, 7, 80, 2, 2, 2798, 2799, 7, 74, 2, 2, 2799, 2800, 7, 71, 2, 2, 2800, 2801, 7, 84, 2, 2, 2801, 2802, 7, 75, 2, 2, 2802, 2803, 7, 86, 2, 2, 2803, 472, 3, 2, 2, 2, 2804, 2805, 7, 85, 2, 2, 2805, 2806, 7, 87, 2, 2, 2806, 2807, 7, 82, 2, 2, 2807, 2808, 7, 71, 2, 2, 2808, 2809, 7, 84, 2, 2, 2809, 2810, 7, 87, 2, 2, 2810, 2811, 7, 85, 2, 2, 2811, 2812, 7, 71, 2, 2, 2812, 2813, 7, 84, 2, 2, 2813, 474, 3, 2, 2, 2, 2814, 2815, 7, 80, 2, 2, 2815, 2816, 7, 81, 2, 2, 2816, 2817, 7, 85, 2, 2, 2817, 2818, 7, 87, 2, 2, 2818, 2819, 7, 82, 2, 2, 2819, 2820, 7, 71, 2, 2, 2820, 2821, 7, 84, 2, 2, 2821, 2822, 7, 87, 2, 2, 2822, 2823, 7, 85, 2, 2, 2823, 2824, 7, 71, 2, 2, 2824, 2825, 7, 84, 2, 2, 2825, 476, 3, 2, 2, 2, 2826, 2827, 7, 69, 2, 2, 2827, 2828, 7, 84, 2, 2, 2828, 2829, 7, 71, 2, 2, 2829, 2830, 7, 67, 2, 2, 2830, 2831, 7, 86, 2, 2, 2831, 2832, 7, 71, 2, 2, 2832, 2833, 7, 70, 2, 2, 2833, 2834, 7, 68, 2, 2, 2834, 478, 3, 2, 2, 2, 2835, 2836, 7, 80, 2, 2, 2836, 2837, 7, 81, 2, 2, 2837, 2838, 7, 69, 2, 2, 2838, 2839, 7, 84, 2, 2, 2839, 2840, 7, 71, 2, 2, 2840, 2841, 7, 67, 2, 2, 2841, 2842, 7, 86, 2, 2, 2842, 2843, 7, 71, 2, 2, 2843, 2844, 7, 70, 2, 2, 2844, 2845, 7, 68, 2, 2, 2845, 480, 3, 2, 2, 2, 2846, 2847, 7, 69, 2, 2, 2847, 2848, 7, 84, 2, 2, 2848, 2849, 7, 71, 2, 2, 2849, 2850, 7, 67, 2, 2, 2850, 2851, 7, 86, 2, 2, 2851, 2852, 7, 71, 2, 2, 2852, 2853, 7, 84, 2, 2, 2853, 2854, 7, 81, 2, 2, 2854, 2855, 7, 78, 2, 2, 2855, 2856, 7, 71, 2, 2, 2856, 482, 3, 2, 2, 2, 2857, 2858, 7, 80, 2, 2, 2858, 2859, 7, 81, 2, 2, 2859, 2860, 7, 69, 2, 2, 2860, 2861, 7, 84, 2, 2, 2861, 2862, 7, 71, 2, 2, 2862, 2863, 7, 67, 2, 2, 2863, 2864, 7, 86, 2, 2, 2864, 2865, 7, 71, 2, 2, 2865, 2866, 7, 84, 2, 2, 2866, 2867, 7, 81, 2, 2, 2867, 2868, 7, 78, 2, 2, 2868, 2869, 7, 71, 2, 2, 2869, 484, 3, 2, 2, 2, 2870, 2871, 7, 69, 2, 2, 2871, 2872, 7, 84, 2, 2, 2872, 2873, 7, 71, 2, 2, 2873, 2874, 7, 67, 2, 2, 2874, 2875, 7, 86, 2, 2, 2875, 2876, 7, 71, 2, 2, 2876, 2877, 7, 87, 2, 2, 2877, 2878, 7, 85, 2, 2, 2878, 2879, 7, 71, 2, 2, 2879, 2880, 7, 84, 2, 2, 2880, 486, 3, 2, 2, 2, 2881, 2882, 7, 80, 2, 2, 2882, 2883, 7, 81, 2, 2, 2883, 2884, 7, 69, 2, 2, 2884, 2885, 7, 84, 2, 2, 2885, 2886, 7, 71, 2, 2, 2886, 2887, 7, 67, 2, 2, 2887, 2888, 7, 86, 2, 2, 2888, 2889, 7, 71, 2, 2, 2889, 2890, 7, 87, 2, 2, 2890, 2891, 7, 85, 2, 2, 2891, 2892, 7, 71, 2, 2, 2892, 2893, 7, 84, 2, 2, 2893, 488, 3, 2, 2, 2, 2894, 2895, 7, 75, 2, 2, 2895, 2896, 7, 80, 2, 2, 2896, 2897, 7, 74, 2, 2, 2897, 2898, 7, 71, 2, 2, 2898, 2899, 7, 84, 2, 2, 2899, 2900, 7, 75, 2, 2, 2900, 2901, 7, 86, 2, 2, 2901, 2902, 7, 85, 2, 2, 2902, 490, 3, 2, 2, 2, 2903, 2904, 7, 75, 2, 2, 2904, 2905, 7, 80, 2, 2, 2905, 2906, 7, 78, 2, 2, 2906, 2907, 7, 75, 2, 2, 2907, 2908, 7, 80, 2, 2, 2908, 2909, 7, 71, 2, 2, 2909, 492, 3, 2, 2, 2, 2910, 2911, 7, 75, 2, 2, 2911, 2912, 7, 80, 2, 2, 2912, 2913, 7, 85, 2, 2, 2913, 2914, 7, 71, 2, 2, 2914, 2915, 7, 80, 2, 2, 2915, 2916, 7, 85, 2, 2, 2916, 2917, 7, 75, 2, 2, 2917, 2918, 7, 86, 2, 2, 2918, 2919, 7, 75, 2, 2, 2919, 2920, 7, 88, 2, 2, 2920, 2921, 7, 71, 2, 2, 2921, 494, 3, 2, 2, 2, 2922, 2923, 7, 75, 2, 2, 2923, 2924, 7, 80, 2, 2, 2924, 2925, 7, 85, 2, 2, 2925, 2926, 7, 71, 2, 2, 2926, 2927, 7, 84, 2, 2, 2927, 2928, 7, 86, 2, 2, 2928, 496, 3, 2, 2, 2, 2929, 2930, 7, 75, 2, 2, 2930, 2931, 7, 80, 2, 2, 2931, 2932, 7, 85, 2, 2, 2932, 2933, 7, 86, 2, 2, 2933, 2934, 7, 71, 2, 2, 2934, 2935, 7, 67, 2, 2, 2935, 2936, 7, 70, 2, 2, 2936, 498, 3, 2, 2, 2, 2937, 2938, 7, 75, 2, 2, 2938, 2939, 7, 80, 2, 2, 2939, 2940, 7, 88, 2, 2, 2940, 2941, 7, 81, 2, 2, 2941, 2942, 7, 77, 2, 2, 2942, 2943, 7, 71, 2, 2, 2943, 2944, 7, 84, 2, 2, 2944, 500, 3, 2, 2, 2, 2945, 2946, 7, 75, 2, 2, 2946, 2947, 7, 85, 2, 2, 2947, 2948, 7, 81, 2, 2, 2948, 2949, 7, 78, 2, 2, 2949, 2950, 7, 67, 2, 2, 2950, 2951, 7, 86, 2, 2, 2951, 2952, 7, 75, 2, 2, 2952, 2953, 7, 81, 2, 2, 2953, 2954, 7, 80, 2, 2, 2954, 502, 3, 2, 2, 2, 2955, 2956, 7, 77, 2, 2, 2956, 2957, 7, 71, 2, 2, 2957, 2958, 7, 91, 2, 2, 2958, 504, 3, 2, 2, 2, 2959, 2960, 7, 78, 2, 2, 2960, 2961, 7, 67, 2, 2, 2961, 2962, 7, 68, 2, 2, 2962, 2963, 7, 71, 2, 2, 2963, 2964, 7, 78, 2, 2, 2964, 506, 3, 2, 2, 2, 2965, 2966, 7, 78, 2, 2, 2966, 2967, 7, 67, 2, 2, 2967, 2968, 7, 80, 2, 2, 2968, 2969, 7, 73, 2, 2, 2969, 2970, 7, 87, 2, 2, 2970, 2971, 7, 67, 2, 2, 2971, 2972, 7, 73, 2, 2, 2972, 2973, 7, 71, 2, 2, 2973, 508, 3, 2, 2, 2, 2974, 2975, 7, 78, 2, 2, 2975, 2976, 7, 67, 2, 2, 2976, 2977, 7, 84, 2, 2, 2977, 2978, 7, 73, 2, 2, 2978, 2979, 7, 71, 2, 2, 2979, 510, 3, 2, 2, 2, 2980, 2981, 7, 78, 2, 2, 2981, 2982, 7, 67, 2, 2, 2982, 2983, 7, 85, 2, 2, 2983, 2984, 7, 86, 2, 2, 2984, 512, 3, 2, 2, 2, 2985, 2986, 7, 78, 2, 2, 2986, 2987, 7, 71, 2, 2, 2987, 2988, 7, 67, 2, 2, 2988, 2989, 7, 77, 2, 2, 2989, 2990, 7, 82, 2, 2, 2990, 2991, 7, 84, 2, 2, 2991, 2992, 7, 81, 2, 2, 2992, 2993, 7, 81, 2, 2, 2993, 2994, 7, 72, 2, 2, 2994, 514, 3, 2, 2, 2, 2995, 2996, 7, 78, 2, 2, 2996, 2997, 7, 71, 2, 2, 2997, 2998, 7, 88, 2, 2, 2998, 2999, 7, 71, 2, 2, 2999, 3000, 7, 78, 2, 2, 3000, 516, 3, 2, 2, 2, 3001, 3002, 7, 78, 2, 2, 3002, 3003, 7, 75, 2, 2, 3003, 3004, 7, 85, 2, 2, 3004, 3005, 7, 86, 2, 2, 3005, 3006, 7, 71, 2, 2, 3006, 3007, 7, 80, 2, 2, 3007, 518, 3, 2, 2, 2, 3008, 3009, 7, 78, 2, 2, 3009, 3010, 7, 81, 2, 2, 3010, 3011, 7, 67, 2, 2, 3011, 3012, 7, 70, 2, 2, 3012, 520, 3, 2, 2, 2, 3013, 3014, 7, 78, 2, 2, 3014, 3015, 7, 81, 2, 2, 3015, 3016, 7, 69, 2, 2, 3016, 3017, 7, 67, 2, 2, 3017, 3018, 7, 78, 2, 2, 3018, 522, 3, 2, 2, 2, 3019, 3020, 7, 78, 2, 2, 3020, 3021, 7, 81, 2, 2, 3021, 3022, 7, 69, 2, 2, 3022, 3023, 7, 67, 2, 2, 3023, 3024, 7, 86, 2, 2, 3024, 3025, 7, 75, 2, 2, 3025, 3026, 7, 81, 2, 2, 3026, 3027, 7, 80, 2, 2, 3027, 524, 3, 2, 2, 2, 3028, 3029, 7, 78, 2, 2, 3029, 3030, 7, 81, 2, 2, 3030, 3031, 7, 69, 2, 2, 3031, 3032, 7, 77, 2, 2, 3032, 526, 3, 2, 2, 2, 3033, 3034, 7, 79, 2, 2, 3034, 3035, 7, 67, 2, 2, 3035, 3036, 7, 82, 2, 2, 3036, 3037, 7, 82, 2, 2, 3037, 3038, 7, 75, 2, 2, 3038, 3039, 7, 80, 2, 2, 3039, 3040, 7, 73, 2, 2, 3040, 528, 3, 2, 2, 2, 3041, 3042, 7, 79, 2, 2, 3042, 3043, 7, 67, 2, 2, 3043, 3044, 7, 86, 2, 2, 3044, 3045, 7, 69, 2, 2, 3045, 3046, 7, 74, 2, 2, 3046, 530, 3, 2, 2, 2, 3047, 3048, 7, 79, 2, 2, 3048, 3049, 7, 67, 2, 2, 3049, 3050, 7, 86, 2, 2, 3050, 3051, 7, 71, 2, 2, 3051, 3052, 7, 84, 2, 2, 3052, 3053, 7, 75, 2, 2, 3053, 3054, 7, 67, 2, 2, 3054, 3055, 7, 78, 2, 2, 3055, 3056, 7, 75, 2, 2, 3056, 3057, 7, 92, 2, 2, 3057, 3058, 7, 71, 2, 2, 3058, 3059, 7, 70, 2, 2, 3059, 532, 3, 2, 2, 2, 3060, 3061, 7, 79, 2, 2, 3061, 3062, 7, 67, 2, 2, 3062, 3063, 7, 90, 2, 2, 3063, 3064, 7, 88, 2, 2, 3064, 3065, 7, 67, 2, 2, 3065, 3066, 7, 78, 2, 2, 3066, 3067, 7, 87, 2, 2, 3067, 3068, 7, 71, 2, 2, 3068, 534, 3, 2, 2, 2, 3069, 3070, 7, 79, 2, 2, 3070, 3071, 7, 75, 2, 2, 3071, 3072, 7, 80, 2, 2, 3072, 3073, 7, 87, 2, 2, 3073, 3074, 7, 86, 2, 2, 3074, 3075, 7, 71, 2, 2, 3075, 536, 3, 2, 2, 2, 3076, 3077, 7, 79, 2, 2, 3077, 3078, 7, 75, 2, 2, 3078, 3079, 7, 80, 2, 2, 3079, 3080, 7, 88, 2, 2, 3080, 3081, 7, 67, 2, 2, 3081, 3082, 7, 78, 2, 2, 3082, 3083, 7, 87, 2, 2, 3083, 3084, 7, 71, 2, 2, 3084, 538, 3, 2, 2, 2, 3085, 3086, 7, 79, 2, 2, 3086, 3087, 7, 81, 2, 2, 3087, 3088, 7, 70, 2, 2, 3088, 3089, 7, 71, 2, 2, 3089, 540, 3, 2, 2, 2, 3090, 3091, 7, 79, 2, 2, 3091, 3092, 7, 81, 2, 2, 3092, 3093, 7, 80, 2, 2, 3093, 3094, 7, 86, 2, 2, 3094, 3095, 7, 74, 2, 2, 3095, 542, 3, 2, 2, 2, 3096, 3097, 7, 79, 2, 2, 3097, 3098, 7, 81, 2, 2, 3098, 3099, 7, 88, 2, 2, 3099, 3100, 7, 71, 2, 2, 3100, 544, 3, 2, 2, 2, 3101, 3102, 7, 80, 2, 2, 3102, 3103, 7, 67, 2, 2, 3103, 3104, 7, 79, 2, 2, 3104, 3105, 7, 71, 2, 2, 3105, 546, 3, 2, 2, 2, 3106, 3107, 7, 80, 2, 2, 3107, 3108, 7, 67, 2, 2, 3108, 3109, 7, 79, 2, 2, 3109, 3110, 7, 71, 2, 2, 3110, 3111, 7, 85, 2, 2, 3111, 548, 3, 2, 2, 2, 3112, 3113, 7, 80, 2, 2, 3113, 3114, 7, 71, 2, 2, 3114, 3115, 7, 90, 2, 2, 3115, 3116, 7, 86, 2, 2, 3116, 550, 3, 2, 2, 2, 3117, 3118, 7, 80, 2, 2, 3118, 3119, 7, 81, 2, 2, 3119, 552, 3, 2, 2, 2, 3120, 3121, 7, 80, 2, 2, 3121, 3122, 7, 81, 2, 2, 3122, 3123, 7, 86, 2, 2, 3123, 3124, 7, 74, 2, 2, 3124, 3125, 7, 75, 2, 2, 3125, 3126, 7, 80, 2, 2, 3126, 3127, 7, 73, 2, 2, 3127, 554, 3, 2, 2, 2, 3128, 3129, 7, 80, 2, 2, 3129, 3130, 7, 81, 2, 2, 3130, 3131, 7, 86, 2, 2, 3131, 3132, 7, 75, 2, 2, 3132, 3133, 7, 72, 2, 2, 3133, 3134, 7, 91, 2, 2, 3134, 556, 3, 2, 2, 2, 3135, 3136, 7, 80, 2, 2, 3136, 3137, 7, 81, 2, 2, 3137, 3138, 7, 89, 2, 2, 3138, 3139, 7, 67, 2, 2, 3139, 3140, 7, 75, 2, 2, 3140, 3141, 7, 86, 2, 2, 3141, 558, 3, 2, 2, 2, 3142, 3143, 7, 80, 2, 2, 3143, 3144, 7, 87, 2, 2, 3144, 3145, 7, 78, 2, 2, 3145, 3146, 7, 78, 2, 2, 3146, 3147, 7, 85, 2, 2, 3147, 560, 3, 2, 2, 2, 3148, 3149, 7, 81, 2, 2, 3149, 3150, 7, 68, 2, 2, 3150, 3151, 7, 76, 2, 2, 3151, 3152, 7, 71, 2, 2, 3152, 3153, 7, 69, 2, 2, 3153, 3154, 7, 86, 2, 2, 3154, 562, 3, 2, 2, 2, 3155, 3156, 7, 81, 2, 2, 3156, 3157, 7, 72, 2, 2, 3157, 564, 3, 2, 2, 2, 3158, 3159, 7, 81, 2, 2, 3159, 3160, 7, 72, 2, 2, 3160, 3161, 7, 72, 2, 2, 3161, 566, 3, 2, 2, 2, 3162, 3163, 7, 81, 2, 2, 3163, 3164, 7, 75, 2, 2, 3164, 3165, 7, 70, 2, 2, 3165, 3166, 7, 85, 2, 2, 3166, 568, 3, 2, 2, 2, 3167, 3168, 7, 81, 2, 2, 3168, 3169, 7, 82, 2, 2, 3169, 3170, 7, 71, 2, 2, 3170, 3171, 7, 84, 2, 2, 3171, 3172, 7, 67, 2, 2, 3172, 3173, 7, 86, 2, 2, 3173, 3174, 7, 81, 2, 2, 3174, 3175, 7, 84, 2, 2, 3175, 570, 3, 2, 2, 2, 3176, 3177, 7, 81, 2, 2, 3177, 3178, 7, 82, 2, 2, 3178, 3179, 7, 86, 2, 2, 3179, 3180, 7, 75, 2, 2, 3180, 3181, 7, 81, 2, 2, 3181, 3182, 7, 80, 2, 2, 3182, 572, 3, 2, 2, 2, 3183, 3184, 7, 81, 2, 2, 3184, 3185, 7, 82, 2, 2, 3185, 3186, 7, 86, 2, 2, 3186, 3187, 7, 75, 2, 2, 3187, 3188, 7, 81, 2, 2, 3188, 3189, 7, 80, 2, 2, 3189, 3190, 7, 85, 2, 2, 3190, 574, 3, 2, 2, 2, 3191, 3192, 7, 81, 2, 2, 3192, 3193, 7, 89, 2, 2, 3193, 3194, 7, 80, 2, 2, 3194, 3195, 7, 71, 2, 2, 3195, 3196, 7, 70, 2, 2, 3196, 576, 3, 2, 2, 2, 3197, 3198, 7, 81, 2, 2, 3198, 3199, 7, 89, 2, 2, 3199, 3200, 7, 80, 2, 2, 3200, 3201, 7, 71, 2, 2, 3201, 3202, 7, 84, 2, 2, 3202, 578, 3, 2, 2, 2, 3203, 3204, 7, 82, 2, 2, 3204, 3205, 7, 67, 2, 2, 3205, 3206, 7, 84, 2, 2, 3206, 3207, 7, 85, 2, 2, 3207, 3208, 7, 71, 2, 2, 3208, 3209, 7, 84, 2, 2, 3209, 580, 3, 2, 2, 2, 3210, 3211, 7, 82, 2, 2, 3211, 3212, 7, 67, 2, 2, 3212, 3213, 7, 84, 2, 2, 3213, 3214, 7, 86, 2, 2, 3214, 3215, 7, 75, 2, 2, 3215, 3216, 7, 67, 2, 2, 3216, 3217, 7, 78, 2, 2, 3217, 582, 3, 2, 2, 2, 3218, 3219, 7, 82, 2, 2, 3219, 3220, 7, 67, 2, 2, 3220, 3221, 7, 84, 2, 2, 3221, 3222, 7, 86, 2, 2, 3222, 3223, 7, 75, 2, 2, 3223, 3224, 7, 86, 2, 2, 3224, 3225, 7, 75, 2, 2, 3225, 3226, 7, 81, 2, 2, 3226, 3227, 7, 80, 2, 2, 3227, 584, 3, 2, 2, 2, 3228, 3229, 7, 82, 2, 2, 3229, 3230, 7, 67, 2, 2, 3230, 3231, 7, 85, 2, 2, 3231, 3232, 7, 85, 2, 2, 3232, 3233, 7, 75, 2, 2, 3233, 3234, 7, 80, 2, 2, 3234, 3235, 7, 73, 2, 2, 3235, 586, 3, 2, 2, 2, 3236, 3237, 7, 82, 2, 2, 3237, 3238, 7, 67, 2, 2, 3238, 3239, 7, 85, 2, 2, 3239, 3240, 7, 85, 2, 2, 3240, 3241, 7, 89, 2, 2, 3241, 3242, 7, 81, 2, 2, 3242, 3243, 7, 84, 2, 2, 3243, 3244, 7, 70, 2, 2, 3244, 588, 3, 2, 2, 2, 3245, 3246, 7, 82, 2, 2, 3246, 3247, 7, 78, 2, 2, 3247, 3248, 7, 67, 2, 2, 3248, 3249, 7, 80, 2, 2, 3249, 3250, 7, 85, 2, 2, 3250, 590, 3, 2, 2, 2, 3251, 3252, 7, 82, 2, 2, 3252, 3253, 7, 84, 2, 2, 3253, 3254, 7, 71, 2, 2, 3254, 3255, 7, 69, 2, 2, 3255, 3256, 7, 71, 2, 2, 3256, 3257, 7, 70, 2, 2, 3257, 3258, 7, 75, 2, 2, 3258, 3259, 7, 80, 2, 2, 3259, 3260, 7, 73, 2, 2, 3260, 592, 3, 2, 2, 2, 3261, 3262, 7, 82, 2, 2, 3262, 3263, 7, 84, 2, 2, 3263, 3264, 7, 71, 2, 2, 3264, 3265, 7, 82, 2, 2, 3265, 3266, 7, 67, 2, 2, 3266, 3267, 7, 84, 2, 2, 3267, 3268, 7, 71, 2, 2, 3268, 594, 3, 2, 2, 2, 3269, 3270, 7, 82, 2, 2, 3270, 3271, 7, 84, 2, 2, 3271, 3272, 7, 71, 2, 2, 3272, 3273, 7, 82, 2, 2, 3273, 3274, 7, 67, 2, 2, 3274, 3275, 7, 84, 2, 2, 3275, 3276, 7, 71, 2, 2, 3276, 3277, 7, 70, 2, 2, 3277, 596, 3, 2, 2, 2, 3278, 3279, 7, 82, 2, 2, 3279, 3280, 7, 84, 2, 2, 3280, 3281, 7, 71, 2, 2, 3281, 3282, 7, 85, 2, 2, 3282, 3283, 7, 71, 2, 2, 3283, 3284, 7, 84, 2, 2, 3284, 3285, 7, 88, 2, 2, 3285, 3286, 7, 71, 2, 2, 3286, 598, 3, 2, 2, 2, 3287, 3288, 7, 82, 2, 2, 3288, 3289, 7, 84, 2, 2, 3289, 3290, 7, 75, 2, 2, 3290, 3291, 7, 81, 2, 2, 3291, 3292, 7, 84, 2, 2, 3292, 600, 3, 2, 2, 2, 3293, 3294, 7, 82, 2, 2, 3294, 3295, 7, 84, 2, 2, 3295, 3296, 7, 75, 2, 2, 3296, 3297, 7, 88, 2, 2, 3297, 3298, 7, 75, 2, 2, 3298, 3299, 7, 78, 2, 2, 3299, 3300, 7, 71, 2, 2, 3300, 3301, 7, 73, 2, 2, 3301, 3302, 7, 71, 2, 2, 3302, 3303, 7, 85, 2, 2, 3303, 602, 3, 2, 2, 2, 3304, 3305, 7, 82, 2, 2, 3305, 3306, 7, 84, 2, 2, 3306, 3307, 7, 81, 2, 2, 3307, 3308, 7, 69, 2, 2, 3308, 3309, 7, 71, 2, 2, 3309, 3310, 7, 70, 2, 2, 3310, 3311, 7, 87, 2, 2, 3311, 3312, 7, 84, 2, 2, 3312, 3313, 7, 67, 2, 2, 3313, 3314, 7, 78, 2, 2, 3314, 604, 3, 2, 2, 2, 3315, 3316, 7, 82, 2, 2, 3316, 3317, 7, 84, 2, 2, 3317, 3318, 7, 81, 2, 2, 3318, 3319, 7, 69, 2, 2, 3319, 3320, 7, 71, 2, 2, 3320, 3321, 7, 70, 2, 2, 3321, 3322, 7, 87, 2, 2, 3322, 3323, 7, 84, 2, 2, 3323, 3324, 7, 71, 2, 2, 3324, 606, 3, 2, 2, 2, 3325, 3326, 7, 82, 2, 2, 3326, 3327, 7, 84, 2, 2, 3327, 3328, 7, 81, 2, 2, 3328, 3329, 7, 73, 2, 2, 3329, 3330, 7, 84, 2, 2, 3330, 3331, 7, 67, 2, 2, 3331, 3332, 7, 79, 2, 2, 3332, 608, 3, 2, 2, 2, 3333, 3334, 7, 83, 2, 2, 3334, 3335, 7, 87, 2, 2, 3335, 3336, 7, 81, 2, 2, 3336, 3337, 7, 86, 2, 2, 3337, 3338, 7, 71, 2, 2, 3338, 610, 3, 2, 2, 2, 3339, 3340, 7, 84, 2, 2, 3340, 3341, 7, 67, 2, 2, 3341, 3342, 7, 80, 2, 2, 3342, 3343, 7, 73, 2, 2, 3343, 3344, 7, 71, 2, 2, 3344, 612, 3, 2, 2, 2, 3345, 3346, 7, 84, 2, 2, 3346, 3347, 7, 71, 2, 2, 3347, 3348, 7, 67, 2, 2, 3348, 3349, 7, 70, 2, 2, 3349, 614, 3, 2, 2, 2, 3350, 3351, 7, 84, 2, 2, 3351, 3352, 7, 71, 2, 2, 3352, 3353, 7, 67, 2, 2, 3353, 3354, 7, 85, 2, 2, 3354, 3355, 7, 85, 2, 2, 3355, 3356, 7, 75, 2, 2, 3356, 3357, 7, 73, 2, 2, 3357, 3358, 7, 80, 2, 2, 3358, 616, 3, 2, 2, 2, 3359, 3360, 7, 84, 2, 2, 3360, 3361, 7, 71, 2, 2, 3361, 3362, 7, 69, 2, 2, 3362, 3363, 7, 74, 2, 2, 3363, 3364, 7, 71, 2, 2, 3364, 3365, 7, 69, 2, 2, 3365, 3366, 7, 77, 2, 2, 3366, 618, 3, 2, 2, 2, 3367, 3368, 7, 84, 2, 2, 3368, 3369, 7, 71, 2, 2, 3369, 3370, 7, 69, 2, 2, 3370, 3371, 7, 87, 2, 2, 3371, 3372, 7, 84, 2, 2, 3372, 3373, 7, 85, 2, 2, 3373, 3374, 7, 75, 2, 2, 3374, 3375, 7, 88, 2, 2, 3375, 3376, 7, 71, 2, 2, 3376, 620, 3, 2, 2, 2, 3377, 3378, 7, 84, 2, 2, 3378, 3379, 7, 71, 2, 2, 3379, 3380, 7, 72, 2, 2, 3380, 622, 3, 2, 2, 2, 3381, 3382, 7, 84, 2, 2, 3382, 3383, 7, 71, 2, 2, 3383, 3384, 7, 72, 2, 2, 3384, 3385, 7, 84, 2, 2, 3385, 3386, 7, 71, 2, 2, 3386, 3387, 7, 85, 2, 2, 3387, 3388, 7, 74, 2, 2, 3388, 624, 3, 2, 2, 2, 3389, 3390, 7, 84, 2, 2, 3390, 3391, 7, 71, 2, 2, 3391, 3392, 7, 75, 2, 2, 3392, 3393, 7, 80, 2, 2, 3393, 3394, 7, 70, 2, 2, 3394, 3395, 7, 71, 2, 2, 3395, 3396, 7, 90, 2, 2, 3396, 626, 3, 2, 2, 2, 3397, 3398, 7, 84, 2, 2, 3398, 3399, 7, 71, 2, 2, 3399, 3400, 7, 78, 2, 2, 3400, 3401, 7, 67, 2, 2, 3401, 3402, 7, 86, 2, 2, 3402, 3403, 7, 75, 2, 2, 3403, 3404, 7, 88, 2, 2, 3404, 3405, 7, 71, 2, 2, 3405, 628, 3, 2, 2, 2, 3406, 3407, 7, 84, 2, 2, 3407, 3408, 7, 71, 2, 2, 3408, 3409, 7, 78, 2, 2, 3409, 3410, 7, 71, 2, 2, 3410, 3411, 7, 67, 2, 2, 3411, 3412, 7, 85, 2, 2, 3412, 3413, 7, 71, 2, 2, 3413, 630, 3, 2, 2, 2, 3414, 3415, 7, 84, 2, 2, 3415, 3416, 7, 71, 2, 2, 3416, 3417, 7, 80, 2, 2, 3417, 3418, 7, 67, 2, 2, 3418, 3419, 7, 79, 2, 2, 3419, 3420, 7, 71, 2, 2, 3420, 632, 3, 2, 2, 2, 3421, 3422, 7, 84, 2, 2, 3422, 3423, 7, 71, 2, 2, 3423, 3424, 7, 82, 2, 2, 3424, 3425, 7, 71, 2, 2, 3425, 3426, 7, 67, 2, 2, 3426, 3427, 7, 86, 2, 2, 3427, 3428, 7, 67, 2, 2, 3428, 3429, 7, 68, 2, 2, 3429, 3430, 7, 78, 2, 2, 3430, 3431, 7, 71, 2, 2, 3431, 634, 3, 2, 2, 2, 3432, 3433, 7, 84, 2, 2, 3433, 3434, 7, 71, 2, 2, 3434, 3435, 7, 82, 2, 2, 3435, 3436, 7, 78, 2, 2, 3436, 3437, 7, 67, 2, 2, 3437, 3438, 7, 69, 2, 2, 3438, 3439, 7, 71, 2, 2, 3439, 636, 3, 2, 2, 2, 3440, 3441, 7, 84, 2, 2, 3441, 3442, 7, 71, 2, 2, 3442, 3443, 7, 82, 2, 2, 3443, 3444, 7, 78, 2, 2, 3444, 3445, 7, 75, 2, 2, 3445, 3446, 7, 69, 2, 2, 3446, 3447, 7, 67, 2, 2, 3447, 638, 3, 2, 2, 2, 3448, 3449, 7, 84, 2, 2, 3449, 3450, 7, 71, 2, 2, 3450, 3451, 7, 85, 2, 2, 3451, 3452, 7, 71, 2, 2, 3452, 3453, 7, 86, 2, 2, 3453, 640, 3, 2, 2, 2, 3454, 3455, 7, 84, 2, 2, 3455, 3456, 7, 71, 2, 2, 3456, 3457, 7, 85, 2, 2, 3457, 3458, 7, 86, 2, 2, 3458, 3459, 7, 67, 2, 2, 3459, 3460, 7, 84, 2, 2, 3460, 3461, 7, 86, 2, 2, 3461, 642, 3, 2, 2, 2, 3462, 3463, 7, 84, 2, 2, 3463, 3464, 7, 71, 2, 2, 3464, 3465, 7, 85, 2, 2, 3465, 3466, 7, 86, 2, 2, 3466, 3467, 7, 84, 2, 2, 3467, 3468, 7, 75, 2, 2, 3468, 3469, 7, 69, 2, 2, 3469, 3470, 7, 86, 2, 2, 3470, 644, 3, 2, 2, 2, 3471, 3472, 7, 84, 2, 2, 3472, 3473, 7, 71, 2, 2, 3473, 3474, 7, 86, 2, 2, 3474, 3475, 7, 87, 2, 2, 3475, 3476, 7, 84, 2, 2, 3476, 3477, 7, 80, 2, 2, 3477, 3478, 7, 85, 2, 2, 3478, 646, 3, 2, 2, 2, 3479, 3480, 7, 84, 2, 2, 3480, 3481, 7, 71, 2, 2, 3481, 3482, 7, 88, 2, 2, 3482, 3483, 7, 81, 2, 2, 3483, 3484, 7, 77, 2, 2, 3484, 3485, 7, 71, 2, 2, 3485, 648, 3, 2, 2, 2, 3486, 3487, 7, 84, 2, 2, 3487, 3488, 7, 81, 2, 2, 3488, 3489, 7, 78, 2, 2, 3489, 3490, 7, 71, 2, 2, 3490, 650, 3, 2, 2, 2, 3491, 3492, 7, 84, 2, 2, 3492, 3493, 7, 81, 2, 2, 3493, 3494, 7, 78, 2, 2, 3494, 3495, 7, 78, 2, 2, 3495, 3496, 7, 68, 2, 2, 3496, 3497, 7, 67, 2, 2, 3497, 3498, 7, 69, 2, 2, 3498, 3499, 7, 77, 2, 2, 3499, 652, 3, 2, 2, 2, 3500, 3501, 7, 84, 2, 2, 3501, 3502, 7, 81, 2, 2, 3502, 3503, 7, 89, 2, 2, 3503, 3504, 7, 85, 2, 2, 3504, 654, 3, 2, 2, 2, 3505, 3506, 7, 84, 2, 2, 3506, 3507, 7, 87, 2, 2, 3507, 3508, 7, 78, 2, 2, 3508, 3509, 7, 71, 2, 2, 3509, 656, 3, 2, 2, 2, 3510, 3511, 7, 85, 2, 2, 3511, 3512, 7, 67, 2, 2, 3512, 3513, 7, 88, 2, 2, 3513, 3514, 7, 71, 2, 2, 3514, 3515, 7, 82, 2, 2, 3515, 3516, 7, 81, 2, 2, 3516, 3517, 7, 75, 2, 2, 3517, 3518, 7, 80, 2, 2, 3518, 3519, 7, 86, 2, 2, 3519, 658, 3, 2, 2, 2, 3520, 3521, 7, 85, 2, 2, 3521, 3522, 7, 69, 2, 2, 3522, 3523, 7, 74, 2, 2, 3523, 3524, 7, 71, 2, 2, 3524, 3525, 7, 79, 2, 2, 3525, 3526, 7, 67, 2, 2, 3526, 660, 3, 2, 2, 2, 3527, 3528, 7, 85, 2, 2, 3528, 3529, 7, 69, 2, 2, 3529, 3530, 7, 84, 2, 2, 3530, 3531, 7, 81, 2, 2, 3531, 3532, 7, 78, 2, 2, 3532, 3533, 7, 78, 2, 2, 3533, 662, 3, 2, 2, 2, 3534, 3535, 7, 85, 2, 2, 3535, 3536, 7, 71, 2, 2, 3536, 3537, 7, 67, 2, 2, 3537, 3538, 7, 84, 2, 2, 3538, 3539, 7, 69, 2, 2, 3539, 3540, 7, 74, 2, 2, 3540, 664, 3, 2, 2, 2, 3541, 3542, 7, 85, 2, 2, 3542, 3543, 7, 71, 2, 2, 3543, 3544, 7, 69, 2, 2, 3544, 3545, 7, 81, 2, 2, 3545, 3546, 7, 80, 2, 2, 3546, 3547, 7, 70, 2, 2, 3547, 666, 3, 2, 2, 2, 3548, 3549, 7, 85, 2, 2, 3549, 3550, 7, 71, 2, 2, 3550, 3551, 7, 69, 2, 2, 3551, 3552, 7, 87, 2, 2, 3552, 3553, 7, 84, 2, 2, 3553, 3554, 7, 75, 2, 2, 3554, 3555, 7, 86, 2, 2, 3555, 3556, 7, 91, 2, 2, 3556, 668, 3, 2, 2, 2, 3557, 3558, 7, 85, 2, 2, 3558, 3559, 7, 71, 2, 2, 3559, 3560, 7, 83, 2, 2, 3560, 3561, 7, 87, 2, 2, 3561, 3562, 7, 71, 2, 2, 3562, 3563, 7, 80, 2, 2, 3563, 3564, 7, 69, 2, 2, 3564, 3565, 7, 71, 2, 2, 3565, 670, 3, 2, 2, 2, 3566, 3567, 7, 85, 2, 2, 3567, 3568, 7, 71, 2, 2, 3568, 3569, 7, 83, 2, 2, 3569, 3570, 7, 87, 2, 2, 3570, 3571, 7, 71, 2, 2, 3571, 3572, 7, 80, 2, 2, 3572, 3573, 7, 69, 2, 2, 3573, 3574, 7, 71, 2, 2, 3574, 3575, 7, 85, 2, 2, 3575, 672, 3, 2, 2, 2, 3576, 3577, 7, 85, 2, 2, 3577, 3578, 7, 71, 2, 2, 3578, 3579, 7, 84, 2, 2, 3579, 3580, 7, 75, 2, 2, 3580, 3581, 7, 67, 2, 2, 3581, 3582, 7, 78, 2, 2, 3582, 3583, 7, 75, 2, 2, 3583, 3584, 7, 92, 2, 2, 3584, 3585, 7, 67, 2, 2, 3585, 3586, 7, 68, 2, 2, 3586, 3587, 7, 78, 2, 2, 3587, 3588, 7, 71, 2, 2, 3588, 674, 3, 2, 2, 2, 3589, 3590, 7, 85, 2, 2, 3590, 3591, 7, 71, 2, 2, 3591, 3592, 7, 84, 2, 2, 3592, 3593, 7, 88, 2, 2, 3593, 3594, 7, 71, 2, 2, 3594, 3595, 7, 84, 2, 2, 3595, 676, 3, 2, 2, 2, 3596, 3597, 7, 85, 2, 2, 3597, 3598, 7, 71, 2, 2, 3598, 3599, 7, 85, 2, 2, 3599, 3600, 7, 85, 2, 2, 3600, 3601, 7, 75, 2, 2, 3601, 3602, 7, 81, 2, 2, 3602, 3603, 7, 80, 2, 2, 3603, 678, 3, 2, 2, 2, 3604, 3605, 7, 85, 2, 2, 3605, 3606, 7, 71, 2, 2, 3606, 3607, 7, 86, 2, 2, 3607, 680, 3, 2, 2, 2, 3608, 3609, 7, 85, 2, 2, 3609, 3610, 7, 74, 2, 2, 3610, 3611, 7, 67, 2, 2, 3611, 3612, 7, 84, 2, 2, 3612, 3613, 7, 71, 2, 2, 3613, 682, 3, 2, 2, 2, 3614, 3615, 7, 85, 2, 2, 3615, 3616, 7, 74, 2, 2, 3616, 3617, 7, 81, 2, 2, 3617, 3618, 7, 89, 2, 2, 3618, 684, 3, 2, 2, 2, 3619, 3620, 7, 85, 2, 2, 3620, 3621, 7, 75, 2, 2, 3621, 3622, 7, 79, 2, 2, 3622, 3623, 7, 82, 2, 2, 3623, 3624, 7, 78, 2, 2, 3624, 3625, 7, 71, 2, 2, 3625, 686, 3, 2, 2, 2, 3626, 3627, 7, 85, 2, 2, 3627, 3628, 7, 80, 2, 2, 3628, 3629, 7, 67, 2, 2, 3629, 3630, 7, 82, 2, 2, 3630, 3631, 7, 85, 2, 2, 3631, 3632, 7, 74, 2, 2, 3632, 3633, 7, 81, 2, 2, 3633, 3634, 7, 86, 2, 2, 3634, 688, 3, 2, 2, 2, 3635, 3636, 7, 85, 2, 2, 3636, 3637, 7, 86, 2, 2, 3637, 3638, 7, 67, 2, 2, 3638, 3639, 7, 68, 2, 2, 3639, 3640, 7, 78, 2, 2, 3640, 3641, 7, 71, 2, 2, 3641, 690, 3, 2, 2, 2, 3642, 3643, 7, 85, 2, 2, 3643, 3644, 7, 86, 2, 2, 3644, 3645, 7, 67, 2, 2, 3645, 3646, 7, 80, 2, 2, 3646, 3647, 7, 70, 2, 2, 3647, 3648, 7, 67, 2, 2, 3648, 3649, 7, 78, 2, 2, 3649, 3650, 7, 81, 2, 2, 3650, 3651, 7, 80, 2, 2, 3651, 3652, 7, 71, 2, 2, 3652, 692, 3, 2, 2, 2, 3653, 3654, 7, 85, 2, 2, 3654, 3655, 7, 86, 2, 2, 3655, 3656, 7, 67, 2, 2, 3656, 3657, 7, 84, 2, 2, 3657, 3658, 7, 86, 2, 2, 3658, 694, 3, 2, 2, 2, 3659, 3660, 7, 85, 2, 2, 3660, 3661, 7, 86, 2, 2, 3661, 3662, 7, 67, 2, 2, 3662, 3663, 7, 86, 2, 2, 3663, 3664, 7, 71, 2, 2, 3664, 3665, 7, 79, 2, 2, 3665, 3666, 7, 71, 2, 2, 3666, 3667, 7, 80, 2, 2, 3667, 3668, 7, 86, 2, 2, 3668, 696, 3, 2, 2, 2, 3669, 3670, 7, 85, 2, 2, 3670, 3671, 7, 86, 2, 2, 3671, 3672, 7, 67, 2, 2, 3672, 3673, 7, 86, 2, 2, 3673, 3674, 7, 75, 2, 2, 3674, 3675, 7, 85, 2, 2, 3675, 3676, 7, 86, 2, 2, 3676, 3677, 7, 75, 2, 2, 3677, 3678, 7, 69, 2, 2, 3678, 3679, 7, 85, 2, 2, 3679, 698, 3, 2, 2, 2, 3680, 3681, 7, 85, 2, 2, 3681, 3682, 7, 86, 2, 2, 3682, 3683, 7, 70, 2, 2, 3683, 3684, 7, 75, 2, 2, 3684, 3685, 7, 80, 2, 2, 3685, 700, 3, 2, 2, 2, 3686, 3687, 7, 85, 2, 2, 3687, 3688, 7, 86, 2, 2, 3688, 3689, 7, 70, 2, 2, 3689, 3690, 7, 81, 2, 2, 3690, 3691, 7, 87, 2, 2, 3691, 3692, 7, 86, 2, 2, 3692, 702, 3, 2, 2, 2, 3693, 3694, 7, 85, 2, 2, 3694, 3695, 7, 86, 2, 2, 3695, 3696, 7, 81, 2, 2, 3696, 3697, 7, 84, 2, 2, 3697, 3698, 7, 67, 2, 2, 3698, 3699, 7, 73, 2, 2, 3699, 3700, 7, 71, 2, 2, 3700, 704, 3, 2, 2, 2, 3701, 3702, 7, 85, 2, 2, 3702, 3703, 7, 86, 2, 2, 3703, 3704, 7, 84, 2, 2, 3704, 3705, 7, 75, 2, 2, 3705, 3706, 7, 69, 2, 2, 3706, 3707, 7, 86, 2, 2, 3707, 706, 3, 2, 2, 2, 3708, 3709, 7, 85, 2, 2, 3709, 3710, 7, 86, 2, 2, 3710, 3711, 7, 84, 2, 2, 3711, 3712, 7, 75, 2, 2, 3712, 3713, 7, 82, 2, 2, 3713, 708, 3, 2, 2, 2, 3714, 3715, 7, 85, 2, 2, 3715, 3716, 7, 91, 2, 2, 3716, 3717, 7, 85, 2, 2, 3717, 3718, 7, 75, 2, 2, 3718, 3719, 7, 70, 2, 2, 3719, 710, 3, 2, 2, 2, 3720, 3721, 7, 85, 2, 2, 3721, 3722, 7, 91, 2, 2, 3722, 3723, 7, 85, 2, 2, 3723, 3724, 7, 86, 2, 2, 3724, 3725, 7, 71, 2, 2, 3725, 3726, 7, 79, 2, 2, 3726, 712, 3, 2, 2, 2, 3727, 3728, 7, 86, 2, 2, 3728, 3729, 7, 67, 2, 2, 3729, 3730, 7, 68, 2, 2, 3730, 3731, 7, 78, 2, 2, 3731, 3732, 7, 71, 2, 2, 3732, 3733, 7, 85, 2, 2, 3733, 714, 3, 2, 2, 2, 3734, 3735, 7, 86, 2, 2, 3735, 3736, 7, 67, 2, 2, 3736, 3737, 7, 68, 2, 2, 3737, 3738, 7, 78, 2, 2, 3738, 3739, 7, 71, 2, 2, 3739, 3740, 7, 85, 2, 2, 3740, 3741, 7, 82, 2, 2, 3741, 3742, 7, 67, 2, 2, 3742, 3743, 7, 69, 2, 2, 3743, 3744, 7, 71, 2, 2, 3744, 716, 3, 2, 2, 2, 3745, 3746, 7, 86, 2, 2, 3746, 3747, 7, 71, 2, 2, 3747, 3748, 7, 79, 2, 2, 3748, 3749, 7, 82, 2, 2, 3749, 718, 3, 2, 2, 2, 3750, 3751, 7, 86, 2, 2, 3751, 3752, 7, 71, 2, 2, 3752, 3753, 7, 79, 2, 2, 3753, 3754, 7, 82, 2, 2, 3754, 3755, 7, 78, 2, 2, 3755, 3756, 7, 67, 2, 2, 3756, 3757, 7, 86, 2, 2, 3757, 3758, 7, 71, 2, 2, 3758, 720, 3, 2, 2, 2, 3759, 3760, 7, 86, 2, 2, 3760, 3761, 7, 71, 2, 2, 3761, 3762, 7, 79, 2, 2, 3762, 3763, 7, 82, 2, 2, 3763, 3764, 7, 81, 2, 2, 3764, 3765, 7, 84, 2, 2, 3765, 3766, 7, 67, 2, 2, 3766, 3767, 7, 84, 2, 2, 3767, 3768, 7, 91, 2, 2, 3768, 722, 3, 2, 2, 2, 3769, 3770, 7, 86, 2, 2, 3770, 3771, 7, 71, 2, 2, 3771, 3772, 7, 90, 2, 2, 3772, 3773, 7, 86, 2, 2, 3773, 724, 3, 2, 2, 2, 3774, 3775, 7, 86, 2, 2, 3775, 3776, 7, 84, 2, 2, 3776, 3777, 7, 67, 2, 2, 3777, 3778, 7, 80, 2, 2, 3778, 3779, 7, 85, 2, 2, 3779, 3780, 7, 67, 2, 2, 3780, 3781, 7, 69, 2, 2, 3781, 3782, 7, 86, 2, 2, 3782, 3783, 7, 75, 2, 2, 3783, 3784, 7, 81, 2, 2, 3784, 3785, 7, 80, 2, 2, 3785, 726, 3, 2, 2, 2, 3786, 3787, 7, 86, 2, 2, 3787, 3788, 7, 84, 2, 2, 3788, 3789, 7, 75, 2, 2, 3789, 3790, 7, 73, 2, 2, 3790, 3791, 7, 73, 2, 2, 3791, 3792, 7, 71, 2, 2, 3792, 3793, 7, 84, 2, 2, 3793, 728, 3, 2, 2, 2, 3794, 3795, 7, 86, 2, 2, 3795, 3796, 7, 84, 2, 2, 3796, 3797, 7, 87, 2, 2, 3797, 3798, 7, 80, 2, 2, 3798, 3799, 7, 69, 2, 2, 3799, 3800, 7, 67, 2, 2, 3800, 3801, 7, 86, 2, 2, 3801, 3802, 7, 71, 2, 2, 3802, 730, 3, 2, 2, 2, 3803, 3804, 7, 86, 2, 2, 3804, 3805, 7, 84, 2, 2, 3805, 3806, 7, 87, 2, 2, 3806, 3807, 7, 85, 2, 2, 3807, 3808, 7, 86, 2, 2, 3808, 3809, 7, 71, 2, 2, 3809, 3810, 7, 70, 2, 2, 3810, 732, 3, 2, 2, 2, 3811, 3812, 7, 86, 2, 2, 3812, 3813, 7, 91, 2, 2, 3813, 3814, 7, 82, 2, 2, 3814, 3815, 7, 71, 2, 2, 3815, 734, 3, 2, 2, 2, 3816, 3817, 7, 86, 2, 2, 3817, 3818, 7, 91, 2, 2, 3818, 3819, 7, 82, 2, 2, 3819, 3820, 7, 71, 2, 2, 3820, 3821, 7, 85, 2, 2, 3821, 736, 3, 2, 2, 2, 3822, 3823, 7, 87, 2, 2, 3823, 3824, 7, 80, 2, 2, 3824, 3825, 7, 68, 2, 2, 3825, 3826, 7, 81, 2, 2, 3826, 3827, 7, 87, 2, 2, 3827, 3828, 7, 80, 2, 2, 3828, 3829, 7, 70, 2, 2, 3829, 3830, 7, 71, 2, 2, 3830, 3831, 7, 70, 2, 2, 3831, 738, 3, 2, 2, 2, 3832, 3833, 7, 87, 2, 2, 3833, 3834, 7, 80, 2, 2, 3834, 3835, 7, 69, 2, 2, 3835, 3836, 7, 81, 2, 2, 3836, 3837, 7, 79, 2, 2, 3837, 3838, 7, 79, 2, 2, 3838, 3839, 7, 75, 2, 2, 3839, 3840, 7, 86, 2, 2, 3840, 3841, 7, 86, 2, 2, 3841, 3842, 7, 71, 2, 2, 3842, 3843, 7, 70, 2, 2, 3843, 740, 3, 2, 2, 2, 3844, 3845, 7, 87, 2, 2, 3845, 3846, 7, 80, 2, 2, 3846, 3847, 7, 71, 2, 2, 3847, 3848, 7, 80, 2, 2, 3848, 3849, 7, 69, 2, 2, 3849, 3850, 7, 84, 2, 2, 3850, 3851, 7, 91, 2, 2, 3851, 3852, 7, 82, 2, 2, 3852, 3853, 7, 86, 2, 2, 3853, 3854, 7, 71, 2, 2, 3854, 3855, 7, 70, 2, 2, 3855, 742, 3, 2, 2, 2, 3856, 3857, 7, 87, 2, 2, 3857, 3858, 7, 80, 2, 2, 3858, 3859, 7, 77, 2, 2, 3859, 3860, 7, 80, 2, 2, 3860, 3861, 7, 81, 2, 2, 3861, 3862, 7, 89, 2, 2, 3862, 3863, 7, 80, 2, 2, 3863, 744, 3, 2, 2, 2, 3864, 3865, 7, 87, 2, 2, 3865, 3866, 7, 80, 2, 2, 3866, 3867, 7, 78, 2, 2, 3867, 3868, 7, 75, 2, 2, 3868, 3869, 7, 85, 2, 2, 3869, 3870, 7, 86, 2, 2, 3870, 3871, 7, 71, 2, 2, 3871, 3872, 7, 80, 2, 2, 3872, 746, 3, 2, 2, 2, 3873, 3874, 7, 87, 2, 2, 3874, 3875, 7, 80, 2, 2, 3875, 3876, 7, 78, 2, 2, 3876, 3877, 7, 81, 2, 2, 3877, 3878, 7, 73, 2, 2, 3878, 3879, 7, 73, 2, 2, 3879, 3880, 7, 71, 2, 2, 3880, 3881, 7, 70, 2, 2, 3881, 748, 3, 2, 2, 2, 3882, 3883, 7, 87, 2, 2, 3883, 3884, 7, 80, 2, 2, 3884, 3885, 7, 86, 2, 2, 3885, 3886, 7, 75, 2, 2, 3886, 3887, 7, 78, 2, 2, 3887, 750, 3, 2, 2, 2, 3888, 3889, 7, 87, 2, 2, 3889, 3890, 7, 82, 2, 2, 3890, 3891, 7, 70, 2, 2, 3891, 3892, 7, 67, 2, 2, 3892, 3893, 7, 86, 2, 2, 3893, 3894, 7, 71, 2, 2, 3894, 752, 3, 2, 2, 2, 3895, 3896, 7, 88, 2, 2, 3896, 3897, 7, 67, 2, 2, 3897, 3898, 7, 69, 2, 2, 3898, 3899, 7, 87, 2, 2, 3899, 3900, 7, 87, 2, 2, 3900, 3901, 7, 79, 2, 2, 3901, 754, 3, 2, 2, 2, 3902, 3903, 7, 88, 2, 2, 3903, 3904, 7, 67, 2, 2, 3904, 3905, 7, 78, 2, 2, 3905, 3906, 7, 75, 2, 2, 3906, 3907, 7, 70, 2, 2, 3907, 756, 3, 2, 2, 2, 3908, 3909, 7, 88, 2, 2, 3909, 3910, 7, 67, 2, 2, 3910, 3911, 7, 78, 2, 2, 3911, 3912, 7, 75, 2, 2, 3912, 3913, 7, 70, 2, 2, 3913, 3914, 7, 67, 2, 2, 3914, 3915, 7, 86, 2, 2, 3915, 3916, 7, 71, 2, 2, 3916, 758, 3, 2, 2, 2, 3917, 3918, 7, 88, 2, 2, 3918, 3919, 7, 67, 2, 2, 3919, 3920, 7, 78, 2, 2, 3920, 3921, 7, 75, 2, 2, 3921, 3922, 7, 70, 2, 2, 3922, 3923, 7, 67, 2, 2, 3923, 3924, 7, 86, 2, 2, 3924, 3925, 7, 81, 2, 2, 3925, 3926, 7, 84, 2, 2, 3926, 760, 3, 2, 2, 2, 3927, 3928, 7, 88, 2, 2, 3928, 3929, 7, 67, 2, 2, 3929, 3930, 7, 84, 2, 2, 3930, 3931, 7, 91, 2, 2, 3931, 3932, 7, 75, 2, 2, 3932, 3933, 7, 80, 2, 2, 3933, 3934, 7, 73, 2, 2, 3934, 762, 3, 2, 2, 2, 3935, 3936, 7, 88, 2, 2, 3936, 3937, 7, 71, 2, 2, 3937, 3938, 7, 84, 2, 2, 3938, 3939, 7, 85, 2, 2, 3939, 3940, 7, 75, 2, 2, 3940, 3941, 7, 81, 2, 2, 3941, 3942, 7, 80, 2, 2, 3942, 764, 3, 2, 2, 2, 3943, 3944, 7, 88, 2, 2, 3944, 3945, 7, 75, 2, 2, 3945, 3946, 7, 71, 2, 2, 3946, 3947, 7, 89, 2, 2, 3947, 766, 3, 2, 2, 2, 3948, 3949, 7, 88, 2, 2, 3949, 3950, 7, 81, 2, 2, 3950, 3951, 7, 78, 2, 2, 3951, 3952, 7, 67, 2, 2, 3952, 3953, 7, 86, 2, 2, 3953, 3954, 7, 75, 2, 2, 3954, 3955, 7, 78, 2, 2, 3955, 3956, 7, 71, 2, 2, 3956, 768, 3, 2, 2, 2, 3957, 3958, 7, 89, 2, 2, 3958, 3959, 7, 74, 2, 2, 3959, 3960, 7, 75, 2, 2, 3960, 3961, 7, 86, 2, 2, 3961, 3962, 7, 71, 2, 2, 3962, 3963, 7, 85, 2, 2, 3963, 3964, 7, 82, 2, 2, 3964, 3965, 7, 67, 2, 2, 3965, 3966, 7, 69, 2, 2, 3966, 3967, 7, 71, 2, 2, 3967, 770, 3, 2, 2, 2, 3968, 3969, 7, 89, 2, 2, 3969, 3970, 7, 75, 2, 2, 3970, 3971, 7, 86, 2, 2, 3971, 3972, 7, 74, 2, 2, 3972, 3973, 7, 81, 2, 2, 3973, 3974, 7, 87, 2, 2, 3974, 3975, 7, 86, 2, 2, 3975, 772, 3, 2, 2, 2, 3976, 3977, 7, 89, 2, 2, 3977, 3978, 7, 81, 2, 2, 3978, 3979, 7, 84, 2, 2, 3979, 3980, 7, 77, 2, 2, 3980, 774, 3, 2, 2, 2, 3981, 3982, 7, 89, 2, 2, 3982, 3983, 7, 84, 2, 2, 3983, 3984, 7, 67, 2, 2, 3984, 3985, 7, 82, 2, 2, 3985, 3986, 7, 82, 2, 2, 3986, 3987, 7, 71, 2, 2, 3987, 3988, 7, 84, 2, 2, 3988, 776, 3, 2, 2, 2, 3989, 3990, 7, 89, 2, 2, 3990, 3991, 7, 84, 2, 2, 3991, 3992, 7, 75, 2, 2, 3992, 3993, 7, 86, 2, 2, 3993, 3994, 7, 71, 2, 2, 3994, 778, 3, 2, 2, 2, 3995, 3996, 7, 90, 2, 2, 3996, 3997, 7, 79, 2, 2, 3997, 3998, 7, 78, 2, 2, 3998, 780, 3, 2, 2, 2, 3999, 4000, 7, 91, 2, 2, 4000, 4001, 7, 71, 2, 2, 4001, 4002, 7, 67, 2, 2, 4002, 4003, 7, 84, 2, 2, 4003, 782, 3, 2, 2, 2, 4004, 4005, 7, 91, 2, 2, 4005, 4006, 7, 71, 2, 2, 4006, 4007, 7, 85, 2, 2, 4007, 784, 3, 2, 2, 2, 4008, 4009, 7, 92, 2, 2, 4009, 4010, 7, 81, 2, 2, 4010, 4011, 7, 80, 2, 2, 4011, 4012, 7, 71, 2, 2, 4012, 786, 3, 2, 2, 2, 4013, 4014, 7, 68, 2, 2, 4014, 4015, 7, 71, 2, 2, 4015, 4016, 7, 86, 2, 2, 4016, 4017, 7, 89, 2, 2, 4017, 4018, 7, 71, 2, 2, 4018, 4019, 7, 71, 2, 2, 4019, 4020, 7, 80, 2, 2, 4020, 788, 3, 2, 2, 2, 4021, 4022, 7, 68, 2, 2, 4022, 4023, 7, 75, 2, 2, 4023, 4024, 7, 73, 2, 2, 4024, 4025, 7, 75, 2, 2, 4025, 4026, 7, 80, 2, 2, 4026, 4027, 7, 86, 2, 2, 4027, 790, 3, 2, 2, 2, 4028, 4029, 7, 68, 2, 2, 4029, 4030, 7, 75, 2, 2, 4030, 4031, 7, 86, 2, 2, 4031, 792, 3, 2, 2, 2, 4032, 4033, 7, 68, 2, 2, 4033, 4034, 7, 81, 2, 2, 4034, 4035, 7, 81, 2, 2, 4035, 4036, 7, 78, 2, 2, 4036, 4037, 7, 71, 2, 2, 4037, 4038, 7, 67, 2, 2, 4038, 4039, 7, 80, 2, 2, 4039, 794, 3, 2, 2, 2, 4040, 4041, 7, 69, 2, 2, 4041, 4042, 7, 74, 2, 2, 4042, 4043, 7, 67, 2, 2, 4043, 4044, 7, 84, 2, 2, 4044, 796, 3, 2, 2, 2, 4045, 4046, 7, 69, 2, 2, 4046, 4047, 7, 74, 2, 2, 4047, 4048, 7, 67, 2, 2, 4048, 4049, 7, 84, 2, 2, 4049, 4050, 7, 67, 2, 2, 4050, 4051, 7, 69, 2, 2, 4051, 4052, 7, 86, 2, 2, 4052, 4053, 7, 71, 2, 2, 4053, 4054, 7, 84, 2, 2, 4054, 798, 3, 2, 2, 2, 4055, 4056, 7, 69, 2, 2, 4056, 4057, 7, 81, 2, 2, 4057, 4058, 7, 67, 2, 2, 4058, 4059, 7, 78, 2, 2, 4059, 4060, 7, 71, 2, 2, 4060, 4061, 7, 85, 2, 2, 4061, 4062, 7, 69, 2, 2, 4062, 4063, 7, 71, 2, 2, 4063, 800, 3, 2, 2, 2, 4064, 4065, 7, 70, 2, 2, 4065, 4066, 7, 71, 2, 2, 4066, 4067, 7, 69, 2, 2, 4067, 802, 3, 2, 2, 2, 4068, 4069, 7, 70, 2, 2, 4069, 4070, 7, 71, 2, 2, 4070, 4071, 7, 69, 2, 2, 4071, 4072, 7, 75, 2, 2, 4072, 4073, 7, 79, 2, 2, 4073, 4074, 7, 67, 2, 2, 4074, 4075, 7, 78, 2, 2, 4075, 804, 3, 2, 2, 2, 4076, 4077, 7, 71, 2, 2, 4077, 4078, 7, 90, 2, 2, 4078, 4079, 7, 75, 2, 2, 4079, 4080, 7, 85, 2, 2, 4080, 4081, 7, 86, 2, 2, 4081, 4082, 7, 85, 2, 2, 4082, 806, 3, 2, 2, 2, 4083, 4084, 7, 71, 2, 2, 4084, 4085, 7, 90, 2, 2, 4085, 4086, 7, 86, 2, 2, 4086, 4087, 7, 84, 2, 2, 4087, 4088, 7, 67, 2, 2, 4088, 4089, 7, 69, 2, 2, 4089, 4090, 7, 86, 2, 2, 4090, 808, 3, 2, 2, 2, 4091, 4092, 7, 72, 2, 2, 4092, 4093, 7, 78, 2, 2, 4093, 4094, 7, 81, 2, 2, 4094, 4095, 7, 67, 2, 2, 4095, 4096, 7, 86, 2, 2, 4096, 810, 3, 2, 2, 2, 4097, 4098, 7, 73, 2, 2, 4098, 4099, 7, 84, 2, 2, 4099, 4100, 7, 71, 2, 2, 4100, 4101, 7, 67, 2, 2, 4101, 4102, 7, 86, 2, 2, 4102, 4103, 7, 71, 2, 2, 4103, 4104, 7, 85, 2, 2, 4104, 4105, 7, 86, 2, 2, 4105, 812, 3, 2, 2, 2, 4106, 4107, 7, 75, 2, 2, 4107, 4108, 7, 80, 2, 2, 4108, 4109, 7, 81, 2, 2, 4109, 4110, 7, 87, 2, 2, 4110, 4111, 7, 86, 2, 2, 4111, 814, 3, 2, 2, 2, 4112, 4113, 7, 75, 2, 2, 4113, 4114, 7, 80, 2, 2, 4114, 4115, 7, 86, 2, 2, 4115, 816, 3, 2, 2, 2, 4116, 4117, 7, 75, 2, 2, 4117, 4118, 7, 80, 2, 2, 4118, 4119, 7, 86, 2, 2, 4119, 4120, 7, 71, 2, 2, 4120, 4121, 7, 73, 2, 2, 4121, 4122, 7, 71, 2, 2, 4122, 4123, 7, 84, 2, 2, 4123, 818, 3, 2, 2, 2, 4124, 4125, 7, 75, 2, 2, 4125, 4126, 7, 80, 2, 2, 4126, 4127, 7, 86, 2, 2, 4127, 4128, 7, 71, 2, 2, 4128, 4129, 7, 84, 2, 2, 4129, 4130, 7, 88, 2, 2, 4130, 4131, 7, 67, 2, 2, 4131, 4132, 7, 78, 2, 2, 4132, 820, 3, 2, 2, 2, 4133, 4134, 7, 78, 2, 2, 4134, 4135, 7, 71, 2, 2, 4135, 4136, 7, 67, 2, 2, 4136, 4137, 7, 85, 2, 2, 4137, 4138, 7, 86, 2, 2, 4138, 822, 3, 2, 2, 2, 4139, 4140, 7, 80, 2, 2, 4140, 4141, 7, 67, 2, 2, 4141, 4142, 7, 86, 2, 2, 4142, 4143, 7, 75, 2, 2, 4143, 4144, 7, 81, 2, 2, 4144, 4145, 7, 80, 2, 2, 4145, 4146, 7, 67, 2, 2, 4146, 4147, 7, 78, 2, 2, 4147, 824, 3, 2, 2, 2, 4148, 4149, 7, 80, 2, 2, 4149, 4150, 7, 69, 2, 2, 4150, 4151, 7, 74, 2, 2, 4151, 4152, 7, 67, 2, 2, 4152, 4153, 7, 84, 2, 2, 4153, 826, 3, 2, 2, 2, 4154, 4155, 7, 80, 2, 2, 4155, 4156, 7, 81, 2, 2, 4156, 4157, 7, 80, 2, 2, 4157, 4158, 7, 71, 2, 2, 4158, 828, 3, 2, 2, 2, 4159, 4160, 7, 80, 2, 2, 4160, 4161, 7, 87, 2, 2, 4161, 4162, 7, 78, 2, 2, 4162, 4163, 7, 78, 2, 2, 4163, 4164, 7, 75, 2, 2, 4164, 4165, 7, 72, 2, 2, 4165, 830, 3, 2, 2, 2, 4166, 4167, 7, 80, 2, 2, 4167, 4168, 7, 87, 2, 2, 4168, 4169, 7, 79, 2, 2, 4169, 4170, 7, 71, 2, 2, 4170, 4171, 7, 84, 2, 2, 4171, 4172, 7, 75, 2, 2, 4172, 4173, 7, 69, 2, 2, 4173, 832, 3, 2, 2, 2, 4174, 4175, 7, 81, 2, 2, 4175, 4176, 7, 88, 2, 2, 4176, 4177, 7, 71, 2, 2, 4177, 4178, 7, 84, 2, 2, 4178, 4179, 7, 78, 2, 2, 4179, 4180, 7, 67, 2, 2, 4180, 4181, 7, 91, 2, 2, 4181, 834, 3, 2, 2, 2, 4182, 4183, 7, 82, 2, 2, 4183, 4184, 7, 81, 2, 2, 4184, 4185, 7, 85, 2, 2, 4185, 4186, 7, 75, 2, 2, 4186, 4187, 7, 86, 2, 2, 4187, 4188, 7, 75, 2, 2, 4188, 4189, 7, 81, 2, 2, 4189, 4190, 7, 80, 2, 2, 4190, 836, 3, 2, 2, 2, 4191, 4192, 7, 82, 2, 2, 4192, 4193, 7, 84, 2, 2, 4193, 4194, 7, 71, 2, 2, 4194, 4195, 7, 69, 2, 2, 4195, 4196, 7, 75, 2, 2, 4196, 4197, 7, 85, 2, 2, 4197, 4198, 7, 75, 2, 2, 4198, 4199, 7, 81, 2, 2, 4199, 4200, 7, 80, 2, 2, 4200, 838, 3, 2, 2, 2, 4201, 4202, 7, 84, 2, 2, 4202, 4203, 7, 71, 2, 2, 4203, 4204, 7, 67, 2, 2, 4204, 4205, 7, 78, 2, 2, 4205, 840, 3, 2, 2, 2, 4206, 4207, 7, 84, 2, 2, 4207, 4208, 7, 81, 2, 2, 4208, 4209, 7, 89, 2, 2, 4209, 842, 3, 2, 2, 2, 4210, 4211, 7, 85, 2, 2, 4211, 4212, 7, 71, 2, 2, 4212, 4213, 7, 86, 2, 2, 4213, 4214, 7, 81, 2, 2, 4214, 4215, 7, 72, 2, 2, 4215, 844, 3, 2, 2, 2, 4216, 4217, 7, 85, 2, 2, 4217, 4218, 7, 79, 2, 2, 4218, 4219, 7, 67, 2, 2, 4219, 4220, 7, 78, 2, 2, 4220, 4221, 7, 78, 2, 2, 4221, 4222, 7, 75, 2, 2, 4222, 4223, 7, 80, 2, 2, 4223, 4224, 7, 86, 2, 2, 4224, 846, 3, 2, 2, 2, 4225, 4226, 7, 85, 2, 2, 4226, 4227, 7, 87, 2, 2, 4227, 4228, 7, 68, 2, 2, 4228, 4229, 7, 85, 2, 2, 4229, 4230, 7, 86, 2, 2, 4230, 4231, 7, 84, 2, 2, 4231, 4232, 7, 75, 2, 2, 4232, 4233, 7, 80, 2, 2, 4233, 4234, 7, 73, 2, 2, 4234, 848, 3, 2, 2, 2, 4235, 4236, 7, 86, 2, 2, 4236, 4237, 7, 75, 2, 2, 4237, 4238, 7, 79, 2, 2, 4238, 4239, 7, 71, 2, 2, 4239, 850, 3, 2, 2, 2, 4240, 4241, 7, 86, 2, 2, 4241, 4242, 7, 75, 2, 2, 4242, 4243, 7, 79, 2, 2, 4243, 4244, 7, 71, 2, 2, 4244, 4245, 7, 85, 2, 2, 4245, 4246, 7, 86, 2, 2, 4246, 4247, 7, 67, 2, 2, 4247, 4248, 7, 79, 2, 2, 4248, 4249, 7, 82, 2, 2, 4249, 852, 3, 2, 2, 2, 4250, 4251, 7, 86, 2, 2, 4251, 4252, 7, 84, 2, 2, 4252, 4253, 7, 71, 2, 2, 4253, 4254, 7, 67, 2, 2, 4254, 4255, 7, 86, 2, 2, 4255, 854, 3, 2, 2, 2, 4256, 4257, 7, 86, 2, 2, 4257, 4258, 7, 84, 2, 2, 4258, 4259, 7, 75, 2, 2, 4259, 4260, 7, 79, 2, 2, 4260, 856, 3, 2, 2, 2, 4261, 4262, 7, 88, 2, 2, 4262, 4263, 7, 67, 2, 2, 4263, 4264, 7, 78, 2, 2, 4264, 4265, 7, 87, 2, 2, 4265, 4266, 7, 71, 2, 2, 4266, 4267, 7, 85, 2, 2, 4267, 858, 3, 2, 2, 2, 4268, 4269, 7, 88, 2, 2, 4269, 4270, 7, 67, 2, 2, 4270, 4271, 7, 84, 2, 2, 4271, 4272, 7, 69, 2, 2, 4272, 4273, 7, 74, 2, 2, 4273, 4274, 7, 67, 2, 2, 4274, 4275, 7, 84, 2, 2, 4275, 860, 3, 2, 2, 2, 4276, 4277, 7, 90, 2, 2, 4277, 4278, 7, 79, 2, 2, 4278, 4279, 7, 78, 2, 2, 4279, 4280, 7, 67, 2, 2, 4280, 4281, 7, 86, 2, 2, 4281, 4282, 7, 86, 2, 2, 4282, 4283, 7, 84, 2, 2, 4283, 4284, 7, 75, 2, 2, 4284, 4285, 7, 68, 2, 2, 4285, 4286, 7, 87, 2, 2, 4286, 4287, 7, 86, 2, 2, 4287, 4288, 7, 71, 2, 2, 4288, 4289, 7, 85, 2, 2, 4289, 862, 3, 2, 2, 2, 4290, 4291, 7, 90, 2, 2, 4291, 4292, 7, 79, 2, 2, 4292, 4293, 7, 78, 2, 2, 4293, 4294, 7, 69, 2, 2, 4294, 4295, 7, 81, 2, 2, 4295, 4296, 7, 80, 2, 2, 4296, 4297, 7, 69, 2, 2, 4297, 4298, 7, 67, 2, 2, 4298, 4299, 7, 86, 2, 2, 4299, 864, 3, 2, 2, 2, 4300, 4301, 7, 90, 2, 2, 4301, 4302, 7, 79, 2, 2, 4302, 4303, 7, 78, 2, 2, 4303, 4304, 7, 71, 2, 2, 4304, 4305, 7, 78, 2, 2, 4305, 4306, 7, 71, 2, 2, 4306, 4307, 7, 79, 2, 2, 4307, 4308, 7, 71, 2, 2, 4308, 4309, 7, 80, 2, 2, 4309, 4310, 7, 86, 2, 2, 4310, 866, 3, 2, 2, 2, 4311, 4312, 7, 90, 2, 2, 4312, 4313, 7, 79, 2, 2, 4313, 4314, 7, 78, 2, 2, 4314, 4315, 7, 71, 2, 2, 4315, 4316, 7, 90, 2, 2, 4316, 4317, 7, 75, 2, 2, 4317, 4318, 7, 85, 2, 2, 4318, 4319, 7, 86, 2, 2, 4319, 4320, 7, 85, 2, 2, 4320, 868, 3, 2, 2, 2, 4321, 4322, 7, 90, 2, 2, 4322, 4323, 7, 79, 2, 2, 4323, 4324, 7, 78, 2, 2, 4324, 4325, 7, 72, 2, 2, 4325, 4326, 7, 81, 2, 2, 4326, 4327, 7, 84, 2, 2, 4327, 4328, 7, 71, 2, 2, 4328, 4329, 7, 85, 2, 2, 4329, 4330, 7, 86, 2, 2, 4330, 870, 3, 2, 2, 2, 4331, 4332, 7, 90, 2, 2, 4332, 4333, 7, 79, 2, 2, 4333, 4334, 7, 78, 2, 2, 4334, 4335, 7, 82, 2, 2, 4335, 4336, 7, 67, 2, 2, 4336, 4337, 7, 84, 2, 2, 4337, 4338, 7, 85, 2, 2, 4338, 4339, 7, 71, 2, 2, 4339, 872, 3, 2, 2, 2, 4340, 4341, 7, 90, 2, 2, 4341, 4342, 7, 79, 2, 2, 4342, 4343, 7, 78, 2, 2, 4343, 4344, 7, 82, 2, 2, 4344, 4345, 7, 75, 2, 2, 4345, 874, 3, 2, 2, 2, 4346, 4347, 7, 90, 2, 2, 4347, 4348, 7, 79, 2, 2, 4348, 4349, 7, 78, 2, 2, 4349, 4350, 7, 84, 2, 2, 4350, 4351, 7, 81, 2, 2, 4351, 4352, 7, 81, 2, 2, 4352, 4353, 7, 86, 2, 2, 4353, 876, 3, 2, 2, 2, 4354, 4355, 7, 90, 2, 2, 4355, 4356, 7, 79, 2, 2, 4356, 4357, 7, 78, 2, 2, 4357, 4358, 7, 85, 2, 2, 4358, 4359, 7, 71, 2, 2, 4359, 4360, 7, 84, 2, 2, 4360, 4361, 7, 75, 2, 2, 4361, 4362, 7, 67, 2, 2, 4362, 4363, 7, 78, 2, 2, 4363, 4364, 7, 75, 2, 2, 4364, 4365, 7, 92, 2, 2, 4365, 4366, 7, 71, 2, 2, 4366, 878, 3, 2, 2, 2, 4367, 4368, 7, 69, 2, 2, 4368, 4369, 7, 67, 2, 2, 4369, 4370, 7, 78, 2, 2, 4370, 4371, 7, 78, 2, 2, 4371, 880, 3, 2, 2, 2, 4372, 4373, 7, 69, 2, 2, 4373, 4374, 7, 87, 2, 2, 4374, 4375, 7, 84, 2, 2, 4375, 4376, 7, 84, 2, 2, 4376, 4377, 7, 71, 2, 2, 4377, 4378, 7, 80, 2, 2, 4378, 4379, 7, 86, 2, 2, 4379, 882, 3, 2, 2, 2, 4380, 4381, 7, 67, 2, 2, 4381, 4382, 7, 86, 2, 2, 4382, 4383, 7, 86, 2, 2, 4383, 4384, 7, 67, 2, 2, 4384, 4385, 7, 69, 2, 2, 4385, 4386, 7, 74, 2, 2, 4386, 884, 3, 2, 2, 2, 4387, 4388, 7, 70, 2, 2, 4388, 4389, 7, 71, 2, 2, 4389, 4390, 7, 86, 2, 2, 4390, 4391, 7, 67, 2, 2, 4391, 4392, 7, 69, 2, 2, 4392, 4393, 7, 74, 2, 2, 4393, 886, 3, 2, 2, 2, 4394, 4395, 7, 71, 2, 2, 4395, 4396, 7, 90, 2, 2, 4396, 4397, 7, 82, 2, 2, 4397, 4398, 7, 84, 2, 2, 4398, 4399, 7, 71, 2, 2, 4399, 4400, 7, 85, 2, 2, 4400, 4401, 7, 85, 2, 2, 4401, 4402, 7, 75, 2, 2, 4402, 4403, 7, 81, 2, 2, 4403, 4404, 7, 80, 2, 2, 4404, 888, 3, 2, 2, 2, 4405, 4406, 7, 73, 2, 2, 4406, 4407, 7, 71, 2, 2, 4407, 4408, 7, 80, 2, 2, 4408, 4409, 7, 71, 2, 2, 4409, 4410, 7, 84, 2, 2, 4410, 4411, 7, 67, 2, 2, 4411, 4412, 7, 86, 2, 2, 4412, 4413, 7, 71, 2, 2, 4413, 4414, 7, 70, 2, 2, 4414, 890, 3, 2, 2, 2, 4415, 4416, 7, 78, 2, 2, 4416, 4417, 7, 81, 2, 2, 4417, 4418, 7, 73, 2, 2, 4418, 4419, 7, 73, 2, 2, 4419, 4420, 7, 71, 2, 2, 4420, 4421, 7, 70, 2, 2, 4421, 892, 3, 2, 2, 2, 4422, 4423, 7, 85, 2, 2, 4423, 4424, 7, 86, 2, 2, 4424, 4425, 7, 81, 2, 2, 4425, 4426, 7, 84, 2, 2, 4426, 4427, 7, 71, 2, 2, 4427, 4428, 7, 70, 2, 2, 4428, 894, 3, 2, 2, 2, 4429, 4430, 7, 75, 2, 2, 4430, 4431, 7, 80, 2, 2, 4431, 4432, 7, 69, 2, 2, 4432, 4433, 7, 78, 2, 2, 4433, 4434, 7, 87, 2, 2, 4434, 4435, 7, 70, 2, 2, 4435, 4436, 7, 71, 2, 2, 4436, 896, 3, 2, 2, 2, 4437, 4438, 7, 84, 2, 2, 4438, 4439, 7, 81, 2, 2, 4439, 4440, 7, 87, 2, 2, 4440, 4441, 7, 86, 2, 2, 4441, 4442, 7, 75, 2, 2, 4442, 4443, 7, 80, 2, 2, 4443, 4444, 7, 71, 2, 2, 4444, 898, 3, 2, 2, 2, 4445, 4446, 7, 86, 2, 2, 4446, 4447, 7, 84, 2, 2, 4447, 4448, 7, 67, 2, 2, 4448, 4449, 7, 80, 2, 2, 4449, 4450, 7, 85, 2, 2, 4450, 4451, 7, 72, 2, 2, 4451, 4452, 7, 81, 2, 2, 4452, 4453, 7, 84, 2, 2, 4453, 4454, 7, 79, 2, 2, 4454, 900, 3, 2, 2, 2, 4455, 4456, 7, 75, 2, 2, 4456, 4457, 7, 79, 2, 2, 4457, 4458, 7, 82, 2, 2, 4458, 4459, 7, 81, 2, 2, 4459, 4460, 7, 84, 2, 2, 4460, 4461, 7, 86, 2, 2, 4461, 902, 3, 2, 2, 2, 4462, 4463, 7, 82, 2, 2, 4463, 4464, 7, 81, 2, 2, 4464, 4465, 7, 78, 2, 2, 4465, 4466, 7, 75, 2, 2, 4466, 4467, 7, 69, 2, 2, 4467, 4468, 7, 91, 2, 2, 4468, 904, 3, 2, 2, 2, 4469, 4470, 7, 79, 2, 2, 4470, 4471, 7, 71, 2, 2, 4471, 4472, 7, 86, 2, 2, 4472, 4473, 7, 74, 2, 2, 4473, 4474, 7, 81, 2, 2, 4474, 4475, 7, 70, 2, 2, 4475, 906, 3, 2, 2, 2, 4476, 4477, 7, 84, 2, 2, 4477, 4478, 7, 71, 2, 2, 4478, 4479, 7, 72, 2, 2, 4479, 4480, 7, 71, 2, 2, 4480, 4481, 7, 84, 2, 2, 4481, 4482, 7, 71, 2, 2, 4482, 4483, 7, 80, 2, 2, 4483, 4484, 7, 69, 2, 2, 4484, 4485, 7, 75, 2, 2, 4485, 4486, 7, 80, 2, 2, 4486, 4487, 7, 73, 2, 2, 4487, 908, 3, 2, 2, 2, 4488, 4489, 7, 80, 2, 2, 4489, 4490, 7, 71, 2, 2, 4490, 4491, 7, 89, 2, 2, 4491, 910, 3, 2, 2, 2, 4492, 4493, 7, 81, 2, 2, 4493, 4494, 7, 78, 2, 2, 4494, 4495, 7, 70, 2, 2, 4495, 912, 3, 2, 2, 2, 4496, 4497, 7, 88, 2, 2, 4497, 4498, 7, 67, 2, 2, 4498, 4499, 7, 78, 2, 2, 4499, 4500, 7, 87, 2, 2, 4500, 4501, 7, 71, 2, 2, 4501, 914, 3, 2, 2, 2, 4502, 4503, 7, 85, 2, 2, 4503, 4504, 7, 87, 2, 2, 4504, 4505, 7, 68, 2, 2, 4505, 4506, 7, 85, 2, 2, 4506, 4507, 7, 69, 2, 2, 4507, 4508, 7, 84, 2, 2, 4508, 4509, 7, 75, 2, 2, 4509, 4510, 7, 82, 2, 2, 4510, 4511, 7, 86, 2, 2, 4511, 4512, 7, 75, 2, 2, 4512, 4513, 7, 81, 2, 2, 4513, 4514, 7, 80, 2, 2, 4514, 916, 3, 2, 2, 2, 4515, 4516, 7, 82, 2, 2, 4516, 4517, 7, 87, 2, 2, 4517, 4518, 7, 68, 2, 2, 4518, 4519, 7, 78, 2, 2, 4519, 4520, 7, 75, 2, 2, 4520, 4521, 7, 69, 2, 2, 4521, 4522, 7, 67, 2, 2, 4522, 4523, 7, 86, 2, 2, 4523, 4524, 7, 75, 2, 2, 4524, 4525, 7, 81, 2, 2, 4525, 4526, 7, 80, 2, 2, 4526, 918, 3, 2, 2, 2, 4527, 4528, 7, 81, 2, 2, 4528, 4529, 7, 87, 2, 2, 4529, 4530, 7, 86, 2, 2, 4530, 920, 3, 2, 2, 2, 4531, 4532, 7, 71, 2, 2, 4532, 4533, 7, 80, 2, 2, 4533, 4534, 7, 70, 2, 2, 4534, 922, 3, 2, 2, 2, 4535, 4536, 7, 84, 2, 2, 4536, 4537, 7, 81, 2, 2, 4537, 4538, 7, 87, 2, 2, 4538, 4539, 7, 86, 2, 2, 4539, 4540, 7, 75, 2, 2, 4540, 4541, 7, 80, 2, 2, 4541, 4542, 7, 71, 2, 2, 4542, 4543, 7, 85, 2, 2, 4543, 924, 3, 2, 2, 2, 4544, 4545, 7, 85, 2, 2, 4545, 4546, 7, 69, 2, 2, 4546, 4547, 7, 74, 2, 2, 4547, 4548, 7, 71, 2, 2, 4548, 4549, 7, 79, 2, 2, 4549, 4550, 7, 67, 2, 2, 4550, 4551, 7, 85, 2, 2, 4551, 926, 3, 2, 2, 2, 4552, 4553, 7, 82, 2, 2, 4553, 4554, 7, 84, 2, 2, 4554, 4555, 7, 81, 2, 2, 4555, 4556, 7, 69, 2, 2, 4556, 4557, 7, 71, 2, 2, 4557, 4558, 7, 70, 2, 2, 4558, 4559, 7, 87, 2, 2, 4559, 4560, 7, 84, 2, 2, 4560, 4561, 7, 71, 2, 2, 4561, 4562, 7, 85, 2, 2, 4562, 928, 3, 2, 2, 2, 4563, 4564, 7, 75, 2, 2, 4564, 4565, 7, 80, 2, 2, 4565, 4566, 7, 82, 2, 2, 4566, 4567, 7, 87, 2, 2, 4567, 4568, 7, 86, 2, 2, 4568, 930, 3, 2, 2, 2, 4569, 4570, 7, 85, 2, 2, 4570, 4571, 7, 87, 2, 2, 4571, 4572, 7, 82, 2, 2, 4572, 4573, 7, 82, 2, 2, 4573, 4574, 7, 81, 2, 2, 4574, 4575, 7, 84, 2, 2, 4575, 4576, 7, 86, 2, 2, 4576, 932, 3, 2, 2, 2, 4577, 4578, 7, 82, 2, 2, 4578, 4579, 7, 67, 2, 2, 4579, 4580, 7, 84, 2, 2, 4580, 4581, 7, 67, 2, 2, 4581, 4582, 7, 78, 2, 2, 4582, 4583, 7, 78, 2, 2, 4583, 4584, 7, 71, 2, 2, 4584, 4585, 7, 78, 2, 2, 4585, 934, 3, 2, 2, 2, 4586, 4587, 7, 85, 2, 2, 4587, 4588, 7, 83, 2, 2, 4588, 4589, 7, 78, 2, 2, 4589, 936, 3, 2, 2, 2, 4590, 4591, 7, 70, 2, 2, 4591, 4592, 7, 71, 2, 2, 4592, 4593, 7, 82, 2, 2, 4593, 4594, 7, 71, 2, 2, 4594, 4595, 7, 80, 2, 2, 4595, 4596, 7, 70, 2, 2, 4596, 4597, 7, 85, 2, 2, 4597, 938, 3, 2, 2, 2, 4598, 4599, 7, 81, 2, 2, 4599, 4600, 7, 88, 2, 2, 4600, 4601, 7, 71, 2, 2, 4601, 4602, 7, 84, 2, 2, 4602, 4603, 7, 84, 2, 2, 4603, 4604, 7, 75, 2, 2, 4604, 4605, 7, 70, 2, 2, 4605, 4606, 7, 75, 2, 2, 4606, 4607, 7, 80, 2, 2, 4607, 4608, 7, 73, 2, 2, 4608, 940, 3, 2, 2, 2, 4609, 4610, 7, 69, 2, 2, 4610, 4611, 7, 81, 2, 2, 4611, 4612, 7, 80, 2, 2, 4612, 4613, 7, 72, 2, 2, 4613, 4614, 7, 78, 2, 2, 4614, 4615, 7, 75, 2, 2, 4615, 4616, 7, 69, 2, 2, 4616, 4617, 7, 86, 2, 2, 4617, 942, 3, 2, 2, 2, 4618, 4619, 7, 85, 2, 2, 4619, 4620, 7, 77, 2, 2, 4620, 4621, 7, 75, 2, 2, 4621, 4622, 7, 82, 2, 2, 4622, 944, 3, 2, 2, 2, 4623, 4624, 7, 78, 2, 2, 4624, 4625, 7, 81, 2, 2, 4625, 4626, 7, 69, 2, 2, 4626, 4627, 7, 77, 2, 2, 4627, 4628, 7, 71, 2, 2, 4628, 4629, 7, 70, 2, 2, 4629, 946, 3, 2, 2, 2, 4630, 4631, 7, 86, 2, 2, 4631, 4632, 7, 75, 2, 2, 4632, 4633, 7, 71, 2, 2, 4633, 4634, 7, 85, 2, 2, 4634, 948, 3, 2, 2, 2, 4635, 4636, 7, 84, 2, 2, 4636, 4637, 7, 81, 2, 2, 4637, 4638, 7, 78, 2, 2, 4638, 4639, 7, 78, 2, 2, 4639, 4640, 7, 87, 2, 2, 4640, 4641, 7, 82, 2, 2, 4641, 950, 3, 2, 2, 2, 4642, 4643, 7, 69, 2, 2, 4643, 4644, 7, 87, 2, 2, 4644, 4645, 7, 68, 2, 2, 4645, 4646, 7, 71, 2, 2, 4646, 952, 3, 2, 2, 2, 4647, 4648, 7, 73, 2, 2, 4648, 4649, 7, 84, 2, 2, 4649, 4650, 7, 81, 2, 2, 4650, 4651, 7, 87, 2, 2, 4651, 4652, 7, 82, 2, 2, 4652, 4653, 7, 75, 2, 2, 4653, 4654, 7, 80, 2, 2, 4654, 4655, 7, 73, 2, 2, 4655, 954, 3, 2, 2, 2, 4656, 4657, 7, 85, 2, 2, 4657, 4658, 7, 71, 2, 2, 4658, 4659, 7, 86, 2, 2, 4659, 4660, 7, 85, 2, 2, 4660, 956, 3, 2, 2, 2, 4661, 4662, 7, 86, 2, 2, 4662, 4663, 7, 67, 2, 2, 4663, 4664, 7, 68, 2, 2, 4664, 4665, 7, 78, 2, 2, 4665, 4666, 7, 71, 2, 2, 4666, 4667, 7, 85, 2, 2, 4667, 4668, 7, 67, 2, 2, 4668, 4669, 7, 79, 2, 2, 4669, 4670, 7, 82, 2, 2, 4670, 4671, 7, 78, 2, 2, 4671, 4672, 7, 71, 2, 2, 4672, 958, 3, 2, 2, 2, 4673, 4674, 7, 81, 2, 2, 4674, 4675, 7, 84, 2, 2, 4675, 4676, 7, 70, 2, 2, 4676, 4677, 7, 75, 2, 2, 4677, 4678, 7, 80, 2, 2, 4678, 4679, 7, 67, 2, 2, 4679, 4680, 7, 78, 2, 2, 4680, 4681, 7, 75, 2, 2, 4681, 4682, 7, 86, 2, 2, 4682, 4683, 7, 91, 2, 2, 4683, 960, 3, 2, 2, 2, 4684, 4685, 7, 90, 2, 2, 4685, 4686, 7, 79, 2, 2, 4686, 4687, 7, 78, 2, 2, 4687, 4688, 7, 86, 2, 2, 4688, 4689, 7, 67, 2, 2, 4689, 4690, 7, 68, 2, 2, 4690, 4691, 7, 78, 2, 2, 4691, 4692, 7, 71, 2, 2, 4692, 962, 3, 2, 2, 2, 4693, 4694, 7, 69, 2, 2, 4694, 4695, 7, 81, 2, 2, 4695, 4696, 7, 78, 2, 2, 4696, 4697, 7, 87, 2, 2, 4697, 4698, 7, 79, 2, 2, 4698, 4699, 7, 80, 2, 2, 4699, 4700, 7, 85, 2, 2, 4700, 964, 3, 2, 2, 2, 4701, 4702, 7, 90, 2, 2, 4702, 4703, 7, 79, 2, 2, 4703, 4704, 7, 78, 2, 2, 4704, 4705, 7, 80, 2, 2, 4705, 4706, 7, 67, 2, 2, 4706, 4707, 7, 79, 2, 2, 4707, 4708, 7, 71, 2, 2, 4708, 4709, 7, 85, 2, 2, 4709, 4710, 7, 82, 2, 2, 4710, 4711, 7, 67, 2, 2, 4711, 4712, 7, 69, 2, 2, 4712, 4713, 7, 71, 2, 2, 4713, 4714, 7, 85, 2, 2, 4714, 966, 3, 2, 2, 2, 4715, 4716, 7, 84, 2, 2, 4716, 4717, 7, 81, 2, 2, 4717, 4718, 7, 89, 2, 2, 4718, 4719, 7, 86, 2, 2, 4719, 4720, 7, 91, 2, 2, 4720, 4721, 7, 82, 2, 2, 4721, 4722, 7, 71, 2, 2, 4722, 968, 3, 2, 2, 2, 4723, 4724, 7, 80, 2, 2, 4724, 4725, 7, 81, 2, 2, 4725, 4726, 7, 84, 2, 2, 4726, 4727, 7, 79, 2, 2, 4727, 4728, 7, 67, 2, 2, 4728, 4729, 7, 78, 2, 2, 4729, 4730, 7, 75, 2, 2, 4730, 4731, 7, 92, 2, 2, 4731, 4732, 7, 71, 2, 2, 4732, 4733, 7, 70, 2, 2, 4733, 970, 3, 2, 2, 2, 4734, 4735, 7, 89, 2, 2, 4735, 4736, 7, 75, 2, 2, 4736, 4737, 7, 86, 2, 2, 4737, 4738, 7, 74, 2, 2, 4738, 4739, 7, 75, 2, 2, 4739, 4740, 7, 80, 2, 2, 4740, 972, 3, 2, 2, 2, 4741, 4742, 7, 72, 2, 2, 4742, 4743, 7, 75, 2, 2, 4743, 4744, 7, 78, 2, 2, 4744, 4745, 7, 86, 2, 2, 4745, 4746, 7, 71, 2, 2, 4746, 4747, 7, 84, 2, 2, 4747, 974, 3, 2, 2, 2, 4748, 4749, 7, 73, 2, 2, 4749, 4750, 7, 84, 2, 2, 4750, 4751, 7, 81, 2, 2, 4751, 4752, 7, 87, 2, 2, 4752, 4753, 7, 82, 2, 2, 4753, 4754, 7, 85, 2, 2, 4754, 976, 3, 2, 2, 2, 4755, 4756, 7, 81, 2, 2, 4756, 4757, 7, 86, 2, 2, 4757, 4758, 7, 74, 2, 2, 4758, 4759, 7, 71, 2, 2, 4759, 4760, 7, 84, 2, 2, 4760, 4761, 7, 85, 2, 2, 4761, 978, 3, 2, 2, 2, 4762, 4763, 7, 80, 2, 2, 4763, 4764, 7, 72, 2, 2, 4764, 4765, 7, 69, 2, 2, 4765, 980, 3, 2, 2, 2, 4766, 4767, 7, 80, 2, 2, 4767, 4768, 7, 72, 2, 2, 4768, 4769, 7, 70, 2, 2, 4769, 982, 3, 2, 2, 2, 4770, 4771, 7, 80, 2, 2, 4771, 4772, 7, 72, 2, 2, 4772, 4773, 7, 77, 2, 2, 4773, 4774, 7, 69, 2, 2, 4774, 984, 3, 2, 2, 2, 4775, 4776, 7, 80, 2, 2, 4776, 4777, 7, 72, 2, 2, 4777, 4778, 7, 77, 2, 2, 4778, 4779, 7, 70, 2, 2, 4779, 986, 3, 2, 2, 2, 4780, 4781, 7, 87, 2, 2, 4781, 4782, 7, 71, 2, 2, 4782, 4783, 7, 85, 2, 2, 4783, 4784, 7, 69, 2, 2, 4784, 4785, 7, 67, 2, 2, 4785, 4786, 7, 82, 2, 2, 4786, 4787, 7, 71, 2, 2, 4787, 988, 3, 2, 2, 2, 4788, 4789, 7, 88, 2, 2, 4789, 4790, 7, 75, 2, 2, 4790, 4791, 7, 71, 2, 2, 4791, 4792, 7, 89, 2, 2, 4792, 4793, 7, 85, 2, 2, 4793, 990, 3, 2, 2, 2, 4794, 4795, 7, 80, 2, 2, 4795, 4796, 7, 81, 2, 2, 4796, 4797, 7, 84, 2, 2, 4797, 4798, 7, 79, 2, 2, 4798, 4799, 7, 67, 2, 2, 4799, 4800, 7, 78, 2, 2, 4800, 4801, 7, 75, 2, 2, 4801, 4802, 7, 92, 2, 2, 4802, 4803, 7, 71, 2, 2, 4803, 992, 3, 2, 2, 2, 4804, 4805, 7, 70, 2, 2, 4805, 4806, 7, 87, 2, 2, 4806, 4807, 7, 79, 2, 2, 4807, 4808, 7, 82, 2, 2, 4808, 994, 3, 2, 2, 2, 4809, 4810, 7, 82, 2, 2, 4810, 4811, 7, 84, 2, 2, 4811, 4812, 7, 75, 2, 2, 4812, 4813, 7, 80, 2, 2, 4813, 4814, 7, 86, 2, 2, 4814, 4815, 7, 97, 2, 2, 4815, 4816, 7, 85, 2, 2, 4816, 4817, 7, 86, 2, 2, 4817, 4818, 7, 84, 2, 2, 4818, 4819, 7, 75, 2, 2, 4819, 4820, 7, 69, 2, 2, 4820, 4821, 7, 86, 2, 2, 4821, 4822, 7, 97, 2, 2, 4822, 4823, 7, 82, 2, 2, 4823, 4824, 7, 67, 2, 2, 4824, 4825, 7, 84, 2, 2, 4825, 4826, 7, 67, 2, 2, 4826, 4827, 7, 79, 2, 2, 4827, 4828, 7, 85, 2, 2, 4828, 996, 3, 2, 2, 2, 4829, 4830, 7, 88, 2, 2, 4830, 4831, 7, 67, 2, 2, 4831, 4832, 7, 84, 2, 2, 4832, 4833, 7, 75, 2, 2, 4833, 4834, 7, 67, 2, 2, 4834, 4835, 7, 68, 2, 2, 4835, 4836, 7, 78, 2, 2, 4836, 4837, 7, 71, 2, 2, 4837, 4838, 7, 97, 2, 2, 4838, 4839, 7, 69, 2, 2, 4839, 4840, 7, 81, 2, 2, 4840, 4841, 7, 80, 2, 2, 4841, 4842, 7, 72, 2, 2, 4842, 4843, 7, 78, 2, 2, 4843, 4844, 7, 75, 2, 2, 4844, 4845, 7, 69, 2, 2, 4845, 4846, 7, 86, 2, 2, 4846, 998, 3, 2, 2, 2, 4847, 4848, 7, 71, 2, 2, 4848, 4849, 7, 84, 2, 2, 4849, 4850, 7, 84, 2, 2, 4850, 4851, 7, 81, 2, 2, 4851, 4852, 7, 84, 2, 2, 4852, 1000, 3, 2, 2, 2, 4853, 4854, 7, 87, 2, 2, 4854, 4855, 7, 85, 2, 2, 4855, 4856, 7, 71, 2, 2, 4856, 4857, 7, 97, 2, 2, 4857, 4858, 7, 88, 2, 2, 4858, 4859, 7, 67, 2, 2, 4859, 4860, 7, 84, 2, 2, 4860, 4861, 7, 75, 2, 2, 4861, 4862, 7, 67, 2, 2, 4862, 4863, 7, 68, 2, 2, 4863, 4864, 7, 78, 2, 2, 4864, 4865, 7, 71, 2, 2, 4865, 1002, 3, 2, 2, 2, 4866, 4867, 7, 87, 2, 2, 4867, 4868, 7, 85, 2, 2, 4868, 4869, 7, 71, 2, 2, 4869, 4870, 7, 97, 2, 2, 4870, 4871, 7, 69, 2, 2, 4871, 4872, 7, 81, 2, 2, 4872, 4873, 7, 78, 2, 2, 4873, 4874, 7, 87, 2, 2, 4874, 4875, 7, 79, 2, 2, 4875, 4876, 7, 80, 2, 2, 4876, 1004, 3, 2, 2, 2, 4877, 4878, 7, 67, 2, 2, 4878, 4879, 7, 78, 2, 2, 4879, 4880, 7, 75, 2, 2, 4880, 4881, 7, 67, 2, 2, 4881, 4882, 7, 85, 2, 2, 4882, 1006, 3, 2, 2, 2, 4883, 4884, 7, 69, 2, 2, 4884, 4885, 7, 81, 2, 2, 4885, 4886, 7, 80, 2, 2, 4886, 4887, 7, 85, 2, 2, 4887, 4888, 7, 86, 2, 2, 4888, 4889, 7, 67, 2, 2, 4889, 4890, 7, 80, 2, 2, 4890, 4891, 7, 86, 2, 2, 4891, 1008, 3, 2, 2, 2, 4892, 4893, 7, 82, 2, 2, 4893, 4894, 7, 71, 2, 2, 4894, 4895, 7, 84, 2, 2, 4895, 4896, 7, 72, 2, 2, 4896, 4897, 7, 81, 2, 2, 4897, 4898, 7, 84, 2, 2, 4898, 4899, 7, 79, 2, 2, 4899, 1010, 3, 2, 2, 2, 4900, 4901, 7, 73, 2, 2, 4901, 4902, 7, 71, 2, 2, 4902, 4903, 7, 86, 2, 2, 4903, 1012, 3, 2, 2, 2, 4904, 4905, 7, 70, 2, 2, 4905, 4906, 7, 75, 2, 2, 4906, 4907, 7, 67, 2, 2, 4907, 4908, 7, 73, 2, 2, 4908, 4909, 7, 80, 2, 2, 4909, 4910, 7, 81, 2, 2, 4910, 4911, 7, 85, 2, 2, 4911, 4912, 7, 86, 2, 2, 4912, 4913, 7, 75, 2, 2, 4913, 4914, 7, 69, 2, 2, 4914, 4915, 7, 85, 2, 2, 4915, 1014, 3, 2, 2, 2, 4916, 4917, 7, 85, 2, 2, 4917, 4918, 7, 86, 2, 2, 4918, 4919, 7, 67, 2, 2, 4919, 4920, 7, 69, 2, 2, 4920, 4921, 7, 77, 2, 2, 4921, 4922, 7, 71, 2, 2, 4922, 4923, 7, 70, 2, 2, 4923, 1016, 3, 2, 2, 2, 4924, 4925, 7, 71, 2, 2, 4925, 4926, 7, 78, 2, 2, 4926, 4927, 7, 85, 2, 2, 4927, 4928, 7, 75, 2, 2, 4928, 4929, 7, 72, 2, 2, 4929, 1018, 3, 2, 2, 2, 4930, 4931, 7, 89, 2, 2, 4931, 4932, 7, 74, 2, 2, 4932, 4933, 7, 75, 2, 2, 4933, 4934, 7, 78, 2, 2, 4934, 4935, 7, 71, 2, 2, 4935, 1020, 3, 2, 2, 2, 4936, 4937, 7, 84, 2, 2, 4937, 4938, 7, 71, 2, 2, 4938, 4939, 7, 88, 2, 2, 4939, 4940, 7, 71, 2, 2, 4940, 4941, 7, 84, 2, 2, 4941, 4942, 7, 85, 2, 2, 4942, 4943, 7, 71, 2, 2, 4943, 1022, 3, 2, 2, 2, 4944, 4945, 7, 72, 2, 2, 4945, 4946, 7, 81, 2, 2, 4946, 4947, 7, 84, 2, 2, 4947, 4948, 7, 71, 2, 2, 4948, 4949, 7, 67, 2, 2, 4949, 4950, 7, 69, 2, 2, 4950, 4951, 7, 74, 2, 2, 4951, 1024, 3, 2, 2, 2, 4952, 4953, 7, 85, 2, 2, 4953, 4954, 7, 78, 2, 2, 4954, 4955, 7, 75, 2, 2, 4955, 4956, 7, 69, 2, 2, 4956, 4957, 7, 71, 2, 2, 4957, 1026, 3, 2, 2, 2, 4958, 4959, 7, 71, 2, 2, 4959, 4960, 7, 90, 2, 2, 4960, 4961, 7, 75, 2, 2, 4961, 4962, 7, 86, 2, 2, 4962, 1028, 3, 2, 2, 2, 4963, 4964, 7, 84, 2, 2, 4964, 4965, 7, 71, 2, 2, 4965, 4966, 7, 86, 2, 2, 4966, 4967, 7, 87, 2, 2, 4967, 4968, 7, 84, 2, 2, 4968, 4969, 7, 80, 2, 2, 4969, 1030, 3, 2, 2, 2, 4970, 4971, 7, 83, 2, 2, 4971, 4972, 7, 87, 2, 2, 4972, 4973, 7, 71, 2, 2, 4973, 4974, 7, 84, 2, 2, 4974, 4975, 7, 91, 2, 2, 4975, 1032, 3, 2, 2, 2, 4976, 4977, 7, 84, 2, 2, 4977, 4978, 7, 67, 2, 2, 4978, 4979, 7, 75, 2, 2, 4979, 4980, 7, 85, 2, 2, 4980, 4981, 7, 71, 2, 2, 4981, 1034, 3, 2, 2, 2, 4982, 4983, 7, 85, 2, 2, 4983, 4984, 7, 83, 2, 2, 4984, 4985, 7, 78, 2, 2, 4985, 4986, 7, 85, 2, 2, 4986, 4987, 7, 86, 2, 2, 4987, 4988, 7, 67, 2, 2, 4988, 4989, 7, 86, 2, 2, 4989, 4990, 7, 71, 2, 2, 4990, 1036, 3, 2, 2, 2, 4991, 4992, 7, 70, 2, 2, 4992, 4993, 7, 71, 2, 2, 4993, 4994, 7, 68, 2, 2, 4994, 4995, 7, 87, 2, 2, 4995, 4996, 7, 73, 2, 2, 4996, 1038, 3, 2, 2, 2, 4997, 4998, 7, 78, 2, 2, 4998, 4999, 7, 81, 2, 2, 4999, 5000, 7, 73, 2, 2, 5000, 1040, 3, 2, 2, 2, 5001, 5002, 7, 75, 2, 2, 5002, 5003, 7, 80, 2, 2, 5003, 5004, 7, 72, 2, 2, 5004, 5005, 7, 81, 2, 2, 5005, 1042, 3, 2, 2, 2, 5006, 5007, 7, 80, 2, 2, 5007, 5008, 7, 81, 2, 2, 5008, 5009, 7, 86, 2, 2, 5009, 5010, 7, 75, 2, 2, 5010, 5011, 7, 69, 2, 2, 5011, 5012, 7, 71, 2, 2, 5012, 1044, 3, 2, 2, 2, 5013, 5014, 7, 89, 2, 2, 5014, 5015, 7, 67, 2, 2, 5015, 5016, 7, 84, 2, 2, 5016, 5017, 7, 80, 2, 2, 5017, 5018, 7, 75, 2, 2, 5018, 5019, 7, 80, 2, 2, 5019, 5020, 7, 73, 2, 2, 5020, 1046, 3, 2, 2, 2, 5021, 5022, 7, 71, 2, 2, 5022, 5023, 7, 90, 2, 2, 5023, 5024, 7, 69, 2, 2, 5024, 5025, 7, 71, 2, 2, 5025, 5026, 7, 82, 2, 2, 5026, 5027, 7, 86, 2, 2, 5027, 5028, 7, 75, 2, 2, 5028, 5029, 7, 81, 2, 2, 5029, 5030, 7, 80, 2, 2, 5030, 1048, 3, 2, 2, 2, 5031, 5032, 7, 67, 2, 2, 5032, 5033, 7, 85, 2, 2, 5033, 5034, 7, 85, 2, 2, 5034, 5035, 7, 71, 2, 2, 5035, 5036, 7, 84, 2, 2, 5036, 5037, 7, 86, 2, 2, 5037, 1050, 3, 2, 2, 2, 5038, 5039, 7, 78, 2, 2, 5039, 5040, 7, 81, 2, 2, 5040, 5041, 7, 81, 2, 2, 5041, 5042, 7, 82, 2, 2, 5042, 1052, 3, 2, 2, 2, 5043, 5044, 7, 81, 2, 2, 5044, 5045, 7, 82, 2, 2, 5045, 5046, 7, 71, 2, 2, 5046, 5047, 7, 80, 2, 2, 5047, 1054, 3, 2, 2, 2, 5048, 5049, 7, 82, 2, 2, 5049, 5050, 7, 71, 2, 2, 5050, 5051, 7, 72, 2, 2, 5051, 5052, 7, 71, 2, 2, 5052, 5053, 7, 84, 2, 2, 5053, 5054, 7, 71, 2, 2, 5054, 5055, 7, 80, 2, 2, 5055, 5056, 7, 69, 2, 2, 5056, 5057, 7, 71, 2, 2, 5057, 5058, 7, 85, 2, 2, 5058, 1056, 3, 2, 2, 2, 5059, 5060, 7, 87, 2, 2, 5060, 5061, 7, 85, 2, 2, 5061, 5062, 7, 67, 2, 2, 5062, 5063, 7, 73, 2, 2, 5063, 5064, 7, 71, 2, 2, 5064, 1058, 3, 2, 2, 2, 5065, 5066, 7, 69, 2, 2, 5066, 5067, 7, 81, 2, 2, 5067, 5068, 7, 80, 2, 2, 5068, 5069, 7, 80, 2, 2, 5069, 5070, 7, 71, 2, 2, 5070, 5071, 7, 69, 2, 2, 5071, 5072, 7, 86, 2, 2, 5072, 1060, 3, 2, 2, 2, 5073, 5074, 7, 82, 2, 2, 5074, 5075, 7, 87, 2, 2, 5075, 5076, 7, 68, 2, 2, 5076, 5077, 7, 78, 2, 2, 5077, 5078, 7, 75, 2, 2, 5078, 5079, 7, 69, 2, 2, 5079, 1062, 3, 2, 2, 2, 5080, 5084, 5, 1065, 531, 2, 5081, 5083, 5, 1067, 532, 2, 5082, 5081, 3, 2, 2, 2, 5083, 5086, 3, 2, 2, 2, 5084, 5082, 3, 2, 2, 2, 5084, 5085, 3, 2, 2, 2, 5085, 1064, 3, 2, 2, 2, 5086, 5084, 3, 2, 2, 2, 5087, 5091, 9, 8, 2, 2, 5088, 5089, 9, 9, 2, 2, 5089, 5091, 9, 10, 2, 2, 5090, 5087, 3, 2, 2, 2, 5090, 5088, 3, 2, 2, 2, 5091, 1066, 3, 2, 2, 2, 5092, 5095, 5, 1069, 533, 2, 5093, 5095, 7, 38, 2, 2, 5094, 5092, 3, 2, 2, 2, 5094, 5093, 3, 2, 2, 2, 5095, 1068, 3, 2, 2, 2, 5096, 5099, 5, 1065, 531, 2, 5097, 5099, 9, 2, 2, 2, 5098, 5096, 3, 2, 2, 2, 5098, 5097, 3, 2, 2, 2, 5099, 1070, 3, 2, 2, 2, 5100, 5101, 5, 1073, 535, 2, 5101, 5102, 7, 36, 2, 2, 5102, 1072, 3, 2, 2, 2, 5103, 5109, 7, 36, 2, 2, 5104, 5105, 7, 36, 2, 2, 5105, 5108, 7, 36, 2, 2, 5106, 5108, 10, 11, 2, 2, 5107, 5104, 3, 2, 2, 2, 5107, 5106, 3, 2, 2, 2, 5108, 5111, 3, 2, 2, 2, 5109, 5107, 3, 2, 2, 2, 5109, 5110, 3, 2, 2, 2, 5110, 1074, 3, 2, 2, 2, 5111, 5109, 3, 2, 2, 2, 5112, 5113, 5, 1077, 537, 2, 5113, 5114, 7, 36, 2, 2, 5114, 1076, 3, 2, 2, 2, 5115, 5121, 7, 36, 2, 2, 5116, 5117, 7, 36, 2, 2, 5117, 5120, 7, 36, 2, 2, 5118, 5120, 10, 12, 2, 2, 5119, 5116, 3, 2, 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, 1078, 3, 2, 2, 2, 5123, 5121, 3, 2, 2, 2, 5124, 5125, 7, 87, 2, 2, 5125, 5126, 7, 40, 2, 2, 5126, 5127, 5, 1071, 534, 2, 5127, 1080, 3, 2, 2, 2, 5128, 5129, 7, 87, 2, 2, 5129, 5130, 7, 40, 2, 2, 5130, 5131, 5, 1073, 535, 2, 5131, 1082, 3, 2, 2, 2, 5132, 5133, 7, 87, 2, 2, 5133, 5134, 7, 40, 2, 2, 5134, 5135, 5, 1075, 536, 2, 5135, 1084, 3, 2, 2, 2, 5136, 5137, 7, 87, 2, 2, 5137, 5138, 7, 40, 2, 2, 5138, 5139, 5, 1077, 537, 2, 5139, 1086, 3, 2, 2, 2, 5140, 5141, 5, 1089, 543, 2, 5141, 5142, 7, 41, 2, 2, 5142, 1088, 3, 2, 2, 2, 5143, 5149, 7, 41, 2, 2, 5144, 5145, 7, 41, 2, 2, 5145, 5148, 7, 41, 2, 2, 5146, 5148, 10, 13, 2, 2, 5147, 5144, 3, 2, 2, 2, 5147, 5146, 3, 2, 2, 2, 5148, 5151, 3, 2, 2, 2, 5149, 5147, 3, 2, 2, 2, 5149, 5150, 3, 2, 2, 2, 5150, 1090, 3, 2, 2, 2, 5151, 5149, 3, 2, 2, 2, 5152, 5153, 7, 71, 2, 2, 5153, 5154, 7, 41, 2, 2, 5154, 5155, 3, 2, 2, 2, 5155, 5156, 8, 544, 3, 2, 5156, 5157, 8, 544, 4, 2, 5157, 1092, 3, 2, 2, 2, 5158, 5159, 5, 1095, 546, 2, 5159, 5160, 7, 41, 2, 2, 5160, 1094, 3, 2, 2, 2, 5161, 5162, 7, 87, 2, 2, 5162, 5163, 7, 40, 2, 2, 5163, 5164, 5, 1089, 543, 2, 5164, 1096, 3, 2, 2, 2, 5165, 5167, 7, 38, 2, 2, 5166, 5168, 5, 1099, 548, 2, 5167, 5166, 3, 2, 2, 2, 5167, 5168, 3, 2, 2, 2, 5168, 5169, 3, 2, 2, 2, 5169, 5170, 7, 38, 2, 2, 5170, 5171, 3, 2, 2, 2, 5171, 5172, 8, 547, 5, 2, 5172, 1098, 3, 2, 2, 2, 5173, 5177, 5, 1065, 531, 2, 5174, 5176, 5, 1069, 533, 2, 5175, 5174, 3, 2, 2, 2, 5176, 5179, 3, 2, 2, 2, 5177, 5175, 3, 2, 2, 2, 5177, 5178, 3, 2, 2, 2, 5178, 1100, 3, 2, 2, 2, 5179, 5177, 3, 2, 2, 2, 5180, 5181, 5, 1103, 550, 2, 5181, 5182, 7, 41, 2, 2, 5182, 1102, 3, 2, 2, 2, 5183, 5184, 7, 68, 2, 2, 5184, 5188, 7, 41, 2, 2, 5185, 5187, 9, 14, 2, 2, 5186, 5185, 3, 2, 2, 2, 5187, 5190, 3, 2, 2, 2, 5188, 5186, 3, 2, 2, 2, 5188, 5189, 3, 2, 2, 2, 5189, 1104, 3, 2, 2, 2, 5190, 5188, 3, 2, 2, 2, 5191, 5192, 5, 1107, 552, 2, 5192, 5193, 7, 41, 2, 2, 5193, 1106, 3, 2, 2, 2, 5194, 5195, 7, 68, 2, 2, 5195, 5196, 5, 1089, 543, 2, 5196, 1108, 3, 2, 2, 2, 5197, 5198, 5, 1111, 554, 2, 5198, 5199, 7, 41, 2, 2, 5199, 1110, 3, 2, 2, 2, 5200, 5201, 7, 90, 2, 2, 5201, 5205, 7, 41, 2, 2, 5202, 5204, 9, 15, 2, 2, 5203, 5202, 3, 2, 2, 2, 5204, 5207, 3, 2, 2, 2, 5205, 5203, 3, 2, 2, 2, 5205, 5206, 3, 2, 2, 2, 5206, 1112, 3, 2, 2, 2, 5207, 5205, 3, 2, 2, 2, 5208, 5209, 5, 1115, 556, 2, 5209, 5210, 7, 41, 2, 2, 5210, 1114, 3, 2, 2, 2, 5211, 5212, 7, 90, 2, 2, 5212, 5213, 5, 1089, 543, 2, 5213, 1116, 3, 2, 2, 2, 5214, 5215, 5, 1123, 560, 2, 5215, 1118, 3, 2, 2, 2, 5216, 5217, 5, 1123, 560, 2, 5217, 5218, 7, 48, 2, 2, 5218, 5219, 7, 48, 2, 2, 5219, 1120, 3, 2, 2, 2, 5220, 5221, 5, 1123, 560, 2, 5221, 5223, 7, 48, 2, 2, 5222, 5224, 5, 1123, 560, 2, 5223, 5222, 3, 2, 2, 2, 5223, 5224, 3, 2, 2, 2, 5224, 5230, 3, 2, 2, 2, 5225, 5227, 7, 71, 2, 2, 5226, 5228, 9, 3, 2, 2, 5227, 5226, 3, 2, 2, 2, 5227, 5228, 3, 2, 2, 2, 5228, 5229, 3, 2, 2, 2, 5229, 5231, 5, 1123, 560, 2, 5230, 5225, 3, 2, 2, 2, 5230, 5231, 3, 2, 2, 2, 5231, 5249, 3, 2, 2, 2, 5232, 5233, 7, 48, 2, 2, 5233, 5239, 5, 1123, 560, 2, 5234, 5236, 7, 71, 2, 2, 5235, 5237, 9, 3, 2, 2, 5236, 5235, 3, 2, 2, 2, 5236, 5237, 3, 2, 2, 2, 5237, 5238, 3, 2, 2, 2, 5238, 5240, 5, 1123, 560, 2, 5239, 5234, 3, 2, 2, 2, 5239, 5240, 3, 2, 2, 2, 5240, 5249, 3, 2, 2, 2, 5241, 5242, 5, 1123, 560, 2, 5242, 5244, 7, 71, 2, 2, 5243, 5245, 9, 3, 2, 2, 5244, 5243, 3, 2, 2, 2, 5244, 5245, 3, 2, 2, 2, 5245, 5246, 3, 2, 2, 2, 5246, 5247, 5, 1123, 560, 2, 5247, 5249, 3, 2, 2, 2, 5248, 5220, 3, 2, 2, 2, 5248, 5232, 3, 2, 2, 2, 5248, 5241, 3, 2, 2, 2, 5249, 1122, 3, 2, 2, 2, 5250, 5252, 9, 2, 2, 2, 5251, 5250, 3, 2, 2, 2, 5252, 5253, 3, 2, 2, 2, 5253, 5251, 3, 2, 2, 2, 5253, 5254, 3, 2, 2, 2, 5254, 1124, 3, 2, 2, 2, 5255, 5256, 7, 60, 2, 2, 5256, 5260, 9, 16, 2, 2, 5257, 5259, 9, 17, 2, 2, 5258, 5257, 3, 2, 2, 2, 5259, 5262, 3, 2, 2, 2, 5260, 5258, 3, 2, 2, 2, 5260, 5261, 3, 2, 2, 2, 5261, 1126, 3, 2, 2, 2, 5262, 5260, 3, 2, 2, 2, 5263, 5264, 7, 60, 2, 2, 5264, 5265, 7, 36, 2, 2, 5265, 5273, 3, 2, 2, 2, 5266, 5267, 7, 94, 2, 2, 5267, 5272, 11, 2, 2, 2, 5268, 5269, 7, 36, 2, 2, 5269, 5272, 7, 36, 2, 2, 5270, 5272, 10, 18, 2, 2, 5271, 5266, 3, 2, 2, 2, 5271, 5268, 3, 2, 2, 2, 5271, 5270, 3, 2, 2, 2, 5272, 5275, 3, 2, 2, 2, 5273, 5271, 3, 2, 2, 2, 5273, 5274, 3, 2, 2, 2, 5274, 5276, 3, 2, 2, 2, 5275, 5273, 3, 2, 2, 2, 5276, 5277, 7, 36, 2, 2, 5277, 1128, 3, 2, 2, 2, 5278, 5280, 9, 19, 2, 2, 5279, 5278, 3, 2, 2, 2, 5280, 5281, 3, 2, 2, 2, 5281, 5279, 3, 2, 2, 2, 5281, 5282, 3, 2, 2, 2, 5282, 5283, 3, 2, 2, 2, 5283, 5284, 8, 563, 6, 2, 5284, 1130, 3, 2, 2, 2, 5285, 5287, 7, 15, 2, 2, 5286, 5288, 7, 12, 2, 2, 5287, 5286, 3, 2, 2, 2, 5287, 5288, 3, 2, 2, 2, 5288, 5291, 3, 2, 2, 2, 5289, 5291, 7, 12, 2, 2, 5290, 5285, 3, 2, 2, 2, 5290, 5289, 3, 2, 2, 2, 5291, 5292, 3, 2, 2, 2, 5292, 5293, 8, 564, 6, 2, 5293, 1132, 3, 2, 2, 2, 5294, 5295, 7, 47, 2, 2, 5295, 5296, 7, 47, 2, 2, 5296, 5300, 3, 2, 2, 2, 5297, 5299, 10, 20, 2, 2, 5298, 5297, 3, 2, 2, 2, 5299, 5302, 3, 2, 2, 2, 5300, 5298, 3, 2, 2, 2, 5300, 5301, 3, 2, 2, 2, 5301, 5303, 3, 2, 2, 2, 5302, 5300, 3, 2, 2, 2, 5303, 5304, 8, 565, 6, 2, 5304, 1134, 3, 2, 2, 2, 5305, 5306, 7, 49, 2, 2, 5306, 5307, 7, 44, 2, 2, 5307, 5330, 3, 2, 2, 2, 5308, 5310, 7, 49, 2, 2, 5309, 5308, 3, 2, 2, 2, 5310, 5313, 3, 2, 2, 2, 5311, 5309, 3, 2, 2, 2, 5311, 5312, 3, 2, 2, 2, 5312, 5314, 3, 2, 2, 2, 5313, 5311, 3, 2, 2, 2, 5314, 5329, 5, 1135, 566, 2, 5315, 5329, 10, 21, 2, 2, 5316, 5318, 7, 49, 2, 2, 5317, 5316, 3, 2, 2, 2, 5318, 5319, 3, 2, 2, 2, 5319, 5317, 3, 2, 2, 2, 5319, 5320, 3, 2, 2, 2, 5320, 5321, 3, 2, 2, 2, 5321, 5329, 10, 21, 2, 2, 5322, 5324, 7, 44, 2, 2, 5323, 5322, 3, 2, 2, 2, 5324, 5325, 3, 2, 2, 2, 5325, 5323, 3, 2, 2, 2, 5325, 5326, 3, 2, 2, 2, 5326, 5327, 3, 2, 2, 2, 5327, 5329, 10, 21, 2, 2, 5328, 5311, 3, 2, 2, 2, 5328, 5315, 3, 2, 2, 2, 5328, 5317, 3, 2, 2, 2, 5328, 5323, 3, 2, 2, 2, 5329, 5332, 3, 2, 2, 2, 5330, 5328, 3, 2, 2, 2, 5330, 5331, 3, 2, 2, 2, 5331, 5336, 3, 2, 2, 2, 5332, 5330, 3, 2, 2, 2, 5333, 5335, 7, 44, 2, 2, 5334, 5333, 3, 2, 2, 2, 5335, 5338, 3, 2, 2, 2, 5336, 5334, 3, 2, 2, 2, 5336, 5337, 3, 2, 2, 2, 5337, 5339, 3, 2, 2, 2, 5338, 5336, 3, 2, 2, 2, 5339, 5340, 7, 44, 2, 2, 5340, 5341, 7, 49, 2, 2, 5341, 5342, 3, 2, 2, 2, 5342, 5343, 8, 566, 6, 2, 5343, 1136, 3, 2, 2, 2, 5344, 5345, 7, 49, 2, 2, 5345, 5346, 7, 44, 2, 2, 5346, 5371, 3, 2, 2, 2, 5347, 5349, 7, 49, 2, 2, 5348, 5347, 3, 2, 2, 2, 5349, 5352, 3, 2, 2, 2, 5350, 5348, 3, 2, 2, 2, 5350, 5351, 3, 2, 2, 2, 5351, 5353, 3, 2, 2, 2, 5352, 5350, 3, 2, 2, 2, 5353, 5370, 5, 1135, 566, 2, 5354, 5370, 10, 21, 2, 2, 5355, 5357, 7, 49, 2, 2, 5356, 5355, 3, 2, 2, 2, 5357, 5358, 3, 2, 2, 2, 5358, 5356, 3, 2, 2, 2, 5358, 5359, 3, 2, 2, 2, 5359, 5360, 3, 2, 2, 2, 5360, 5368, 10, 21, 2, 2, 5361, 5363, 7, 44, 2, 2, 5362, 5361, 3, 2, 2, 2, 5363, 5364, 3, 2, 2, 2, 5364, 5362, 3, 2, 2, 2, 5364, 5365, 3, 2, 2, 2, 5365, 5366, 3, 2, 2, 2, 5366, 5368, 10, 21, 2, 2, 5367, 5356, 3, 2, 2, 2, 5367, 5362, 3, 2, 2, 2, 5368, 5370, 3, 2, 2, 2, 5369, 5350, 3, 2, 2, 2, 5369, 5354, 3, 2, 2, 2, 5369, 5367, 3, 2, 2, 2, 5370, 5373, 3, 2, 2, 2, 5371, 5369, 3, 2, 2, 2, 5371, 5372, 3, 2, 2, 2, 5372, 5391, 3, 2, 2, 2, 5373, 5371, 3, 2, 2, 2, 5374, 5376, 7, 49, 2, 2, 5375, 5374, 3, 2, 2, 2, 5376, 5377, 3, 2, 2, 2, 5377, 5375, 3, 2, 2, 2, 5377, 5378, 3, 2, 2, 2, 5378, 5392, 3, 2, 2, 2, 5379, 5381, 7, 44, 2, 2, 5380, 5379, 3, 2, 2, 2, 5381, 5382, 3, 2, 2, 2, 5382, 5380, 3, 2, 2, 2, 5382, 5383, 3, 2, 2, 2, 5383, 5392, 3, 2, 2, 2, 5384, 5386, 7, 49, 2, 2, 5385, 5384, 3, 2, 2, 2, 5386, 5389, 3, 2, 2, 2, 5387, 5385, 3, 2, 2, 2, 5387, 5388, 3, 2, 2, 2, 5388, 5390, 3, 2, 2, 2, 5389, 5387, 3, 2, 2, 2, 5390, 5392, 5, 1137, 567, 2, 5391, 5375, 3, 2, 2, 2, 5391, 5380, 3, 2, 2, 2, 5391, 5387, 3, 2, 2, 2, 5391, 5392, 3, 2, 2, 2, 5392, 1138, 3, 2, 2, 2, 5393, 5405, 7, 94, 2, 2, 5394, 5404, 10, 22, 2, 2, 5395, 5399, 7, 36, 2, 2, 5396, 5398, 10, 23, 2, 2, 5397, 5396, 3, 2, 2, 2, 5398, 5401, 3, 2, 2, 2, 5399, 5397, 3, 2, 2, 2, 5399, 5400, 3, 2, 2, 2, 5400, 5402, 3, 2, 2, 2, 5401, 5399, 3, 2, 2, 2, 5402, 5404, 7, 36, 2, 2, 5403, 5394, 3, 2, 2, 2, 5403, 5395, 3, 2, 2, 2, 5404, 5407, 3, 2, 2, 2, 5405, 5403, 3, 2, 2, 2, 5405, 5406, 3, 2, 2, 2, 5406, 5415, 3, 2, 2, 2, 5407, 5405, 3, 2, 2, 2, 5408, 5412, 7, 36, 2, 2, 5409, 5411, 10, 23, 2, 2, 5410, 5409, 3, 2, 2, 2, 5411, 5414, 3, 2, 2, 2, 5412, 5410, 3, 2, 2, 2, 5412, 5413, 3, 2, 2, 2, 5413, 5416, 3, 2, 2, 2, 5414, 5412, 3, 2, 2, 2, 5415, 5408, 3, 2, 2, 2, 5415, 5416, 3, 2, 2, 2, 5416, 1140, 3, 2, 2, 2, 5417, 5418, 7, 94, 2, 2, 5418, 5419, 7, 94, 2, 2, 5419, 1142, 3, 2, 2, 2, 5420, 5421, 11, 2, 2, 2, 5421, 1144, 3, 2, 2, 2, 5422, 5423, 5, 1149, 573, 2, 5423, 5424, 7, 41, 2, 2, 5424, 5425, 3, 2, 2, 2, 5425, 5426, 8, 571, 7, 2, 5426, 1146, 3, 2, 2, 2, 5427, 5429, 5, 1149, 573, 2, 5428, 5430, 7, 94, 2, 2, 5429, 5428, 3, 2, 2, 2, 5429, 5430, 3, 2, 2, 2, 5430, 5431, 3, 2, 2, 2, 5431, 5432, 7, 2, 2, 3, 5432, 1148, 3, 2, 2, 2, 5433, 5434, 7, 41, 2, 2, 5434, 5457, 7, 41, 2, 2, 5435, 5453, 7, 94, 2, 2, 5436, 5437, 7, 122, 2, 2, 5437, 5454, 9, 15, 2, 2, 5438, 5439, 7, 119, 2, 2, 5439, 5440, 9, 15, 2, 2, 5440, 5441, 9, 15, 2, 2, 5441, 5442, 9, 15, 2, 2, 5442, 5454, 9, 15, 2, 2, 5443, 5444, 7, 87, 2, 2, 5444, 5445, 9, 15, 2, 2, 5445, 5446, 9, 15, 2, 2, 5446, 5447, 9, 15, 2, 2, 5447, 5448, 9, 15, 2, 2, 5448, 5449, 9, 15, 2, 2, 5449, 5450, 9, 15, 2, 2, 5450, 5451, 9, 15, 2, 2, 5451, 5454, 9, 15, 2, 2, 5452, 5454, 10, 24, 2, 2, 5453, 5436, 3, 2, 2, 2, 5453, 5438, 3, 2, 2, 2, 5453, 5443, 3, 2, 2, 2, 5453, 5452, 3, 2, 2, 2, 5454, 5457, 3, 2, 2, 2, 5455, 5457, 10, 25, 2, 2, 5456, 5433, 3, 2, 2, 2, 5456, 5435, 3, 2, 2, 2, 5456, 5455, 3, 2, 2, 2, 5457, 5460, 3, 2, 2, 2, 5458, 5456, 3, 2, 2, 2, 5458, 5459, 3, 2, 2, 2, 5459, 1150, 3, 2, 2, 2, 5460, 5458, 3, 2, 2, 2, 5461, 5462, 5, 1155, 576, 2, 5462, 5463, 7, 41, 2, 2, 5463, 5464, 3, 2, 2, 2, 5464, 5465, 8, 574, 7, 2, 5465, 1152, 3, 2, 2, 2, 5466, 5468, 5, 1155, 576, 2, 5467, 5469, 7, 94, 2, 2, 5468, 5467, 3, 2, 2, 2, 5468, 5469, 3, 2, 2, 2, 5469, 5470, 3, 2, 2, 2, 5470, 5471, 7, 2, 2, 3, 5471, 1154, 3, 2, 2, 2, 5472, 5473, 7, 41, 2, 2, 5473, 5478, 7, 41, 2, 2, 5474, 5475, 7, 94, 2, 2, 5475, 5478, 11, 2, 2, 2, 5476, 5478, 10, 25, 2, 2, 5477, 5472, 3, 2, 2, 2, 5477, 5474, 3, 2, 2, 2, 5477, 5476, 3, 2, 2, 2, 5478, 5481, 3, 2, 2, 2, 5479, 5477, 3, 2, 2, 2, 5479, 5480, 3, 2, 2, 2, 5480, 1156, 3, 2, 2, 2, 5481, 5479, 3, 2, 2, 2, 5482, 5483, 5, 1129, 563, 2, 5483, 5484, 3, 2, 2, 2, 5484, 5485, 8, 577, 8, 2, 5485, 5486, 8, 577, 6, 2, 5486, 1158, 3, 2, 2, 2, 5487, 5488, 5, 1131, 564, 2, 5488, 5489, 3, 2, 2, 2, 5489, 5490, 8, 578, 9, 2, 5490, 5491, 8, 578, 6, 2, 5491, 5492, 8, 578, 10, 2, 5492, 1160, 3, 2, 2, 2, 5493, 5494, 5, 1129, 563, 2, 5494, 5495, 3, 2, 2, 2, 5495, 5496, 8, 579, 8, 2, 5496, 5497, 8, 579, 6, 2, 5497, 1162, 3, 2, 2, 2, 5498, 5499, 5, 1131, 564, 2, 5499, 5500, 3, 2, 2, 2, 5500, 5501, 8, 580, 9, 2, 5501, 5502, 8, 580, 6, 2, 5502, 1164, 3, 2, 2, 2, 5503, 5504, 7, 41, 2, 2, 5504, 5505, 3, 2, 2, 2, 5505, 5506, 8, 581, 3, 2, 5506, 5507, 8, 581, 11, 2, 5507, 1166, 3, 2, 2, 2, 5508, 5510, 10, 26, 2, 2, 5509, 5508, 3, 2, 2, 2, 5510, 5511, 3, 2, 2, 2, 5511, 5509, 3, 2, 2, 2, 5511, 5512, 3, 2, 2, 2, 5512, 5521, 3, 2, 2, 2, 5513, 5517, 7, 38, 2, 2, 5514, 5516, 10, 26, 2, 2, 5515, 5514, 3, 2, 2, 2, 5516, 5519, 3, 2, 2, 2, 5517, 5515, 3, 2, 2, 2, 5517, 5518, 3, 2, 2, 2, 5518, 5521, 3, 2, 2, 2, 5519, 5517, 3, 2, 2, 2, 5520, 5509, 3, 2, 2, 2, 5520, 5513, 3, 2, 2, 2, 5521, 1168, 3, 2, 2, 2, 5522, 5524, 7, 38, 2, 2, 5523, 5525, 5, 1099, 548, 2, 5524, 5523, 3, 2, 2, 2, 5524, 5525, 3, 2, 2, 2, 5525, 5526, 3, 2, 2, 2, 5526, 5527, 7, 38, 2, 2, 5527, 5528, 3, 2, 2, 2, 5528, 5529, 8, 583, 12, 2, 5529, 1170, 3, 2, 2, 2, 79, 2, 3, 4, 5, 6, 1238, 1244, 1248, 1250, 1253, 1255, 1258, 1262, 1264, 1269, 1274, 5084, 5090, 5094, 5098, 5107, 5109, 5119, 5121, 5147, 5149, 5167, 5177, 5188, 5205, 5223, 5227, 5230, 5236, 5239, 5244, 5248, 5253, 5260, 5271, 5273, 5281, 5287, 5290, 5300, 5311, 5319, 5325, 5328, 5330, 5336, 5350, 5358, 5364, 5367, 5369, 5371, 5377, 5382, 5387, 5391, 5399, 5403, 5405, 5412, 5415, 5429, 5453, 5456, 5458, 5468, 5477, 5479, 5511, 5517, 5520, 5524, 13, 9, 31, 2, 5, 2, 2, 7, 3, 2, 7, 6, 2, 2, 3, 2, 4, 4, 2, 9, 554, 2, 9, 555, 2, 4, 5, 2, 4, 3, 2, 6, 2, 2] \ No newline at end of file diff --git a/src/lib/pgsql/PostgreSQLLexer.tokens b/src/lib/pgsql/PostgreSQLLexer.tokens index 149c268..1c441f2 100644 --- a/src/lib/pgsql/PostgreSQLLexer.tokens +++ b/src/lib/pgsql/PostgreSQLLexer.tokens @@ -27,530 +27,543 @@ 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 -DollarText=551 -EndDollarStringConstant=552 -AfterEscapeStringConstantWithNewlineMode_Continued=553 +KW_ALL=30 +KW_ANALYSE=31 +KW_ANALYZE=32 +KW_AND=33 +KW_ANY=34 +KW_ARRAY=35 +KW_AS=36 +KW_ASC=37 +KW_ASYMMETRIC=38 +KW_BOTH=39 +KW_CASE=40 +KW_CAST=41 +KW_CHECK=42 +KW_COLLATE=43 +KW_COLUMN=44 +KW_CONSTRAINT=45 +KW_CREATE=46 +KW_CURRENT_CATALOG=47 +KW_CURRENT_DATE=48 +KW_CURRENT_ROLE=49 +KW_CURRENT_TIME=50 +KW_CURRENT_TIMESTAMP=51 +KW_CURRENT_USER=52 +KW_DEFAULT=53 +KW_DEFERRABLE=54 +KW_DESC=55 +KW_DISTINCT=56 +KW_DO=57 +KW_ELSE=58 +KW_EXCEPT=59 +KW_FALSE=60 +KW_FETCH=61 +KW_FOR=62 +KW_FOREIGN=63 +KW_FROM=64 +KW_GRANT=65 +KW_GROUP=66 +KW_HAVING=67 +KW_IN=68 +KW_INITIALLY=69 +KW_INTERSECT=70 +KW_INTO=71 +KW_LATERAL=72 +KW_LEADING=73 +KW_LIMIT=74 +KW_LOCALTIME=75 +KW_LOCALTIMESTAMP=76 +KW_NOT=77 +KW_NULL=78 +KW_OFFSET=79 +KW_ON=80 +KW_ONLY=81 +KW_OR=82 +KW_ORDER=83 +KW_PLACING=84 +KW_PRIMARY=85 +KW_REFERENCES=86 +KW_RETURNING=87 +KW_SELECT=88 +KW_SESSION_USER=89 +KW_SOME=90 +KW_SYMMETRIC=91 +KW_TABLE=92 +KW_THEN=93 +KW_TO=94 +KW_TRAILING=95 +KW_TRUE=96 +KW_UNION=97 +KW_UNIQUE=98 +KW_USER=99 +KW_USING=100 +KW_VARIADIC=101 +KW_WHEN=102 +KW_WHERE=103 +KW_WINDOW=104 +KW_WITH=105 +KW_AUTHORIZATION=106 +KW_BINARY=107 +KW_COLLATION=108 +KW_CONCURRENTLY=109 +KW_CROSS=110 +KW_CURRENT_SCHEMA=111 +KW_FREEZE=112 +KW_FULL=113 +KW_ILIKE=114 +KW_INNER=115 +KW_IS=116 +KW_ISNULL=117 +KW_JOIN=118 +KW_LEFT=119 +KW_LIKE=120 +KW_NATURAL=121 +KW_NOTNULL=122 +KW_OUTER=123 +KW_OVER=124 +KW_OVERLAPS=125 +KW_RIGHT=126 +KW_SIMILAR=127 +KW_VERBOSE=128 +KW_ABORT=129 +KW_ABSOLUTE=130 +KW_ACCESS=131 +KW_ACTION=132 +KW_ADD=133 +KW_ADMIN=134 +KW_AFTER=135 +KW_AGGREGATE=136 +KW_ALSO=137 +KW_ALTER=138 +KW_ALWAYS=139 +KW_ASSERTION=140 +KW_ASSIGNMENT=141 +KW_AT=142 +KW_ATTRIBUTE=143 +KW_BACKWARD=144 +KW_BEFORE=145 +KW_BEGIN=146 +KW_BY=147 +KW_CACHE=148 +KW_CALLED=149 +KW_CASCADE=150 +KW_CASCADED=151 +KW_CATALOG=152 +KW_CHAIN=153 +KW_CHARACTERISTICS=154 +KW_CHECKPOINT=155 +KW_CLASS=156 +KW_CLOSE=157 +KW_CLUSTER=158 +KW_COMMENT=159 +KW_COMMENTS=160 +KW_COMMIT=161 +KW_COMMITTED=162 +KW_CONFIGURATION=163 +KW_CONNECTION=164 +KW_CONSTRAINTS=165 +KW_CONTENT=166 +KW_CONTINUE=167 +KW_CONVERSION=168 +KW_COPY=169 +KW_COST=170 +KW_CSV=171 +KW_CURSOR=172 +KW_CYCLE=173 +KW_DATA=174 +KW_DATABASE=175 +KW_DAY=176 +KW_DEALLOCATE=177 +KW_DECLARE=178 +KW_DEFAULTS=179 +KW_DEFERRED=180 +KW_DEFINER=181 +KW_DELETE=182 +KW_DELIMITER=183 +KW_DELIMITERS=184 +KW_DICTIONARY=185 +KW_DISABLE=186 +KW_DISCARD=187 +KW_DOCUMENT=188 +KW_DOMAIN=189 +KW_DOUBLE=190 +KW_DROP=191 +KW_EACH=192 +KW_ENABLE=193 +KW_ENCODING=194 +KW_ENCRYPTED=195 +KW_ENUM=196 +KW_ESCAPE=197 +KW_EVENT=198 +KW_EXCLUDE=199 +KW_EXCLUDING=200 +KW_EXCLUSIVE=201 +KW_EXECUTE=202 +KW_EXPLAIN=203 +KW_EXTENSION=204 +KW_EXTERNAL=205 +KW_FAMILY=206 +KW_FIRST=207 +KW_FOLLOWING=208 +KW_FORCE=209 +KW_FORWARD=210 +KW_FUNCTION=211 +KW_FUNCTIONS=212 +KW_GLOBAL=213 +KW_GRANTED=214 +KW_HANDLER=215 +KW_HEADER=216 +KW_HOLD=217 +KW_HOUR=218 +KW_IDENTITY=219 +KW_IF=220 +KW_IMMEDIATE=221 +KW_IMMUTABLE=222 +KW_IMPLICIT=223 +KW_INCLUDING=224 +KW_INCREMENT=225 +KW_INDEX=226 +KW_INDEXES=227 +KW_INHERIT=228 +KW_NOINHERIT=229 +KW_SUPERUSER=230 +KW_NOSUPERUSER=231 +KW_CREATEDB=232 +KW_NOCREATEDB=233 +KW_CREATEROLE=234 +KW_NOCREATEROLE=235 +KW_CREATEUSER=236 +KW_NOCREATEUSER=237 +KW_INHERITS=238 +KW_INLINE=239 +KW_INSENSITIVE=240 +KW_INSERT=241 +KW_INSTEAD=242 +KW_INVOKER=243 +KW_ISOLATION=244 +KW_KEY=245 +KW_LABEL=246 +KW_LANGUAGE=247 +KW_LARGE=248 +KW_LAST=249 +KW_LEAKPROOF=250 +KW_LEVEL=251 +KW_LISTEN=252 +KW_LOAD=253 +KW_LOCAL=254 +KW_LOCATION=255 +KW_LOCK=256 +KW_MAPPING=257 +KW_MATCH=258 +KW_MATERIALIZED=259 +KW_MAXVALUE=260 +KW_MINUTE=261 +KW_MINVALUE=262 +KW_MODE=263 +KW_MONTH=264 +KW_MOVE=265 +KW_NAME=266 +KW_NAMES=267 +KW_NEXT=268 +KW_NO=269 +KW_NOTHING=270 +KW_NOTIFY=271 +KW_NOWAIT=272 +KW_NULLS=273 +KW_OBJECT=274 +KW_OF=275 +KW_OFF=276 +KW_OIDS=277 +KW_OPERATOR=278 +KW_OPTION=279 +KW_OPTIONS=280 +KW_OWNED=281 +KW_OWNER=282 +KW_PARSER=283 +KW_PARTIAL=284 +KW_PARTITION=285 +KW_PASSING=286 +KW_PASSWORD=287 +KW_PLANS=288 +KW_PRECEDING=289 +KW_PREPARE=290 +KW_PREPARED=291 +KW_PRESERVE=292 +KW_PRIOR=293 +KW_PRIVILEGES=294 +KW_PROCEDURAL=295 +KW_PROCEDURE=296 +KW_PROGRAM=297 +KW_QUOTE=298 +KW_RANGE=299 +KW_READ=300 +KW_REASSIGN=301 +KW_RECHECK=302 +KW_RECURSIVE=303 +KW_REF=304 +KW_REFRESH=305 +KW_REINDEX=306 +KW_RELATIVE=307 +KW_RELEASE=308 +KW_RENAME=309 +KW_REPEATABLE=310 +KW_REPLACE=311 +KW_REPLICA=312 +KW_RESET=313 +KW_RESTART=314 +KW_RESTRICT=315 +KW_RETURNS=316 +KW_REVOKE=317 +KW_ROLE=318 +KW_ROLLBACK=319 +KW_ROWS=320 +KW_RULE=321 +KW_SAVEPOINT=322 +KW_SCHEMA=323 +KW_SCROLL=324 +KW_SEARCH=325 +KW_SECOND=326 +KW_SECURITY=327 +KW_SEQUENCE=328 +KW_SEQUENCES=329 +KW_SERIALIZABLE=330 +KW_SERVER=331 +KW_SESSION=332 +KW_SET=333 +KW_SHARE=334 +KW_SHOW=335 +KW_SIMPLE=336 +KW_SNAPSHOT=337 +KW_STABLE=338 +KW_STANDALONE=339 +KW_START=340 +KW_STATEMENT=341 +KW_STATISTICS=342 +KW_STDIN=343 +KW_STDOUT=344 +KW_STORAGE=345 +KW_STRICT=346 +KW_STRIP=347 +KW_SYSID=348 +KW_SYSTEM=349 +KW_TABLES=350 +KW_TABLESPACE=351 +KW_TEMP=352 +KW_TEMPLATE=353 +KW_TEMPORARY=354 +KW_TEXT=355 +KW_TRANSACTION=356 +KW_TRIGGER=357 +KW_TRUNCATE=358 +KW_TRUSTED=359 +KW_TYPE=360 +KW_TYPES=361 +KW_UNBOUNDED=362 +KW_UNCOMMITTED=363 +KW_UNENCRYPTED=364 +KW_UNKNOWN=365 +KW_UNLISTEN=366 +KW_UNLOGGED=367 +KW_UNTIL=368 +KW_UPDATE=369 +KW_VACUUM=370 +KW_VALID=371 +KW_VALIDATE=372 +KW_VALIDATOR=373 +KW_VARYING=374 +KW_VERSION=375 +KW_VIEW=376 +KW_VOLATILE=377 +KW_WHITESPACE=378 +KW_WITHOUT=379 +KW_WORK=380 +KW_WRAPPER=381 +KW_WRITE=382 +KW_XML=383 +KW_YEAR=384 +KW_YES=385 +KW_ZONE=386 +KW_BETWEEN=387 +KW_BIGINT=388 +KW_BIT=389 +KW_BOOLEAN=390 +KW_CHAR=391 +KW_CHARACTER=392 +KW_COALESCE=393 +KW_DEC=394 +KW_DECIMAL=395 +KW_EXISTS=396 +KW_EXTRACT=397 +KW_FLOAT=398 +KW_GREATEST=399 +KW_INOUT=400 +KW_INT=401 +KW_INTEGER=402 +KW_INTERVAL=403 +KW_LEAST=404 +KW_NATIONAL=405 +KW_NCHAR=406 +KW_NONE=407 +KW_NULLIF=408 +KW_NUMERIC=409 +KW_OVERLAY=410 +KW_POSITION=411 +KW_PRECISION=412 +KW_REAL=413 +KW_ROW=414 +KW_SETOF=415 +KW_SMALLINT=416 +KW_SUBSTRING=417 +KW_TIME=418 +KW_TIMESTAMP=419 +KW_TREAT=420 +KW_TRIM=421 +KW_VALUES=422 +KW_VARCHAR=423 +KW_XMLATTRIBUTES=424 +KW_XMLCONCAT=425 +KW_XMLELEMENT=426 +KW_XMLEXISTS=427 +KW_XMLFOREST=428 +KW_XMLPARSE=429 +KW_XMLPI=430 +KW_XMLROOT=431 +KW_XMLSERIALIZE=432 +KW_CALL=433 +KW_CURRENT=434 +KW_ATTACH=435 +KW_DETACH=436 +KW_EXPRESSION=437 +KW_GENERATED=438 +KW_LOGGED=439 +KW_STORED=440 +KW_INCLUDE=441 +KW_ROUTINE=442 +KW_TRANSFORM=443 +KW_IMPORT=444 +KW_POLICY=445 +KW_METHOD=446 +KW_REFERENCING=447 +KW_NEW=448 +KW_OLD=449 +KW_VALUE=450 +KW_SUBSCRIPTION=451 +KW_PUBLICATION=452 +KW_OUT=453 +KW_END=454 +KW_ROUTINES=455 +KW_SCHEMAS=456 +KW_PROCEDURES=457 +KW_INPUT=458 +KW_SUPPORT=459 +KW_PARALLEL=460 +KW_SQL=461 +KW_DEPENDS=462 +KW_OVERRIDING=463 +KW_CONFLICT=464 +KW_SKIP=465 +KW_LOCKED=466 +KW_TIES=467 +KW_ROLLUP=468 +KW_CUBE=469 +KW_GROUPING=470 +KW_SETS=471 +KW_TABLESAMPLE=472 +KW_ORDINALITY=473 +KW_XMLTABLE=474 +KW_COLUMNS=475 +KW_XMLNAMESPACES=476 +KW_ROWTYPE=477 +KW_NORMALIZED=478 +KW_WITHIN=479 +KW_FILTER=480 +KW_GROUPS=481 +KW_OTHERS=482 +KW_NFC=483 +KW_NFD=484 +KW_NFKC=485 +KW_NFKD=486 +KW_UESCAPE=487 +KW_VIEWS=488 +KW_NORMALIZE=489 +KW_DUMP=490 +KW_PRINT_STRICT_PARAMS=491 +KW_VARIABLE_CONFLICT=492 +KW_ERROR=493 +KW_USE_VARIABLE=494 +KW_USE_COLUMN=495 +KW_ALIAS=496 +KW_CONSTANT=497 +KW_PERFORM=498 +KW_GET=499 +KW_DIAGNOSTICS=500 +KW_STACKED=501 +KW_ELSIF=502 +KW_WHILE=503 +KW_REVERSE=504 +KW_FOREACH=505 +KW_SLICE=506 +KW_EXIT=507 +KW_RETURN=508 +KW_QUERY=509 +KW_RAISE=510 +KW_SQLSTATE=511 +KW_DEBUG=512 +KW_LOG=513 +KW_INFO=514 +KW_NOTICE=515 +KW_WARNING=516 +KW_EXCEPTION=517 +KW_ASSERT=518 +KW_LOOP=519 +KW_OPEN=520 +KW_PEFERENCES=521 +KW_USAGE=522 +KW_CONNECT=523 +KW_PUBLIC=524 +Identifier=525 +QuotedIdentifier=526 +UnterminatedQuotedIdentifier=527 +InvalidQuotedIdentifier=528 +InvalidUnterminatedQuotedIdentifier=529 +UnicodeQuotedIdentifier=530 +UnterminatedUnicodeQuotedIdentifier=531 +InvalidUnicodeQuotedIdentifier=532 +InvalidUnterminatedUnicodeQuotedIdentifier=533 +StringConstant=534 +UnterminatedStringConstant=535 +UnicodeEscapeStringConstant=536 +UnterminatedUnicodeEscapeStringConstant=537 +BeginDollarStringConstant=538 +BinaryStringConstant=539 +UnterminatedBinaryStringConstant=540 +InvalidBinaryStringConstant=541 +InvalidUnterminatedBinaryStringConstant=542 +HexadecimalStringConstant=543 +UnterminatedHexadecimalStringConstant=544 +InvalidHexadecimalStringConstant=545 +InvalidUnterminatedHexadecimalStringConstant=546 +Integral=547 +NumericFail=548 +Numeric=549 +PLSQLVARIABLENAME=550 +PLSQLIDENTIFIER=551 +Whitespace=552 +Newline=553 +LineComment=554 +BlockComment=555 +UnterminatedBlockComment=556 +MetaCommand=557 +EndMetaCommand=558 +ErrorCharacter=559 +EscapeStringConstant=560 +UnterminatedEscapeStringConstant=561 +InvalidEscapeStringConstant=562 +InvalidUnterminatedEscapeStringConstant=563 +DollarText=564 +EndDollarStringConstant=565 +AfterEscapeStringConstantWithNewlineMode_Continued=566 '$'=1 '('=2 ')'=3 @@ -777,288 +790,301 @@ AfterEscapeStringConstantWithNewlineMode_Continued=553 '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 -'\''=553 +'NOINHERIT'=229 +'SUPERUSER'=230 +'NOSUPERUSER'=231 +'CREATEDB'=232 +'NOCREATEDB'=233 +'CREATEROLE'=234 +'NOCREATEROLE'=235 +'CREATEUSER'=236 +'NOCREATEUSER'=237 +'INHERITS'=238 +'INLINE'=239 +'INSENSITIVE'=240 +'INSERT'=241 +'INSTEAD'=242 +'INVOKER'=243 +'ISOLATION'=244 +'KEY'=245 +'LABEL'=246 +'LANGUAGE'=247 +'LARGE'=248 +'LAST'=249 +'LEAKPROOF'=250 +'LEVEL'=251 +'LISTEN'=252 +'LOAD'=253 +'LOCAL'=254 +'LOCATION'=255 +'LOCK'=256 +'MAPPING'=257 +'MATCH'=258 +'MATERIALIZED'=259 +'MAXVALUE'=260 +'MINUTE'=261 +'MINVALUE'=262 +'MODE'=263 +'MONTH'=264 +'MOVE'=265 +'NAME'=266 +'NAMES'=267 +'NEXT'=268 +'NO'=269 +'NOTHING'=270 +'NOTIFY'=271 +'NOWAIT'=272 +'NULLS'=273 +'OBJECT'=274 +'OF'=275 +'OFF'=276 +'OIDS'=277 +'OPERATOR'=278 +'OPTION'=279 +'OPTIONS'=280 +'OWNED'=281 +'OWNER'=282 +'PARSER'=283 +'PARTIAL'=284 +'PARTITION'=285 +'PASSING'=286 +'PASSWORD'=287 +'PLANS'=288 +'PRECEDING'=289 +'PREPARE'=290 +'PREPARED'=291 +'PRESERVE'=292 +'PRIOR'=293 +'PRIVILEGES'=294 +'PROCEDURAL'=295 +'PROCEDURE'=296 +'PROGRAM'=297 +'QUOTE'=298 +'RANGE'=299 +'READ'=300 +'REASSIGN'=301 +'RECHECK'=302 +'RECURSIVE'=303 +'REF'=304 +'REFRESH'=305 +'REINDEX'=306 +'RELATIVE'=307 +'RELEASE'=308 +'RENAME'=309 +'REPEATABLE'=310 +'REPLACE'=311 +'REPLICA'=312 +'RESET'=313 +'RESTART'=314 +'RESTRICT'=315 +'RETURNS'=316 +'REVOKE'=317 +'ROLE'=318 +'ROLLBACK'=319 +'ROWS'=320 +'RULE'=321 +'SAVEPOINT'=322 +'SCHEMA'=323 +'SCROLL'=324 +'SEARCH'=325 +'SECOND'=326 +'SECURITY'=327 +'SEQUENCE'=328 +'SEQUENCES'=329 +'SERIALIZABLE'=330 +'SERVER'=331 +'SESSION'=332 +'SET'=333 +'SHARE'=334 +'SHOW'=335 +'SIMPLE'=336 +'SNAPSHOT'=337 +'STABLE'=338 +'STANDALONE'=339 +'START'=340 +'STATEMENT'=341 +'STATISTICS'=342 +'STDIN'=343 +'STDOUT'=344 +'STORAGE'=345 +'STRICT'=346 +'STRIP'=347 +'SYSID'=348 +'SYSTEM'=349 +'TABLES'=350 +'TABLESPACE'=351 +'TEMP'=352 +'TEMPLATE'=353 +'TEMPORARY'=354 +'TEXT'=355 +'TRANSACTION'=356 +'TRIGGER'=357 +'TRUNCATE'=358 +'TRUSTED'=359 +'TYPE'=360 +'TYPES'=361 +'UNBOUNDED'=362 +'UNCOMMITTED'=363 +'UNENCRYPTED'=364 +'UNKNOWN'=365 +'UNLISTEN'=366 +'UNLOGGED'=367 +'UNTIL'=368 +'UPDATE'=369 +'VACUUM'=370 +'VALID'=371 +'VALIDATE'=372 +'VALIDATOR'=373 +'VARYING'=374 +'VERSION'=375 +'VIEW'=376 +'VOLATILE'=377 +'WHITESPACE'=378 +'WITHOUT'=379 +'WORK'=380 +'WRAPPER'=381 +'WRITE'=382 +'XML'=383 +'YEAR'=384 +'YES'=385 +'ZONE'=386 +'BETWEEN'=387 +'BIGINT'=388 +'BIT'=389 +'BOOLEAN'=390 +'CHAR'=391 +'CHARACTER'=392 +'COALESCE'=393 +'DEC'=394 +'DECIMAL'=395 +'EXISTS'=396 +'EXTRACT'=397 +'FLOAT'=398 +'GREATEST'=399 +'INOUT'=400 +'INT'=401 +'INTEGER'=402 +'INTERVAL'=403 +'LEAST'=404 +'NATIONAL'=405 +'NCHAR'=406 +'NONE'=407 +'NULLIF'=408 +'NUMERIC'=409 +'OVERLAY'=410 +'POSITION'=411 +'PRECISION'=412 +'REAL'=413 +'ROW'=414 +'SETOF'=415 +'SMALLINT'=416 +'SUBSTRING'=417 +'TIME'=418 +'TIMESTAMP'=419 +'TREAT'=420 +'TRIM'=421 +'VALUES'=422 +'VARCHAR'=423 +'XMLATTRIBUTES'=424 +'XMLCONCAT'=425 +'XMLELEMENT'=426 +'XMLEXISTS'=427 +'XMLFOREST'=428 +'XMLPARSE'=429 +'XMLPI'=430 +'XMLROOT'=431 +'XMLSERIALIZE'=432 +'CALL'=433 +'CURRENT'=434 +'ATTACH'=435 +'DETACH'=436 +'EXPRESSION'=437 +'GENERATED'=438 +'LOGGED'=439 +'STORED'=440 +'INCLUDE'=441 +'ROUTINE'=442 +'TRANSFORM'=443 +'IMPORT'=444 +'POLICY'=445 +'METHOD'=446 +'REFERENCING'=447 +'NEW'=448 +'OLD'=449 +'VALUE'=450 +'SUBSCRIPTION'=451 +'PUBLICATION'=452 +'OUT'=453 +'END'=454 +'ROUTINES'=455 +'SCHEMAS'=456 +'PROCEDURES'=457 +'INPUT'=458 +'SUPPORT'=459 +'PARALLEL'=460 +'SQL'=461 +'DEPENDS'=462 +'OVERRIDING'=463 +'CONFLICT'=464 +'SKIP'=465 +'LOCKED'=466 +'TIES'=467 +'ROLLUP'=468 +'CUBE'=469 +'GROUPING'=470 +'SETS'=471 +'TABLESAMPLE'=472 +'ORDINALITY'=473 +'XMLTABLE'=474 +'COLUMNS'=475 +'XMLNAMESPACES'=476 +'ROWTYPE'=477 +'NORMALIZED'=478 +'WITHIN'=479 +'FILTER'=480 +'GROUPS'=481 +'OTHERS'=482 +'NFC'=483 +'NFD'=484 +'NFKC'=485 +'NFKD'=486 +'UESCAPE'=487 +'VIEWS'=488 +'NORMALIZE'=489 +'DUMP'=490 +'PRINT_STRICT_PARAMS'=491 +'VARIABLE_CONFLICT'=492 +'ERROR'=493 +'USE_VARIABLE'=494 +'USE_COLUMN'=495 +'ALIAS'=496 +'CONSTANT'=497 +'PERFORM'=498 +'GET'=499 +'DIAGNOSTICS'=500 +'STACKED'=501 +'ELSIF'=502 +'WHILE'=503 +'REVERSE'=504 +'FOREACH'=505 +'SLICE'=506 +'EXIT'=507 +'RETURN'=508 +'QUERY'=509 +'RAISE'=510 +'SQLSTATE'=511 +'DEBUG'=512 +'LOG'=513 +'INFO'=514 +'NOTICE'=515 +'WARNING'=516 +'EXCEPTION'=517 +'ASSERT'=518 +'LOOP'=519 +'OPEN'=520 +'PEFERENCES'=521 +'USAGE'=522 +'CONNECT'=523 +'PUBLIC'=524 +'\\\\'=558 +'\''=566 diff --git a/src/lib/pgsql/PostgreSQLLexer.ts b/src/lib/pgsql/PostgreSQLLexer.ts index 0d00623..b301068 100644 --- a/src/lib/pgsql/PostgreSQLLexer.ts +++ b/src/lib/pgsql/PostgreSQLLexer.ts @@ -1,7 +1,4 @@ -// Generated from /Users/ziv/github.com/dt-sql-parser/src/grammar/pgsql/PostgreSQLLexer.g4 by ANTLR 4.9.0-SNAPSHOT - - -import PostgreSQLLexerBase from "./PostgreSQLLexerBase"; +// Generated from /Users/xuxiaoqi/Documents/work/daishu-code/dt-sql-parser/src/grammar/pgsql/PostgreSQLLexer.g4 by ANTLR 4.9.0-SNAPSHOT import { ATN } from "antlr4ts/atn/ATN"; @@ -18,7 +15,7 @@ import { VocabularyImpl } from "antlr4ts/VocabularyImpl"; import * as Utils from "antlr4ts/misc/Utils"; -export class PostgreSQLLexer extends PostgreSQLLexerBase { +export class PostgreSQLLexer extends Lexer { public static readonly Dollar = 1; public static readonly OPEN_PAREN = 2; public static readonly CLOSE_PAREN = 3; @@ -48,530 +45,543 @@ export class PostgreSQLLexer extends PostgreSQLLexerBase { public static readonly PERCENT = 27; public static readonly PARAM = 28; public static readonly Operator = 29; - public static readonly ALL = 30; - public static readonly ANALYSE = 31; - public static readonly ANALYZE = 32; - public static readonly AND = 33; - public static readonly ANY = 34; - public static readonly ARRAY = 35; - public static readonly AS = 36; - public static readonly ASC = 37; - public static readonly ASYMMETRIC = 38; - public static readonly BOTH = 39; - public static readonly CASE = 40; - public static readonly CAST = 41; - public static readonly CHECK = 42; - public static readonly COLLATE = 43; - public static readonly COLUMN = 44; - public static readonly CONSTRAINT = 45; - public static readonly CREATE = 46; - public static readonly CURRENT_CATALOG = 47; - public static readonly CURRENT_DATE = 48; - public static readonly CURRENT_ROLE = 49; - public static readonly CURRENT_TIME = 50; - public static readonly CURRENT_TIMESTAMP = 51; - public static readonly CURRENT_USER = 52; - public static readonly DEFAULT = 53; - public static readonly DEFERRABLE = 54; - public static readonly DESC = 55; - public static readonly DISTINCT = 56; - public static readonly DO = 57; - public static readonly ELSE = 58; - public static readonly EXCEPT = 59; - public static readonly FALSE_P = 60; - public static readonly FETCH = 61; - public static readonly FOR = 62; - public static readonly FOREIGN = 63; - public static readonly FROM = 64; - public static readonly GRANT = 65; - public static readonly GROUP_P = 66; - public static readonly HAVING = 67; - public static readonly IN_P = 68; - public static readonly INITIALLY = 69; - public static readonly INTERSECT = 70; - public static readonly INTO = 71; - public static readonly LATERAL_P = 72; - public static readonly LEADING = 73; - public static readonly LIMIT = 74; - public static readonly LOCALTIME = 75; - public static readonly LOCALTIMESTAMP = 76; - public static readonly NOT = 77; - public static readonly NULL_P = 78; - public static readonly OFFSET = 79; - public static readonly ON = 80; - public static readonly ONLY = 81; - public static readonly OR = 82; - public static readonly ORDER = 83; - public static readonly PLACING = 84; - public static readonly PRIMARY = 85; - public static readonly REFERENCES = 86; - public static readonly RETURNING = 87; - public static readonly SELECT = 88; - public static readonly SESSION_USER = 89; - public static readonly SOME = 90; - public static readonly SYMMETRIC = 91; - public static readonly TABLE = 92; - public static readonly THEN = 93; - public static readonly TO = 94; - public static readonly TRAILING = 95; - public static readonly TRUE_P = 96; - public static readonly UNION = 97; - public static readonly UNIQUE = 98; - public static readonly USER = 99; - public static readonly USING = 100; - public static readonly VARIADIC = 101; - public static readonly WHEN = 102; - public static readonly WHERE = 103; - public static readonly WINDOW = 104; - public static readonly WITH = 105; - public static readonly AUTHORIZATION = 106; - public static readonly BINARY = 107; - public static readonly COLLATION = 108; - public static readonly CONCURRENTLY = 109; - public static readonly CROSS = 110; - public static readonly CURRENT_SCHEMA = 111; - public static readonly FREEZE = 112; - public static readonly FULL = 113; - public static readonly ILIKE = 114; - public static readonly INNER_P = 115; - public static readonly IS = 116; - public static readonly ISNULL = 117; - public static readonly JOIN = 118; - public static readonly LEFT = 119; - public static readonly LIKE = 120; - public static readonly NATURAL = 121; - public static readonly NOTNULL = 122; - public static readonly OUTER_P = 123; - public static readonly OVER = 124; - public static readonly OVERLAPS = 125; - public static readonly RIGHT = 126; - public static readonly SIMILAR = 127; - public static readonly VERBOSE = 128; - public static readonly ABORT_P = 129; - public static readonly ABSOLUTE_P = 130; - public static readonly ACCESS = 131; - public static readonly ACTION = 132; - public static readonly ADD_P = 133; - public static readonly ADMIN = 134; - public static readonly AFTER = 135; - public static readonly AGGREGATE = 136; - public static readonly ALSO = 137; - public static readonly ALTER = 138; - public static readonly ALWAYS = 139; - public static readonly ASSERTION = 140; - public static readonly ASSIGNMENT = 141; - public static readonly AT = 142; - public static readonly ATTRIBUTE = 143; - public static readonly BACKWARD = 144; - public static readonly BEFORE = 145; - public static readonly BEGIN_P = 146; - public static readonly BY = 147; - public static readonly CACHE = 148; - public static readonly CALLED = 149; - public static readonly CASCADE = 150; - public static readonly CASCADED = 151; - public static readonly CATALOG = 152; - public static readonly CHAIN = 153; - public static readonly CHARACTERISTICS = 154; - public static readonly CHECKPOINT = 155; - public static readonly CLASS = 156; - public static readonly CLOSE = 157; - public static readonly CLUSTER = 158; - public static readonly COMMENT = 159; - public static readonly COMMENTS = 160; - public static readonly COMMIT = 161; - public static readonly COMMITTED = 162; - public static readonly CONFIGURATION = 163; - public static readonly CONNECTION = 164; - public static readonly CONSTRAINTS = 165; - public static readonly CONTENT_P = 166; - public static readonly CONTINUE_P = 167; - public static readonly CONVERSION_P = 168; - public static readonly COPY = 169; - public static readonly COST = 170; - public static readonly CSV = 171; - public static readonly CURSOR = 172; - public static readonly CYCLE = 173; - public static readonly DATA_P = 174; - public static readonly DATABASE = 175; - public static readonly DAY_P = 176; - public static readonly DEALLOCATE = 177; - public static readonly DECLARE = 178; - public static readonly DEFAULTS = 179; - public static readonly DEFERRED = 180; - public static readonly DEFINER = 181; - public static readonly DELETE_P = 182; - public static readonly DELIMITER = 183; - public static readonly DELIMITERS = 184; - public static readonly DICTIONARY = 185; - public static readonly DISABLE_P = 186; - public static readonly DISCARD = 187; - public static readonly DOCUMENT_P = 188; - public static readonly DOMAIN_P = 189; - public static readonly DOUBLE_P = 190; - public static readonly DROP = 191; - public static readonly EACH = 192; - public static readonly ENABLE_P = 193; - public static readonly ENCODING = 194; - public static readonly ENCRYPTED = 195; - public static readonly ENUM_P = 196; - public static readonly ESCAPE = 197; - public static readonly EVENT = 198; - public static readonly EXCLUDE = 199; - public static readonly EXCLUDING = 200; - public static readonly EXCLUSIVE = 201; - public static readonly EXECUTE = 202; - public static readonly EXPLAIN = 203; - public static readonly EXTENSION = 204; - public static readonly EXTERNAL = 205; - public static readonly FAMILY = 206; - public static readonly FIRST_P = 207; - public static readonly FOLLOWING = 208; - public static readonly FORCE = 209; - public static readonly FORWARD = 210; - public static readonly FUNCTION = 211; - public static readonly FUNCTIONS = 212; - public static readonly GLOBAL = 213; - public static readonly GRANTED = 214; - public static readonly HANDLER = 215; - public static readonly HEADER_P = 216; - public static readonly HOLD = 217; - public static readonly HOUR_P = 218; - public static readonly IDENTITY_P = 219; - public static readonly IF_P = 220; - public static readonly IMMEDIATE = 221; - public static readonly IMMUTABLE = 222; - public static readonly IMPLICIT_P = 223; - public static readonly INCLUDING = 224; - public static readonly INCREMENT = 225; - public static readonly INDEX = 226; - public static readonly INDEXES = 227; - public static readonly INHERIT = 228; - public static readonly INHERITS = 229; - public static readonly INLINE_P = 230; - public static readonly INSENSITIVE = 231; - public static readonly INSERT = 232; - public static readonly INSTEAD = 233; - public static readonly INVOKER = 234; - public static readonly ISOLATION = 235; - public static readonly KEY = 236; - public static readonly LABEL = 237; - public static readonly LANGUAGE = 238; - public static readonly LARGE_P = 239; - public static readonly LAST_P = 240; - public static readonly LEAKPROOF = 241; - public static readonly LEVEL = 242; - public static readonly LISTEN = 243; - public static readonly LOAD = 244; - public static readonly LOCAL = 245; - public static readonly LOCATION = 246; - public static readonly LOCK_P = 247; - public static readonly MAPPING = 248; - public static readonly MATCH = 249; - public static readonly MATERIALIZED = 250; - public static readonly MAXVALUE = 251; - public static readonly MINUTE_P = 252; - public static readonly MINVALUE = 253; - public static readonly MODE = 254; - public static readonly MONTH_P = 255; - public static readonly MOVE = 256; - public static readonly NAME_P = 257; - public static readonly NAMES = 258; - public static readonly NEXT = 259; - public static readonly NO = 260; - public static readonly NOTHING = 261; - public static readonly NOTIFY = 262; - public static readonly NOWAIT = 263; - public static readonly NULLS_P = 264; - public static readonly OBJECT_P = 265; - public static readonly OF = 266; - public static readonly OFF = 267; - public static readonly OIDS = 268; - public static readonly OPERATOR = 269; - public static readonly OPTION = 270; - public static readonly OPTIONS = 271; - public static readonly OWNED = 272; - public static readonly OWNER = 273; - public static readonly PARSER = 274; - public static readonly PARTIAL = 275; - public static readonly PARTITION = 276; - public static readonly PASSING = 277; - public static readonly PASSWORD = 278; - public static readonly PLANS = 279; - public static readonly PRECEDING = 280; - public static readonly PREPARE = 281; - public static readonly PREPARED = 282; - public static readonly PRESERVE = 283; - public static readonly PRIOR = 284; - public static readonly PRIVILEGES = 285; - public static readonly PROCEDURAL = 286; - public static readonly PROCEDURE = 287; - public static readonly PROGRAM = 288; - public static readonly QUOTE = 289; - public static readonly RANGE = 290; - public static readonly READ = 291; - public static readonly REASSIGN = 292; - public static readonly RECHECK = 293; - public static readonly RECURSIVE = 294; - public static readonly REF = 295; - public static readonly REFRESH = 296; - public static readonly REINDEX = 297; - public static readonly RELATIVE_P = 298; - public static readonly RELEASE = 299; - public static readonly RENAME = 300; - public static readonly REPEATABLE = 301; - public static readonly REPLACE = 302; - public static readonly REPLICA = 303; - public static readonly RESET = 304; - public static readonly RESTART = 305; - public static readonly RESTRICT = 306; - public static readonly RETURNS = 307; - public static readonly REVOKE = 308; - public static readonly ROLE = 309; - public static readonly ROLLBACK = 310; - public static readonly ROWS = 311; - public static readonly RULE = 312; - public static readonly SAVEPOINT = 313; - public static readonly SCHEMA = 314; - public static readonly SCROLL = 315; - public static readonly SEARCH = 316; - public static readonly SECOND_P = 317; - public static readonly SECURITY = 318; - public static readonly SEQUENCE = 319; - public static readonly SEQUENCES = 320; - public static readonly SERIALIZABLE = 321; - public static readonly SERVER = 322; - public static readonly SESSION = 323; - public static readonly SET = 324; - public static readonly SHARE = 325; - public static readonly SHOW = 326; - public static readonly SIMPLE = 327; - public static readonly SNAPSHOT = 328; - public static readonly STABLE = 329; - public static readonly STANDALONE_P = 330; - public static readonly START = 331; - public static readonly STATEMENT = 332; - public static readonly STATISTICS = 333; - public static readonly STDIN = 334; - public static readonly STDOUT = 335; - public static readonly STORAGE = 336; - public static readonly STRICT_P = 337; - public static readonly STRIP_P = 338; - public static readonly SYSID = 339; - public static readonly SYSTEM_P = 340; - public static readonly TABLES = 341; - public static readonly TABLESPACE = 342; - public static readonly TEMP = 343; - public static readonly TEMPLATE = 344; - public static readonly TEMPORARY = 345; - public static readonly TEXT_P = 346; - public static readonly TRANSACTION = 347; - public static readonly TRIGGER = 348; - public static readonly TRUNCATE = 349; - public static readonly TRUSTED = 350; - public static readonly TYPE_P = 351; - public static readonly TYPES_P = 352; - public static readonly UNBOUNDED = 353; - public static readonly UNCOMMITTED = 354; - public static readonly UNENCRYPTED = 355; - public static readonly UNKNOWN = 356; - public static readonly UNLISTEN = 357; - public static readonly UNLOGGED = 358; - public static readonly UNTIL = 359; - public static readonly UPDATE = 360; - public static readonly VACUUM = 361; - public static readonly VALID = 362; - public static readonly VALIDATE = 363; - public static readonly VALIDATOR = 364; - public static readonly VARYING = 365; - public static readonly VERSION_P = 366; - public static readonly VIEW = 367; - public static readonly VOLATILE = 368; - public static readonly WHITESPACE_P = 369; - public static readonly WITHOUT = 370; - public static readonly WORK = 371; - public static readonly WRAPPER = 372; - public static readonly WRITE = 373; - public static readonly XML_P = 374; - public static readonly YEAR_P = 375; - public static readonly YES_P = 376; - public static readonly ZONE = 377; - public static readonly BETWEEN = 378; - public static readonly BIGINT = 379; - public static readonly BIT = 380; - public static readonly BOOLEAN_P = 381; - public static readonly CHAR_P = 382; - public static readonly CHARACTER = 383; - public static readonly COALESCE = 384; - public static readonly DEC = 385; - public static readonly DECIMAL_P = 386; - public static readonly EXISTS = 387; - public static readonly EXTRACT = 388; - public static readonly FLOAT_P = 389; - public static readonly GREATEST = 390; - public static readonly INOUT = 391; - public static readonly INT_P = 392; - public static readonly INTEGER = 393; - public static readonly INTERVAL = 394; - public static readonly LEAST = 395; - public static readonly NATIONAL = 396; - public static readonly NCHAR = 397; - public static readonly NONE = 398; - public static readonly NULLIF = 399; - public static readonly NUMERIC = 400; - public static readonly OVERLAY = 401; - public static readonly POSITION = 402; - public static readonly PRECISION = 403; - public static readonly REAL = 404; - public static readonly ROW = 405; - public static readonly SETOF = 406; - public static readonly SMALLINT = 407; - public static readonly SUBSTRING = 408; - public static readonly TIME = 409; - public static readonly TIMESTAMP = 410; - public static readonly TREAT = 411; - public static readonly TRIM = 412; - public static readonly VALUES = 413; - public static readonly VARCHAR = 414; - public static readonly XMLATTRIBUTES = 415; - public static readonly XMLCONCAT = 416; - public static readonly XMLELEMENT = 417; - public static readonly XMLEXISTS = 418; - public static readonly XMLFOREST = 419; - public static readonly XMLPARSE = 420; - public static readonly XMLPI = 421; - public static readonly XMLROOT = 422; - public static readonly XMLSERIALIZE = 423; - public static readonly CALL = 424; - public static readonly CURRENT_P = 425; - public static readonly ATTACH = 426; - public static readonly DETACH = 427; - public static readonly EXPRESSION = 428; - public static readonly GENERATED = 429; - public static readonly LOGGED = 430; - public static readonly STORED = 431; - public static readonly INCLUDE = 432; - public static readonly ROUTINE = 433; - public static readonly TRANSFORM = 434; - public static readonly IMPORT_P = 435; - public static readonly POLICY = 436; - public static readonly METHOD = 437; - public static readonly REFERENCING = 438; - public static readonly NEW = 439; - public static readonly OLD = 440; - public static readonly VALUE_P = 441; - public static readonly SUBSCRIPTION = 442; - public static readonly PUBLICATION = 443; - public static readonly OUT_P = 444; - public static readonly END_P = 445; - public static readonly ROUTINES = 446; - public static readonly SCHEMAS = 447; - public static readonly PROCEDURES = 448; - public static readonly INPUT_P = 449; - public static readonly SUPPORT = 450; - public static readonly PARALLEL = 451; - public static readonly SQL_P = 452; - public static readonly DEPENDS = 453; - public static readonly OVERRIDING = 454; - public static readonly CONFLICT = 455; - public static readonly SKIP_P = 456; - public static readonly LOCKED = 457; - public static readonly TIES = 458; - public static readonly ROLLUP = 459; - public static readonly CUBE = 460; - public static readonly GROUPING = 461; - public static readonly SETS = 462; - public static readonly TABLESAMPLE = 463; - public static readonly ORDINALITY = 464; - public static readonly XMLTABLE = 465; - public static readonly COLUMNS = 466; - public static readonly XMLNAMESPACES = 467; - public static readonly ROWTYPE = 468; - public static readonly NORMALIZED = 469; - public static readonly WITHIN = 470; - public static readonly FILTER = 471; - public static readonly GROUPS = 472; - public static readonly OTHERS = 473; - public static readonly NFC = 474; - public static readonly NFD = 475; - public static readonly NFKC = 476; - public static readonly NFKD = 477; - public static readonly UESCAPE = 478; - public static readonly VIEWS = 479; - public static readonly NORMALIZE = 480; - public static readonly DUMP = 481; - public static readonly PRINT_STRICT_PARAMS = 482; - public static readonly VARIABLE_CONFLICT = 483; - public static readonly ERROR = 484; - public static readonly USE_VARIABLE = 485; - public static readonly USE_COLUMN = 486; - public static readonly ALIAS = 487; - public static readonly CONSTANT = 488; - public static readonly PERFORM = 489; - public static readonly GET = 490; - public static readonly DIAGNOSTICS = 491; - public static readonly STACKED = 492; - public static readonly ELSIF = 493; - public static readonly WHILE = 494; - public static readonly REVERSE = 495; - public static readonly FOREACH = 496; - public static readonly SLICE = 497; - public static readonly EXIT = 498; - public static readonly RETURN = 499; - public static readonly QUERY = 500; - public static readonly RAISE = 501; - public static readonly SQLSTATE = 502; - public static readonly DEBUG = 503; - public static readonly LOG = 504; - public static readonly INFO = 505; - public static readonly NOTICE = 506; - public static readonly WARNING = 507; - public static readonly EXCEPTION = 508; - public static readonly ASSERT = 509; - public static readonly LOOP = 510; - public static readonly OPEN = 511; - public static readonly Identifier = 512; - public static readonly QuotedIdentifier = 513; - public static readonly UnterminatedQuotedIdentifier = 514; - public static readonly InvalidQuotedIdentifier = 515; - public static readonly InvalidUnterminatedQuotedIdentifier = 516; - public static readonly UnicodeQuotedIdentifier = 517; - public static readonly UnterminatedUnicodeQuotedIdentifier = 518; - public static readonly InvalidUnicodeQuotedIdentifier = 519; - public static readonly InvalidUnterminatedUnicodeQuotedIdentifier = 520; - public static readonly StringConstant = 521; - public static readonly UnterminatedStringConstant = 522; - public static readonly UnicodeEscapeStringConstant = 523; - public static readonly UnterminatedUnicodeEscapeStringConstant = 524; - public static readonly BeginDollarStringConstant = 525; - public static readonly BinaryStringConstant = 526; - public static readonly UnterminatedBinaryStringConstant = 527; - public static readonly InvalidBinaryStringConstant = 528; - public static readonly InvalidUnterminatedBinaryStringConstant = 529; - public static readonly HexadecimalStringConstant = 530; - public static readonly UnterminatedHexadecimalStringConstant = 531; - public static readonly InvalidHexadecimalStringConstant = 532; - public static readonly InvalidUnterminatedHexadecimalStringConstant = 533; - public static readonly Integral = 534; - public static readonly NumericFail = 535; - public static readonly Numeric = 536; - public static readonly PLSQLVARIABLENAME = 537; - public static readonly PLSQLIDENTIFIER = 538; - public static readonly Whitespace = 539; - public static readonly Newline = 540; - public static readonly LineComment = 541; - public static readonly BlockComment = 542; - public static readonly UnterminatedBlockComment = 543; - public static readonly MetaCommand = 544; - public static readonly EndMetaCommand = 545; - public static readonly ErrorCharacter = 546; - public static readonly EscapeStringConstant = 547; - public static readonly UnterminatedEscapeStringConstant = 548; - public static readonly InvalidEscapeStringConstant = 549; - public static readonly InvalidUnterminatedEscapeStringConstant = 550; - public static readonly DollarText = 551; - public static readonly EndDollarStringConstant = 552; - public static readonly AfterEscapeStringConstantWithNewlineMode_Continued = 553; + public static readonly KW_ALL = 30; + public static readonly KW_ANALYSE = 31; + public static readonly KW_ANALYZE = 32; + public static readonly KW_AND = 33; + public static readonly KW_ANY = 34; + public static readonly KW_ARRAY = 35; + public static readonly KW_AS = 36; + public static readonly KW_ASC = 37; + public static readonly KW_ASYMMETRIC = 38; + public static readonly KW_BOTH = 39; + public static readonly KW_CASE = 40; + public static readonly KW_CAST = 41; + public static readonly KW_CHECK = 42; + public static readonly KW_COLLATE = 43; + public static readonly KW_COLUMN = 44; + public static readonly KW_CONSTRAINT = 45; + public static readonly KW_CREATE = 46; + public static readonly KW_CURRENT_CATALOG = 47; + public static readonly KW_CURRENT_DATE = 48; + public static readonly KW_CURRENT_ROLE = 49; + public static readonly KW_CURRENT_TIME = 50; + public static readonly KW_CURRENT_TIMESTAMP = 51; + public static readonly KW_CURRENT_USER = 52; + public static readonly KW_DEFAULT = 53; + public static readonly KW_DEFERRABLE = 54; + public static readonly KW_DESC = 55; + public static readonly KW_DISTINCT = 56; + public static readonly KW_DO = 57; + public static readonly KW_ELSE = 58; + public static readonly KW_EXCEPT = 59; + public static readonly KW_FALSE = 60; + public static readonly KW_FETCH = 61; + public static readonly KW_FOR = 62; + public static readonly KW_FOREIGN = 63; + public static readonly KW_FROM = 64; + public static readonly KW_GRANT = 65; + public static readonly KW_GROUP = 66; + public static readonly KW_HAVING = 67; + public static readonly KW_IN = 68; + public static readonly KW_INITIALLY = 69; + public static readonly KW_INTERSECT = 70; + public static readonly KW_INTO = 71; + public static readonly KW_LATERAL = 72; + public static readonly KW_LEADING = 73; + public static readonly KW_LIMIT = 74; + public static readonly KW_LOCALTIME = 75; + public static readonly KW_LOCALTIMESTAMP = 76; + public static readonly KW_NOT = 77; + public static readonly KW_NULL = 78; + public static readonly KW_OFFSET = 79; + public static readonly KW_ON = 80; + public static readonly KW_ONLY = 81; + public static readonly KW_OR = 82; + public static readonly KW_ORDER = 83; + public static readonly KW_PLACING = 84; + public static readonly KW_PRIMARY = 85; + public static readonly KW_REFERENCES = 86; + public static readonly KW_RETURNING = 87; + public static readonly KW_SELECT = 88; + public static readonly KW_SESSION_USER = 89; + public static readonly KW_SOME = 90; + public static readonly KW_SYMMETRIC = 91; + public static readonly KW_TABLE = 92; + public static readonly KW_THEN = 93; + public static readonly KW_TO = 94; + public static readonly KW_TRAILING = 95; + public static readonly KW_TRUE = 96; + public static readonly KW_UNION = 97; + public static readonly KW_UNIQUE = 98; + public static readonly KW_USER = 99; + public static readonly KW_USING = 100; + public static readonly KW_VARIADIC = 101; + public static readonly KW_WHEN = 102; + public static readonly KW_WHERE = 103; + public static readonly KW_WINDOW = 104; + public static readonly KW_WITH = 105; + public static readonly KW_AUTHORIZATION = 106; + public static readonly KW_BINARY = 107; + public static readonly KW_COLLATION = 108; + public static readonly KW_CONCURRENTLY = 109; + public static readonly KW_CROSS = 110; + public static readonly KW_CURRENT_SCHEMA = 111; + public static readonly KW_FREEZE = 112; + public static readonly KW_FULL = 113; + public static readonly KW_ILIKE = 114; + public static readonly KW_INNER = 115; + public static readonly KW_IS = 116; + public static readonly KW_ISNULL = 117; + public static readonly KW_JOIN = 118; + public static readonly KW_LEFT = 119; + public static readonly KW_LIKE = 120; + public static readonly KW_NATURAL = 121; + public static readonly KW_NOTNULL = 122; + public static readonly KW_OUTER = 123; + public static readonly KW_OVER = 124; + public static readonly KW_OVERLAPS = 125; + public static readonly KW_RIGHT = 126; + public static readonly KW_SIMILAR = 127; + public static readonly KW_VERBOSE = 128; + public static readonly KW_ABORT = 129; + public static readonly KW_ABSOLUTE = 130; + public static readonly KW_ACCESS = 131; + public static readonly KW_ACTION = 132; + public static readonly KW_ADD = 133; + public static readonly KW_ADMIN = 134; + public static readonly KW_AFTER = 135; + public static readonly KW_AGGREGATE = 136; + public static readonly KW_ALSO = 137; + public static readonly KW_ALTER = 138; + public static readonly KW_ALWAYS = 139; + public static readonly KW_ASSERTION = 140; + public static readonly KW_ASSIGNMENT = 141; + public static readonly KW_AT = 142; + public static readonly KW_ATTRIBUTE = 143; + public static readonly KW_BACKWARD = 144; + public static readonly KW_BEFORE = 145; + public static readonly KW_BEGIN = 146; + public static readonly KW_BY = 147; + public static readonly KW_CACHE = 148; + public static readonly KW_CALLED = 149; + public static readonly KW_CASCADE = 150; + public static readonly KW_CASCADED = 151; + public static readonly KW_CATALOG = 152; + public static readonly KW_CHAIN = 153; + public static readonly KW_CHARACTERISTICS = 154; + public static readonly KW_CHECKPOINT = 155; + public static readonly KW_CLASS = 156; + public static readonly KW_CLOSE = 157; + public static readonly KW_CLUSTER = 158; + public static readonly KW_COMMENT = 159; + public static readonly KW_COMMENTS = 160; + public static readonly KW_COMMIT = 161; + public static readonly KW_COMMITTED = 162; + public static readonly KW_CONFIGURATION = 163; + public static readonly KW_CONNECTION = 164; + public static readonly KW_CONSTRAINTS = 165; + public static readonly KW_CONTENT = 166; + public static readonly KW_CONTINUE = 167; + public static readonly KW_CONVERSION = 168; + public static readonly KW_COPY = 169; + public static readonly KW_COST = 170; + public static readonly KW_CSV = 171; + public static readonly KW_CURSOR = 172; + public static readonly KW_CYCLE = 173; + public static readonly KW_DATA = 174; + public static readonly KW_DATABASE = 175; + public static readonly KW_DAY = 176; + public static readonly KW_DEALLOCATE = 177; + public static readonly KW_DECLARE = 178; + public static readonly KW_DEFAULTS = 179; + public static readonly KW_DEFERRED = 180; + public static readonly KW_DEFINER = 181; + public static readonly KW_DELETE = 182; + public static readonly KW_DELIMITER = 183; + public static readonly KW_DELIMITERS = 184; + public static readonly KW_DICTIONARY = 185; + public static readonly KW_DISABLE = 186; + public static readonly KW_DISCARD = 187; + public static readonly KW_DOCUMENT = 188; + public static readonly KW_DOMAIN = 189; + public static readonly KW_DOUBLE = 190; + public static readonly KW_DROP = 191; + public static readonly KW_EACH = 192; + public static readonly KW_ENABLE = 193; + public static readonly KW_ENCODING = 194; + public static readonly KW_ENCRYPTED = 195; + public static readonly KW_ENUM = 196; + public static readonly KW_ESCAPE = 197; + public static readonly KW_EVENT = 198; + public static readonly KW_EXCLUDE = 199; + public static readonly KW_EXCLUDING = 200; + public static readonly KW_EXCLUSIVE = 201; + public static readonly KW_EXECUTE = 202; + public static readonly KW_EXPLAIN = 203; + public static readonly KW_EXTENSION = 204; + public static readonly KW_EXTERNAL = 205; + public static readonly KW_FAMILY = 206; + public static readonly KW_FIRST = 207; + public static readonly KW_FOLLOWING = 208; + public static readonly KW_FORCE = 209; + public static readonly KW_FORWARD = 210; + public static readonly KW_FUNCTION = 211; + public static readonly KW_FUNCTIONS = 212; + public static readonly KW_GLOBAL = 213; + public static readonly KW_GRANTED = 214; + public static readonly KW_HANDLER = 215; + public static readonly KW_HEADER = 216; + public static readonly KW_HOLD = 217; + public static readonly KW_HOUR = 218; + public static readonly KW_IDENTITY = 219; + public static readonly KW_IF = 220; + public static readonly KW_IMMEDIATE = 221; + public static readonly KW_IMMUTABLE = 222; + public static readonly KW_IMPLICIT = 223; + public static readonly KW_INCLUDING = 224; + public static readonly KW_INCREMENT = 225; + public static readonly KW_INDEX = 226; + public static readonly KW_INDEXES = 227; + public static readonly KW_INHERIT = 228; + public static readonly KW_NOINHERIT = 229; + public static readonly KW_SUPERUSER = 230; + public static readonly KW_NOSUPERUSER = 231; + public static readonly KW_CREATEDB = 232; + public static readonly KW_NOCREATEDB = 233; + public static readonly KW_CREATEROLE = 234; + public static readonly KW_NOCREATEROLE = 235; + public static readonly KW_CREATEUSER = 236; + public static readonly KW_NOCREATEUSER = 237; + public static readonly KW_INHERITS = 238; + public static readonly KW_INLINE = 239; + public static readonly KW_INSENSITIVE = 240; + public static readonly KW_INSERT = 241; + public static readonly KW_INSTEAD = 242; + public static readonly KW_INVOKER = 243; + public static readonly KW_ISOLATION = 244; + public static readonly KW_KEY = 245; + public static readonly KW_LABEL = 246; + public static readonly KW_LANGUAGE = 247; + public static readonly KW_LARGE = 248; + public static readonly KW_LAST = 249; + public static readonly KW_LEAKPROOF = 250; + public static readonly KW_LEVEL = 251; + public static readonly KW_LISTEN = 252; + public static readonly KW_LOAD = 253; + public static readonly KW_LOCAL = 254; + public static readonly KW_LOCATION = 255; + public static readonly KW_LOCK = 256; + public static readonly KW_MAPPING = 257; + public static readonly KW_MATCH = 258; + public static readonly KW_MATERIALIZED = 259; + public static readonly KW_MAXVALUE = 260; + public static readonly KW_MINUTE = 261; + public static readonly KW_MINVALUE = 262; + public static readonly KW_MODE = 263; + public static readonly KW_MONTH = 264; + public static readonly KW_MOVE = 265; + public static readonly KW_NAME = 266; + public static readonly KW_NAMES = 267; + public static readonly KW_NEXT = 268; + public static readonly KW_NO = 269; + public static readonly KW_NOTHING = 270; + public static readonly KW_NOTIFY = 271; + public static readonly KW_NOWAIT = 272; + public static readonly KW_NULLS = 273; + public static readonly KW_OBJECT = 274; + public static readonly KW_OF = 275; + public static readonly KW_OFF = 276; + public static readonly KW_OIDS = 277; + public static readonly KW_OPERATOR = 278; + public static readonly KW_OPTION = 279; + public static readonly KW_OPTIONS = 280; + public static readonly KW_OWNED = 281; + public static readonly KW_OWNER = 282; + public static readonly KW_PARSER = 283; + public static readonly KW_PARTIAL = 284; + public static readonly KW_PARTITION = 285; + public static readonly KW_PASSING = 286; + public static readonly KW_PASSWORD = 287; + public static readonly KW_PLANS = 288; + public static readonly KW_PRECEDING = 289; + public static readonly KW_PREPARE = 290; + public static readonly KW_PREPARED = 291; + public static readonly KW_PRESERVE = 292; + public static readonly KW_PRIOR = 293; + public static readonly KW_PRIVILEGES = 294; + public static readonly KW_PROCEDURAL = 295; + public static readonly KW_PROCEDURE = 296; + public static readonly KW_PROGRAM = 297; + public static readonly KW_QUOTE = 298; + public static readonly KW_RANGE = 299; + public static readonly KW_READ = 300; + public static readonly KW_REASSIGN = 301; + public static readonly KW_RECHECK = 302; + public static readonly KW_RECURSIVE = 303; + public static readonly KW_REF = 304; + public static readonly KW_REFRESH = 305; + public static readonly KW_REINDEX = 306; + public static readonly KW_RELATIVE = 307; + public static readonly KW_RELEASE = 308; + public static readonly KW_RENAME = 309; + public static readonly KW_REPEATABLE = 310; + public static readonly KW_REPLACE = 311; + public static readonly KW_REPLICA = 312; + public static readonly KW_RESET = 313; + public static readonly KW_RESTART = 314; + public static readonly KW_RESTRICT = 315; + public static readonly KW_RETURNS = 316; + public static readonly KW_REVOKE = 317; + public static readonly KW_ROLE = 318; + public static readonly KW_ROLLBACK = 319; + public static readonly KW_ROWS = 320; + public static readonly KW_RULE = 321; + public static readonly KW_SAVEPOINT = 322; + public static readonly KW_SCHEMA = 323; + public static readonly KW_SCROLL = 324; + public static readonly KW_SEARCH = 325; + public static readonly KW_SECOND = 326; + public static readonly KW_SECURITY = 327; + public static readonly KW_SEQUENCE = 328; + public static readonly KW_SEQUENCES = 329; + public static readonly KW_SERIALIZABLE = 330; + public static readonly KW_SERVER = 331; + public static readonly KW_SESSION = 332; + public static readonly KW_SET = 333; + public static readonly KW_SHARE = 334; + public static readonly KW_SHOW = 335; + public static readonly KW_SIMPLE = 336; + public static readonly KW_SNAPSHOT = 337; + public static readonly KW_STABLE = 338; + public static readonly KW_STANDALONE = 339; + public static readonly KW_START = 340; + public static readonly KW_STATEMENT = 341; + public static readonly KW_STATISTICS = 342; + public static readonly KW_STDIN = 343; + public static readonly KW_STDOUT = 344; + public static readonly KW_STORAGE = 345; + public static readonly KW_STRICT = 346; + public static readonly KW_STRIP = 347; + public static readonly KW_SYSID = 348; + public static readonly KW_SYSTEM = 349; + public static readonly KW_TABLES = 350; + public static readonly KW_TABLESPACE = 351; + public static readonly KW_TEMP = 352; + public static readonly KW_TEMPLATE = 353; + public static readonly KW_TEMPORARY = 354; + public static readonly KW_TEXT = 355; + public static readonly KW_TRANSACTION = 356; + public static readonly KW_TRIGGER = 357; + public static readonly KW_TRUNCATE = 358; + public static readonly KW_TRUSTED = 359; + public static readonly KW_TYPE = 360; + public static readonly KW_TYPES = 361; + public static readonly KW_UNBOUNDED = 362; + public static readonly KW_UNCOMMITTED = 363; + public static readonly KW_UNENCRYPTED = 364; + public static readonly KW_UNKNOWN = 365; + public static readonly KW_UNLISTEN = 366; + public static readonly KW_UNLOGGED = 367; + public static readonly KW_UNTIL = 368; + public static readonly KW_UPDATE = 369; + public static readonly KW_VACUUM = 370; + public static readonly KW_VALID = 371; + public static readonly KW_VALIDATE = 372; + public static readonly KW_VALIDATOR = 373; + public static readonly KW_VARYING = 374; + public static readonly KW_VERSION = 375; + public static readonly KW_VIEW = 376; + public static readonly KW_VOLATILE = 377; + public static readonly KW_WHITESPACE = 378; + public static readonly KW_WITHOUT = 379; + public static readonly KW_WORK = 380; + public static readonly KW_WRAPPER = 381; + public static readonly KW_WRITE = 382; + public static readonly KW_XML = 383; + public static readonly KW_YEAR = 384; + public static readonly KW_YES = 385; + public static readonly KW_ZONE = 386; + public static readonly KW_BETWEEN = 387; + public static readonly KW_BIGINT = 388; + public static readonly KW_BIT = 389; + public static readonly KW_BOOLEAN = 390; + public static readonly KW_CHAR = 391; + public static readonly KW_CHARACTER = 392; + public static readonly KW_COALESCE = 393; + public static readonly KW_DEC = 394; + public static readonly KW_DECIMAL = 395; + public static readonly KW_EXISTS = 396; + public static readonly KW_EXTRACT = 397; + public static readonly KW_FLOAT = 398; + public static readonly KW_GREATEST = 399; + public static readonly KW_INOUT = 400; + public static readonly KW_INT = 401; + public static readonly KW_INTEGER = 402; + public static readonly KW_INTERVAL = 403; + public static readonly KW_LEAST = 404; + public static readonly KW_NATIONAL = 405; + public static readonly KW_NCHAR = 406; + public static readonly KW_NONE = 407; + public static readonly KW_NULLIF = 408; + public static readonly KW_NUMERIC = 409; + public static readonly KW_OVERLAY = 410; + public static readonly KW_POSITION = 411; + public static readonly KW_PRECISION = 412; + public static readonly KW_REAL = 413; + public static readonly KW_ROW = 414; + public static readonly KW_SETOF = 415; + public static readonly KW_SMALLINT = 416; + public static readonly KW_SUBSTRING = 417; + public static readonly KW_TIME = 418; + public static readonly KW_TIMESTAMP = 419; + public static readonly KW_TREAT = 420; + public static readonly KW_TRIM = 421; + public static readonly KW_VALUES = 422; + public static readonly KW_VARCHAR = 423; + public static readonly KW_XMLATTRIBUTES = 424; + public static readonly KW_XMLCONCAT = 425; + public static readonly KW_XMLELEMENT = 426; + public static readonly KW_XMLEXISTS = 427; + public static readonly KW_XMLFOREST = 428; + public static readonly KW_XMLPARSE = 429; + public static readonly KW_XMLPI = 430; + public static readonly KW_XMLROOT = 431; + public static readonly KW_XMLSERIALIZE = 432; + public static readonly KW_CALL = 433; + public static readonly KW_CURRENT = 434; + public static readonly KW_ATTACH = 435; + public static readonly KW_DETACH = 436; + public static readonly KW_EXPRESSION = 437; + public static readonly KW_GENERATED = 438; + public static readonly KW_LOGGED = 439; + public static readonly KW_STORED = 440; + public static readonly KW_INCLUDE = 441; + public static readonly KW_ROUTINE = 442; + public static readonly KW_TRANSFORM = 443; + public static readonly KW_IMPORT = 444; + public static readonly KW_POLICY = 445; + public static readonly KW_METHOD = 446; + public static readonly KW_REFERENCING = 447; + public static readonly KW_NEW = 448; + public static readonly KW_OLD = 449; + public static readonly KW_VALUE = 450; + public static readonly KW_SUBSCRIPTION = 451; + public static readonly KW_PUBLICATION = 452; + public static readonly KW_OUT = 453; + public static readonly KW_END = 454; + public static readonly KW_ROUTINES = 455; + public static readonly KW_SCHEMAS = 456; + public static readonly KW_PROCEDURES = 457; + public static readonly KW_INPUT = 458; + public static readonly KW_SUPPORT = 459; + public static readonly KW_PARALLEL = 460; + public static readonly KW_SQL = 461; + public static readonly KW_DEPENDS = 462; + public static readonly KW_OVERRIDING = 463; + public static readonly KW_CONFLICT = 464; + public static readonly KW_SKIP = 465; + public static readonly KW_LOCKED = 466; + public static readonly KW_TIES = 467; + public static readonly KW_ROLLUP = 468; + public static readonly KW_CUBE = 469; + public static readonly KW_GROUPING = 470; + public static readonly KW_SETS = 471; + public static readonly KW_TABLESAMPLE = 472; + public static readonly KW_ORDINALITY = 473; + public static readonly KW_XMLTABLE = 474; + public static readonly KW_COLUMNS = 475; + public static readonly KW_XMLNAMESPACES = 476; + public static readonly KW_ROWTYPE = 477; + public static readonly KW_NORMALIZED = 478; + public static readonly KW_WITHIN = 479; + public static readonly KW_FILTER = 480; + public static readonly KW_GROUPS = 481; + public static readonly KW_OTHERS = 482; + public static readonly KW_NFC = 483; + public static readonly KW_NFD = 484; + public static readonly KW_NFKC = 485; + public static readonly KW_NFKD = 486; + public static readonly KW_UESCAPE = 487; + public static readonly KW_VIEWS = 488; + public static readonly KW_NORMALIZE = 489; + public static readonly KW_DUMP = 490; + public static readonly KW_PRINT_STRICT_PARAMS = 491; + public static readonly KW_VARIABLE_CONFLICT = 492; + public static readonly KW_ERROR = 493; + public static readonly KW_USE_VARIABLE = 494; + public static readonly KW_USE_COLUMN = 495; + public static readonly KW_ALIAS = 496; + public static readonly KW_CONSTANT = 497; + public static readonly KW_PERFORM = 498; + public static readonly KW_GET = 499; + public static readonly KW_DIAGNOSTICS = 500; + public static readonly KW_STACKED = 501; + public static readonly KW_ELSIF = 502; + public static readonly KW_WHILE = 503; + public static readonly KW_REVERSE = 504; + public static readonly KW_FOREACH = 505; + public static readonly KW_SLICE = 506; + public static readonly KW_EXIT = 507; + public static readonly KW_RETURN = 508; + public static readonly KW_QUERY = 509; + public static readonly KW_RAISE = 510; + public static readonly KW_SQLSTATE = 511; + public static readonly KW_DEBUG = 512; + public static readonly KW_LOG = 513; + public static readonly KW_INFO = 514; + public static readonly KW_NOTICE = 515; + public static readonly KW_WARNING = 516; + public static readonly KW_EXCEPTION = 517; + public static readonly KW_ASSERT = 518; + public static readonly KW_LOOP = 519; + public static readonly KW_OPEN = 520; + public static readonly KW_PEFERENCES = 521; + public static readonly KW_USAGE = 522; + public static readonly KW_CONNECT = 523; + public static readonly KW_PUBLIC = 524; + public static readonly Identifier = 525; + public static readonly QuotedIdentifier = 526; + public static readonly UnterminatedQuotedIdentifier = 527; + public static readonly InvalidQuotedIdentifier = 528; + public static readonly InvalidUnterminatedQuotedIdentifier = 529; + public static readonly UnicodeQuotedIdentifier = 530; + public static readonly UnterminatedUnicodeQuotedIdentifier = 531; + public static readonly InvalidUnicodeQuotedIdentifier = 532; + public static readonly InvalidUnterminatedUnicodeQuotedIdentifier = 533; + public static readonly StringConstant = 534; + public static readonly UnterminatedStringConstant = 535; + public static readonly UnicodeEscapeStringConstant = 536; + public static readonly UnterminatedUnicodeEscapeStringConstant = 537; + public static readonly BeginDollarStringConstant = 538; + public static readonly BinaryStringConstant = 539; + public static readonly UnterminatedBinaryStringConstant = 540; + public static readonly InvalidBinaryStringConstant = 541; + public static readonly InvalidUnterminatedBinaryStringConstant = 542; + public static readonly HexadecimalStringConstant = 543; + public static readonly UnterminatedHexadecimalStringConstant = 544; + public static readonly InvalidHexadecimalStringConstant = 545; + public static readonly InvalidUnterminatedHexadecimalStringConstant = 546; + public static readonly Integral = 547; + public static readonly NumericFail = 548; + public static readonly Numeric = 549; + public static readonly PLSQLVARIABLENAME = 550; + public static readonly PLSQLIDENTIFIER = 551; + public static readonly Whitespace = 552; + public static readonly Newline = 553; + public static readonly LineComment = 554; + public static readonly BlockComment = 555; + public static readonly UnterminatedBlockComment = 556; + public static readonly MetaCommand = 557; + public static readonly EndMetaCommand = 558; + public static readonly ErrorCharacter = 559; + public static readonly EscapeStringConstant = 560; + public static readonly UnterminatedEscapeStringConstant = 561; + public static readonly InvalidEscapeStringConstant = 562; + public static readonly InvalidUnterminatedEscapeStringConstant = 563; + public static readonly DollarText = 564; + public static readonly EndDollarStringConstant = 565; + public static readonly AfterEscapeStringConstantWithNewlineMode_Continued = 566; public static readonly EscapeStringConstantMode = 1; public static readonly AfterEscapeStringConstantMode = 2; public static readonly AfterEscapeStringConstantWithNewlineMode = 3; @@ -595,79 +605,98 @@ export class PostgreSQLLexer extends PostgreSQLLexerBase { "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", + "KW_ALL", "KW_ANALYSE", "KW_ANALYZE", "KW_AND", "KW_ANY", "KW_ARRAY", + "KW_AS", "KW_ASC", "KW_ASYMMETRIC", "KW_BOTH", "KW_CASE", "KW_CAST", "KW_CHECK", + "KW_COLLATE", "KW_COLUMN", "KW_CONSTRAINT", "KW_CREATE", "KW_CURRENT_CATALOG", + "KW_CURRENT_DATE", "KW_CURRENT_ROLE", "KW_CURRENT_TIME", "KW_CURRENT_TIMESTAMP", + "KW_CURRENT_USER", "KW_DEFAULT", "KW_DEFERRABLE", "KW_DESC", "KW_DISTINCT", + "KW_DO", "KW_ELSE", "KW_EXCEPT", "KW_FALSE", "KW_FETCH", "KW_FOR", "KW_FOREIGN", + "KW_FROM", "KW_GRANT", "KW_GROUP", "KW_HAVING", "KW_IN", "KW_INITIALLY", + "KW_INTERSECT", "KW_INTO", "KW_LATERAL", "KW_LEADING", "KW_LIMIT", "KW_LOCALTIME", + "KW_LOCALTIMESTAMP", "KW_NOT", "KW_NULL", "KW_OFFSET", "KW_ON", "KW_ONLY", + "KW_OR", "KW_ORDER", "KW_PLACING", "KW_PRIMARY", "KW_REFERENCES", "KW_RETURNING", + "KW_SELECT", "KW_SESSION_USER", "KW_SOME", "KW_SYMMETRIC", "KW_TABLE", + "KW_THEN", "KW_TO", "KW_TRAILING", "KW_TRUE", "KW_UNION", "KW_UNIQUE", + "KW_USER", "KW_USING", "KW_VARIADIC", "KW_WHEN", "KW_WHERE", "KW_WINDOW", + "KW_WITH", "KW_AUTHORIZATION", "KW_BINARY", "KW_COLLATION", "KW_CONCURRENTLY", + "KW_CROSS", "KW_CURRENT_SCHEMA", "KW_FREEZE", "KW_FULL", "KW_ILIKE", "KW_INNER", + "KW_IS", "KW_ISNULL", "KW_JOIN", "KW_LEFT", "KW_LIKE", "KW_NATURAL", "KW_NOTNULL", + "KW_OUTER", "KW_OVER", "KW_OVERLAPS", "KW_RIGHT", "KW_SIMILAR", "KW_VERBOSE", + "KW_ABORT", "KW_ABSOLUTE", "KW_ACCESS", "KW_ACTION", "KW_ADD", "KW_ADMIN", + "KW_AFTER", "KW_AGGREGATE", "KW_ALSO", "KW_ALTER", "KW_ALWAYS", "KW_ASSERTION", + "KW_ASSIGNMENT", "KW_AT", "KW_ATTRIBUTE", "KW_BACKWARD", "KW_BEFORE", + "KW_BEGIN", "KW_BY", "KW_CACHE", "KW_CALLED", "KW_CASCADE", "KW_CASCADED", + "KW_CATALOG", "KW_CHAIN", "KW_CHARACTERISTICS", "KW_CHECKPOINT", "KW_CLASS", + "KW_CLOSE", "KW_CLUSTER", "KW_COMMENT", "KW_COMMENTS", "KW_COMMIT", "KW_COMMITTED", + "KW_CONFIGURATION", "KW_CONNECTION", "KW_CONSTRAINTS", "KW_CONTENT", "KW_CONTINUE", + "KW_CONVERSION", "KW_COPY", "KW_COST", "KW_CSV", "KW_CURSOR", "KW_CYCLE", + "KW_DATA", "KW_DATABASE", "KW_DAY", "KW_DEALLOCATE", "KW_DECLARE", "KW_DEFAULTS", + "KW_DEFERRED", "KW_DEFINER", "KW_DELETE", "KW_DELIMITER", "KW_DELIMITERS", + "KW_DICTIONARY", "KW_DISABLE", "KW_DISCARD", "KW_DOCUMENT", "KW_DOMAIN", + "KW_DOUBLE", "KW_DROP", "KW_EACH", "KW_ENABLE", "KW_ENCODING", "KW_ENCRYPTED", + "KW_ENUM", "KW_ESCAPE", "KW_EVENT", "KW_EXCLUDE", "KW_EXCLUDING", "KW_EXCLUSIVE", + "KW_EXECUTE", "KW_EXPLAIN", "KW_EXTENSION", "KW_EXTERNAL", "KW_FAMILY", + "KW_FIRST", "KW_FOLLOWING", "KW_FORCE", "KW_FORWARD", "KW_FUNCTION", "KW_FUNCTIONS", + "KW_GLOBAL", "KW_GRANTED", "KW_HANDLER", "KW_HEADER", "KW_HOLD", "KW_HOUR", + "KW_IDENTITY", "KW_IF", "KW_IMMEDIATE", "KW_IMMUTABLE", "KW_IMPLICIT", + "KW_INCLUDING", "KW_INCREMENT", "KW_INDEX", "KW_INDEXES", "KW_INHERIT", + "KW_NOINHERIT", "KW_SUPERUSER", "KW_NOSUPERUSER", "KW_CREATEDB", "KW_NOCREATEDB", + "KW_CREATEROLE", "KW_NOCREATEROLE", "KW_CREATEUSER", "KW_NOCREATEUSER", + "KW_INHERITS", "KW_INLINE", "KW_INSENSITIVE", "KW_INSERT", "KW_INSTEAD", + "KW_INVOKER", "KW_ISOLATION", "KW_KEY", "KW_LABEL", "KW_LANGUAGE", "KW_LARGE", + "KW_LAST", "KW_LEAKPROOF", "KW_LEVEL", "KW_LISTEN", "KW_LOAD", "KW_LOCAL", + "KW_LOCATION", "KW_LOCK", "KW_MAPPING", "KW_MATCH", "KW_MATERIALIZED", + "KW_MAXVALUE", "KW_MINUTE", "KW_MINVALUE", "KW_MODE", "KW_MONTH", "KW_MOVE", + "KW_NAME", "KW_NAMES", "KW_NEXT", "KW_NO", "KW_NOTHING", "KW_NOTIFY", + "KW_NOWAIT", "KW_NULLS", "KW_OBJECT", "KW_OF", "KW_OFF", "KW_OIDS", "KW_OPERATOR", + "KW_OPTION", "KW_OPTIONS", "KW_OWNED", "KW_OWNER", "KW_PARSER", "KW_PARTIAL", + "KW_PARTITION", "KW_PASSING", "KW_PASSWORD", "KW_PLANS", "KW_PRECEDING", + "KW_PREPARE", "KW_PREPARED", "KW_PRESERVE", "KW_PRIOR", "KW_PRIVILEGES", + "KW_PROCEDURAL", "KW_PROCEDURE", "KW_PROGRAM", "KW_QUOTE", "KW_RANGE", + "KW_READ", "KW_REASSIGN", "KW_RECHECK", "KW_RECURSIVE", "KW_REF", "KW_REFRESH", + "KW_REINDEX", "KW_RELATIVE", "KW_RELEASE", "KW_RENAME", "KW_REPEATABLE", + "KW_REPLACE", "KW_REPLICA", "KW_RESET", "KW_RESTART", "KW_RESTRICT", "KW_RETURNS", + "KW_REVOKE", "KW_ROLE", "KW_ROLLBACK", "KW_ROWS", "KW_RULE", "KW_SAVEPOINT", + "KW_SCHEMA", "KW_SCROLL", "KW_SEARCH", "KW_SECOND", "KW_SECURITY", "KW_SEQUENCE", + "KW_SEQUENCES", "KW_SERIALIZABLE", "KW_SERVER", "KW_SESSION", "KW_SET", + "KW_SHARE", "KW_SHOW", "KW_SIMPLE", "KW_SNAPSHOT", "KW_STABLE", "KW_STANDALONE", + "KW_START", "KW_STATEMENT", "KW_STATISTICS", "KW_STDIN", "KW_STDOUT", + "KW_STORAGE", "KW_STRICT", "KW_STRIP", "KW_SYSID", "KW_SYSTEM", "KW_TABLES", + "KW_TABLESPACE", "KW_TEMP", "KW_TEMPLATE", "KW_TEMPORARY", "KW_TEXT", + "KW_TRANSACTION", "KW_TRIGGER", "KW_TRUNCATE", "KW_TRUSTED", "KW_TYPE", + "KW_TYPES", "KW_UNBOUNDED", "KW_UNCOMMITTED", "KW_UNENCRYPTED", "KW_UNKNOWN", + "KW_UNLISTEN", "KW_UNLOGGED", "KW_UNTIL", "KW_UPDATE", "KW_VACUUM", "KW_VALID", + "KW_VALIDATE", "KW_VALIDATOR", "KW_VARYING", "KW_VERSION", "KW_VIEW", + "KW_VOLATILE", "KW_WHITESPACE", "KW_WITHOUT", "KW_WORK", "KW_WRAPPER", + "KW_WRITE", "KW_XML", "KW_YEAR", "KW_YES", "KW_ZONE", "KW_BETWEEN", "KW_BIGINT", + "KW_BIT", "KW_BOOLEAN", "KW_CHAR", "KW_CHARACTER", "KW_COALESCE", "KW_DEC", + "KW_DECIMAL", "KW_EXISTS", "KW_EXTRACT", "KW_FLOAT", "KW_GREATEST", "KW_INOUT", + "KW_INT", "KW_INTEGER", "KW_INTERVAL", "KW_LEAST", "KW_NATIONAL", "KW_NCHAR", + "KW_NONE", "KW_NULLIF", "KW_NUMERIC", "KW_OVERLAY", "KW_POSITION", "KW_PRECISION", + "KW_REAL", "KW_ROW", "KW_SETOF", "KW_SMALLINT", "KW_SUBSTRING", "KW_TIME", + "KW_TIMESTAMP", "KW_TREAT", "KW_TRIM", "KW_VALUES", "KW_VARCHAR", "KW_XMLATTRIBUTES", + "KW_XMLCONCAT", "KW_XMLELEMENT", "KW_XMLEXISTS", "KW_XMLFOREST", "KW_XMLPARSE", + "KW_XMLPI", "KW_XMLROOT", "KW_XMLSERIALIZE", "KW_CALL", "KW_CURRENT", + "KW_ATTACH", "KW_DETACH", "KW_EXPRESSION", "KW_GENERATED", "KW_LOGGED", + "KW_STORED", "KW_INCLUDE", "KW_ROUTINE", "KW_TRANSFORM", "KW_IMPORT", + "KW_POLICY", "KW_METHOD", "KW_REFERENCING", "KW_NEW", "KW_OLD", "KW_VALUE", + "KW_SUBSCRIPTION", "KW_PUBLICATION", "KW_OUT", "KW_END", "KW_ROUTINES", + "KW_SCHEMAS", "KW_PROCEDURES", "KW_INPUT", "KW_SUPPORT", "KW_PARALLEL", + "KW_SQL", "KW_DEPENDS", "KW_OVERRIDING", "KW_CONFLICT", "KW_SKIP", "KW_LOCKED", + "KW_TIES", "KW_ROLLUP", "KW_CUBE", "KW_GROUPING", "KW_SETS", "KW_TABLESAMPLE", + "KW_ORDINALITY", "KW_XMLTABLE", "KW_COLUMNS", "KW_XMLNAMESPACES", "KW_ROWTYPE", + "KW_NORMALIZED", "KW_WITHIN", "KW_FILTER", "KW_GROUPS", "KW_OTHERS", "KW_NFC", + "KW_NFD", "KW_NFKC", "KW_NFKD", "KW_UESCAPE", "KW_VIEWS", "KW_NORMALIZE", + "KW_DUMP", "KW_PRINT_STRICT_PARAMS", "KW_VARIABLE_CONFLICT", "KW_ERROR", + "KW_USE_VARIABLE", "KW_USE_COLUMN", "KW_ALIAS", "KW_CONSTANT", "KW_PERFORM", + "KW_GET", "KW_DIAGNOSTICS", "KW_STACKED", "KW_ELSIF", "KW_WHILE", "KW_REVERSE", + "KW_FOREACH", "KW_SLICE", "KW_EXIT", "KW_RETURN", "KW_QUERY", "KW_RAISE", + "KW_SQLSTATE", "KW_DEBUG", "KW_LOG", "KW_INFO", "KW_NOTICE", "KW_WARNING", + "KW_EXCEPTION", "KW_ASSERT", "KW_LOOP", "KW_OPEN", "KW_PEFERENCES", "KW_USAGE", + "KW_CONNECT", "KW_PUBLIC", "Identifier", "IdentifierStartChar", "IdentifierChar", + "StrictIdentifierChar", "QuotedIdentifier", "UnterminatedQuotedIdentifier", + "InvalidQuotedIdentifier", "InvalidUnterminatedQuotedIdentifier", "UnicodeQuotedIdentifier", + "UnterminatedUnicodeQuotedIdentifier", "InvalidUnicodeQuotedIdentifier", "InvalidUnterminatedUnicodeQuotedIdentifier", "StringConstant", "UnterminatedStringConstant", "BeginEscapeStringConstant", "UnicodeEscapeStringConstant", "UnterminatedUnicodeEscapeStringConstant", "BeginDollarStringConstant", "Tag", "BinaryStringConstant", "UnterminatedBinaryStringConstant", @@ -720,8 +749,10 @@ export class PostgreSQLLexer extends PostgreSQLLexerBase { "'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'", + "'INCLUDING'", "'INCREMENT'", "'INDEX'", "'INDEXES'", "'INHERIT'", "'NOINHERIT'", + "'SUPERUSER'", "'NOSUPERUSER'", "'CREATEDB'", "'NOCREATEDB'", "'CREATEROLE'", + "'NOCREATEROLE'", "'CREATEUSER'", "'NOCREATEUSER'", "'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'", @@ -767,102 +798,122 @@ export class PostgreSQLLexer extends PostgreSQLLexerBase { "'CONSTANT'", "'PERFORM'", "'GET'", "'DIAGNOSTICS'", "'STACKED'", "'ELSIF'", "'WHILE'", "'REVERSE'", "'FOREACH'", "'SLICE'", "'EXIT'", "'RETURN'", "'QUERY'", "'RAISE'", "'SQLSTATE'", "'DEBUG'", "'LOG'", "'INFO'", "'NOTICE'", - "'WARNING'", "'EXCEPTION'", "'ASSERT'", "'LOOP'", "'OPEN'", undefined, + "'WARNING'", "'EXCEPTION'", "'ASSERT'", "'LOOP'", "'OPEN'", "'PEFERENCES'", + "'USAGE'", "'CONNECT'", "'PUBLIC'", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, - undefined, undefined, undefined, undefined, "'\\''", undefined, undefined, - undefined, undefined, undefined, undefined, undefined, "'''", + undefined, "'\\''", undefined, undefined, undefined, undefined, undefined, + undefined, undefined, "'''", ]; private static readonly _SYMBOLIC_NAMES: Array = [ undefined, "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", + "PERCENT", "PARAM", "Operator", "KW_ALL", "KW_ANALYSE", "KW_ANALYZE", + "KW_AND", "KW_ANY", "KW_ARRAY", "KW_AS", "KW_ASC", "KW_ASYMMETRIC", "KW_BOTH", + "KW_CASE", "KW_CAST", "KW_CHECK", "KW_COLLATE", "KW_COLUMN", "KW_CONSTRAINT", + "KW_CREATE", "KW_CURRENT_CATALOG", "KW_CURRENT_DATE", "KW_CURRENT_ROLE", + "KW_CURRENT_TIME", "KW_CURRENT_TIMESTAMP", "KW_CURRENT_USER", "KW_DEFAULT", + "KW_DEFERRABLE", "KW_DESC", "KW_DISTINCT", "KW_DO", "KW_ELSE", "KW_EXCEPT", + "KW_FALSE", "KW_FETCH", "KW_FOR", "KW_FOREIGN", "KW_FROM", "KW_GRANT", + "KW_GROUP", "KW_HAVING", "KW_IN", "KW_INITIALLY", "KW_INTERSECT", "KW_INTO", + "KW_LATERAL", "KW_LEADING", "KW_LIMIT", "KW_LOCALTIME", "KW_LOCALTIMESTAMP", + "KW_NOT", "KW_NULL", "KW_OFFSET", "KW_ON", "KW_ONLY", "KW_OR", "KW_ORDER", + "KW_PLACING", "KW_PRIMARY", "KW_REFERENCES", "KW_RETURNING", "KW_SELECT", + "KW_SESSION_USER", "KW_SOME", "KW_SYMMETRIC", "KW_TABLE", "KW_THEN", "KW_TO", + "KW_TRAILING", "KW_TRUE", "KW_UNION", "KW_UNIQUE", "KW_USER", "KW_USING", + "KW_VARIADIC", "KW_WHEN", "KW_WHERE", "KW_WINDOW", "KW_WITH", "KW_AUTHORIZATION", + "KW_BINARY", "KW_COLLATION", "KW_CONCURRENTLY", "KW_CROSS", "KW_CURRENT_SCHEMA", + "KW_FREEZE", "KW_FULL", "KW_ILIKE", "KW_INNER", "KW_IS", "KW_ISNULL", + "KW_JOIN", "KW_LEFT", "KW_LIKE", "KW_NATURAL", "KW_NOTNULL", "KW_OUTER", + "KW_OVER", "KW_OVERLAPS", "KW_RIGHT", "KW_SIMILAR", "KW_VERBOSE", "KW_ABORT", + "KW_ABSOLUTE", "KW_ACCESS", "KW_ACTION", "KW_ADD", "KW_ADMIN", "KW_AFTER", + "KW_AGGREGATE", "KW_ALSO", "KW_ALTER", "KW_ALWAYS", "KW_ASSERTION", "KW_ASSIGNMENT", + "KW_AT", "KW_ATTRIBUTE", "KW_BACKWARD", "KW_BEFORE", "KW_BEGIN", "KW_BY", + "KW_CACHE", "KW_CALLED", "KW_CASCADE", "KW_CASCADED", "KW_CATALOG", "KW_CHAIN", + "KW_CHARACTERISTICS", "KW_CHECKPOINT", "KW_CLASS", "KW_CLOSE", "KW_CLUSTER", + "KW_COMMENT", "KW_COMMENTS", "KW_COMMIT", "KW_COMMITTED", "KW_CONFIGURATION", + "KW_CONNECTION", "KW_CONSTRAINTS", "KW_CONTENT", "KW_CONTINUE", "KW_CONVERSION", + "KW_COPY", "KW_COST", "KW_CSV", "KW_CURSOR", "KW_CYCLE", "KW_DATA", "KW_DATABASE", + "KW_DAY", "KW_DEALLOCATE", "KW_DECLARE", "KW_DEFAULTS", "KW_DEFERRED", + "KW_DEFINER", "KW_DELETE", "KW_DELIMITER", "KW_DELIMITERS", "KW_DICTIONARY", + "KW_DISABLE", "KW_DISCARD", "KW_DOCUMENT", "KW_DOMAIN", "KW_DOUBLE", "KW_DROP", + "KW_EACH", "KW_ENABLE", "KW_ENCODING", "KW_ENCRYPTED", "KW_ENUM", "KW_ESCAPE", + "KW_EVENT", "KW_EXCLUDE", "KW_EXCLUDING", "KW_EXCLUSIVE", "KW_EXECUTE", + "KW_EXPLAIN", "KW_EXTENSION", "KW_EXTERNAL", "KW_FAMILY", "KW_FIRST", + "KW_FOLLOWING", "KW_FORCE", "KW_FORWARD", "KW_FUNCTION", "KW_FUNCTIONS", + "KW_GLOBAL", "KW_GRANTED", "KW_HANDLER", "KW_HEADER", "KW_HOLD", "KW_HOUR", + "KW_IDENTITY", "KW_IF", "KW_IMMEDIATE", "KW_IMMUTABLE", "KW_IMPLICIT", + "KW_INCLUDING", "KW_INCREMENT", "KW_INDEX", "KW_INDEXES", "KW_INHERIT", + "KW_NOINHERIT", "KW_SUPERUSER", "KW_NOSUPERUSER", "KW_CREATEDB", "KW_NOCREATEDB", + "KW_CREATEROLE", "KW_NOCREATEROLE", "KW_CREATEUSER", "KW_NOCREATEUSER", + "KW_INHERITS", "KW_INLINE", "KW_INSENSITIVE", "KW_INSERT", "KW_INSTEAD", + "KW_INVOKER", "KW_ISOLATION", "KW_KEY", "KW_LABEL", "KW_LANGUAGE", "KW_LARGE", + "KW_LAST", "KW_LEAKPROOF", "KW_LEVEL", "KW_LISTEN", "KW_LOAD", "KW_LOCAL", + "KW_LOCATION", "KW_LOCK", "KW_MAPPING", "KW_MATCH", "KW_MATERIALIZED", + "KW_MAXVALUE", "KW_MINUTE", "KW_MINVALUE", "KW_MODE", "KW_MONTH", "KW_MOVE", + "KW_NAME", "KW_NAMES", "KW_NEXT", "KW_NO", "KW_NOTHING", "KW_NOTIFY", + "KW_NOWAIT", "KW_NULLS", "KW_OBJECT", "KW_OF", "KW_OFF", "KW_OIDS", "KW_OPERATOR", + "KW_OPTION", "KW_OPTIONS", "KW_OWNED", "KW_OWNER", "KW_PARSER", "KW_PARTIAL", + "KW_PARTITION", "KW_PASSING", "KW_PASSWORD", "KW_PLANS", "KW_PRECEDING", + "KW_PREPARE", "KW_PREPARED", "KW_PRESERVE", "KW_PRIOR", "KW_PRIVILEGES", + "KW_PROCEDURAL", "KW_PROCEDURE", "KW_PROGRAM", "KW_QUOTE", "KW_RANGE", + "KW_READ", "KW_REASSIGN", "KW_RECHECK", "KW_RECURSIVE", "KW_REF", "KW_REFRESH", + "KW_REINDEX", "KW_RELATIVE", "KW_RELEASE", "KW_RENAME", "KW_REPEATABLE", + "KW_REPLACE", "KW_REPLICA", "KW_RESET", "KW_RESTART", "KW_RESTRICT", "KW_RETURNS", + "KW_REVOKE", "KW_ROLE", "KW_ROLLBACK", "KW_ROWS", "KW_RULE", "KW_SAVEPOINT", + "KW_SCHEMA", "KW_SCROLL", "KW_SEARCH", "KW_SECOND", "KW_SECURITY", "KW_SEQUENCE", + "KW_SEQUENCES", "KW_SERIALIZABLE", "KW_SERVER", "KW_SESSION", "KW_SET", + "KW_SHARE", "KW_SHOW", "KW_SIMPLE", "KW_SNAPSHOT", "KW_STABLE", "KW_STANDALONE", + "KW_START", "KW_STATEMENT", "KW_STATISTICS", "KW_STDIN", "KW_STDOUT", + "KW_STORAGE", "KW_STRICT", "KW_STRIP", "KW_SYSID", "KW_SYSTEM", "KW_TABLES", + "KW_TABLESPACE", "KW_TEMP", "KW_TEMPLATE", "KW_TEMPORARY", "KW_TEXT", + "KW_TRANSACTION", "KW_TRIGGER", "KW_TRUNCATE", "KW_TRUSTED", "KW_TYPE", + "KW_TYPES", "KW_UNBOUNDED", "KW_UNCOMMITTED", "KW_UNENCRYPTED", "KW_UNKNOWN", + "KW_UNLISTEN", "KW_UNLOGGED", "KW_UNTIL", "KW_UPDATE", "KW_VACUUM", "KW_VALID", + "KW_VALIDATE", "KW_VALIDATOR", "KW_VARYING", "KW_VERSION", "KW_VIEW", + "KW_VOLATILE", "KW_WHITESPACE", "KW_WITHOUT", "KW_WORK", "KW_WRAPPER", + "KW_WRITE", "KW_XML", "KW_YEAR", "KW_YES", "KW_ZONE", "KW_BETWEEN", "KW_BIGINT", + "KW_BIT", "KW_BOOLEAN", "KW_CHAR", "KW_CHARACTER", "KW_COALESCE", "KW_DEC", + "KW_DECIMAL", "KW_EXISTS", "KW_EXTRACT", "KW_FLOAT", "KW_GREATEST", "KW_INOUT", + "KW_INT", "KW_INTEGER", "KW_INTERVAL", "KW_LEAST", "KW_NATIONAL", "KW_NCHAR", + "KW_NONE", "KW_NULLIF", "KW_NUMERIC", "KW_OVERLAY", "KW_POSITION", "KW_PRECISION", + "KW_REAL", "KW_ROW", "KW_SETOF", "KW_SMALLINT", "KW_SUBSTRING", "KW_TIME", + "KW_TIMESTAMP", "KW_TREAT", "KW_TRIM", "KW_VALUES", "KW_VARCHAR", "KW_XMLATTRIBUTES", + "KW_XMLCONCAT", "KW_XMLELEMENT", "KW_XMLEXISTS", "KW_XMLFOREST", "KW_XMLPARSE", + "KW_XMLPI", "KW_XMLROOT", "KW_XMLSERIALIZE", "KW_CALL", "KW_CURRENT", + "KW_ATTACH", "KW_DETACH", "KW_EXPRESSION", "KW_GENERATED", "KW_LOGGED", + "KW_STORED", "KW_INCLUDE", "KW_ROUTINE", "KW_TRANSFORM", "KW_IMPORT", + "KW_POLICY", "KW_METHOD", "KW_REFERENCING", "KW_NEW", "KW_OLD", "KW_VALUE", + "KW_SUBSCRIPTION", "KW_PUBLICATION", "KW_OUT", "KW_END", "KW_ROUTINES", + "KW_SCHEMAS", "KW_PROCEDURES", "KW_INPUT", "KW_SUPPORT", "KW_PARALLEL", + "KW_SQL", "KW_DEPENDS", "KW_OVERRIDING", "KW_CONFLICT", "KW_SKIP", "KW_LOCKED", + "KW_TIES", "KW_ROLLUP", "KW_CUBE", "KW_GROUPING", "KW_SETS", "KW_TABLESAMPLE", + "KW_ORDINALITY", "KW_XMLTABLE", "KW_COLUMNS", "KW_XMLNAMESPACES", "KW_ROWTYPE", + "KW_NORMALIZED", "KW_WITHIN", "KW_FILTER", "KW_GROUPS", "KW_OTHERS", "KW_NFC", + "KW_NFD", "KW_NFKC", "KW_NFKD", "KW_UESCAPE", "KW_VIEWS", "KW_NORMALIZE", + "KW_DUMP", "KW_PRINT_STRICT_PARAMS", "KW_VARIABLE_CONFLICT", "KW_ERROR", + "KW_USE_VARIABLE", "KW_USE_COLUMN", "KW_ALIAS", "KW_CONSTANT", "KW_PERFORM", + "KW_GET", "KW_DIAGNOSTICS", "KW_STACKED", "KW_ELSIF", "KW_WHILE", "KW_REVERSE", + "KW_FOREACH", "KW_SLICE", "KW_EXIT", "KW_RETURN", "KW_QUERY", "KW_RAISE", + "KW_SQLSTATE", "KW_DEBUG", "KW_LOG", "KW_INFO", "KW_NOTICE", "KW_WARNING", + "KW_EXCEPTION", "KW_ASSERT", "KW_LOOP", "KW_OPEN", "KW_PEFERENCES", "KW_USAGE", + "KW_CONNECT", "KW_PUBLIC", "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", "DollarText", "EndDollarStringConstant", "AfterEscapeStringConstantWithNewlineMode_Continued", ]; public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(PostgreSQLLexer._LITERAL_NAMES, PostgreSQLLexer._SYMBOLIC_NAMES, []); @@ -895,135 +946,9 @@ export class PostgreSQLLexer extends PostgreSQLLexerBase { // @Override public get modeNames(): string[] { return PostgreSQLLexer.modeNames; } - // @Override - public action(_localctx: RuleContext, ruleIndex: number, actionIndex: number): void { - 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 568: - this.EndDollarStringConstant_action(_localctx, actionIndex); - break; - } - } - private Operator_action(_localctx: RuleContext, actionIndex: number): void { - switch (actionIndex) { - case 0: - - this.HandleLessLessGreaterGreater(); - - break; - } - } - private BeginDollarStringConstant_action(_localctx: RuleContext, actionIndex: number): void { - switch (actionIndex) { - case 1: - this.pushTag(); - break; - } - } - private NumericFail_action(_localctx: RuleContext, actionIndex: number): void { - switch (actionIndex) { - case 2: - this.HandleNumericFail(); - break; - } - } - private UnterminatedBlockComment_action(_localctx: RuleContext, actionIndex: number): void { - switch (actionIndex) { - case 3: - - this.UnterminatedBlockCommentDebugAssert(); - - break; - } - } - private EndDollarStringConstant_action(_localctx: RuleContext, actionIndex: number): void { - switch (actionIndex) { - case 4: - this.popTag(); - break; - } - } - // @Override - public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean { - 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 568: - return this.EndDollarStringConstant_sempred(_localctx, predIndex); - } - return true; - } - private Operator_sempred(_localctx: RuleContext, predIndex: number): boolean { - switch (predIndex) { - case 0: - return this.checkLA('-'); - - case 1: - return this.checkLA('*'); - - case 2: - return this.checkLA('*'); - } - return true; - } - private OperatorEndingWithPlusMinus_sempred(_localctx: RuleContext, predIndex: number): boolean { - switch (predIndex) { - case 3: - return this.checkLA('-'); - - case 4: - return this.checkLA('*'); - - case 5: - return this.checkLA('-'); - } - return true; - } - private IdentifierStartChar_sempred(_localctx: RuleContext, predIndex: number): boolean { - switch (predIndex) { - case 6: - return this.charIsLetter(); - - case 7: - return - this.CheckIfUtf32Letter() - ; - } - return true; - } - private EndDollarStringConstant_sempred(_localctx: RuleContext, predIndex: number): boolean { - switch (predIndex) { - case 8: - return this.isTag(); - } - return true; - } - private static readonly _serializedATNSegments: number = 10; private static readonly _serializedATNSegment0: string = - "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x02\u022B\u1510\b" + + "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x02\u0238\u159A\b" + "\x01\b\x01\b\x01\b\x01\b\x01\x04\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04" + "\x04\x05\t\x05\x04\x06\t\x06\x04\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t" + "\n\x04\v\t\v\x04\f\t\f\x04\r\t\r\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t" + @@ -1145,762 +1070,785 @@ export class PostgreSQLLexer extends PostgreSQLLexerBase { "\t\u022D\x04\u022E\t\u022E\x04\u022F\t\u022F\x04\u0230\t\u0230\x04\u0231" + "\t\u0231\x04\u0232\t\u0232\x04\u0233\t\u0233\x04\u0234\t\u0234\x04\u0235" + "\t\u0235\x04\u0236\t\u0236\x04\u0237\t\u0237\x04\u0238\t\u0238\x04\u0239" + - "\t\u0239\x04\u023A\t\u023A\x03\x02\x03\x02\x03\x03\x03\x03\x03\x04\x03" + - "\x04\x03\x05\x03\x05\x03\x06\x03\x06\x03\x07\x03\x07\x03\b\x03\b\x03\t" + - "\x03\t\x03\n\x03\n\x03\v\x03\v\x03\f\x03\f\x03\r\x03\r\x03\x0E\x03\x0E" + - "\x03\x0F\x03\x0F\x03\x10\x03\x10\x03\x11\x03\x11\x03\x12\x03\x12\x03\x13" + - "\x03\x13\x03\x13\x03\x14\x03\x14\x03\x14\x03\x15\x03\x15\x03\x15\x03\x16" + - "\x03\x16\x03\x16\x03\x17\x03\x17\x03\x17\x03\x18\x03\x18\x03\x18\x03\x19" + - "\x03\x19\x03\x19\x03\x1A\x03\x1A\x03\x1A\x03\x1B\x03\x1B\x03\x1B\x03\x1C" + - "\x03\x1C\x03\x1D\x03\x1D\x06\x1D\u04BB\n\x1D\r\x1D\x0E\x1D\u04BC\x03\x1E" + - "\x03\x1E\x03\x1E\x03\x1E\x06\x1E\u04C3\n\x1E\r\x1E\x0E\x1E\u04C4\x03\x1E" + - "\x03\x1E\x03\x1E\x05\x1E\u04CA\n\x1E\x03\x1E\x03\x1E\x06\x1E\u04CE\n\x1E" + - "\r\x1E\x0E\x1E\u04CF\x03\x1E\x05\x1E\u04D3\n\x1E\x03\x1E\x03\x1E\x03\x1F" + - "\x03\x1F\x03\x1F\x03\x1F\x03\x1F\x07\x1F\u04DC\n\x1F\f\x1F\x0E\x1F\u04DF" + - "\v\x1F\x03\x1F\x03\x1F\x05\x1F\u04E3\n\x1F\x03\x1F\x03\x1F\x03\x1F\x06" + - "\x1F\u04E8\n\x1F\r\x1F\x0E\x1F\u04E9\x03\x1F\x03\x1F\x03 \x03 \x03!\x03" + - "!\x03\"\x03\"\x03#\x03#\x03#\x03#\x03$\x03$\x03$\x03$\x03$\x03$\x03$\x03" + - "$\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03&\x03&\x03&\x03&\x03\'\x03" + - "\'\x03\'\x03\'\x03(\x03(\x03(\x03(\x03(\x03(\x03)\x03)\x03)\x03*\x03*" + - "\x03*\x03*\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03" + - ",\x03,\x03,\x03,\x03,\x03-\x03-\x03-\x03-\x03-\x03.\x03.\x03.\x03.\x03" + - ".\x03/\x03/\x03/\x03/\x03/\x03/\x030\x030\x030\x030\x030\x030\x030\x03" + - "0\x031\x031\x031\x031\x031\x031\x031\x032\x032\x032\x032\x032\x032\x03" + - "2\x032\x032\x032\x032\x033\x033\x033\x033\x033\x033\x033\x034\x034\x03" + - "4\x034\x034\x034\x034\x034\x034\x034\x034\x034\x034\x034\x034\x034\x03" + - "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x036\x03" + - "6\x036\x036\x036\x036\x036\x036\x036\x036\x036\x036\x036\x037\x037\x03" + - "7\x037\x037\x037\x037\x037\x037\x037\x037\x037\x037\x038\x038\x038\x03" + - "8\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x03" + - "8\x039\x039\x039\x039\x039\x039\x039\x039\x039\x039\x039\x039\x039\x03" + - ":\x03:\x03:\x03:\x03:\x03:\x03:\x03:\x03;\x03;\x03;\x03;\x03;\x03;\x03" + - ";\x03;\x03;\x03;\x03;\x03<\x03<\x03<\x03<\x03<\x03=\x03=\x03=\x03=\x03" + - "=\x03=\x03=\x03=\x03=\x03>\x03>\x03>\x03?\x03?\x03?\x03?\x03?\x03@\x03" + - "@\x03@\x03@\x03@\x03@\x03@\x03A\x03A\x03A\x03A\x03A\x03A\x03B\x03B\x03" + - "B\x03B\x03B\x03B\x03C\x03C\x03C\x03C\x03D\x03D\x03D\x03D\x03D\x03D\x03" + - "D\x03D\x03E\x03E\x03E\x03E\x03E\x03F\x03F\x03F\x03F\x03F\x03F\x03G\x03" + - "G\x03G\x03G\x03G\x03G\x03H\x03H\x03H\x03H\x03H\x03H\x03H\x03I\x03I\x03" + - "I\x03J\x03J\x03J\x03J\x03J\x03J\x03J\x03J\x03J\x03J\x03K\x03K\x03K\x03" + - "K\x03K\x03K\x03K\x03K\x03K\x03K\x03L\x03L\x03L\x03L\x03L\x03M\x03M\x03" + - "M\x03M\x03M\x03M\x03M\x03M\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03" + - "O\x03O\x03O\x03O\x03O\x03O\x03P\x03P\x03P\x03P\x03P\x03P\x03P\x03P\x03" + - "P\x03P\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03" + - "Q\x03Q\x03Q\x03R\x03R\x03R\x03R\x03S\x03S\x03S\x03S\x03S\x03T\x03T\x03" + - "T\x03T\x03T\x03T\x03T\x03U\x03U\x03U\x03V\x03V\x03V\x03V\x03V\x03W\x03" + - "W\x03W\x03X\x03X\x03X\x03X\x03X\x03X\x03Y\x03Y\x03Y\x03Y\x03Y\x03Y\x03" + - "Y\x03Y\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03[\x03[\x03[\x03[\x03" + - "[\x03[\x03[\x03[\x03[\x03[\x03[\x03\\\x03\\\x03\\\x03\\\x03\\\x03\\\x03" + - "\\\x03\\\x03\\\x03\\\x03]\x03]\x03]\x03]\x03]\x03]\x03]\x03^\x03^\x03" + - "^\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03_\x03_\x03_\x03" + - "_\x03_\x03`\x03`\x03`\x03`\x03`\x03`\x03`\x03`\x03`\x03`\x03a\x03a\x03" + - "a\x03a\x03a\x03a\x03b\x03b\x03b\x03b\x03b\x03c\x03c\x03c\x03d\x03d\x03" + - "d\x03d\x03d\x03d\x03d\x03d\x03d\x03e\x03e\x03e\x03e\x03e\x03f\x03f\x03" + - "f\x03f\x03f\x03f\x03g\x03g\x03g\x03g\x03g\x03g\x03g\x03h\x03h\x03h\x03" + - "h\x03h\x03i\x03i\x03i\x03i\x03i\x03i\x03j\x03j\x03j\x03j\x03j\x03j\x03" + - "j\x03j\x03j\x03k\x03k\x03k\x03k\x03k\x03l\x03l\x03l\x03l\x03l\x03l\x03" + - "m\x03m\x03m\x03m\x03m\x03m\x03m\x03n\x03n\x03n\x03n\x03n\x03o\x03o\x03" + - "o\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03p\x03p\x03" + - "p\x03p\x03p\x03p\x03p\x03q\x03q\x03q\x03q\x03q\x03q\x03q\x03q\x03q\x03" + - "q\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03" + - "s\x03s\x03s\x03s\x03s\x03s\x03t\x03t\x03t\x03t\x03t\x03t\x03t\x03t\x03" + - "t\x03t\x03t\x03t\x03t\x03t\x03t\x03u\x03u\x03u\x03u\x03u\x03u\x03u\x03" + - "v\x03v\x03v\x03v\x03v\x03w\x03w\x03w\x03w\x03w\x03w\x03x\x03x\x03x\x03" + - "x\x03x\x03x\x03y\x03y\x03y\x03z\x03z\x03z\x03z\x03z\x03z\x03z\x03{\x03" + - "{\x03{\x03{\x03{\x03|\x03|\x03|\x03|\x03|\x03}\x03}\x03}\x03}\x03}\x03" + - "~\x03~\x03~\x03~\x03~\x03~\x03~\x03~\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03" + - "\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x80\x03\x80\x03\x80\x03\x80\x03\x80\x03" + - "\x80\x03\x81\x03\x81\x03\x81\x03\x81\x03\x81\x03\x82\x03\x82\x03\x82\x03" + - "\x82\x03\x82\x03\x82\x03\x82\x03\x82\x03\x82\x03\x83\x03\x83\x03\x83\x03" + - "\x83\x03\x83\x03\x83\x03\x84\x03\x84\x03\x84\x03\x84\x03\x84\x03\x84\x03" + - "\x84\x03\x84\x03\x85\x03\x85\x03\x85\x03\x85\x03\x85\x03\x85\x03\x85\x03" + - "\x85\x03\x86\x03\x86\x03\x86\x03\x86\x03\x86\x03\x86\x03\x87\x03\x87\x03" + - "\x87\x03\x87\x03\x87\x03\x87\x03\x87\x03\x87\x03\x87\x03\x88\x03\x88\x03" + - "\x88\x03\x88\x03\x88\x03\x88\x03\x88\x03\x89\x03\x89\x03\x89\x03\x89\x03" + - "\x89\x03\x89\x03\x89\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8B\x03\x8B\x03" + - "\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03" + - "\x8C\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03" + - "\x8D\x03\x8D\x03\x8E\x03\x8E\x03\x8E\x03\x8E\x03\x8E\x03\x8F\x03\x8F\x03" + - "\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x90\x03\x90\x03\x90\x03\x90\x03\x90\x03" + - "\x90\x03\x90\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03" + - "\x91\x03\x91\x03\x91\x03\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03" + - "\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03\x93\x03\x93\x03\x93\x03\x94\x03" + - "\x94\x03\x94\x03\x94\x03\x94\x03\x94\x03\x94\x03\x94\x03\x94\x03\x94\x03" + - "\x95\x03\x95\x03\x95\x03\x95\x03\x95\x03\x95\x03\x95\x03\x95\x03\x95\x03" + - "\x96\x03\x96\x03\x96\x03\x96\x03\x96\x03\x96\x03\x96\x03\x97\x03\x97\x03" + - "\x97\x03\x97\x03\x97\x03\x97\x03\x98\x03\x98\x03\x98\x03\x99\x03\x99\x03" + - "\x99\x03\x99\x03\x99\x03\x99\x03\x9A\x03\x9A\x03\x9A\x03\x9A\x03\x9A\x03" + - "\x9A\x03\x9A\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03" + - "\x9B\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03" + - "\x9C\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03" + - "\x9E\x03\x9E\x03\x9E\x03\x9E\x03\x9E\x03\x9E\x03\x9F\x03\x9F\x03\x9F\x03" + - "\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03" + - "\x9F\x03\x9F\x03\x9F\x03\x9F\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03" + - "\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA1\x03\xA1\x03\xA1\x03" + - "\xA1\x03\xA1\x03\xA1\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03" + - "\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA4\x03" + - "\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA6\x03\xA6\x03" + - "\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03" + - "\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA8\x03\xA8\x03\xA8\x03" + - "\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03" + - "\xA8\x03\xA8\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x03" + - "\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03" + - "\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAB\x03\xAB\x03" + - "\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAC\x03\xAC\x03\xAC\x03" + - "\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAD\x03\xAD\x03\xAD\x03" + - "\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAE\x03" + - "\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03" + - "\xB0\x03\xB0\x03\xB0\x03\xB0\x03\xB1\x03\xB1\x03\xB1\x03\xB1\x03\xB1\x03" + - "\xB1\x03\xB1\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB2\x03\xB3\x03" + - "\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03" + - "\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB5\x03\xB5\x03\xB5\x03\xB5\x03\xB6\x03" + - "\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03" + - "\xB6\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03" + - "\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03" + - "\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03" + - "\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBB\x03" + - "\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBC\x03\xBC\x03\xBC\x03" + - "\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBD\x03\xBD\x03" + - "\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03" + - "\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03" + - "\xBE\x03\xBE\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03" + - "\xBF\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03" + - "\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03" + - "\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC3\x03\xC3\x03" + - "\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC4\x03\xC4\x03\xC4\x03\xC4\x03" + - "\xC4\x03\xC5\x03\xC5\x03\xC5\x03"; + "\t\u0239\x04\u023A\t\u023A\x04\u023B\t\u023B\x04\u023C\t\u023C\x04\u023D" + + "\t\u023D\x04\u023E\t\u023E\x04\u023F\t\u023F\x04\u0240\t\u0240\x04\u0241" + + "\t\u0241\x04\u0242\t\u0242\x04\u0243\t\u0243\x04\u0244\t\u0244\x04\u0245" + + "\t\u0245\x04\u0246\t\u0246\x04\u0247\t\u0247\x03\x02\x03\x02\x03\x03\x03" + + "\x03\x03\x04\x03\x04\x03\x05\x03\x05\x03\x06\x03\x06\x03\x07\x03\x07\x03" + + "\b\x03\b\x03\t\x03\t\x03\n\x03\n\x03\v\x03\v\x03\f\x03\f\x03\r\x03\r\x03" + + "\x0E\x03\x0E\x03\x0F\x03\x0F\x03\x10\x03\x10\x03\x11\x03\x11\x03\x12\x03" + + "\x12\x03\x13\x03\x13\x03\x13\x03\x14\x03\x14\x03\x14\x03\x15\x03\x15\x03" + + "\x15\x03\x16\x03\x16\x03\x16\x03\x17\x03\x17\x03\x17\x03\x18\x03\x18\x03" + + "\x18\x03\x19\x03\x19\x03\x19\x03\x1A\x03\x1A\x03\x1A\x03\x1B\x03\x1B\x03" + + "\x1B\x03\x1C\x03\x1C\x03\x1D\x03\x1D\x06\x1D\u04D5\n\x1D\r\x1D\x0E\x1D" + + "\u04D6\x03\x1E\x03\x1E\x06\x1E\u04DB\n\x1E\r\x1E\x0E\x1E\u04DC\x03\x1E" + + "\x03\x1E\x05\x1E\u04E1\n\x1E\x05\x1E\u04E3\n\x1E\x03\x1E\x06\x1E\u04E6" + + "\n\x1E\r\x1E\x0E\x1E\u04E7\x03\x1E\x05\x1E\u04EB\n\x1E\x03\x1F\x03\x1F" + + "\x07\x1F\u04EF\n\x1F\f\x1F\x0E\x1F\u04F2\v\x1F\x03\x1F\x03\x1F\x05\x1F" + + "\u04F6\n\x1F\x03\x1F\x06\x1F\u04F9\n\x1F\r\x1F\x0E\x1F\u04FA\x03\x1F\x03" + + "\x1F\x03 \x03 \x03!\x03!\x03\"\x03\"\x03#\x03#\x03#\x03#\x03$\x03$\x03" + + "$\x03$\x03$\x03$\x03$\x03$\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03%\x03" + + "&\x03&\x03&\x03&\x03\'\x03\'\x03\'\x03\'\x03(\x03(\x03(\x03(\x03(\x03" + + "(\x03)\x03)\x03)\x03*\x03*\x03*\x03*\x03+\x03+\x03+\x03+\x03+\x03+\x03" + + "+\x03+\x03+\x03+\x03+\x03,\x03,\x03,\x03,\x03,\x03-\x03-\x03-\x03-\x03" + + "-\x03.\x03.\x03.\x03.\x03.\x03/\x03/\x03/\x03/\x03/\x03/\x030\x030\x03" + + "0\x030\x030\x030\x030\x030\x031\x031\x031\x031\x031\x031\x031\x032\x03" + + "2\x032\x032\x032\x032\x032\x032\x032\x032\x032\x033\x033\x033\x033\x03" + + "3\x033\x033\x034\x034\x034\x034\x034\x034\x034\x034\x034\x034\x034\x03" + + "4\x034\x034\x034\x034\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + + "5\x035\x035\x035\x036\x036\x036\x036\x036\x036\x036\x036\x036\x036\x03" + + "6\x036\x036\x037\x037\x037\x037\x037\x037\x037\x037\x037\x037\x037\x03" + + "7\x037\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x038\x03" + + "8\x038\x038\x038\x038\x038\x039\x039\x039\x039\x039\x039\x039\x039\x03" + + "9\x039\x039\x039\x039\x03:\x03:\x03:\x03:\x03:\x03:\x03:\x03:\x03;\x03" + + ";\x03;\x03;\x03;\x03;\x03;\x03;\x03;\x03;\x03;\x03<\x03<\x03<\x03<\x03" + + "<\x03=\x03=\x03=\x03=\x03=\x03=\x03=\x03=\x03=\x03>\x03>\x03>\x03?\x03" + + "?\x03?\x03?\x03?\x03@\x03@\x03@\x03@\x03@\x03@\x03@\x03A\x03A\x03A\x03" + + "A\x03A\x03A\x03B\x03B\x03B\x03B\x03B\x03B\x03C\x03C\x03C\x03C\x03D\x03" + + "D\x03D\x03D\x03D\x03D\x03D\x03D\x03E\x03E\x03E\x03E\x03E\x03F\x03F\x03" + + "F\x03F\x03F\x03F\x03G\x03G\x03G\x03G\x03G\x03G\x03H\x03H\x03H\x03H\x03" + + "H\x03H\x03H\x03I\x03I\x03I\x03J\x03J\x03J\x03J\x03J\x03J\x03J\x03J\x03" + + "J\x03J\x03K\x03K\x03K\x03K\x03K\x03K\x03K\x03K\x03K\x03K\x03L\x03L\x03" + + "L\x03L\x03L\x03M\x03M\x03M\x03M\x03M\x03M\x03M\x03M\x03N\x03N\x03N\x03" + + "N\x03N\x03N\x03N\x03N\x03O\x03O\x03O\x03O\x03O\x03O\x03P\x03P\x03P\x03" + + "P\x03P\x03P\x03P\x03P\x03P\x03P\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03" + + "Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03Q\x03R\x03R\x03R\x03R\x03S\x03S\x03" + + "S\x03S\x03S\x03T\x03T\x03T\x03T\x03T\x03T\x03T\x03U\x03U\x03U\x03V\x03" + + "V\x03V\x03V\x03V\x03W\x03W\x03W\x03X\x03X\x03X\x03X\x03X\x03X\x03Y\x03" + + "Y\x03Y\x03Y\x03Y\x03Y\x03Y\x03Y\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03Z\x03" + + "Z\x03[\x03[\x03[\x03[\x03[\x03[\x03[\x03[\x03[\x03[\x03[\x03\\\x03\\\x03" + + "\\\x03\\\x03\\\x03\\\x03\\\x03\\\x03\\\x03\\\x03]\x03]\x03]\x03]\x03]" + + "\x03]\x03]\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03^\x03" + + "^\x03^\x03_\x03_\x03_\x03_\x03_\x03`\x03`\x03`\x03`\x03`\x03`\x03`\x03" + + "`\x03`\x03`\x03a\x03a\x03a\x03a\x03a\x03a\x03b\x03b\x03b\x03b\x03b\x03" + + "c\x03c\x03c\x03d\x03d\x03d\x03d\x03d\x03d\x03d\x03d\x03d\x03e\x03e\x03" + + "e\x03e\x03e\x03f\x03f\x03f\x03f\x03f\x03f\x03g\x03g\x03g\x03g\x03g\x03" + + "g\x03g\x03h\x03h\x03h\x03h\x03h\x03i\x03i\x03i\x03i\x03i\x03i\x03j\x03" + + "j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03k\x03k\x03k\x03k\x03k\x03l\x03" + + "l\x03l\x03l\x03l\x03l\x03m\x03m\x03m\x03m\x03m\x03m\x03m\x03n\x03n\x03" + + "n\x03n\x03n\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03o\x03" + + "o\x03o\x03o\x03p\x03p\x03p\x03p\x03p\x03p\x03p\x03q\x03q\x03q\x03q\x03" + + "q\x03q\x03q\x03q\x03q\x03q\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03r\x03" + + "r\x03r\x03r\x03r\x03r\x03s\x03s\x03s\x03s\x03s\x03s\x03t\x03t\x03t\x03" + + "t\x03t\x03t\x03t\x03t\x03t\x03t\x03t\x03t\x03t\x03t\x03t\x03u\x03u\x03" + + "u\x03u\x03u\x03u\x03u\x03v\x03v\x03v\x03v\x03v\x03w\x03w\x03w\x03w\x03" + + "w\x03w\x03x\x03x\x03x\x03x\x03x\x03x\x03y\x03y\x03y\x03z\x03z\x03z\x03" + + "z\x03z\x03z\x03z\x03{\x03{\x03{\x03{\x03{\x03|\x03|\x03|\x03|\x03|\x03" + + "}\x03}\x03}\x03}\x03}\x03~\x03~\x03~\x03~\x03~\x03~\x03~\x03~\x03\x7F" + + "\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x80\x03\x80" + + "\x03\x80\x03\x80\x03\x80\x03\x80\x03\x81\x03\x81\x03\x81\x03\x81\x03\x81" + + "\x03\x82\x03\x82\x03\x82\x03\x82\x03\x82\x03\x82\x03\x82\x03\x82\x03\x82" + + "\x03\x83\x03\x83\x03\x83\x03\x83\x03\x83\x03\x83\x03\x84\x03\x84\x03\x84" + + "\x03\x84\x03\x84\x03\x84\x03\x84\x03\x84\x03\x85\x03\x85\x03\x85\x03\x85" + + "\x03\x85\x03\x85\x03\x85\x03\x85\x03\x86\x03\x86\x03\x86\x03\x86\x03\x86" + + "\x03\x86\x03\x87\x03\x87\x03\x87\x03\x87\x03\x87\x03\x87\x03\x87\x03\x87" + + "\x03\x87\x03\x88\x03\x88\x03\x88\x03\x88\x03\x88\x03\x88\x03\x88\x03\x89" + + "\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x89\x03\x8A\x03\x8A\x03\x8A" + + "\x03\x8A\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8B\x03\x8C\x03\x8C" + + "\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D" + + "\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8E\x03\x8E\x03\x8E\x03\x8E" + + "\x03\x8E\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x90\x03\x90" + + "\x03\x90\x03\x90\x03\x90\x03\x90\x03\x90\x03\x91\x03\x91\x03\x91\x03\x91" + + "\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x92\x03\x92\x03\x92" + + "\x03\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03\x92\x03\x93" + + "\x03\x93\x03\x93\x03\x94\x03\x94\x03\x94\x03\x94\x03\x94\x03\x94\x03\x94" + + "\x03\x94\x03\x94\x03\x94\x03\x95\x03\x95\x03\x95\x03\x95\x03\x95\x03\x95" + + "\x03\x95\x03\x95\x03\x95\x03\x96\x03\x96\x03\x96\x03\x96\x03\x96\x03\x96" + + "\x03\x96\x03\x97\x03\x97\x03\x97\x03\x97\x03\x97\x03\x97\x03\x98\x03\x98" + + "\x03\x98\x03\x99\x03\x99\x03\x99\x03\x99\x03\x99\x03\x99\x03\x9A\x03\x9A" + + "\x03\x9A\x03\x9A\x03\x9A\x03\x9A\x03\x9A\x03\x9B\x03\x9B\x03\x9B\x03\x9B" + + "\x03\x9B\x03\x9B\x03\x9B\x03\x9B\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9C" + + "\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x03\x9D\x03\x9D\x03\x9D\x03\x9D\x03\x9D" + + "\x03\x9D\x03\x9D\x03\x9D\x03\x9E\x03\x9E\x03\x9E\x03\x9E\x03\x9E\x03\x9E" + + "\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F" + + "\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\xA0\x03\xA0" + + "\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x03\xA0" + + "\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x03\xA2\x03\xA2\x03\xA2" + + "\x03\xA2\x03\xA2\x03\xA2\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3" + + "\x03\xA3\x03\xA3\x03\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA4" + + "\x03\xA4\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5" + + "\x03\xA5\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8" + + "\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA9\x03\xA9\x03\xA9\x03\xA9" + + "\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xAA\x03\xAA" + + "\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA" + + "\x03\xAA\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB\x03\xAB" + + "\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC" + + "\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD" + + "\x03\xAD\x03\xAD\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAE\x03\xAF\x03\xAF" + + "\x03\xAF\x03\xAF\x03\xAF\x03\xB0\x03\xB0\x03\xB0\x03\xB0\x03\xB1\x03\xB1" + + "\x03\xB1\x03\xB1\x03\xB1\x03\xB1\x03\xB1\x03\xB2\x03\xB2\x03\xB2\x03\xB2" + + "\x03\xB2\x03\xB2\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB4\x03\xB4" + + "\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB4\x03\xB5\x03\xB5" + + "\x03\xB5\x03\xB5\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB6" + + "\x03\xB6\x03\xB6\x03\xB6\x03\xB6\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7" + + "\x03\xB7\x03\xB7\x03\xB7\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8" + + "\x03\xB8\x03\xB8\x03\xB8\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9" + + "\x03\xB9\x03\xB9\x03\xB9\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA" + + "\x03\xBA\x03\xBA\x03\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBB" + + "\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC" + + "\x03\xBC\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD" + + "\x03\xBD\x03\xBD\x03\xBD\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE" + + "\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBF\x03\xBF\x03\xBF\x03\xBF" + + "\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0" + + "\x03\xC0\x03\xC0\x03\xC0\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1" + + "\x03\xC1\x03\xC1\x03\xC1\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC2"; private static readonly _serializedATNSegment1: string = - "\xC5\x03\xC5\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03" + - "\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03" + - "\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03" + - "\xC8\x03\xC9\x03\xC9\x03\xC9\x03\xC9\x03\xC9\x03\xCA\x03\xCA\x03\xCA\x03" + - "\xCA\x03\xCA\x03\xCA\x03\xCA\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03" + - "\xCB\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03" + - "\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03" + - "\xCD\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03" + - "\xCE\x03\xCE\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03" + - "\xCF\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03" + - "\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03" + - "\xD1\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03" + - "\xD2\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD4\x03" + - "\xD4\x03\xD4\x03\xD4\x03\xD4\x03\xD4\x03\xD5\x03\xD5\x03\xD5\x03\xD5\x03" + - "\xD5\x03\xD5\x03\xD5\x03\xD5\x03\xD5\x03\xD5\x03\xD6\x03\xD6\x03\xD6\x03" + - "\xD6\x03\xD6\x03\xD6\x03\xD7\x03\xD7\x03\xD7\x03\xD7\x03\xD7\x03\xD7\x03" + - "\xD7\x03\xD7\x03\xD8\x03\xD8\x03\xD8\x03\xD8\x03\xD8\x03\xD8\x03\xD8\x03" + - "\xD8\x03\xD8\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03" + - "\xD9\x03\xD9\x03\xD9\x03\xDA\x03\xDA\x03\xDA\x03\xDA\x03\xDA\x03\xDA\x03" + - "\xDA\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03" + - "\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDD\x03" + - "\xDD\x03\xDD\x03\xDD\x03\xDD\x03\xDD\x03\xDD\x03\xDE\x03\xDE\x03\xDE\x03" + - "\xDE\x03\xDE\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xE0\x03\xE0\x03" + - "\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE1\x03\xE1\x03" + - "\xE1\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03" + - "\xE2\x03\xE2\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03" + - "\xE3\x03\xE3\x03\xE3\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03" + - "\xE4\x03\xE4\x03\xE4\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03" + - "\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE7\x03\xE7\x03\xE7\x03\xE7\x03" + - "\xE7\x03\xE7\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03" + - "\xE8\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03" + - "\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03" + - "\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEC\x03\xEC\x03" + - "\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03" + - "\xEC\x03\xED\x03\xED\x03\xED\x03\xED\x03\xED\x03\xED\x03\xED\x03\xEE\x03" + - "\xEE\x03\xEE\x03\xEE\x03\xEE\x03\xEE\x03\xEE\x03\xEE\x03\xEF\x03\xEF\x03" + - "\xEF\x03\xEF\x03\xEF\x03\xEF\x03\xEF\x03\xEF\x03\xF0\x03\xF0\x03\xF0\x03" + - "\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF1\x03\xF1\x03" + - "\xF1\x03\xF1\x03\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF3\x03" + - "\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF4\x03" + - "\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF5\x03\xF5\x03\xF5\x03\xF5\x03" + - "\xF5\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03" + - "\xF6\x03\xF6\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x03\xF8\x03" + - "\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF9\x03\xF9\x03\xF9\x03" + - "\xF9\x03\xF9\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFB\x03" + - "\xFB\x03\xFB\x03\xFB\x03\xFB\x03\xFB\x03\xFB\x03\xFB\x03\xFB\x03\xFC\x03" + - "\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03" + - "\xFD\x03\xFD\x03\xFD\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03" + - "\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03" + - "\xFF\x03\xFF\x03\xFF\x03\xFF\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03" + - "\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0101\x03\u0101\x03" + - "\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0102\x03\u0102\x03" + - "\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03" + + "\x03\xC2\x03\xC2\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC3" + + "\x03\xC4\x03\xC4\x03\xC4\x03\xC4\x03\xC4\x03\xC5\x03\xC5\x03\xC5\x03\xC5" + + "\x03\xC5\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC6\x03\xC7" + + "\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC7\x03\xC8" + + "\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8\x03\xC8" + + "\x03\xC9\x03\xC9\x03\xC9\x03\xC9\x03\xC9\x03\xCA\x03\xCA\x03\xCA\x03\xCA" + + "\x03\xCA\x03\xCA\x03\xCA\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB" + + "\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x03\xCD" + + "\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD" + + "\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE" + + "\x03\xCE\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF\x03\xCF" + + "\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD0\x03\xD1" + + "\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1\x03\xD1" + + "\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2\x03\xD2" + + "\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD3\x03\xD4\x03\xD4" + + "\x03\xD4\x03\xD4\x03\xD4\x03\xD4\x03\xD5\x03\xD5\x03\xD5\x03\xD5\x03\xD5" + + "\x03\xD5\x03\xD5\x03\xD5\x03\xD5\x03\xD5\x03\xD6\x03\xD6\x03\xD6\x03\xD6" + + "\x03\xD6\x03\xD6\x03\xD7\x03\xD7\x03\xD7\x03\xD7\x03\xD7\x03\xD7\x03\xD7" + + "\x03\xD7\x03\xD8\x03\xD8\x03\xD8\x03\xD8\x03\xD8\x03\xD8\x03\xD8\x03\xD8" + + "\x03\xD8\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03\xD9\x03\xD9" + + "\x03\xD9\x03\xD9\x03\xDA\x03\xDA\x03\xDA\x03\xDA\x03\xDA\x03\xDA\x03\xDA" + + "\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDB\x03\xDC" + + "\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDD\x03\xDD" + + "\x03\xDD\x03\xDD\x03\xDD\x03\xDD\x03\xDD\x03\xDE\x03\xDE\x03\xDE\x03\xDE" + + "\x03\xDE\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xE0\x03\xE0\x03\xE0" + + "\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE0\x03\xE1\x03\xE1\x03\xE1" + + "\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2" + + "\x03\xE2\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3" + + "\x03\xE3\x03\xE3\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x03\xE4" + + "\x03\xE4\x03\xE4\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5" + + "\x03\xE5\x03\xE5\x03\xE5\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6" + + "\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE7\x03\xE7\x03\xE7\x03\xE7\x03\xE7" + + "\x03\xE7\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03\xE8" + + "\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEB" + + "\x03\xEB\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xEC" + + "\x03\xEC\x03\xEC\x03\xEC\x03\xEC\x03\xED\x03\xED\x03\xED\x03\xED\x03\xED" + + "\x03\xED\x03\xED\x03\xED\x03\xED\x03\xEE\x03\xEE\x03\xEE\x03\xEE\x03\xEE" + + "\x03\xEE\x03\xEE\x03\xEE\x03\xEE\x03\xEE\x03\xEE\x03\xEF\x03\xEF\x03\xEF" + + "\x03\xEF\x03\xEF\x03\xEF\x03\xEF\x03\xEF\x03\xEF\x03\xEF\x03\xEF\x03\xF0" + + "\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0" + + "\x03\xF0\x03\xF0\x03\xF0\x03\xF1\x03\xF1\x03\xF1\x03\xF1\x03\xF1\x03\xF1" + + "\x03\xF1\x03\xF1\x03\xF1\x03\xF1\x03\xF1\x03\xF2\x03\xF2\x03\xF2\x03\xF2" + + "\x03\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF2" + + "\x03\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF3\x03\xF3" + + "\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF5\x03\xF5" + + "\x03\xF5\x03\xF5\x03\xF5\x03\xF5\x03\xF5\x03\xF5\x03\xF5\x03\xF5\x03\xF5" + + "\x03\xF5\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF7" + + "\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x03\xF8\x03\xF8" + + "\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF9\x03\xF9\x03\xF9" + + "\x03\xF9\x03\xF9\x03\xF9\x03\xF9\x03\xF9\x03\xF9\x03\xF9\x03\xFA\x03\xFA" + + "\x03\xFA\x03\xFA\x03\xFB\x03\xFB\x03\xFB\x03\xFB\x03\xFB\x03\xFB\x03\xFC" + + "\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFD" + + "\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFE\x03\xFE\x03\xFE\x03\xFE" + + "\x03\xFE\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF" + + "\x03\xFF\x03\xFF\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03" + + "\u0100\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03" + + "\u0101\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0103\x03" + "\u0103\x03\u0103\x03\u0103\x03\u0103\x03\u0103\x03\u0104\x03\u0104\x03" + - "\u0104\x03\u0104\x03\u0104\x03\u0104\x03\u0105\x03\u0105\x03\u0105\x03" + - "\u0105\x03\u0105\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03" + - "\u0107\x03\u0107\x03\u0107\x03\u0107\x03\u0107\x03\u0107\x03\u0108\x03" + + "\u0104\x03\u0104\x03\u0104\x03\u0104\x03\u0104\x03\u0104\x03\u0104\x03" + + "\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0106\x03\u0106\x03" + + "\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0107\x03" + + "\u0107\x03\u0107\x03\u0107\x03\u0107\x03\u0107\x03\u0108\x03\u0108\x03" + + "\u0108\x03\u0108\x03\u0108\x03\u0108\x03\u0108\x03\u0108\x03\u0108\x03" + "\u0108\x03\u0108\x03\u0108\x03\u0108\x03\u0109\x03\u0109\x03\u0109\x03" + - "\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03" + - "\u010A\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03" + - "\u010B\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03" + - "\u010C\x03\u010D\x03\u010D\x03\u010D\x03\u010D\x03\u010D\x03\u010D\x03" + - "\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03" + - "\u010F\x03\u010F\x03\u010F\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03" + + "\u0109\x03\u0109\x03\u0109\x03\u0109\x03\u0109\x03\u0109\x03\u010A\x03" + + "\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010A\x03\u010B\x03" + + "\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03\u010B\x03" + + "\u010B\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010D\x03" + + "\u010D\x03\u010D\x03\u010D\x03\u010D\x03\u010D\x03\u010E\x03\u010E\x03" + + "\u010E\x03\u010E\x03\u010E\x03\u010F\x03\u010F\x03\u010F\x03\u010F\x03" + + "\u010F\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03" + "\u0111\x03\u0111\x03\u0111\x03\u0111\x03\u0111\x03\u0112\x03\u0112\x03" + - "\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03" + - "\u0113\x03\u0113\x03\u0113\x03\u0113\x03\u0113\x03\u0113\x03\u0113\x03" + - "\u0114\x03\u0114\x03\u0114\x03\u0114\x03\u0114\x03\u0114\x03\u0114\x03" + - "\u0114\x03\u0115\x03\u0115\x03\u0115\x03\u0115\x03\u0115\x03\u0115\x03" + - "\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0117\x03" + - "\u0117\x03\u0117\x03\u0117\x03\u0117\x03\u0117\x03\u0117\x03\u0118\x03" + - "\u0118\x03\u0118\x03\u0118\x03\u0118\x03\u0118\x03\u0118\x03\u0118\x03" + - "\u0119\x03\u0119\x03\u0119\x03\u0119\x03\u0119\x03\u0119\x03\u0119\x03" + - "\u0119\x03\u0119\x03\u0119\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03" + - "\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011B\x03\u011B\x03\u011B\x03" + - "\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011C\x03" + - "\u011C\x03\u011C\x03\u011C\x03\u011C\x03\u011C\x03\u011D\x03\u011D\x03" + - "\u011D\x03\u011D\x03\u011D\x03\u011D\x03\u011D\x03\u011D\x03\u011D\x03" + - "\u011D\x03\u011E\x03\u011E\x03\u011E\x03\u011E\x03\u011E\x03\u011E\x03" + - "\u011E\x03\u011E\x03\u011F\x03\u011F\x03\u011F\x03\u011F\x03\u011F\x03" + - "\u011F\x03\u011F\x03\u011F\x03\u011F\x03\u0120\x03\u0120\x03\u0120\x03" + - "\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0121\x03" + - "\u0121\x03\u0121\x03\u0121\x03\u0121\x03\u0121\x03\u0122\x03\u0122\x03" + - "\u0122\x03\u0122\x03\u0122\x03\u0122\x03\u0122\x03\u0122\x03\u0122\x03" + - "\u0122\x03\u0122\x03\u0123\x03\u0123\x03\u0123\x03\u0123\x03\u0123\x03" + - "\u0123\x03\u0123\x03\u0123\x03\u0123\x03\u0123\x03\u0123\x03\u0124\x03" + + "\u0112\x03\u0113\x03\u0113\x03\u0113\x03\u0113\x03\u0113\x03\u0113\x03" + + "\u0113\x03\u0113\x03\u0114\x03\u0114\x03\u0114\x03\u0114\x03\u0114\x03" + + "\u0114\x03\u0114\x03\u0115\x03\u0115\x03\u0115\x03\u0115\x03\u0115\x03" + + "\u0115\x03\u0115\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03" + + "\u0116\x03\u0117\x03\u0117\x03\u0117\x03\u0117\x03\u0117\x03\u0117\x03" + + "\u0117\x03\u0118\x03\u0118\x03\u0118\x03\u0119\x03\u0119\x03\u0119\x03" + + "\u0119\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011B\x03" + + "\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x03" + + "\u011B\x03\u011C\x03\u011C\x03\u011C\x03\u011C\x03\u011C\x03\u011C\x03" + + "\u011C\x03\u011D\x03\u011D\x03\u011D\x03\u011D\x03\u011D\x03\u011D\x03" + + "\u011D\x03\u011D\x03\u011E\x03\u011E\x03\u011E\x03\u011E\x03\u011E\x03" + + "\u011E\x03\u011F\x03\u011F\x03\u011F\x03\u011F\x03\u011F\x03\u011F\x03" + + "\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03" + + "\u0121\x03\u0121\x03\u0121\x03\u0121\x03\u0121\x03\u0121\x03\u0121\x03" + + "\u0121\x03\u0122\x03\u0122\x03\u0122\x03\u0122\x03\u0122\x03\u0122\x03" + + "\u0122\x03\u0122\x03\u0122\x03\u0122\x03\u0123\x03\u0123\x03\u0123\x03" + + "\u0123\x03\u0123\x03\u0123\x03\u0123\x03\u0123\x03\u0124\x03\u0124\x03" + "\u0124\x03\u0124\x03\u0124\x03\u0124\x03\u0124\x03\u0124\x03\u0124\x03" + - "\u0124\x03\u0124\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x03" + - "\u0125\x03\u0125\x03\u0125\x03\u0126\x03\u0126\x03\u0126\x03\u0126\x03" + + "\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0126\x03" + + "\u0126\x03\u0126\x03\u0126\x03\u0126\x03\u0126\x03\u0126\x03\u0126\x03" + "\u0126\x03\u0126\x03\u0127\x03\u0127\x03\u0127\x03\u0127\x03\u0127\x03" + - "\u0127\x03\u0128\x03\u0128\x03\u0128\x03\u0128\x03\u0128\x03\u0129\x03" + + "\u0127\x03\u0127\x03\u0127\x03\u0128\x03\u0128\x03\u0128\x03\u0128\x03" + + "\u0128\x03\u0128\x03\u0128\x03\u0128\x03\u0128\x03\u0129\x03\u0129\x03" + "\u0129\x03\u0129\x03\u0129\x03\u0129\x03\u0129\x03\u0129\x03\u0129\x03" + - "\u0129\x03\u012A\x03\u012A\x03\u012A\x03\u012A\x03\u012A\x03\u012A\x03" + - "\u012A\x03\u012A\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03" + - "\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012C\x03\u012C\x03" + - "\u012C\x03\u012C\x03\u012D\x03\u012D\x03\u012D\x03\u012D\x03\u012D\x03" + + "\u012A\x03\u012A\x03\u012A\x03\u012A\x03\u012A\x03\u012A\x03\u012B\x03" + + "\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03" + + "\u012B\x03\u012B\x03\u012B\x03\u012C\x03\u012C\x03\u012C\x03\u012C\x03" + + "\u012C\x03\u012C\x03\u012C\x03\u012C\x03\u012C\x03\u012C\x03\u012C\x03" + + "\u012D\x03\u012D\x03\u012D\x03\u012D\x03\u012D\x03\u012D\x03\u012D\x03" + "\u012D\x03\u012D\x03\u012D\x03\u012E\x03\u012E\x03\u012E\x03\u012E\x03" + "\u012E\x03\u012E\x03\u012E\x03\u012E\x03\u012F\x03\u012F\x03\u012F\x03" + - "\u012F\x03\u012F\x03\u012F\x03\u012F\x03\u012F\x03\u012F\x03\u0130\x03" + - "\u0130\x03\u0130\x03\u0130\x03\u0130\x03\u0130\x03\u0130\x03\u0130\x03" + - "\u0131\x03\u0131\x03\u0131\x03\u0131\x03\u0131\x03\u0131\x03\u0131\x03" + + "\u012F\x03\u012F\x03\u012F\x03\u0130\x03\u0130\x03\u0130\x03\u0130\x03" + + "\u0130\x03\u0130\x03\u0131\x03\u0131\x03\u0131\x03\u0131\x03\u0131\x03" + "\u0132\x03\u0132\x03\u0132\x03\u0132\x03\u0132\x03\u0132\x03\u0132\x03" + - "\u0132\x03\u0132\x03\u0132\x03\u0132\x03\u0133\x03\u0133\x03\u0133\x03" + - "\u0133\x03\u0133\x03\u0133\x03\u0133\x03\u0133\x03\u0134\x03\u0134\x03" + + "\u0132\x03\u0132\x03\u0133\x03\u0133\x03\u0133\x03\u0133\x03\u0133\x03" + + "\u0133\x03\u0133\x03\u0133\x03\u0134\x03\u0134\x03\u0134\x03\u0134\x03" + "\u0134\x03\u0134\x03\u0134\x03\u0134\x03\u0134\x03\u0134\x03\u0135\x03" + - "\u0135\x03\u0135\x03\u0135\x03\u0135\x03\u0135\x03\u0136\x03\u0136\x03" + - "\u0136\x03\u0136\x03\u0136\x03\u0136\x03\u0136\x03\u0136\x03\u0137\x03" + - "\u0137\x03\u0137\x03\u0137\x03\u0137\x03\u0137\x03\u0137\x03\u0137\x03" + - "\u0137\x03\u0138\x03\u0138\x03\u0138\x03\u0138\x03\u0138\x03\u0138\x03" + - "\u0138\x03\u0138\x03\u0139\x03\u0139\x03\u0139\x03\u0139\x03\u0139\x03" + - "\u0139\x03\u0139\x03\u013A\x03\u013A\x03\u013A\x03\u013A\x03\u013A\x03" + - "\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03" + - "\u013B\x03\u013B\x03\u013C\x03\u013C\x03\u013C\x03\u013C\x03\u013C\x03" + - "\u013D\x03\u013D\x03\u013D\x03\u013D\x03\u013D\x03\u013E\x03\u013E\x03" + - "\u013E\x03\u013E\x03\u013E\x03\u013E\x03\u013E\x03\u013E\x03\u013E\x03" + - "\u013E\x03\u013F\x03\u013F\x03\u013F\x03\u013F\x03\u013F\x03\u013F\x03" + - "\u013F\x03\u0140\x03\u0140\x03\u0140\x03\u0140\x03\u0140\x03\u0140\x03" + - "\u0140\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x03" + - "\u0141\x03\u0142\x03\u0142\x03\u0142\x03\u0142\x03\u0142\x03\u0142\x03" + - "\u0142\x03\u0143\x03\u0143\x03\u0143\x03\u0143\x03\u0143\x03\u0143\x03" + - "\u0143\x03\u0143\x03\u0143\x03\u0144\x03\u0144\x03\u0144\x03\u0144\x03" + - "\u0144\x03\u0144\x03\u0144\x03\u0144\x03\u0144\x03\u0145\x03\u0145\x03" + - "\u0145\x03\u0145\x03\u0145\x03\u0145\x03\u0145\x03\u0145\x03\u0145\x03" + - "\u0145\x03\u0146\x03\u0146\x03\u0146\x03\u0146\x03\u0146\x03\u0146\x03" + - "\u0146\x03\u0146\x03\u0146\x03\u0146\x03\u0146\x03\u0146\x03\u0146\x03" + + "\u0135\x03\u0135\x03\u0135\x03\u0136\x03\u0136\x03\u0136\x03\u0136\x03" + + "\u0136\x03\u0136\x03\u0136\x03\u0136\x03\u0137\x03\u0137\x03\u0137\x03" + + "\u0137\x03\u0137\x03\u0137\x03\u0137\x03\u0137\x03\u0138\x03\u0138\x03" + + "\u0138\x03\u0138\x03\u0138\x03\u0138\x03\u0138\x03\u0138\x03\u0138\x03" + + "\u0139\x03\u0139\x03\u0139\x03\u0139\x03\u0139\x03\u0139\x03\u0139\x03" + + "\u0139\x03\u013A\x03\u013A\x03\u013A\x03\u013A\x03\u013A\x03\u013A\x03" + + "\u013A\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03" + + "\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013C\x03\u013C\x03" + + "\u013C\x03\u013C\x03\u013C\x03\u013C\x03\u013C\x03\u013C\x03\u013D\x03" + + "\u013D\x03\u013D\x03\u013D\x03\u013D\x03\u013D\x03\u013D\x03\u013D\x03" + + "\u013E\x03\u013E\x03\u013E\x03\u013E\x03\u013E\x03\u013E\x03\u013F\x03" + + "\u013F\x03\u013F\x03\u013F\x03\u013F\x03\u013F\x03\u013F\x03\u013F\x03" + + "\u0140\x03\u0140\x03\u0140\x03\u0140\x03\u0140\x03\u0140\x03\u0140\x03" + + "\u0140\x03\u0140\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x03" + + "\u0141\x03\u0141\x03\u0141\x03\u0142\x03\u0142\x03\u0142\x03\u0142\x03" + + "\u0142\x03\u0142\x03\u0142\x03\u0143\x03\u0143\x03\u0143\x03\u0143\x03" + + "\u0143\x03\u0144\x03\u0144\x03\u0144\x03\u0144\x03\u0144\x03\u0144\x03" + + "\u0144\x03\u0144\x03\u0144\x03\u0145\x03\u0145\x03\u0145\x03\u0145\x03" + + "\u0145\x03\u0146\x03\u0146\x03\u0146\x03\u0146\x03\u0146\x03\u0147\x03" + "\u0147\x03\u0147\x03\u0147\x03\u0147\x03\u0147\x03\u0147\x03\u0147\x03" + - "\u0148\x03\u0148\x03\u0148\x03\u0148\x03\u0148\x03\u0148\x03\u0148\x03" + - "\u0148\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u014A\x03\u014A\x03" + - "\u014A\x03\u014A\x03\u014A\x03\u014A\x03\u014B\x03\u014B\x03\u014B\x03" + + "\u0147\x03\u0147\x03\u0148\x03\u0148\x03\u0148\x03\u0148\x03\u0148\x03" + + "\u0148\x03\u0148\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03" + + "\u0149\x03\u0149\x03\u014A\x03\u014A\x03\u014A\x03\u014A\x03\u014A\x03" + + "\u014A\x03\u014A\x03\u014B\x03\u014B\x03\u014B\x03\u014B\x03\u014B\x03" + "\u014B\x03\u014B\x03\u014C\x03\u014C\x03\u014C\x03\u014C\x03\u014C\x03" + - "\u014C\x03\u014C\x03\u014D\x03\u014D\x03\u014D\x03\u014D\x03\u014D\x03" + - "\u014D\x03\u014D\x03\u014D\x03\u014D\x03\u014E\x03\u014E\x03\u014E\x03" + - "\u014E\x03\u014E\x03\u014E\x03\u014E\x03\u014F\x03\u014F\x03\u014F\x03" + + "\u014C\x03\u014C\x03\u014C\x03\u014C\x03\u014D\x03\u014D\x03\u014D\x03" + + "\u014D\x03\u014D\x03\u014D\x03\u014D\x03\u014D\x03\u014D\x03\u014E\x03" + + "\u014E\x03\u014E\x03\u014E\x03\u014E\x03\u014E\x03\u014E\x03\u014E\x03" + + "\u014E\x03\u014E\x03\u014F\x03\u014F\x03\u014F\x03\u014F\x03\u014F\x03" + "\u014F\x03\u014F\x03\u014F\x03\u014F\x03\u014F\x03\u014F\x03\u014F\x03" + "\u014F\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03" + - "\u0151\x03\u0151\x03\u0151\x03\u0151\x03\u0151\x03\u0151\x03\u0151\x03" + - "\u0151\x03\u0151\x03\u0151\x03\u0152\x03\u0152\x03\u0152\x03\u0152\x03" + - "\u0152\x03\u0152\x03\u0152\x03\u0152\x03\u0152\x03\u0152\x03\u0152\x03" + - "\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0154\x03" + - "\u0154\x03\u0154\x03\u0154\x03\u0154\x03\u0154\x03\u0154\x03\u0155\x03" + - "\u0155\x03\u0155\x03\u0155\x03\u0155\x03\u0155\x03\u0155\x03\u0155\x03" + - "\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03" + - "\u0157\x03\u0157\x03\u0157\x03\u0157\x03\u0157\x03\u0157\x03\u0158\x03" + - "\u0158\x03\u0158\x03\u0158\x03\u0158\x03\u0158\x03\u0159\x03\u0159\x03" + - "\u0159\x03\u0159\x03\u0159\x03\u0159\x03\u0159\x03\u015A\x03\u015A\x03" + - "\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015B\x03\u015B\x03" + + "\u0150\x03\u0151\x03\u0151\x03\u0151\x03\u0151\x03\u0151\x03\u0151\x03" + + "\u0151\x03\u0151\x03\u0152\x03\u0152\x03\u0152\x03\u0152\x03\u0153\x03" + + "\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0154\x03\u0154\x03" + + "\u0154\x03\u0154\x03\u0154\x03\u0155\x03\u0155\x03\u0155\x03\u0155\x03" + + "\u0155\x03\u0155\x03\u0155\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03" + + "\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0157\x03\u0157\x03" + + "\u0157\x03\u0157\x03\u0157\x03\u0157\x03\u0157\x03\u0158\x03\u0158\x03" + + "\u0158\x03\u0158\x03\u0158\x03\u0158\x03\u0158\x03\u0158\x03\u0158\x03" + + "\u0158\x03\u0158\x03\u0159\x03\u0159\x03\u0159\x03\u0159\x03\u0159\x03" + + "\u0159\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03" + + "\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015B\x03\u015B\x03\u015B\x03" + "\u015B\x03\u015B\x03\u015B\x03\u015B\x03\u015B\x03\u015B\x03\u015B\x03" + - "\u015B\x03\u015B\x03\u015C\x03\u015C\x03\u015C\x03\u015C\x03\u015C\x03" + + "\u015B\x03\u015C\x03\u015C\x03\u015C\x03\u015C\x03\u015C\x03\u015C\x03" + "\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03" + - "\u015D\x03\u015D\x03\u015E\x03\u015E\x03\u015E\x03\u015E\x03\u015E\x03" + - "\u015E\x03\u015E\x03\u015E\x03\u015E\x03\u015E\x03\u015F\x03\u015F\x03" + - "\u015F\x03\u015F\x03\u015F\x03\u0160\x03\u0160\x03\u0160\x03\u0160\x03" + - "\u0160\x03\u0160\x03\u0160\x03\u0160\x03\u0160\x03\u0160\x03\u0160\x03" + - "\u0160\x03\u0161\x03\u0161\x03\u0161\x03\u0161\x03\u0161\x03\u0161\x03" + - "\u0161\x03\u0161\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03" + - "\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0163\x03\u0163\x03\u0163\x03" + - "\u0163\x03\u0163\x03\u0163\x03\u0163\x03\u0163\x03\u0164\x03\u0164\x03" + + "\u015E\x03\u015E\x03\u015E\x03\u015E\x03\u015E\x03\u015E\x03\u015E\x03" + + "\u015E\x03\u015F\x03\u015F\x03\u015F\x03\u015F\x03\u015F\x03\u015F\x03" + + "\u015F\x03\u0160\x03\u0160\x03\u0160\x03\u0160\x03\u0160\x03\u0160\x03" + + "\u0161\x03\u0161\x03\u0161\x03\u0161\x03\u0161\x03\u0161\x03\u0162\x03" + + "\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0163\x03" + + "\u0163\x03\u0163\x03\u0163\x03\u0163\x03\u0163\x03\u0163\x03\u0164\x03" + + "\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03" + "\u0164\x03\u0164\x03\u0164\x03\u0165\x03\u0165\x03\u0165\x03\u0165\x03" + - "\u0165\x03\u0165\x03\u0166\x03\u0166\x03\u0166\x03\u0166\x03\u0166\x03" + - "\u0166\x03\u0166\x03\u0166\x03\u0166\x03\u0166\x03\u0167\x03\u0167\x03" + - "\u0167\x03\u0167\x03\u0167\x03\u0167\x03\u0167\x03\u0167\x03\u0167\x03" + - "\u0167\x03\u0167\x03\u0167\x03\u0168\x03\u0168\x03\u0168\x03\u0168\x03" + - "\u0168\x03\u0168\x03\u0168\x03\u0168\x03\u0168\x03\u0168\x03\u0168\x03" + - "\u0168\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03" + + "\u0165\x03\u0166\x03\u0166\x03\u0166\x03\u0166\x03\u0166\x03\u0166\x03" + + "\u0166\x03\u0166\x03\u0166\x03\u0167\x03\u0167\x03\u0167\x03\u0167\x03" + + "\u0167\x03\u0167\x03\u0167\x03\u0167\x03\u0167\x03\u0167\x03\u0168\x03" + + "\u0168\x03\u0168\x03\u0168\x03\u0168\x03\u0169\x03\u0169\x03\u0169\x03" + + "\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03" + "\u0169\x03\u0169\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03" + - "\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016B\x03\u016B\x03\u016B\x03" + - "\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016C\x03" + - "\u016C\x03\u016C\x03\u016C\x03\u016C\x03\u016C\x03\u016D\x03\u016D\x03" + - "\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016E\x03\u016E\x03" + - "\u016E\x03\u016E\x03\u016E\x03\u016E\x03\u016E\x03\u016F\x03\u016F\x03" + - "\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u0170\x03\u0170\x03\u0170\x03" + - "\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0171\x03" + + "\u016A\x03\u016A\x03\u016A\x03\u016B\x03\u016B\x03\u016B\x03\u016B\x03" + + "\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016C\x03\u016C\x03" + + "\u016C\x03\u016C\x03\u016C\x03\u016C\x03\u016C\x03\u016C\x03\u016D\x03" + + "\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016E\x03\u016E\x03\u016E\x03" + + "\u016E\x03\u016E\x03\u016E\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03" + + "\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u0170\x03" + + "\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03" + + "\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0171\x03\u0171\x03\u0171\x03" + "\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03" + "\u0171\x03\u0171\x03\u0172\x03\u0172\x03\u0172\x03\u0172\x03\u0172\x03" + "\u0172\x03\u0172\x03\u0172\x03\u0173\x03\u0173\x03\u0173\x03\u0173\x03" + - "\u0173\x03\u0173\x03\u0173\x03\u0173\x03\u0174\x03\u0174\x03\u0174\x03" + - "\u0174\x03\u0174\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03" + - "\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0176\x03\u0176\x03\u0176\x03" + - "\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03" + - "\u0176\x03\u0177\x03\u0177\x03\u0177\x03\u0177\x03\u0177\x03\u0177\x03" + - "\u0177\x03\u0177\x03\u0178\x03\u0178\x03\u0178\x03\u0178\x03\u0178\x03" + + "\u0173\x03\u0173\x03\u0173\x03\u0173\x03\u0173\x03\u0174\x03\u0174\x03" + + "\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03" + + "\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0176\x03" + + "\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0177\x03" + + "\u0177\x03\u0177\x03\u0177\x03\u0177\x03\u0177\x03\u0177\x03\u0178\x03" + + "\u0178\x03\u0178\x03\u0178\x03\u0178\x03\u0178\x03\u0179\x03\u0179\x03" + "\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03" + - "\u0179\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03" + + "\u017A\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03" + + "\u017A\x03\u017A\x03\u017A\x03\u017B\x03\u017B\x03\u017B\x03\u017B\x03" + "\u017B\x03\u017B\x03\u017B\x03\u017B\x03\u017C\x03\u017C\x03\u017C\x03" + - "\u017C\x03\u017C\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017E\x03" + - "\u017E\x03\u017E\x03\u017E\x03\u017E\x03\u017F\x03\u017F\x03\u017F\x03" + - "\u017F\x03\u017F\x03\u017F\x03\u017F\x03\u017F\x03\u0180\x03\u0180\x03" + - "\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0181\x03\u0181\x03" + - "\u0181\x03\u0181\x03\u0182\x03\u0182\x03\u0182\x03\u0182\x03\u0182\x03" + - "\u0182\x03\u0182\x03\u0182\x03\u0183\x03\u0183\x03\u0183\x03\u0183\x03" + - "\u0183\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03" + - "\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0185\x03\u0185\x03\u0185\x03" + - "\u0185\x03\u0185\x03\u0185\x03\u0185\x03\u0185\x03\u0185\x03\u0186\x03" + - "\u0186\x03\u0186\x03\u0186\x03\u0187\x03\u0187\x03\u0187\x03\u0187\x03" + - "\u0187\x03\u0187\x03\u0187\x03\u0187\x03\u0188\x03\u0188\x03\u0188\x03" + - "\u0188\x03\u0188\x03\u0188\x03\u0188\x03\u0189\x03\u0189\x03\u0189\x03" + - "\u0189\x03\u0189\x03\u0189\x03\u0189\x03\u0189\x03\u018A\x03\u018A\x03" + - "\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018B\x03\u018B\x03\u018B\x03" + - "\u018B\x03\u018B\x03\u018B\x03\u018B\x03\u018B\x03\u018B\x03\u018C\x03" + - "\u018C\x03\u018C\x03\u018C\x03\u018C\x03\u018C\x03\u018D\x03\u018D\x03" + - "\u018D\x03\u018D\x03\u018E\x03\u018E\x03\u018E\x03\u018E\x03\u018E\x03" + - "\u018E\x03\u018E\x03\u018E\x03\u018F\x03\u018F\x03\u018F\x03\u018F\x03" + - "\u018F\x03\u018F\x03\u018F\x03\u018F\x03\u018F\x03\u0190\x03\u0190\x03" + - "\u0190\x03\u0190\x03\u0190\x03\u0190\x03\u0191\x03\u0191\x03\u0191\x03" + - "\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0192\x03" + - "\u0192\x03\u0192\x03\u0192\x03\u0192\x03\u0192\x03\u0193\x03\u0193\x03" + - "\u0193\x03\u0193\x03\u0193\x03\u0194\x03\u0194\x03\u0194\x03\u0194\x03" + - "\u0194\x03\u0194\x03\u0194\x03\u0195\x03\u0195\x03\u0195\x03\u0195\x03" + - "\u0195\x03\u0195\x03\u0195\x03\u0195\x03\u0196\x03\u0196\x03\u0196\x03" + - "\u0196\x03\u0196\x03\u0196\x03\u0196\x03\u0196\x03\u0197\x03\u0197\x03" + - "\u0197\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x03" + - "\u0198\x03\u0198\x03\u0198\x03\u0198\x03\u0198\x03\u0198\x03\u0198\x03" + - "\u0198\x03\u0198\x03\u0198\x03\u0199\x03\u0199\x03\u0199\x03\u0199\x03" + - "\u0199\x03\u019A\x03\u019A\x03\u019A\x03\u019A\x03\u019B\x03\u019B\x03" + - "\u019B\x03\u019B\x03\u019B\x03\u019B\x03\u019C\x03\u019C\x03\u019C\x03" + - "\u019C\x03\u019C\x03\u019C\x03\u019C\x03\u019C\x03\u019C\x03\u019D\x03" + - "\u019D\x03\u019D\x03\u019D\x03\u019D\x03\u019D\x03\u019D\x03\u019D\x03" + - "\u019D\x03\u019D\x03\u019E\x03\u019E\x03\u019E\x03\u019E\x03\u019E\x03" + - "\u019F\x03\u019F\x03\u019F\x03\u019F\x03\u019F\x03\u019F\x03\u019F\x03" + - "\u019F\x03\u019F\x03\u019F\x03\u01A0\x03\u01A0\x03\u01A0\x03\u01A0\x03" + - "\u01A0\x03\u01A0\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03" + - "\u01A2\x03\u01A2\x03\u01A2\x03\u01A2\x03\u01A2\x03\u01A2\x03\u01A2\x03" + - "\u01A3\x03\u01A3\x03\u01A3\x03\u01A3\x03\u01A3\x03\u01A3\x03\u01A3\x03" + - "\u01A3\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03" + - "\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03" + - "\u01A4\x03\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03" + - "\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03\u01A6\x03\u01A6\x03\u01A6\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017D\x03\u017D\x03" + + "\u017D\x03\u017D\x03\u017D\x03\u017E\x03\u017E\x03\u017E\x03\u017E\x03" + + "\u017E\x03\u017E\x03\u017E\x03\u017E\x03\u017E\x03\u017F\x03\u017F\x03" + + "\u017F\x03\u017F\x03\u017F\x03\u017F\x03\u017F\x03\u017F\x03\u017F\x03" + + "\u017F\x03\u017F\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03" + + "\u0180\x03\u0180\x03\u0180\x03\u0181\x03\u0181\x03\u0181\x03\u0181\x03" + + "\u0181\x03\u0182\x03\u0182\x03\u0182\x03\u0182\x03\u0182\x03\u0182\x03" + + "\u0182\x03\u0182\x03\u0183\x03\u0183\x03\u0183\x03\u0183\x03\u0183\x03" + + "\u0183\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0185\x03\u0185\x03" + + "\u0185\x03\u0185\x03\u0185\x03\u0186\x03\u0186\x03\u0186\x03\u0186\x03" + + "\u0187\x03\u0187\x03\u0187\x03\u0187\x03\u0187\x03\u0188\x03\u0188\x03" + + "\u0188\x03\u0188\x03\u0188\x03\u0188\x03\u0188\x03\u0188\x03\u0189\x03" + + "\u0189\x03\u0189\x03\u0189\x03\u0189\x03\u0189\x03\u0189\x03\u018A\x03" + + "\u018A\x03\u018A\x03\u018A\x03\u018B\x03\u018B\x03\u018B\x03\u018B\x03" + + "\u018B\x03\u018B\x03\u018B\x03\u018B\x03\u018C\x03\u018C\x03\u018C\x03" + + "\u018C\x03\u018C\x03\u018D\x03\u018D\x03\u018D\x03\u018D\x03\u018D\x03" + + "\u018D\x03\u018D\x03\u018D\x03\u018D\x03\u018D\x03\u018E\x03\u018E\x03" + + "\u018E\x03\u018E\x03\u018E\x03\u018E\x03\u018E\x03\u018E\x03\u018E\x03" + + "\u018F\x03\u018F\x03\u018F\x03\u018F\x03\u0190\x03\u0190\x03\u0190\x03" + + "\u0190\x03\u0190\x03\u0190\x03\u0190\x03\u0190\x03\u0191\x03\u0191\x03" + + "\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0192\x03\u0192\x03" + + "\u0192\x03\u0192\x03\u0192\x03\u0192\x03\u0192\x03\u0192\x03\u0193\x03" + + "\u0193\x03\u0193\x03\u0193\x03\u0193\x03\u0193\x03\u0194\x03\u0194\x03" + + "\u0194\x03\u0194\x03\u0194\x03\u0194\x03\u0194\x03\u0194\x03\u0194\x03" + + "\u0195\x03\u0195\x03\u0195\x03\u0195\x03\u0195\x03\u0195\x03\u0196\x03" + + "\u0196\x03\u0196\x03\u0196\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x03" + + "\u0197\x03\u0197\x03\u0197\x03\u0197\x03\u0198\x03\u0198\x03\u0198\x03" + + "\u0198\x03\u0198\x03\u0198\x03\u0198\x03\u0198\x03\u0198\x03\u0199\x03" + + "\u0199\x03\u0199\x03\u0199\x03\u0199\x03\u0199\x03\u019A\x03\u019A\x03" + + "\u019A\x03\u019A\x03\u019A\x03\u019A\x03\u019A\x03\u019A\x03\u019A\x03" + + "\u019B\x03\u019B\x03\u019B\x03\u019B\x03\u019B\x03\u019B\x03\u019C\x03" + + "\u019C\x03\u019C\x03\u019C\x03\u019C\x03\u019D\x03\u019D\x03\u019D\x03" + + "\u019D\x03\u019D\x03\u019D\x03\u019D\x03\u019E\x03\u019E\x03\u019E\x03" + + "\u019E\x03\u019E\x03\u019E\x03\u019E\x03\u019E\x03\u019F\x03\u019F\x03" + + "\u019F\x03\u019F\x03\u019F\x03\u019F\x03\u019F\x03\u019F\x03\u01A0\x03" + + "\u01A0\x03\u01A0\x03\u01A0\x03\u01A0\x03\u01A0\x03\u01A0\x03\u01A0\x03" + + "\u01A0\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03" + + "\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A2\x03\u01A2\x03\u01A2\x03" + + "\u01A2\x03\u01A2\x03\u01A3\x03\u01A3\x03\u01A3\x03\u01A3\x03\u01A4\x03" + + "\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A5\x03\u01A5\x03" + + "\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03" + "\u01A6\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A6\x03" + - "\u01A6\x03\u01A7\x03\u01A7\x03\u01A7\x03\u01A7\x03\u01A7\x03\u01A7\x03" + - "\u01A7\x03\u01A7\x03\u01A7\x03\u01A7\x03\u01A8\x03\u01A8\x03\u01A8\x03" + - "\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03" + - "\u01A9\x03\u01A9\x03\u01A9\x03\u01A9\x03\u01A9\x03\u01A9\x03\u01A9\x03" + - "\u01A9\x03\u01A9\x03\u01AA\x03\u01AA\x03\u01AA\x03\u01AA\x03\u01AA\x03" + + "\u01A6\x03\u01A6\x03\u01A6\x03\u01A7\x03\u01A7\x03\u01A7\x03\u01A7\x03" + + "\u01A7\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03" + + "\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A9\x03\u01A9\x03\u01A9\x03" + + "\u01A9\x03\u01A9\x03\u01A9\x03\u01AA\x03\u01AA\x03\u01AA\x03\u01AA\x03" + "\u01AA\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + - "\u01AB\x03\u01AB\x03\u01AC\x03\u01AC\x03\u01AC\x03\u01AC\x03\u01AC\x03" + - "\u01AC\x03\u01AC\x03\u01AC\x03\u01AC\x03\u01AC\x03\u01AC\x03\u01AC\x03" + - "\u01AC\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AE\x03" + - "\u01AE\x03\u01AE\x03\u01AE\x03\u01AE\x03\u01AE\x03\u01AE\x03\u01AE\x03" + + "\u01AB\x03\u01AC\x03\u01AC\x03\u01AC\x03\u01AC\x03\u01AC\x03\u01AC\x03" + + "\u01AC\x03\u01AC\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03" + + "\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03" + + "\u01AD\x03\u01AD\x03\u01AE\x03\u01AE\x03\u01AE\x03\u01AE\x03\u01AE\x03" + + "\u01AE\x03\u01AE\x03\u01AE\x03\u01AE\x03\u01AE\x03\u01AF\x03\u01AF\x03" + "\u01AF\x03\u01AF\x03\u01AF\x03\u01AF\x03\u01AF\x03\u01AF\x03\u01AF\x03" + - "\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03" + + "\u01AF\x03\u01AF\x03\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03" + + "\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03\u01B1\x03\u01B1\x03" + "\u01B1\x03\u01B1\x03\u01B1\x03\u01B1\x03\u01B1\x03\u01B1\x03\u01B1\x03" + - "\u01B1\x03\u01B1\x03\u01B1\x03\u01B1\x03\u01B2\x03\u01B2\x03\u01B2\x03" + - "\u01B2\x03\u01B2\x03\u01B2\x03\u01B2\x03\u01B2\x03\u01B2\x03\u01B2\x03" + - "\u01B3\x03\u01B3\x03\u01B3\x03\u01B3\x03\u01B3\x03\u01B3\x03\u01B3\x03" + - "\u01B4\x03\u01B4\x03\u01B4\x03\u01B4\x03\u01B4\x03\u01B4\x03\u01B4\x03" + + "\u01B1\x03\u01B2\x03\u01B2\x03\u01B2\x03\u01B2\x03\u01B2\x03\u01B2\x03" + + "\u01B2\x03\u01B2\x03\u01B2\x03\u01B3\x03\u01B3\x03\u01B3\x03\u01B3\x03" + + "\u01B3\x03\u01B3\x03\u01B4\x03\u01B4\x03\u01B4\x03\u01B4\x03\u01B4\x03" + + "\u01B4\x03\u01B4\x03\u01B4\x03\u01B5\x03\u01B5\x03\u01B5\x03\u01B5\x03" + "\u01B5\x03\u01B5\x03\u01B5\x03\u01B5\x03\u01B5\x03\u01B5\x03\u01B5\x03" + - "\u01B5\x03\u01B6\x03\u01B6\x03\u01B6\x03\u01B6\x03\u01B6\x03\u01B6\x03" + - "\u01B6\x03\u01B6\x03\u01B7\x03\u01B7\x03\u01B7\x03\u01B7\x03\u01B7\x03" + - "\u01B7\x03\u01B7\x03\u01B7\x03\u01B7\x03\u01B7\x03\u01B8\x03\u01B8\x03" + - "\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B9\x03\u01B9\x03" + - "\u01B9\x03\u01B9\x03\u01B9\x03\u01B9\x03\u01B9\x03\u01BA\x03\u01BA\x03" + + "\u01B5\x03\u01B5\x03\u01B6\x03\u01B6\x03\u01B6\x03\u01B6\x03\u01B6\x03" + + "\u01B7\x03\u01B7\x03\u01B7\x03\u01B7\x03\u01B7\x03\u01B7\x03\u01B7\x03" + + "\u01B7\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03" + + "\u01B8\x03\u01B9\x03\u01B9\x03\u01B9\x03\u01B9\x03\u01B9\x03\u01B9\x03" + + "\u01B9\x03\u01BA\x03\u01BA\x03\u01BA\x03\u01BA\x03\u01BA\x03\u01BA\x03" + "\u01BA\x03\u01BA\x03\u01BA\x03\u01BA\x03\u01BA\x03\u01BB\x03\u01BB\x03" + "\u01BB\x03\u01BB\x03\u01BB\x03\u01BB\x03\u01BB\x03\u01BB\x03\u01BB\x03" + - "\u01BB\x03\u01BB\x03\u01BB\x03\u01BC\x03\u01BC\x03\u01BC\x03\u01BC\x03" + - "\u01BD\x03\u01BD\x03\u01BD\x03\u01BD\x03\u01BE\x03\u01BE\x03\u01BE\x03" + - "\u01BE\x03\u01BE\x03\u01BE\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03" + - "\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03" + - "\u01BF\x03\u01BF\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03" + - "\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03" + - "\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x03\u01C2\x03\u01C2\x03\u01C2\x03" + - "\u01C2\x03\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x03" + - "\u01C3\x03\u01C3\x03\u01C3\x03\u01C4\x03\u01C4\x03\u01C4\x03\u01C4\x03" + + "\u01BB\x03\u01BC\x03\u01BC\x03\u01BC\x03\u01BC\x03\u01BC\x03\u01BC\x03" + + "\u01BC\x03\u01BD\x03\u01BD\x03\u01BD\x03\u01BD\x03\u01BD\x03\u01BD\x03" + + "\u01BD\x03\u01BE\x03\u01BE\x03\u01BE\x03\u01BE\x03\u01BE\x03\u01BE\x03" + + "\u01BE\x03\u01BE\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03" + + "\u01BF\x03\u01BF\x03\u01BF\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03" + + "\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C1\x03" + + "\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x03\u01C2\x03" + + "\u01C2\x03\u01C2\x03\u01C2\x03\u01C2\x03\u01C2\x03\u01C2\x03\u01C3\x03" + + "\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x03\u01C4\x03" + + "\u01C4\x03\u01C4\x03\u01C4\x03\u01C4\x03\u01C4\x03\u01C4\x03\u01C4\x03" + "\u01C4\x03\u01C4\x03\u01C4\x03\u01C4\x03\u01C5\x03\u01C5\x03\u01C5\x03" + - "\u01C5\x03\u01C5\x03\u01C5\x03\u01C5\x03\u01C5\x03\u01C5\x03\u01C5\x03" + - "\u01C5\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C6\x03" + - "\u01C7\x03\u01C7\x03\u01C7\x03\u01C7\x03\u01C7\x03\u01C7\x03\u01C7\x03" + - "\u01C7\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03" + + "\u01C5\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C7\x03\u01C7\x03" + + "\u01C7\x03\u01C7\x03\u01C7\x03\u01C7\x03\u01C8\x03\u01C8\x03\u01C8\x03" + + "\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03" + "\u01C8\x03\u01C8\x03\u01C8\x03\u01C9\x03\u01C9\x03\u01C9\x03\u01C9\x03" + - "\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03" + - "\u01CA\x03\u01CB\x03\u01CB\x03\u01CB\x03\u01CB\x03\u01CB\x03\u01CB\x03" + - "\u01CB\x03\u01CB\x03\u01CB\x03\u01CB\x03\u01CB\x03\u01CC\x03\u01CC\x03" + - "\u01CC\x03\u01CC\x03\u01CC\x03\u01CC\x03\u01CC\x03\u01CC\x03\u01CC\x03" + + "\u01C9\x03\u01C9\x03\u01C9\x03\u01C9\x03\u01C9\x03\u01C9\x03\u01C9\x03" + + "\u01C9\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CB\x03\u01CB\x03" + + "\u01CB\x03\u01CB\x03\u01CC\x03\u01CC\x03\u01CC\x03\u01CC\x03\u01CC\x03" + + "\u01CC\x03\u01CC\x03\u01CC\x03\u01CC\x03\u01CD\x03\u01CD\x03\u01CD\x03" + "\u01CD\x03\u01CD\x03\u01CD\x03\u01CD\x03\u01CD\x03\u01CE\x03\u01CE\x03" + - "\u01CE\x03\u01CE\x03\u01CE\x03\u01CE\x03\u01CE\x03\u01CF\x03\u01CF\x03" + - "\u01CF\x03\u01CF\x03\u01CF\x03\u01D0\x03\u01D0\x03\u01D0\x03\u01D0\x03" + - "\u01D0\x03\u01D0\x03\u01D0\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D1\x03" + - "\u01D1\x03\u01D2\x03\u01D2\x03\u01D2\x03\u01D2\x03\u01D2\x03\u01D2\x03" + - "\u01D2\x03\u01D2\x03\u01D2\x03\u01D3\x03\u01D3\x03\u01D3\x03\u01D3\x03" + - "\u01D3\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03" + + "\u01CE\x03\u01CE\x03\u01CE\x03\u01CE\x03\u01CE\x03\u01CE\x03\u01CE\x03" + + "\u01CE\x03\u01CE\x03\u01CF\x03\u01CF\x03\u01CF\x03\u01CF\x03\u01CF\x03" + + "\u01CF\x03\u01D0\x03\u01D0\x03\u01D0\x03\u01D0\x03\u01D0\x03\u01D0\x03" + + "\u01D0\x03\u01D0\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D1\x03" + + "\u01D1\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D2\x03\u01D2\x03\u01D2\x03" + + "\u01D2\x03\u01D3\x03\u01D3\x03\u01D3\x03\u01D3\x03\u01D3\x03\u01D3\x03" + + "\u01D3\x03\u01D3\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03" + "\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D5\x03" + "\u01D5\x03\u01D5\x03\u01D5\x03\u01D5\x03\u01D5\x03\u01D5\x03\u01D5\x03" + - "\u01D5\x03\u01D5\x03\u01D5\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D6\x03" + - "\u01D6\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D7\x03\u01D7\x03" + + "\u01D5\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D7\x03" + "\u01D7\x03\u01D7\x03\u01D7\x03\u01D7\x03\u01D7\x03\u01D7\x03\u01D8\x03" + - "\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03" + - "\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D9\x03" + - "\u01D9\x03\u01D9\x03\u01D9\x03\u01D9\x03\u01D9\x03\u01D9\x03\u01D9\x03" + - "\u01DA\x03\u01DA\x03\u01DA\x03\u01DA\x03\u01DA\x03\u01DA\x03\u01DA\x03" + - "\u01DA\x03\u01DA\x03\u01DA\x03\u01DA\x03\u01DB\x03\u01DB\x03\u01DB\x03" + + "\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D9\x03\u01D9\x03\u01D9\x03" + + "\u01D9\x03\u01D9\x03\u01D9\x03\u01D9\x03\u01DA\x03\u01DA\x03\u01DA\x03" + + "\u01DA\x03\u01DA\x03\u01DB\x03\u01DB\x03\u01DB\x03\u01DB\x03\u01DB\x03" + "\u01DB\x03\u01DB\x03\u01DB\x03\u01DB\x03\u01DC\x03\u01DC\x03\u01DC\x03" + - "\u01DC\x03\u01DC\x03\u01DC\x03\u01DC\x03\u01DD\x03\u01DD\x03\u01DD\x03" + - "\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DE\x03\u01DE\x03\u01DE\x03" + + "\u01DC\x03\u01DC\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x03" + + "\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x03" + + "\u01DE\x03\u01DE\x03\u01DE\x03\u01DE\x03\u01DE\x03\u01DE\x03\u01DE\x03" + "\u01DE\x03\u01DE\x03\u01DE\x03\u01DE\x03\u01DF\x03\u01DF\x03\u01DF\x03" + - "\u01DF\x03\u01E0\x03\u01E0\x03\u01E0\x03\u01E0\x03\u01E1\x03\u01E1\x03" + - "\u01E1\x03\u01E1\x03\u01E1\x03\u01E2\x03\u01E2\x03\u01E2\x03\u01E2\x03" + + "\u01DF\x03\u01DF\x03\u01DF\x03\u01DF\x03\u01DF\x03\u01DF\x03\u01E0\x03" + + "\u01E0\x03\u01E0\x03\u01E0\x03\u01E0\x03\u01E0\x03\u01E0\x03\u01E0\x03" + + "\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03" + + "\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03" + + "\u01E2\x03\u01E2\x03\u01E2\x03\u01E2\x03\u01E2\x03\u01E2\x03\u01E2\x03" + "\u01E2\x03\u01E3\x03\u01E3\x03\u01E3\x03\u01E3\x03\u01E3\x03\u01E3\x03" + - "\u01E3\x03\u01E3\x03\u01E4\x03\u01E4\x03\u01E4\x03\u01E4\x03\u01E4\x03" + - "\u01E4\x03\u01E5\x03\u01E5\x03\u01E5\x03\u01E5\x03\u01E5\x03\u01E5\x03" + - "\u01E5\x03\u01E5\x03\u01E5\x03\u01E5\x03\u01E6\x03\u01E6\x03\u01E6\x03" + - "\u01E6\x03\u01E6\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03" + - "\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03" + - "\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03" + - "\u01E7\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03" + - "\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03" + - "\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E9\x03\u01E9\x03" + - "\u01E9\x03\u01E9\x03\u01E9\x03\u01E9\x03\u01EA\x03\u01EA\x03\u01EA\x03" + - "\u01EA\x03\u01EA\x03\u01EA\x03\u01EA\x03\u01EA\x03\u01EA\x03\u01EA\x03" + - "\u01EA\x03\u01EA\x03\u01EA\x03\u01EB\x03\u01EB\x03\u01EB\x03\u01EB\x03" + - "\u01EB\x03\u01EB\x03\u01EB\x03\u01EB\x03\u01EB\x03\u01EB\x03\u01EB\x03" + - "\u01EC\x03\u01EC\x03\u01EC\x03\u01EC\x03\u01EC\x03\u01EC\x03\u01ED\x03" + - "\u01ED\x03\u01ED\x03\u01ED\x03\u01ED\x03\u01ED\x03\u01ED\x03\u01ED\x03" + - "\u01ED\x03\u01EE\x03\u01EE\x03\u01EE\x03\u01EE\x03\u01EE\x03\u01EE\x03" + - "\u01EE\x03\u01EE\x03\u01EF\x03\u01EF\x03\u01EF\x03\u01EF\x03\u01F0\x03" + + "\u01E3\x03\u01E3\x03\u01E3\x03\u01E3\x03\u01E3\x03\u01E4\x03\u01E4\x03" + + "\u01E4\x03\u01E4\x03\u01E4\x03\u01E4\x03\u01E4\x03\u01E5\x03\u01E5\x03" + + "\u01E5\x03\u01E5\x03\u01E5\x03\u01E5\x03\u01E5\x03\u01E6\x03\u01E6\x03" + + "\u01E6\x03\u01E6\x03\u01E6\x03\u01E6\x03\u01E6\x03\u01E7\x03\u01E7\x03" + + "\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E7\x03\u01E8\x03\u01E8\x03" + + "\u01E8\x03\u01E8\x03\u01E9\x03\u01E9\x03\u01E9\x03\u01E9\x03\u01EA\x03" + + "\u01EA\x03\u01EA\x03\u01EA\x03\u01EA\x03\u01EB\x03\u01EB\x03\u01EB\x03" + + "\u01EB\x03\u01EB\x03\u01EC\x03\u01EC\x03\u01EC\x03\u01EC\x03\u01EC\x03" + + "\u01EC\x03\u01EC\x03\u01EC\x03\u01ED\x03\u01ED\x03\u01ED\x03\u01ED\x03" + + "\u01ED\x03\u01ED\x03\u01EE\x03\u01EE\x03\u01EE\x03\u01EE\x03\u01EE\x03" + + "\u01EE\x03\u01EE\x03\u01EE\x03\u01EE\x03\u01EE\x03\u01EF\x03\u01EF\x03" + + "\u01EF\x03\u01EF\x03\u01EF\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03" + "\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03" + - "\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F1\x03\u01F1\x03\u01F1\x03" + - "\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F2\x03\u01F2\x03" + - "\u01F2\x03\u01F2\x03\u01F2\x03\u01F2\x03\u01F3\x03\u01F3\x03\u01F3\x03" + - "\u01F3\x03\u01F3\x03\u01F3\x03\u01F4\x03\u01F4\x03\u01F4\x03\u01F4\x03" + - "\u01F4\x03\u01F4\x03\u01F4\x03\u01F4\x03\u01F5\x03\u01F5\x03\u01F5\x03" + - "\u01F5\x03\u01F5\x03\u01F5\x03\u01F5\x03\u01F5\x03\u01F6\x03\u01F6\x03" + - "\u01F6\x03\u01F6\x03\u01F6\x03\u01F6\x03\u01F7\x03\u01F7\x03\u01F7\x03" + - "\u01F7\x03\u01F7\x03\u01F8\x03\u01F8\x03\u01F8\x03\u01F8\x03\u01F8\x03" + - "\u01F8\x03\u01F8\x03\u01F9\x03\u01F9\x03\u01F9\x03\u01F9\x03\u01F9\x03" + - "\u01F9\x03\u01FA\x03\u01FA\x03\u01FA\x03\u01FA\x03\u01FA\x03\u01FA\x03" + - "\u01FB\x03\u01FB\x03\u01FB\x03\u01FB\x03\u01FB\x03\u01FB\x03\u01FB\x03" + - "\u01FB\x03\u01FB\x03\u01FC\x03\u01FC\x03\u01FC\x03\u01FC\x03\u01FC\x03" + - "\u01FC\x03\u01FD\x03\u01FD\x03\u01FD\x03\u01FD\x03\u01FE\x03\u01FE\x03" + - "\u01FE\x03\u01FE\x03\u01FE\x03\u01FF\x03\u01FF\x03\u01FF\x03\u01FF\x03" + - "\u01FF\x03\u01FF\x03\u01FF\x03\u0200\x03\u0200\x03\u0200\x03\u0200\x03" + - "\u0200\x03\u0200\x03\u0200\x03\u0200\x03\u0201\x03\u0201\x03\u0201\x03" + - "\u0201\x03\u0201\x03\u0201\x03\u0201\x03\u0201\x03\u0201\x03\u0201\x03" + - "\u0202\x03\u0202\x03\u0202\x03\u0202\x03\u0202\x03\u0202\x03\u0202\x03" + - "\u0203\x03\u0203\x03\u0203\x03\u0203\x03\u0203\x03\u0204\x03\u0204\x03" + - "\u0204\x03\u0204\x03\u0204\x03\u0205\x03\u0205\x07\u0205\u1346\n\u0205" + - "\f\u0205\x0E\u0205\u1349\v\u0205\x03\u0206\x03\u0206\x03\u0206\x03\u0206" + - "\x03\u0206\x03\u0206\x05\u0206\u1351\n\u0206\x03\u0207\x03\u0207\x05\u0207" + - "\u1355\n\u0207\x03\u0208\x03\u0208\x05\u0208\u1359\n\u0208\x03\u0209\x03" + - "\u0209\x03\u0209\x03\u020A\x03\u020A\x03\u020A\x03\u020A\x07\u020A\u1362" + - "\n\u020A\f\u020A\x0E\u020A\u1365\v\u020A\x03\u020B\x03\u020B\x03\u020B" + - "\x03\u020C\x03\u020C\x03\u020C\x03\u020C\x07\u020C\u136E\n\u020C\f\u020C" + - "\x0E\u020C\u1371\v\u020C\x03\u020D\x03\u020D\x03\u020D\x03\u020D\x03\u020E" + - "\x03\u020E\x03\u020E"; + "\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03" + + "\u01F0\x03\u01F0\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03" + + "\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03" + + "\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F2\x03" + + "\u01F2\x03\u01F2\x03\u01F2\x03\u01F2\x03\u01F2\x03\u01F3\x03\u01F3\x03" + + "\u01F3\x03\u01F3\x03\u01F3\x03\u01F3\x03\u01F3\x03\u01F3\x03\u01F3\x03" + + "\u01F3\x03\u01F3\x03\u01F3\x03\u01F3\x03\u01F4\x03\u01F4\x03\u01F4\x03" + + "\u01F4\x03\u01F4\x03\u01F4\x03\u01F4\x03\u01F4\x03\u01F4\x03\u01F4\x03" + + "\u01F4\x03\u01F5\x03\u01F5\x03\u01F5\x03\u01F5\x03\u01F5\x03\u01F5\x03" + + "\u01F6\x03\u01F6\x03\u01F6\x03\u01F6\x03\u01F6\x03\u01F6\x03\u01F6\x03" + + "\u01F6\x03\u01F6\x03\u01F7\x03\u01F7\x03\u01F7\x03\u01F7\x03\u01F7\x03" + + "\u01F7\x03\u01F7\x03\u01F7\x03\u01F8\x03\u01F8\x03\u01F8\x03\u01F8\x03" + + "\u01F9\x03\u01F9\x03\u01F9\x03\u01F9\x03\u01F9\x03\u01F9\x03\u01F9\x03" + + "\u01F9\x03\u01F9\x03\u01F9\x03\u01F9\x03\u01F9\x03\u01FA\x03\u01FA\x03" + + "\u01FA\x03\u01FA\x03\u01FA\x03\u01FA\x03\u01FA\x03\u01FA\x03\u01FB\x03" + + "\u01FB\x03\u01FB\x03\u01FB\x03\u01FB\x03\u01FB\x03\u01FC\x03\u01FC\x03" + + "\u01FC\x03\u01FC\x03\u01FC\x03\u01FC\x03\u01FD\x03\u01FD\x03\u01FD\x03" + + "\u01FD\x03\u01FD\x03\u01FD\x03\u01FD\x03\u01FD\x03\u01FE\x03\u01FE\x03" + + "\u01FE\x03\u01FE\x03\u01FE\x03\u01FE\x03\u01FE\x03\u01FE\x03\u01FF\x03" + + "\u01FF\x03\u01FF\x03\u01FF\x03\u01FF\x03\u01FF\x03\u0200\x03\u0200\x03" + + "\u0200\x03\u0200\x03\u0200\x03\u0201\x03\u0201\x03\u0201\x03\u0201\x03" + + "\u0201\x03\u0201\x03\u0201\x03\u0202\x03\u0202\x03\u0202\x03\u0202\x03" + + "\u0202\x03\u0202\x03\u0203\x03\u0203\x03\u0203\x03\u0203\x03\u0203\x03" + + "\u0203\x03\u0204\x03\u0204\x03\u0204\x03\u0204\x03\u0204\x03\u0204\x03" + + "\u0204"; private static readonly _serializedATNSegment2: string = - "\x03\u020E\x03\u020F\x03\u020F\x03\u020F\x03\u020F\x03\u0210\x03\u0210" + - "\x03\u0210\x03\u0210\x03\u0211\x03\u0211\x03\u0211\x03\u0212\x03\u0212" + - "\x03\u0212\x03\u0212\x07\u0212\u138A\n\u0212\f\u0212\x0E\u0212\u138D\v" + - "\u0212\x03\u0213\x03\u0213\x03\u0213\x03\u0213\x03\u0213\x03\u0213\x03" + - "\u0214\x03\u0214\x03\u0214\x03\u0215\x03\u0215\x03\u0215\x03\u0215\x03" + - "\u0216\x03\u0216\x05\u0216\u139E\n\u0216\x03\u0216\x03\u0216\x03\u0216" + - "\x03\u0216\x03\u0216\x03\u0217\x03\u0217\x07\u0217\u13A7\n\u0217\f\u0217" + - "\x0E\u0217\u13AA\v\u0217\x03\u0218\x03\u0218\x03\u0218\x03\u0219\x03\u0219" + - "\x03\u0219\x07\u0219\u13B2\n\u0219\f\u0219\x0E\u0219\u13B5\v\u0219\x03" + - "\u021A\x03\u021A\x03\u021A\x03\u021B\x03\u021B\x03\u021B\x03\u021C\x03" + - "\u021C\x03\u021C\x03\u021D\x03\u021D\x03\u021D\x07\u021D\u13C3\n\u021D" + - "\f\u021D\x0E\u021D\u13C6\v\u021D\x03\u021E\x03\u021E\x03\u021E\x03\u021F" + - "\x03\u021F\x03\u021F\x03\u0220\x03\u0220\x03\u0221\x03\u0221\x03\u0221" + - "\x03\u0221\x03\u0221\x03\u0221\x03\u0222\x03\u0222\x03\u0222\x05\u0222" + - "\u13D9\n\u0222\x03\u0222\x03\u0222\x05\u0222\u13DD\n\u0222\x03\u0222\x05" + - "\u0222\u13E0\n\u0222\x03\u0222\x03\u0222\x03\u0222\x03\u0222\x05\u0222" + - "\u13E6\n\u0222\x03\u0222\x05\u0222\u13E9\n\u0222\x03\u0222\x03\u0222\x03" + - "\u0222\x05\u0222\u13EE\n\u0222\x03\u0222\x03\u0222\x05\u0222\u13F2\n\u0222" + - "\x03\u0223\x06\u0223\u13F5\n\u0223\r\u0223\x0E\u0223\u13F6\x03\u0224\x03" + - "\u0224\x03\u0224\x07\u0224\u13FC\n\u0224\f\u0224\x0E\u0224\u13FF\v\u0224" + - "\x03\u0225\x03\u0225\x03\u0225\x03\u0225\x03\u0225\x03\u0225\x03\u0225" + - "\x03\u0225\x07\u0225\u1409\n\u0225\f\u0225\x0E\u0225\u140C\v\u0225\x03" + - "\u0225\x03\u0225\x03\u0226\x06\u0226\u1411\n\u0226\r\u0226\x0E\u0226\u1412" + - "\x03\u0226\x03\u0226\x03\u0227\x03\u0227\x05\u0227\u1419\n\u0227\x03\u0227" + - "\x05\u0227\u141C\n\u0227\x03\u0227\x03\u0227\x03\u0228\x03\u0228\x03\u0228" + - "\x03\u0228\x07\u0228\u1424\n\u0228\f\u0228\x0E\u0228\u1427\v\u0228\x03" + - "\u0228\x03\u0228\x03\u0229\x03\u0229\x03\u0229\x03\u0229\x07\u0229\u142F" + - "\n\u0229\f\u0229\x0E\u0229\u1432\v\u0229\x03\u0229\x03\u0229\x03\u0229" + - "\x06\u0229\u1437\n\u0229\r\u0229\x0E\u0229\u1438\x03\u0229\x03\u0229\x06" + - "\u0229\u143D\n\u0229\r\u0229\x0E\u0229\u143E\x03\u0229\x07\u0229\u1442" + - "\n\u0229\f\u0229\x0E\u0229\u1445\v\u0229\x03\u0229\x07\u0229\u1448\n\u0229" + - "\f\u0229\x0E\u0229\u144B\v\u0229\x03\u0229\x03\u0229\x03\u0229\x03\u0229" + - "\x03\u0229\x03\u022A\x03\u022A\x03\u022A\x03\u022A\x07\u022A\u1456\n\u022A" + - "\f\u022A\x0E\u022A\u1459\v\u022A\x03\u022A\x03\u022A\x03\u022A\x06\u022A" + - "\u145E\n\u022A\r\u022A\x0E\u022A\u145F\x03\u022A\x03\u022A\x06\u022A\u1464" + - "\n\u022A\r\u022A\x0E\u022A\u1465\x03\u022A\x05\u022A\u1469\n\u022A\x07" + - "\u022A\u146B\n\u022A\f\u022A\x0E\u022A\u146E\v\u022A\x03\u022A\x06\u022A" + - "\u1471\n\u022A\r\u022A\x0E\u022A\u1472\x03\u022A\x06\u022A\u1476\n\u022A" + - "\r\u022A\x0E\u022A\u1477\x03\u022A\x07\u022A\u147B\n\u022A\f\u022A\x0E" + - "\u022A\u147E\v\u022A\x03\u022A\x05\u022A\u1481\n\u022A\x03\u022A\x03\u022A" + - "\x03\u022B\x03\u022B\x03\u022B\x03\u022B\x07\u022B\u1489\n\u022B\f\u022B" + - "\x0E\u022B\u148C\v\u022B\x03\u022B\x07\u022B\u148F\n\u022B\f\u022B\x0E" + - "\u022B\u1492\v\u022B\x03\u022B\x03\u022B\x07\u022B\u1496\n\u022B\f\u022B" + - "\x0E\u022B\u1499\v\u022B\x05\u022B\u149B\n\u022B\x03\u022C\x03\u022C\x03" + - "\u022C\x03\u022D\x03\u022D\x03\u022E\x03\u022E\x03\u022E\x03\u022E\x03" + - "\u022E\x03\u022F\x03\u022F\x05\u022F\u14A9\n\u022F\x03\u022F\x03\u022F" + - "\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x03\u0230" + - "\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x03\u0230" + - "\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x05\u0230" + - "\u14C1\n\u0230\x03\u0230\x07\u0230\u14C4\n\u0230\f\u0230\x0E\u0230\u14C7" + - "\v\u0230\x03\u0231\x03\u0231\x03\u0231\x03\u0231\x03\u0231\x03\u0232\x03" + - "\u0232\x05\u0232\u14D0\n\u0232\x03\u0232\x03\u0232\x03\u0233\x03\u0233" + - "\x03\u0233\x03\u0233\x03\u0233\x07\u0233\u14D9\n\u0233\f\u0233\x0E\u0233" + - "\u14DC\v\u0233\x03\u0234\x03\u0234\x03\u0234\x03\u0234\x03\u0234\x03\u0235" + - "\x03\u0235\x03\u0235\x03\u0235\x03\u0235\x03\u0235\x03\u0236\x03\u0236" + - "\x03\u0236\x03\u0236\x03\u0236\x03\u0237\x03\u0237\x03\u0237\x03\u0237" + - "\x03\u0237\x03\u0238\x03\u0238\x03\u0238\x03\u0238\x03\u0238\x03\u0239" + - "\x06\u0239\u14F9\n\u0239\r\u0239\x0E\u0239\u14FA\x03\u0239\x03\u0239\x07" + - "\u0239\u14FF\n\u0239\f\u0239\x0E\u0239\u1502\v\u0239\x05\u0239\u1504\n" + - "\u0239\x03\u023A\x03\u023A\x05\u023A\u1508\n\u023A\x03\u023A\x03\u023A" + - "\x03\u023A\x03\u023A\x03\u023A\x03\u023A\x03\u023A\x02\x02\x02\u023B\x07" + - "\x02\x03\t\x02\x04\v\x02\x05\r\x02\x06\x0F\x02\x07\x11\x02\b\x13\x02\t" + - "\x15\x02\n\x17\x02\v\x19\x02\f\x1B\x02\r\x1D\x02\x0E\x1F\x02\x0F!\x02" + - "\x10#\x02\x11%\x02\x12\'\x02\x13)\x02\x14+\x02\x15-\x02\x16/\x02\x171" + - "\x02\x183\x02\x195\x02\x1A7\x02\x1B9\x02\x1C;\x02\x1D=\x02\x1E?\x02\x1F" + - "A\x02\x02C\x02\x02E\x02\x02G\x02\x02I\x02 K\x02!M\x02\"O\x02#Q\x02$S\x02" + - "%U\x02&W\x02\'Y\x02([\x02)]\x02*_\x02+a\x02,c\x02-e\x02.g\x02/i\x020k" + - "\x021m\x022o\x023q\x024s\x025u\x026w\x027y\x028{\x029}\x02:\x7F\x02;\x81" + - "\x02<\x83\x02=\x85\x02>\x87\x02?\x89\x02@\x8B\x02A\x8D\x02B\x8F\x02C\x91" + - "\x02D\x93\x02E\x95\x02F\x97\x02G\x99\x02H\x9B\x02I\x9D\x02J\x9F\x02K\xA1" + - "\x02L\xA3\x02M\xA5\x02N\xA7\x02O\xA9\x02P\xAB\x02Q\xAD\x02R\xAF\x02S\xB1" + - "\x02T\xB3\x02U\xB5\x02V\xB7\x02W\xB9\x02X\xBB\x02Y\xBD\x02Z\xBF\x02[\xC1" + - "\x02\\\xC3\x02]\xC5\x02^\xC7\x02_\xC9\x02`\xCB\x02a\xCD\x02b\xCF\x02c" + - "\xD1\x02d\xD3\x02e\xD5\x02f\xD7\x02g\xD9\x02h\xDB\x02i\xDD\x02j\xDF\x02" + - "k\xE1\x02l\xE3\x02m\xE5\x02n\xE7\x02o\xE9\x02p\xEB\x02q\xED\x02r\xEF\x02" + - "s\xF1\x02t\xF3\x02u\xF5\x02v\xF7\x02w\xF9\x02x\xFB\x02y\xFD\x02z\xFF\x02" + - "{\u0101\x02|\u0103\x02}\u0105\x02~\u0107\x02\x7F\u0109\x02\x80\u010B\x02" + - "\x81\u010D\x02\x82\u010F\x02\x83\u0111\x02\x84\u0113\x02\x85\u0115\x02" + - "\x86\u0117\x02\x87\u0119\x02\x88\u011B\x02\x89\u011D\x02\x8A\u011F\x02" + - "\x8B\u0121\x02\x8C\u0123\x02\x8D\u0125\x02\x8E\u0127\x02\x8F\u0129\x02" + - "\x90\u012B\x02\x91\u012D\x02\x92\u012F\x02\x93\u0131\x02\x94\u0133\x02" + - "\x95\u0135\x02\x96\u0137\x02\x97\u0139\x02\x98\u013B\x02\x99\u013D\x02" + - "\x9A\u013F\x02\x9B\u0141\x02\x9C\u0143\x02\x9D\u0145\x02\x9E\u0147\x02" + - "\x9F\u0149\x02\xA0\u014B\x02\xA1\u014D\x02\xA2\u014F\x02\xA3\u0151\x02" + - "\xA4\u0153\x02\xA5\u0155\x02\xA6\u0157\x02\xA7\u0159\x02\xA8\u015B\x02" + - "\xA9\u015D\x02\xAA\u015F\x02\xAB\u0161\x02\xAC\u0163\x02\xAD\u0165\x02" + - "\xAE\u0167\x02\xAF\u0169\x02\xB0\u016B\x02\xB1\u016D\x02\xB2\u016F\x02" + - "\xB3\u0171\x02\xB4\u0173\x02\xB5\u0175\x02\xB6\u0177\x02\xB7\u0179\x02" + - "\xB8\u017B\x02\xB9\u017D\x02\xBA\u017F\x02\xBB\u0181\x02\xBC\u0183\x02" + - "\xBD\u0185\x02\xBE\u0187\x02\xBF\u0189\x02\xC0\u018B\x02\xC1\u018D\x02" + - "\xC2\u018F\x02\xC3\u0191\x02\xC4\u0193\x02\xC5\u0195\x02\xC6\u0197\x02" + - "\xC7\u0199\x02\xC8\u019B\x02\xC9\u019D\x02\xCA\u019F\x02\xCB\u01A1\x02" + - "\xCC\u01A3\x02\xCD\u01A5\x02\xCE\u01A7\x02\xCF\u01A9\x02\xD0\u01AB\x02" + - "\xD1\u01AD\x02\xD2\u01AF\x02\xD3\u01B1\x02\xD4\u01B3\x02\xD5\u01B5\x02" + - "\xD6\u01B7\x02\xD7\u01B9\x02\xD8\u01BB\x02\xD9\u01BD\x02\xDA\u01BF\x02" + - "\xDB\u01C1\x02\xDC\u01C3\x02\xDD\u01C5\x02\xDE\u01C7\x02\xDF\u01C9\x02" + - "\xE0\u01CB\x02\xE1\u01CD\x02\xE2\u01CF\x02\xE3\u01D1\x02\xE4\u01D3\x02" + - "\xE5\u01D5\x02\xE6\u01D7\x02\xE7\u01D9\x02\xE8\u01DB\x02\xE9\u01DD\x02" + - "\xEA\u01DF\x02\xEB\u01E1\x02\xEC\u01E3\x02\xED\u01E5\x02\xEE\u01E7\x02" + - "\xEF\u01E9\x02\xF0\u01EB\x02\xF1\u01ED\x02\xF2\u01EF\x02\xF3\u01F1\x02" + - "\xF4\u01F3\x02\xF5\u01F5\x02\xF6\u01F7\x02\xF7\u01F9\x02\xF8\u01FB\x02" + - "\xF9\u01FD\x02\xFA\u01FF\x02\xFB\u0201\x02\xFC\u0203\x02\xFD\u0205\x02" + - "\xFE\u0207\x02\xFF\u0209\x02\u0100\u020B\x02\u0101\u020D\x02\u0102\u020F" + - "\x02\u0103\u0211\x02\u0104\u0213\x02\u0105\u0215\x02\u0106\u0217\x02\u0107" + - "\u0219\x02\u0108\u021B\x02\u0109\u021D\x02\u010A\u021F\x02\u010B\u0221" + - "\x02\u010C\u0223\x02\u010D\u0225\x02\u010E\u0227\x02\u010F\u0229\x02\u0110" + - "\u022B\x02\u0111\u022D\x02\u0112\u022F\x02\u0113\u0231\x02\u0114\u0233" + - "\x02\u0115\u0235\x02\u0116\u0237\x02\u0117\u0239\x02\u0118\u023B\x02\u0119" + - "\u023D\x02\u011A\u023F\x02\u011B\u0241\x02\u011C\u0243\x02\u011D\u0245" + - "\x02\u011E\u0247\x02\u011F\u0249\x02\u0120\u024B\x02\u0121\u024D\x02\u0122" + - "\u024F\x02\u0123\u0251\x02\u0124\u0253\x02\u0125\u0255\x02\u0126\u0257" + - "\x02\u0127\u0259\x02\u0128\u025B\x02\u0129\u025D\x02\u012A\u025F\x02\u012B" + - "\u0261\x02\u012C\u0263\x02\u012D\u0265\x02\u012E\u0267\x02\u012F\u0269" + - "\x02\u0130\u026B\x02\u0131\u026D\x02\u0132\u026F\x02\u0133\u0271\x02\u0134" + - "\u0273\x02\u0135\u0275\x02\u0136\u0277\x02\u0137\u0279\x02\u0138\u027B" + - "\x02\u0139\u027D\x02\u013A\u027F\x02\u013B\u0281\x02\u013C\u0283\x02\u013D" + - "\u0285\x02\u013E\u0287\x02\u013F\u0289\x02\u0140\u028B\x02\u0141\u028D" + - "\x02\u0142\u028F\x02\u0143\u0291\x02\u0144\u0293\x02\u0145\u0295\x02\u0146" + - "\u0297\x02\u0147\u0299\x02\u0148\u029B\x02\u0149\u029D\x02\u014A\u029F" + - "\x02\u014B\u02A1\x02\u014C\u02A3\x02\u014D\u02A5\x02\u014E\u02A7\x02\u014F" + - "\u02A9\x02\u0150\u02AB\x02\u0151\u02AD\x02\u0152\u02AF\x02\u0153\u02B1" + - "\x02\u0154\u02B3\x02\u0155\u02B5\x02\u0156\u02B7\x02\u0157\u02B9\x02\u0158" + - "\u02BB\x02\u0159\u02BD\x02\u015A\u02BF\x02\u015B\u02C1\x02\u015C\u02C3" + - "\x02\u015D\u02C5\x02\u015E\u02C7\x02\u015F\u02C9\x02\u0160\u02CB\x02\u0161" + - "\u02CD\x02\u0162\u02CF\x02\u0163\u02D1\x02\u0164\u02D3\x02\u0165\u02D5" + - "\x02\u0166\u02D7\x02\u0167\u02D9\x02\u0168\u02DB\x02\u0169\u02DD\x02\u016A" + - "\u02DF\x02\u016B\u02E1\x02\u016C\u02E3\x02\u016D\u02E5\x02\u016E\u02E7" + - "\x02\u016F\u02E9\x02\u0170\u02EB\x02\u0171\u02ED\x02\u0172\u02EF\x02\u0173" + - "\u02F1\x02\u0174\u02F3\x02\u0175\u02F5\x02\u0176\u02F7\x02\u0177\u02F9" + - "\x02\u0178\u02FB\x02\u0179\u02FD\x02\u017A\u02FF\x02\u017B\u0301\x02\u017C" + - "\u0303\x02\u017D\u0305\x02\u017E\u0307\x02\u017F\u0309\x02\u0180\u030B" + - "\x02\u0181\u030D\x02\u0182\u030F\x02\u0183\u0311\x02\u0184\u0313\x02\u0185" + - "\u0315\x02\u0186\u0317\x02\u0187\u0319\x02\u0188\u031B\x02\u0189\u031D" + - "\x02\u018A\u031F\x02\u018B\u0321\x02\u018C\u0323\x02\u018D\u0325\x02\u018E" + - "\u0327\x02\u018F\u0329\x02\u0190\u032B\x02\u0191\u032D\x02\u0192\u032F" + - "\x02\u0193\u0331\x02\u0194\u0333\x02\u0195\u0335\x02\u0196\u0337\x02\u0197" + - "\u0339\x02\u0198\u033B\x02\u0199\u033D\x02\u019A\u033F\x02\u019B\u0341" + - "\x02\u019C\u0343\x02\u019D\u0345\x02\u019E\u0347\x02\u019F\u0349\x02\u01A0" + - "\u034B\x02\u01A1\u034D\x02\u01A2\u034F\x02\u01A3\u0351\x02\u01A4\u0353" + - "\x02\u01A5\u0355\x02\u01A6\u0357\x02\u01A7\u0359\x02\u01A8\u035B\x02\u01A9" + - "\u035D\x02\u01AA\u035F\x02\u01AB\u0361\x02\u01AC\u0363\x02\u01AD\u0365" + - "\x02\u01AE\u0367\x02\u01AF\u0369\x02\u01B0\u036B\x02\u01B1\u036D\x02\u01B2" + - "\u036F\x02\u01B3\u0371\x02\u01B4\u0373\x02\u01B5\u0375\x02\u01B6\u0377" + - "\x02\u01B7\u0379\x02\u01B8\u037B\x02\u01B9\u037D\x02\u01BA\u037F\x02\u01BB" + - "\u0381\x02\u01BC\u0383\x02\u01BD\u0385\x02\u01BE\u0387\x02\u01BF\u0389" + - "\x02\u01C0\u038B\x02\u01C1\u038D\x02\u01C2\u038F\x02\u01C3\u0391\x02\u01C4" + - "\u0393\x02\u01C5\u0395\x02\u01C6\u0397\x02\u01C7\u0399\x02\u01C8\u039B" + - "\x02\u01C9\u039D\x02\u01CA\u039F\x02\u01CB\u03A1\x02\u01CC\u03A3\x02\u01CD" + - "\u03A5\x02\u01CE\u03A7\x02\u01CF\u03A9\x02\u01D0\u03AB\x02\u01D1\u03AD" + - "\x02\u01D2\u03AF\x02\u01D3\u03B1\x02\u01D4\u03B3\x02\u01D5\u03B5\x02\u01D6" + - "\u03B7\x02\u01D7\u03B9\x02\u01D8\u03BB\x02\u01D9\u03BD\x02\u01DA\u03BF" + - "\x02\u01DB\u03C1\x02\u01DC\u03C3\x02\u01DD\u03C5\x02\u01DE\u03C7\x02\u01DF" + - "\u03C9\x02\u01E0\u03CB\x02\u01E1\u03CD\x02\u01E2\u03CF\x02\u01E3\u03D1" + - "\x02\u01E4\u03D3\x02\u01E5\u03D5\x02\u01E6\u03D7\x02\u01E7\u03D9\x02\u01E8" + - "\u03DB\x02\u01E9\u03DD\x02\u01EA\u03DF\x02\u01EB\u03E1\x02\u01EC\u03E3" + - "\x02\u01ED\u03E5\x02\u01EE\u03E7\x02\u01EF\u03E9\x02\u01F0\u03EB\x02\u01F1" + - "\u03ED\x02\u01F2\u03EF\x02\u01F3\u03F1\x02\u01F4\u03F3\x02\u01F5\u03F5" + - "\x02\u01F6\u03F7\x02\u01F7\u03F9\x02\u01F8\u03FB\x02\u01F9\u03FD\x02\u01FA" + - "\u03FF\x02\u01FB\u0401\x02\u01FC\u0403\x02\u01FD\u0405\x02\u01FE\u0407" + - "\x02\u01FF\u0409\x02\u0200\u040B\x02\u0201\u040D\x02\u0202\u040F\x02\x02" + - "\u0411\x02\x02\u0413\x02\x02\u0415\x02\u0203\u0417\x02\u0204\u0419\x02" + - "\u0205\u041B\x02\u0206\u041D\x02\u0207\u041F\x02\u0208\u0421\x02\u0209" + - "\u0423\x02\u020A\u0425\x02\u020B\u0427\x02\u020C\u0429\x02\x02\u042B\x02" + - "\u020D\u042D\x02\u020E\u042F\x02\u020F\u0431\x02\x02\u0433\x02\u0210\u0435" + - "\x02\u0211\u0437\x02\u0212\u0439\x02\u0213\u043B\x02\u0214\u043D\x02\u0215" + - "\u043F\x02\u0216\u0441\x02\u0217\u0443\x02\u0218\u0445\x02\u0219\u0447" + - "\x02\u021A\u0449\x02\x02\u044B\x02\u021B\u044D\x02\u021C\u044F\x02\u021D" + - "\u0451\x02\u021E\u0453\x02\u021F\u0455\x02\u0220\u0457\x02\u0221\u0459" + - "\x02\u0222\u045B\x02\u0223\u045D\x02\u0224\u045F\x02\u0225\u0461\x02\u0226" + - "\u0463\x02\x02\u0465\x02\u0227\u0467\x02\u0228\u0469\x02\x02\u046B\x02" + - "\x02\u046D\x02\x02\u046F\x02\x02\u0471\x02\x02\u0473\x02\u022B\u0475\x02" + - "\u0229\u0477\x02\u022A\x07\x02\x03\x04\x05\x06\x1B\x03\x022;\x04\x02-" + - "-//\v\x02##%%\'(,,>B``bb~~\x80\x80\x04\x02,->@\n\x02##%%\'(AB``bb~~\x80" + - "\x80\v\x02C\\aac|\xAC\xAC\xB7\xB7\xBC\xBC\xC2\xD8\xDA\xF8\xFA\u0101\x04" + - "\x02\u0102\uD801\uE002\x01\x03\x02\uD802\uDC01\x03\x02\uDC02\uE001\x04" + - "\x02\x02\x02$$\x03\x02$$\x03\x02))\x03\x0223\x05\x022;CHch\x05\x02C\\" + - "aac|\x07\x02&&2;C\\aac|\x04\x02$$^^\x04\x02\v\v\"\"\x04\x02\f\f\x0F\x0F" + - "\x04\x02,,11\x06\x02\f\f\x0F\x0F$$^^\x05\x02\f\f\x0F\x0F$$\x05\x02WWw" + - "wzz\x04\x02))^^\x03\x02&&\x02\u1558\x02\x07\x03\x02\x02\x02\x02\t\x03" + - "\x02\x02\x02\x02\v\x03\x02\x02\x02\x02\r\x03\x02\x02\x02\x02\x0F\x03\x02" + - "\x02\x02\x02\x11\x03\x02\x02\x02\x02\x13\x03\x02\x02\x02\x02\x15\x03\x02" + - "\x02\x02\x02\x17\x03\x02\x02\x02\x02\x19\x03\x02\x02\x02\x02\x1B\x03\x02" + - "\x02\x02\x02\x1D\x03\x02\x02\x02\x02\x1F\x03\x02\x02\x02\x02!\x03\x02" + - "\x02\x02\x02#\x03\x02\x02\x02\x02%\x03\x02\x02\x02\x02\'\x03\x02\x02\x02" + - "\x02)\x03\x02\x02\x02\x02+\x03\x02\x02\x02\x02-\x03\x02\x02\x02\x02/\x03" + - "\x02\x02\x02\x021\x03\x02\x02\x02\x023\x03\x02\x02\x02\x025\x03\x02\x02" + - "\x02\x027\x03\x02\x02\x02\x029\x03\x02\x02\x02\x02;\x03\x02\x02\x02\x02" + - "=\x03\x02\x02\x02\x02?\x03\x02\x02\x02\x02A\x03\x02\x02\x02\x02I\x03\x02" + - "\x02\x02\x02K\x03\x02\x02\x02\x02M\x03\x02\x02\x02\x02O\x03\x02\x02\x02" + - "\x02Q\x03\x02\x02\x02\x02S\x03\x02\x02\x02\x02U\x03\x02\x02\x02\x02W\x03" + - "\x02\x02\x02\x02Y\x03\x02\x02\x02\x02[\x03\x02\x02\x02\x02]\x03\x02\x02" + - "\x02\x02_\x03\x02\x02\x02\x02a\x03\x02\x02\x02\x02c\x03\x02\x02\x02\x02" + - "e\x03\x02\x02\x02\x02g\x03\x02\x02\x02\x02i\x03\x02\x02\x02\x02k\x03\x02" + - "\x02\x02\x02m\x03\x02\x02\x02\x02o\x03\x02\x02\x02\x02q\x03\x02\x02\x02" + - "\x02s\x03\x02\x02\x02\x02u\x03\x02\x02\x02\x02w\x03\x02\x02\x02\x02y\x03" + - "\x02\x02\x02\x02{\x03\x02\x02\x02\x02}\x03\x02\x02\x02\x02\x7F\x03\x02" + - "\x02\x02\x02\x81\x03\x02\x02\x02\x02\x83\x03\x02\x02\x02\x02\x85\x03\x02" + - "\x02\x02\x02\x87\x03\x02\x02\x02\x02\x89\x03\x02\x02\x02\x02\x8B\x03\x02" + - "\x02\x02\x02\x8D\x03\x02\x02\x02\x02\x8F\x03\x02\x02\x02\x02\x91\x03\x02" + - "\x02\x02\x02\x93\x03\x02\x02\x02\x02\x95\x03\x02\x02\x02\x02\x97\x03\x02" + - "\x02\x02\x02\x99\x03\x02\x02\x02\x02\x9B\x03\x02\x02\x02\x02\x9D\x03\x02" + - "\x02\x02\x02\x9F\x03\x02\x02\x02\x02\xA1\x03\x02\x02\x02\x02\xA3\x03\x02" + - "\x02\x02\x02\xA5\x03\x02\x02\x02\x02\xA7\x03\x02\x02\x02\x02\xA9\x03\x02" + - "\x02\x02\x02\xAB\x03\x02\x02\x02\x02\xAD\x03\x02\x02\x02\x02\xAF\x03\x02" + - "\x02\x02\x02\xB1\x03\x02\x02\x02\x02\xB3\x03\x02\x02\x02\x02\xB5\x03\x02" + - "\x02\x02\x02\xB7\x03\x02\x02\x02\x02\xB9\x03\x02\x02\x02\x02\xBB\x03\x02" + - "\x02\x02\x02\xBD\x03\x02\x02\x02\x02\xBF\x03\x02\x02\x02\x02\xC1\x03\x02" + - "\x02\x02\x02\xC3\x03\x02\x02\x02\x02\xC5\x03\x02\x02\x02\x02\xC7\x03\x02" + - "\x02\x02\x02\xC9\x03\x02\x02\x02\x02\xCB\x03\x02\x02\x02\x02\xCD\x03\x02" + - "\x02\x02\x02\xCF\x03\x02\x02\x02\x02\xD1\x03\x02\x02\x02\x02\xD3\x03\x02" + - "\x02\x02\x02\xD5\x03\x02\x02\x02\x02\xD7\x03\x02\x02\x02\x02\xD9\x03\x02" + - "\x02\x02\x02\xDB\x03\x02\x02\x02\x02\xDD\x03\x02\x02\x02\x02\xDF\x03\x02" + - "\x02\x02\x02\xE1\x03\x02\x02\x02\x02\xE3\x03\x02\x02\x02\x02\xE5\x03\x02" + - "\x02\x02\x02\xE7\x03\x02\x02\x02\x02\xE9\x03\x02\x02\x02\x02\xEB\x03\x02" + - "\x02\x02\x02\xED\x03\x02\x02\x02\x02\xEF\x03\x02\x02\x02\x02\xF1\x03\x02" + - "\x02\x02\x02\xF3\x03\x02\x02\x02\x02\xF5\x03\x02\x02\x02\x02\xF7\x03\x02" + - "\x02\x02\x02\xF9\x03\x02\x02\x02\x02\xFB\x03\x02\x02\x02\x02\xFD\x03\x02" + - "\x02\x02\x02\xFF\x03\x02\x02\x02\x02\u0101\x03\x02\x02\x02\x02\u0103\x03" + - "\x02\x02\x02\x02\u0105\x03\x02\x02\x02\x02\u0107\x03\x02\x02\x02\x02\u0109" + - "\x03\x02\x02\x02\x02\u010B\x03\x02\x02\x02\x02\u010D\x03\x02\x02\x02\x02" + - "\u010F\x03\x02\x02\x02\x02\u0111\x03\x02\x02\x02\x02\u0113\x03\x02\x02" + - "\x02\x02\u0115\x03\x02\x02\x02\x02\u0117\x03\x02\x02\x02\x02\u0119\x03" + - "\x02\x02\x02\x02\u011B\x03\x02\x02\x02\x02\u011D\x03\x02\x02\x02\x02\u011F" + - "\x03\x02\x02\x02\x02\u0121\x03\x02\x02\x02\x02\u0123\x03\x02\x02\x02\x02" + - "\u0125\x03\x02\x02\x02\x02\u0127\x03\x02\x02\x02\x02\u0129\x03\x02\x02" + - "\x02\x02\u012B\x03\x02\x02\x02\x02\u012D\x03\x02\x02\x02\x02\u012F\x03" + - "\x02\x02\x02\x02\u0131\x03\x02\x02\x02\x02\u0133\x03\x02\x02\x02\x02\u0135" + - "\x03\x02\x02\x02\x02\u0137\x03\x02\x02\x02\x02\u0139\x03\x02\x02\x02\x02" + - "\u013B\x03\x02\x02\x02\x02\u013D\x03\x02\x02\x02\x02\u013F\x03\x02\x02" + - "\x02\x02\u0141\x03\x02\x02\x02\x02\u0143\x03\x02\x02\x02\x02\u0145\x03" + - "\x02\x02\x02\x02\u0147\x03\x02\x02\x02\x02\u0149\x03\x02\x02\x02\x02\u014B" + - "\x03\x02\x02\x02\x02\u014D\x03\x02\x02\x02\x02\u014F\x03\x02\x02\x02\x02" + - "\u0151\x03\x02\x02\x02\x02\u0153\x03\x02\x02\x02\x02\u0155\x03\x02\x02" + - "\x02\x02\u0157\x03\x02\x02\x02\x02\u0159\x03\x02\x02\x02\x02\u015B\x03" + - "\x02\x02\x02\x02\u015D\x03\x02\x02\x02\x02\u015F\x03\x02\x02\x02\x02\u0161" + - "\x03\x02\x02\x02\x02\u0163\x03\x02\x02\x02\x02\u0165\x03\x02\x02\x02\x02" + - "\u0167\x03\x02\x02\x02\x02\u0169\x03\x02\x02\x02\x02\u016B\x03\x02\x02" + - "\x02\x02\u016D\x03\x02\x02\x02\x02\u016F\x03\x02\x02\x02\x02\u0171\x03" + - "\x02\x02\x02\x02\u0173\x03\x02\x02\x02\x02\u0175\x03\x02\x02\x02\x02\u0177" + - "\x03\x02\x02\x02\x02\u0179\x03\x02\x02\x02\x02\u017B\x03\x02\x02\x02\x02" + - "\u017D\x03\x02\x02\x02\x02\u017F\x03\x02\x02\x02\x02\u0181\x03\x02\x02" + - "\x02\x02\u0183\x03\x02\x02\x02\x02\u0185\x03\x02\x02\x02\x02\u0187\x03" + - "\x02\x02\x02\x02\u0189\x03\x02\x02\x02\x02\u018B\x03\x02\x02\x02\x02\u018D" + - "\x03\x02\x02\x02\x02\u018F\x03\x02\x02\x02\x02\u0191\x03\x02\x02\x02\x02" + - "\u0193\x03\x02\x02\x02\x02\u0195\x03\x02\x02\x02\x02\u0197\x03\x02\x02" + - "\x02\x02\u0199\x03\x02\x02\x02\x02\u019B\x03\x02\x02\x02\x02\u019D\x03" + - "\x02\x02\x02\x02\u019F\x03\x02\x02\x02\x02\u01A1\x03\x02\x02\x02\x02\u01A3" + - "\x03\x02\x02\x02\x02\u01A5\x03\x02\x02\x02\x02\u01A7\x03\x02\x02\x02\x02" + - "\u01A9\x03\x02\x02\x02\x02\u01AB\x03\x02\x02\x02\x02\u01AD\x03\x02\x02" + - "\x02\x02\u01AF\x03\x02\x02\x02\x02\u01B1\x03\x02\x02\x02\x02\u01B3\x03" + - "\x02\x02\x02\x02\u01B5\x03\x02\x02\x02\x02\u01B7\x03\x02\x02\x02\x02\u01B9" + - "\x03\x02\x02\x02\x02\u01BB\x03\x02\x02\x02\x02\u01BD\x03\x02\x02\x02\x02" + - "\u01BF\x03\x02\x02\x02\x02\u01C1\x03\x02\x02\x02\x02\u01C3\x03\x02\x02" + - "\x02\x02\u01C5\x03\x02\x02\x02\x02\u01C7\x03\x02\x02\x02\x02\u01C9\x03" + - "\x02\x02\x02\x02\u01CB\x03\x02\x02\x02\x02\u01CD\x03\x02\x02\x02\x02\u01CF" + - "\x03\x02\x02\x02\x02\u01D1\x03\x02\x02\x02\x02\u01D3\x03\x02\x02\x02\x02" + - "\u01D5\x03\x02\x02\x02\x02\u01D7\x03\x02\x02\x02\x02\u01D9\x03\x02\x02" + - "\x02\x02\u01DB\x03\x02\x02\x02\x02\u01DD\x03\x02\x02\x02\x02\u01DF\x03" + - "\x02\x02\x02\x02\u01E1\x03\x02\x02\x02\x02\u01E3\x03\x02\x02\x02\x02\u01E5" + - "\x03\x02\x02\x02\x02\u01E7\x03\x02\x02\x02\x02\u01E9\x03\x02\x02\x02\x02" + - "\u01EB\x03\x02\x02\x02\x02\u01ED\x03\x02\x02\x02\x02\u01EF\x03\x02\x02" + - "\x02\x02\u01F1\x03\x02\x02\x02\x02\u01F3\x03\x02\x02\x02\x02\u01F5\x03" + - "\x02\x02\x02\x02\u01F7\x03\x02\x02\x02\x02\u01F9\x03\x02\x02\x02\x02\u01FB" + - "\x03\x02\x02\x02\x02\u01FD\x03\x02\x02\x02\x02\u01FF\x03\x02\x02\x02\x02" + - "\u0201\x03\x02\x02\x02\x02\u0203\x03\x02\x02\x02\x02\u0205\x03\x02\x02" + - "\x02\x02\u0207\x03\x02\x02\x02\x02\u0209\x03\x02\x02\x02\x02\u020B\x03" + - "\x02\x02\x02\x02\u020D\x03\x02\x02\x02\x02\u020F\x03\x02\x02\x02\x02\u0211" + - "\x03\x02\x02\x02\x02\u0213\x03\x02\x02\x02\x02\u0215\x03\x02\x02\x02\x02" + - "\u0217\x03\x02\x02\x02\x02\u0219\x03\x02\x02\x02\x02\u021B\x03\x02\x02" + - "\x02\x02\u021D\x03\x02\x02\x02\x02\u021F\x03\x02\x02\x02\x02\u0221\x03" + - "\x02\x02\x02\x02\u0223\x03\x02\x02\x02\x02\u0225\x03\x02\x02\x02\x02\u0227" + - "\x03\x02\x02\x02\x02\u0229\x03\x02\x02\x02\x02\u022B\x03\x02\x02\x02\x02" + - "\u022D\x03\x02\x02\x02\x02\u022F\x03\x02\x02\x02\x02\u0231\x03\x02\x02" + - "\x02\x02\u0233\x03\x02\x02\x02\x02\u0235\x03\x02\x02\x02\x02\u0237\x03" + - "\x02\x02\x02\x02\u0239\x03\x02\x02\x02\x02\u023B\x03\x02\x02\x02\x02\u023D" + - "\x03\x02\x02\x02\x02\u023F\x03\x02\x02\x02\x02\u0241\x03\x02\x02\x02\x02" + - "\u0243\x03\x02\x02\x02\x02\u0245\x03\x02\x02\x02\x02\u0247\x03\x02\x02" + - "\x02\x02\u0249\x03\x02\x02\x02\x02\u024B\x03\x02\x02\x02\x02\u024D\x03" + - "\x02\x02\x02\x02\u024F\x03\x02\x02\x02\x02\u0251\x03\x02\x02\x02\x02\u0253" + - "\x03\x02\x02\x02\x02\u0255\x03\x02\x02\x02\x02\u0257\x03\x02\x02\x02\x02" + - "\u0259\x03\x02\x02\x02\x02\u025B\x03\x02\x02\x02\x02\u025D\x03\x02\x02" + - "\x02\x02\u025F\x03\x02\x02\x02\x02\u0261\x03\x02\x02\x02\x02\u0263\x03" + - "\x02\x02\x02\x02\u0265\x03\x02\x02\x02\x02\u0267\x03\x02\x02\x02\x02\u0269" + - "\x03\x02\x02\x02\x02\u026B\x03\x02\x02\x02\x02\u026D\x03\x02\x02\x02\x02" + - "\u026F\x03\x02\x02\x02\x02\u0271\x03\x02\x02\x02\x02\u0273\x03\x02\x02" + - "\x02\x02\u0275\x03\x02\x02\x02\x02\u0277\x03\x02\x02\x02\x02\u0279\x03" + - "\x02\x02\x02\x02\u027B\x03\x02\x02\x02\x02\u027D\x03\x02\x02\x02\x02\u027F" + + "\x03\u0204\x03\u0204\x03\u0205\x03\u0205\x03\u0205\x03\u0205\x03\u0205" + + "\x03\u0205\x03\u0206\x03\u0206\x03\u0206\x03\u0206\x03\u0207\x03\u0207" + + "\x03\u0207\x03\u0207\x03\u0207\x03\u0208\x03\u0208\x03\u0208\x03\u0208" + + "\x03\u0208\x03\u0208\x03\u0208\x03\u0209\x03\u0209\x03\u0209\x03\u0209" + + "\x03\u0209\x03\u0209\x03\u0209\x03\u0209\x03\u020A\x03\u020A\x03\u020A" + + "\x03\u020A\x03\u020A\x03\u020A\x03\u020A\x03\u020A\x03\u020A\x03\u020A" + + "\x03\u020B\x03\u020B\x03\u020B\x03\u020B\x03\u020B\x03\u020B\x03\u020B" + + "\x03\u020C\x03\u020C\x03\u020C\x03\u020C\x03\u020C\x03\u020D\x03\u020D" + + "\x03\u020D\x03\u020D\x03\u020D\x03\u020E\x03\u020E\x03\u020E\x03\u020E" + + "\x03\u020E\x03\u020E\x03\u020E\x03\u020E\x03\u020E\x03\u020E\x03\u020E" + + "\x03\u020F\x03\u020F\x03\u020F\x03\u020F\x03\u020F\x03\u020F\x03\u0210" + + "\x03\u0210\x03\u0210\x03\u0210\x03\u0210\x03\u0210\x03\u0210\x03\u0210" + + "\x03\u0211\x03\u0211\x03\u0211\x03\u0211\x03\u0211\x03\u0211\x03\u0211" + + "\x03\u0212\x03\u0212\x07\u0212\u13DB\n\u0212\f\u0212\x0E\u0212\u13DE\v" + + "\u0212\x03\u0213\x03\u0213\x03\u0213\x05\u0213\u13E3\n\u0213\x03\u0214" + + "\x03\u0214\x05\u0214\u13E7\n\u0214\x03\u0215\x03\u0215\x05\u0215\u13EB" + + "\n\u0215\x03\u0216\x03\u0216\x03\u0216\x03\u0217\x03\u0217\x03\u0217\x03" + + "\u0217\x07\u0217\u13F4\n\u0217\f\u0217\x0E\u0217\u13F7\v\u0217\x03\u0218" + + "\x03\u0218\x03\u0218\x03\u0219\x03\u0219\x03\u0219\x03\u0219\x07\u0219" + + "\u1400\n\u0219\f\u0219\x0E\u0219\u1403\v\u0219\x03\u021A\x03\u021A\x03" + + "\u021A\x03\u021A\x03\u021B\x03\u021B\x03\u021B\x03\u021B\x03\u021C\x03" + + "\u021C\x03\u021C\x03\u021C\x03\u021D\x03\u021D\x03\u021D\x03\u021D\x03" + + "\u021E\x03\u021E\x03\u021E\x03\u021F\x03\u021F\x03\u021F\x03\u021F\x07" + + "\u021F\u141C\n\u021F\f\u021F\x0E\u021F\u141F\v\u021F\x03\u0220\x03\u0220" + + "\x03\u0220\x03\u0220\x03\u0220\x03\u0220\x03\u0221\x03\u0221\x03\u0221" + + "\x03\u0222\x03\u0222\x03\u0222\x03\u0222\x03\u0223\x03\u0223\x05\u0223" + + "\u1430\n\u0223\x03\u0223\x03\u0223\x03\u0223\x03\u0223\x03\u0224\x03\u0224" + + "\x07\u0224\u1438\n\u0224\f\u0224\x0E\u0224\u143B\v\u0224\x03\u0225\x03" + + "\u0225\x03\u0225\x03\u0226\x03\u0226\x03\u0226\x07\u0226\u1443\n\u0226" + + "\f\u0226\x0E\u0226\u1446\v\u0226\x03\u0227\x03\u0227\x03\u0227\x03\u0228" + + "\x03\u0228\x03\u0228\x03\u0229\x03\u0229\x03\u0229\x03\u022A\x03\u022A" + + "\x03\u022A\x07\u022A\u1454\n\u022A\f\u022A\x0E\u022A\u1457\v\u022A\x03" + + "\u022B\x03\u022B\x03\u022B\x03\u022C\x03\u022C\x03\u022C\x03\u022D\x03" + + "\u022D\x03\u022E\x03\u022E\x03\u022E\x03\u022E\x03\u022F\x03\u022F\x03" + + "\u022F\x05\u022F\u1468\n\u022F\x03\u022F\x03\u022F\x05\u022F\u146C\n\u022F" + + "\x03\u022F\x05\u022F\u146F\n\u022F\x03\u022F\x03\u022F\x03\u022F\x03\u022F" + + "\x05\u022F\u1475\n\u022F\x03\u022F\x05\u022F\u1478\n\u022F\x03\u022F\x03" + + "\u022F\x03\u022F\x05\u022F\u147D\n\u022F\x03\u022F\x03\u022F\x05\u022F" + + "\u1481\n\u022F\x03\u0230\x06\u0230\u1484\n\u0230\r\u0230\x0E\u0230\u1485" + + "\x03\u0231\x03\u0231\x03\u0231\x07\u0231\u148B\n\u0231\f\u0231\x0E\u0231" + + "\u148E\v\u0231\x03\u0232\x03\u0232\x03\u0232\x03\u0232\x03\u0232\x03\u0232" + + "\x03\u0232\x03\u0232\x07\u0232\u1498\n\u0232\f\u0232\x0E\u0232\u149B\v" + + "\u0232\x03\u0232\x03\u0232\x03\u0233\x06\u0233\u14A0\n\u0233\r\u0233\x0E" + + "\u0233\u14A1\x03\u0233\x03\u0233\x03\u0234\x03\u0234\x05\u0234\u14A8\n" + + "\u0234\x03\u0234\x05\u0234\u14AB\n\u0234\x03\u0234\x03\u0234\x03\u0235" + + "\x03\u0235\x03\u0235\x03\u0235\x07\u0235\u14B3\n\u0235\f\u0235\x0E\u0235" + + "\u14B6\v\u0235\x03\u0235\x03\u0235\x03\u0236\x03\u0236\x03\u0236\x03\u0236" + + "\x07\u0236\u14BE\n\u0236\f\u0236\x0E\u0236\u14C1\v\u0236\x03\u0236\x03" + + "\u0236\x03\u0236\x06\u0236\u14C6\n\u0236\r\u0236\x0E\u0236\u14C7\x03\u0236" + + "\x03\u0236\x06\u0236\u14CC\n\u0236\r\u0236\x0E\u0236\u14CD\x03\u0236\x07" + + "\u0236\u14D1\n\u0236\f\u0236\x0E\u0236\u14D4\v\u0236\x03\u0236\x07\u0236" + + "\u14D7\n\u0236\f\u0236\x0E\u0236\u14DA\v\u0236\x03\u0236\x03\u0236\x03" + + "\u0236\x03\u0236\x03\u0236\x03\u0237\x03\u0237\x03\u0237\x03\u0237\x07" + + "\u0237\u14E5\n\u0237\f\u0237\x0E\u0237\u14E8\v\u0237\x03\u0237\x03\u0237" + + "\x03\u0237\x06\u0237\u14ED\n\u0237\r\u0237\x0E\u0237\u14EE\x03\u0237\x03" + + "\u0237\x06\u0237\u14F3\n\u0237\r\u0237\x0E\u0237\u14F4\x03\u0237\x05\u0237" + + "\u14F8\n\u0237\x07\u0237\u14FA\n\u0237\f\u0237\x0E\u0237\u14FD\v\u0237" + + "\x03\u0237\x06\u0237\u1500\n\u0237\r\u0237\x0E\u0237\u1501\x03\u0237\x06" + + "\u0237\u1505\n\u0237\r\u0237\x0E\u0237\u1506\x03\u0237\x07\u0237\u150A" + + "\n\u0237\f\u0237\x0E\u0237\u150D\v\u0237\x03\u0237\x05\u0237\u1510\n\u0237" + + "\x03\u0238\x03\u0238\x03\u0238\x03\u0238\x07\u0238\u1516\n\u0238\f\u0238" + + "\x0E\u0238\u1519\v\u0238\x03\u0238\x07\u0238\u151C\n\u0238\f\u0238\x0E" + + "\u0238\u151F\v\u0238\x03\u0238\x03\u0238\x07\u0238\u1523\n\u0238\f\u0238" + + "\x0E\u0238\u1526\v\u0238\x05\u0238\u1528\n\u0238\x03\u0239\x03\u0239\x03" + + "\u0239\x03\u023A\x03\u023A\x03\u023B\x03\u023B\x03\u023B\x03\u023B\x03" + + "\u023B\x03\u023C\x03\u023C\x05\u023C\u1536\n\u023C\x03\u023C\x03\u023C" + + "\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D" + + "\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D" + + "\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x05\u023D" + + "\u154E\n\u023D\x03\u023D\x07\u023D\u1551\n\u023D\f\u023D\x0E\u023D\u1554" + + "\v\u023D\x03\u023E\x03\u023E\x03\u023E\x03\u023E\x03\u023E\x03\u023F\x03" + + "\u023F\x05\u023F\u155D\n\u023F\x03\u023F\x03\u023F\x03\u0240\x03\u0240" + + "\x03\u0240\x03\u0240\x03\u0240\x07\u0240\u1566\n\u0240\f\u0240\x0E\u0240" + + "\u1569\v\u0240\x03\u0241\x03\u0241\x03\u0241\x03\u0241\x03\u0241\x03\u0242" + + "\x03\u0242\x03\u0242\x03\u0242\x03\u0242\x03\u0242\x03\u0243\x03\u0243" + + "\x03\u0243\x03\u0243\x03\u0243\x03\u0244\x03\u0244\x03\u0244\x03\u0244" + + "\x03\u0244\x03\u0245\x03\u0245\x03\u0245\x03\u0245\x03\u0245\x03\u0246" + + "\x06\u0246\u1586\n\u0246\r\u0246\x0E\u0246\u1587\x03\u0246\x03\u0246\x07" + + "\u0246\u158C\n\u0246\f\u0246\x0E\u0246\u158F\v\u0246\x05\u0246\u1591\n" + + "\u0246\x03\u0247\x03\u0247\x05\u0247\u1595\n\u0247\x03\u0247\x03\u0247" + + "\x03\u0247\x03\u0247\x02\x02\x02\u0248\x07\x02\x03\t\x02\x04\v\x02\x05" + + "\r\x02\x06\x0F\x02\x07\x11\x02\b\x13\x02\t\x15\x02\n\x17\x02\v\x19\x02" + + "\f\x1B\x02\r\x1D\x02\x0E\x1F\x02\x0F!\x02\x10#\x02\x11%\x02\x12\'\x02" + + "\x13)\x02\x14+\x02\x15-\x02\x16/\x02\x171\x02\x183\x02\x195\x02\x1A7\x02" + + "\x1B9\x02\x1C;\x02\x1D=\x02\x1E?\x02\x1FA\x02\x02C\x02\x02E\x02\x02G\x02" + + "\x02I\x02 K\x02!M\x02\"O\x02#Q\x02$S\x02%U\x02&W\x02\'Y\x02([\x02)]\x02" + + "*_\x02+a\x02,c\x02-e\x02.g\x02/i\x020k\x021m\x022o\x023q\x024s\x025u\x02" + + "6w\x027y\x028{\x029}\x02:\x7F\x02;\x81\x02<\x83\x02=\x85\x02>\x87\x02" + + "?\x89\x02@\x8B\x02A\x8D\x02B\x8F\x02C\x91\x02D\x93\x02E\x95\x02F\x97\x02" + + "G\x99\x02H\x9B\x02I\x9D\x02J\x9F\x02K\xA1\x02L\xA3\x02M\xA5\x02N\xA7\x02" + + "O\xA9\x02P\xAB\x02Q\xAD\x02R\xAF\x02S\xB1\x02T\xB3\x02U\xB5\x02V\xB7\x02" + + "W\xB9\x02X\xBB\x02Y\xBD\x02Z\xBF\x02[\xC1\x02\\\xC3\x02]\xC5\x02^\xC7" + + "\x02_\xC9\x02`\xCB\x02a\xCD\x02b\xCF\x02c\xD1\x02d\xD3\x02e\xD5\x02f\xD7" + + "\x02g\xD9\x02h\xDB\x02i\xDD\x02j\xDF\x02k\xE1\x02l\xE3\x02m\xE5\x02n\xE7" + + "\x02o\xE9\x02p\xEB\x02q\xED\x02r\xEF\x02s\xF1\x02t\xF3\x02u\xF5\x02v\xF7" + + "\x02w\xF9\x02x\xFB\x02y\xFD\x02z\xFF\x02{\u0101\x02|\u0103\x02}\u0105" + + "\x02~\u0107\x02\x7F\u0109\x02\x80\u010B\x02\x81\u010D\x02\x82\u010F\x02" + + "\x83\u0111\x02\x84\u0113\x02\x85\u0115\x02\x86\u0117\x02\x87\u0119\x02" + + "\x88\u011B\x02\x89\u011D\x02\x8A\u011F\x02\x8B\u0121\x02\x8C\u0123\x02" + + "\x8D\u0125\x02\x8E\u0127\x02\x8F\u0129\x02\x90\u012B\x02\x91\u012D\x02" + + "\x92\u012F\x02\x93\u0131\x02\x94\u0133\x02\x95\u0135\x02\x96\u0137\x02" + + "\x97\u0139\x02\x98\u013B\x02\x99\u013D\x02\x9A\u013F\x02\x9B\u0141\x02" + + "\x9C\u0143\x02\x9D\u0145\x02\x9E\u0147\x02\x9F\u0149\x02\xA0\u014B\x02" + + "\xA1\u014D\x02\xA2\u014F\x02\xA3\u0151\x02\xA4\u0153\x02\xA5\u0155\x02" + + "\xA6\u0157\x02\xA7\u0159\x02\xA8\u015B\x02\xA9\u015D\x02\xAA\u015F\x02" + + "\xAB\u0161\x02\xAC\u0163\x02\xAD\u0165\x02\xAE\u0167\x02\xAF\u0169\x02" + + "\xB0\u016B\x02\xB1\u016D\x02\xB2\u016F\x02\xB3\u0171\x02\xB4\u0173\x02" + + "\xB5\u0175\x02\xB6\u0177\x02\xB7\u0179\x02\xB8\u017B\x02\xB9\u017D\x02" + + "\xBA\u017F\x02\xBB\u0181\x02\xBC\u0183\x02\xBD\u0185\x02\xBE\u0187\x02" + + "\xBF\u0189\x02\xC0\u018B\x02\xC1\u018D\x02\xC2\u018F\x02\xC3\u0191\x02" + + "\xC4\u0193\x02\xC5\u0195\x02\xC6\u0197\x02\xC7\u0199\x02\xC8\u019B\x02" + + "\xC9\u019D\x02\xCA\u019F\x02\xCB\u01A1\x02\xCC\u01A3\x02\xCD\u01A5\x02" + + "\xCE\u01A7\x02\xCF\u01A9\x02\xD0\u01AB\x02\xD1\u01AD\x02\xD2\u01AF\x02" + + "\xD3\u01B1\x02\xD4\u01B3\x02\xD5\u01B5\x02\xD6\u01B7\x02\xD7\u01B9\x02" + + "\xD8\u01BB\x02\xD9\u01BD\x02\xDA\u01BF\x02\xDB\u01C1\x02\xDC\u01C3\x02" + + "\xDD\u01C5\x02\xDE\u01C7\x02\xDF\u01C9\x02\xE0\u01CB\x02\xE1\u01CD\x02" + + "\xE2\u01CF\x02\xE3\u01D1\x02\xE4\u01D3\x02\xE5\u01D5\x02\xE6\u01D7\x02" + + "\xE7\u01D9\x02\xE8\u01DB\x02\xE9\u01DD\x02\xEA\u01DF\x02\xEB\u01E1\x02" + + "\xEC\u01E3\x02\xED\u01E5\x02\xEE\u01E7\x02\xEF\u01E9\x02\xF0\u01EB\x02" + + "\xF1\u01ED\x02\xF2\u01EF\x02\xF3\u01F1\x02\xF4\u01F3\x02\xF5\u01F5\x02" + + "\xF6\u01F7\x02\xF7\u01F9\x02\xF8\u01FB\x02\xF9\u01FD\x02\xFA\u01FF\x02" + + "\xFB\u0201\x02\xFC\u0203\x02\xFD\u0205\x02\xFE\u0207\x02\xFF\u0209\x02" + + "\u0100\u020B\x02\u0101\u020D\x02\u0102\u020F\x02\u0103\u0211\x02\u0104" + + "\u0213\x02\u0105\u0215\x02\u0106\u0217\x02\u0107\u0219\x02\u0108\u021B" + + "\x02\u0109\u021D\x02\u010A\u021F\x02\u010B\u0221\x02\u010C\u0223\x02\u010D" + + "\u0225\x02\u010E\u0227\x02\u010F\u0229\x02\u0110\u022B\x02\u0111\u022D" + + "\x02\u0112\u022F\x02\u0113\u0231\x02\u0114\u0233\x02\u0115\u0235\x02\u0116" + + "\u0237\x02\u0117\u0239\x02\u0118\u023B\x02\u0119\u023D\x02\u011A\u023F" + + "\x02\u011B\u0241\x02\u011C\u0243\x02\u011D\u0245\x02\u011E\u0247\x02\u011F" + + "\u0249\x02\u0120\u024B\x02\u0121\u024D\x02\u0122\u024F\x02\u0123\u0251" + + "\x02\u0124\u0253\x02\u0125\u0255\x02\u0126\u0257\x02\u0127\u0259\x02\u0128" + + "\u025B\x02\u0129\u025D\x02\u012A\u025F\x02\u012B\u0261\x02\u012C\u0263" + + "\x02\u012D\u0265\x02\u012E\u0267\x02\u012F\u0269\x02\u0130\u026B\x02\u0131" + + "\u026D\x02\u0132\u026F\x02\u0133\u0271\x02\u0134\u0273\x02\u0135\u0275" + + "\x02\u0136\u0277\x02\u0137\u0279\x02\u0138\u027B\x02\u0139\u027D\x02\u013A" + + "\u027F\x02\u013B\u0281\x02\u013C\u0283\x02\u013D\u0285\x02\u013E\u0287" + + "\x02\u013F\u0289\x02\u0140\u028B\x02\u0141\u028D\x02\u0142\u028F\x02\u0143" + + "\u0291\x02\u0144\u0293\x02\u0145\u0295\x02\u0146\u0297\x02\u0147\u0299" + + "\x02\u0148\u029B\x02\u0149\u029D\x02\u014A\u029F\x02\u014B\u02A1\x02\u014C" + + "\u02A3\x02\u014D\u02A5\x02\u014E\u02A7\x02\u014F\u02A9\x02\u0150\u02AB" + + "\x02\u0151\u02AD\x02\u0152\u02AF\x02\u0153\u02B1\x02\u0154\u02B3\x02\u0155" + + "\u02B5\x02\u0156\u02B7\x02\u0157\u02B9\x02\u0158\u02BB\x02\u0159\u02BD" + + "\x02\u015A\u02BF\x02\u015B\u02C1\x02\u015C\u02C3\x02\u015D\u02C5\x02\u015E" + + "\u02C7\x02\u015F\u02C9\x02\u0160\u02CB\x02\u0161\u02CD\x02\u0162\u02CF" + + "\x02\u0163\u02D1\x02\u0164\u02D3\x02\u0165\u02D5\x02\u0166\u02D7\x02\u0167" + + "\u02D9\x02\u0168\u02DB\x02\u0169\u02DD\x02\u016A\u02DF\x02\u016B\u02E1" + + "\x02\u016C\u02E3\x02\u016D\u02E5\x02\u016E\u02E7\x02\u016F\u02E9\x02\u0170" + + "\u02EB\x02\u0171\u02ED\x02\u0172\u02EF\x02\u0173\u02F1\x02\u0174\u02F3" + + "\x02\u0175\u02F5\x02\u0176\u02F7\x02\u0177\u02F9\x02\u0178\u02FB\x02\u0179" + + "\u02FD\x02\u017A\u02FF\x02\u017B\u0301\x02\u017C\u0303\x02\u017D\u0305" + + "\x02\u017E\u0307\x02\u017F\u0309\x02\u0180\u030B\x02\u0181\u030D\x02\u0182" + + "\u030F\x02\u0183\u0311\x02\u0184\u0313\x02\u0185\u0315\x02\u0186\u0317" + + "\x02\u0187\u0319\x02\u0188\u031B\x02\u0189\u031D\x02\u018A\u031F\x02\u018B" + + "\u0321\x02\u018C\u0323\x02\u018D\u0325\x02\u018E\u0327\x02\u018F\u0329" + + "\x02\u0190\u032B\x02\u0191\u032D\x02\u0192\u032F\x02\u0193\u0331\x02\u0194" + + "\u0333\x02\u0195\u0335\x02\u0196\u0337\x02\u0197\u0339\x02\u0198\u033B" + + "\x02\u0199\u033D\x02\u019A\u033F\x02\u019B\u0341\x02\u019C\u0343\x02\u019D" + + "\u0345\x02\u019E\u0347\x02\u019F\u0349\x02\u01A0\u034B\x02\u01A1\u034D" + + "\x02\u01A2\u034F\x02\u01A3\u0351\x02\u01A4\u0353\x02\u01A5\u0355\x02\u01A6" + + "\u0357\x02\u01A7\u0359\x02\u01A8\u035B\x02\u01A9\u035D\x02\u01AA\u035F" + + "\x02\u01AB\u0361\x02\u01AC\u0363\x02\u01AD\u0365\x02\u01AE\u0367\x02\u01AF" + + "\u0369\x02\u01B0\u036B\x02\u01B1\u036D\x02\u01B2\u036F\x02\u01B3\u0371" + + "\x02\u01B4\u0373\x02\u01B5\u0375\x02\u01B6\u0377\x02\u01B7\u0379\x02\u01B8" + + "\u037B\x02\u01B9\u037D\x02\u01BA\u037F\x02\u01BB\u0381\x02\u01BC\u0383" + + "\x02\u01BD\u0385\x02\u01BE\u0387\x02\u01BF\u0389\x02\u01C0\u038B\x02\u01C1" + + "\u038D\x02\u01C2\u038F\x02\u01C3\u0391\x02\u01C4\u0393\x02\u01C5\u0395" + + "\x02\u01C6\u0397\x02\u01C7\u0399\x02\u01C8\u039B\x02\u01C9\u039D\x02\u01CA" + + "\u039F\x02\u01CB\u03A1\x02\u01CC\u03A3\x02\u01CD\u03A5\x02\u01CE\u03A7" + + "\x02\u01CF\u03A9\x02\u01D0\u03AB\x02\u01D1\u03AD\x02\u01D2\u03AF\x02\u01D3" + + "\u03B1\x02\u01D4\u03B3\x02\u01D5\u03B5\x02\u01D6\u03B7\x02\u01D7\u03B9" + + "\x02\u01D8\u03BB\x02\u01D9\u03BD\x02\u01DA\u03BF\x02\u01DB\u03C1\x02\u01DC" + + "\u03C3\x02\u01DD\u03C5\x02\u01DE\u03C7\x02\u01DF\u03C9\x02\u01E0\u03CB" + + "\x02\u01E1\u03CD\x02\u01E2\u03CF\x02\u01E3\u03D1\x02\u01E4\u03D3\x02\u01E5" + + "\u03D5\x02\u01E6\u03D7\x02\u01E7\u03D9\x02\u01E8\u03DB\x02\u01E9\u03DD" + + "\x02\u01EA\u03DF\x02\u01EB\u03E1\x02\u01EC\u03E3\x02\u01ED\u03E5\x02\u01EE" + + "\u03E7\x02\u01EF\u03E9\x02\u01F0\u03EB\x02\u01F1\u03ED\x02\u01F2\u03EF" + + "\x02\u01F3\u03F1\x02\u01F4\u03F3\x02\u01F5\u03F5\x02\u01F6\u03F7\x02\u01F7" + + "\u03F9\x02\u01F8\u03FB\x02\u01F9\u03FD\x02\u01FA\u03FF\x02\u01FB\u0401" + + "\x02\u01FC\u0403\x02\u01FD\u0405\x02\u01FE\u0407\x02\u01FF\u0409\x02\u0200" + + "\u040B\x02\u0201\u040D\x02\u0202\u040F\x02\u0203\u0411\x02\u0204\u0413" + + "\x02\u0205\u0415\x02\u0206\u0417\x02\u0207\u0419\x02\u0208\u041B\x02\u0209" + + "\u041D\x02\u020A\u041F\x02\u020B\u0421\x02\u020C\u0423\x02\u020D\u0425" + + "\x02\u020E\u0427\x02\u020F\u0429\x02\x02\u042B\x02\x02\u042D\x02\x02\u042F" + + "\x02\u0210\u0431\x02\u0211\u0433\x02\u0212\u0435\x02\u0213\u0437\x02\u0214" + + "\u0439\x02\u0215\u043B\x02\u0216\u043D\x02\u0217\u043F\x02\u0218\u0441" + + "\x02\u0219\u0443\x02\x02\u0445\x02\u021A\u0447\x02\u021B\u0449\x02\u021C" + + "\u044B\x02\x02\u044D\x02\u021D\u044F\x02\u021E\u0451\x02\u021F\u0453\x02" + + "\u0220\u0455\x02\u0221\u0457\x02\u0222\u0459\x02\u0223\u045B\x02\u0224" + + "\u045D\x02\u0225\u045F\x02\u0226\u0461\x02\u0227\u0463\x02\x02\u0465\x02" + + "\u0228\u0467\x02\u0229\u0469\x02\u022A\u046B\x02\u022B\u046D\x02\u022C" + + "\u046F\x02\u022D\u0471\x02\u022E\u0473\x02\u022F\u0475\x02\u0230\u0477" + + "\x02\u0231\u0479\x02\u0232\u047B\x02\u0233\u047D\x02\x02\u047F\x02\u0234" + + "\u0481\x02\u0235\u0483\x02\x02\u0485\x02\x02\u0487\x02\x02\u0489\x02\x02" + + "\u048B\x02\x02\u048D\x02\u0238\u048F\x02\u0236\u0491\x02\u0237\x07\x02" + + "\x03\x04\x05\x06\x1B\x03\x022;\x04\x02--//\x04\x02//11\v\x02##%%\'(,," + + ">B``bb~~\x80\x80\x04\x02,->@\n\x02##%%\'(AB``bb~~\x80\x80\f\x02C\\aac" + + "|\xAC\xAC\xB7\xB7\xBC\xBC\xC2\xD8\xDA\xF8\xFA\uD801\uE002\x01\x03\x02" + + "\uD802\uDC01\x03\x02\uDC02\uE001\x04\x02\x02\x02$$\x03\x02$$\x03\x02)" + + ")\x03\x0223\x05\x022;CHch\x05\x02C\\aac|\x07\x02&&2;C\\aac|\x04\x02$$" + + "^^\x04\x02\v\v\"\"\x04\x02\f\f\x0F\x0F\x04\x02,,11\x06\x02\f\f\x0F\x0F" + + "$$^^\x05\x02\f\f\x0F\x0F$$\x05\x02WWwwzz\x04\x02))^^\x03\x02&&\x02\u15DF" + + "\x02\x07\x03\x02\x02\x02\x02\t\x03\x02\x02\x02\x02\v\x03\x02\x02\x02\x02" + + "\r\x03\x02\x02\x02\x02\x0F\x03\x02\x02\x02\x02\x11\x03\x02\x02\x02\x02" + + "\x13\x03\x02\x02\x02\x02\x15\x03\x02\x02\x02\x02\x17\x03\x02\x02\x02\x02" + + "\x19\x03\x02\x02\x02\x02\x1B\x03\x02\x02\x02\x02\x1D\x03\x02\x02\x02\x02" + + "\x1F\x03\x02\x02\x02\x02!\x03\x02\x02\x02\x02#\x03\x02\x02\x02\x02%\x03" + + "\x02\x02\x02\x02\'\x03\x02\x02\x02\x02)\x03\x02\x02\x02\x02+\x03\x02\x02" + + "\x02\x02-\x03\x02\x02\x02\x02/\x03\x02\x02\x02\x021\x03\x02\x02\x02\x02" + + "3\x03\x02\x02\x02\x025\x03\x02\x02\x02\x027\x03\x02\x02\x02\x029\x03\x02" + + "\x02\x02\x02;\x03\x02\x02\x02\x02=\x03\x02\x02\x02\x02?\x03\x02\x02\x02" + + "\x02A\x03\x02\x02\x02\x02I\x03\x02\x02\x02\x02K\x03\x02\x02\x02\x02M\x03" + + "\x02\x02\x02\x02O\x03\x02\x02\x02\x02Q\x03\x02\x02\x02\x02S\x03\x02\x02" + + "\x02\x02U\x03\x02\x02\x02\x02W\x03\x02\x02\x02\x02Y\x03\x02\x02\x02\x02" + + "[\x03\x02\x02\x02\x02]\x03\x02\x02\x02\x02_\x03\x02\x02\x02\x02a\x03\x02" + + "\x02\x02\x02c\x03\x02\x02\x02\x02e\x03\x02\x02\x02\x02g\x03\x02\x02\x02" + + "\x02i\x03\x02\x02\x02\x02k\x03\x02\x02\x02\x02m\x03\x02\x02\x02\x02o\x03" + + "\x02\x02\x02\x02q\x03\x02\x02\x02\x02s\x03\x02\x02\x02\x02u\x03\x02\x02" + + "\x02\x02w\x03\x02\x02\x02\x02y\x03\x02\x02\x02\x02{\x03\x02\x02\x02\x02" + + "}\x03\x02\x02\x02\x02\x7F\x03\x02\x02\x02\x02\x81\x03\x02\x02\x02\x02" + + "\x83\x03\x02\x02\x02\x02\x85\x03\x02\x02\x02\x02\x87\x03\x02\x02\x02\x02" + + "\x89\x03\x02\x02\x02\x02\x8B\x03\x02\x02\x02\x02\x8D\x03\x02\x02\x02\x02" + + "\x8F\x03\x02\x02\x02\x02\x91\x03\x02\x02\x02\x02\x93\x03\x02\x02\x02\x02" + + "\x95\x03\x02\x02\x02\x02\x97\x03\x02\x02\x02\x02\x99\x03\x02\x02\x02\x02" + + "\x9B\x03\x02\x02\x02\x02\x9D\x03\x02\x02\x02\x02\x9F\x03\x02\x02\x02\x02" + + "\xA1\x03\x02\x02\x02\x02\xA3\x03\x02\x02\x02\x02\xA5\x03\x02\x02\x02\x02" + + "\xA7\x03\x02\x02\x02\x02\xA9\x03\x02\x02\x02\x02\xAB\x03\x02\x02\x02\x02" + + "\xAD\x03\x02\x02\x02\x02\xAF\x03\x02\x02\x02\x02\xB1\x03\x02\x02\x02\x02" + + "\xB3\x03\x02\x02\x02\x02\xB5\x03\x02\x02\x02\x02\xB7\x03\x02\x02\x02\x02" + + "\xB9\x03\x02\x02\x02\x02\xBB\x03\x02\x02\x02\x02\xBD\x03\x02\x02\x02\x02" + + "\xBF\x03\x02\x02\x02\x02\xC1\x03\x02\x02\x02\x02\xC3\x03\x02\x02\x02\x02" + + "\xC5\x03\x02\x02\x02\x02\xC7\x03\x02\x02\x02\x02\xC9\x03\x02\x02\x02\x02" + + "\xCB\x03\x02\x02\x02\x02\xCD\x03\x02\x02\x02\x02\xCF\x03\x02\x02\x02\x02" + + "\xD1\x03\x02\x02\x02\x02\xD3\x03\x02\x02\x02\x02\xD5\x03\x02\x02\x02\x02" + + "\xD7\x03\x02\x02\x02\x02\xD9\x03\x02\x02\x02\x02\xDB\x03\x02\x02\x02\x02" + + "\xDD\x03\x02\x02\x02\x02\xDF\x03\x02\x02\x02\x02\xE1\x03\x02\x02\x02\x02" + + "\xE3\x03\x02\x02\x02\x02\xE5\x03\x02\x02\x02\x02\xE7\x03\x02\x02\x02\x02" + + "\xE9\x03\x02\x02\x02\x02\xEB\x03\x02\x02\x02\x02\xED\x03\x02\x02\x02\x02" + + "\xEF\x03\x02\x02\x02\x02\xF1\x03\x02\x02\x02\x02\xF3\x03\x02\x02\x02\x02" + + "\xF5\x03\x02\x02\x02\x02\xF7\x03\x02\x02\x02\x02\xF9\x03\x02\x02\x02\x02" + + "\xFB\x03\x02\x02\x02\x02\xFD\x03\x02\x02\x02\x02\xFF\x03\x02\x02\x02\x02" + + "\u0101\x03\x02\x02\x02\x02\u0103\x03\x02\x02\x02\x02\u0105\x03\x02\x02" + + "\x02\x02\u0107\x03\x02\x02\x02\x02\u0109\x03\x02\x02\x02\x02\u010B\x03" + + "\x02\x02\x02\x02\u010D\x03\x02\x02\x02\x02\u010F\x03\x02\x02\x02\x02\u0111" + + "\x03\x02\x02\x02\x02\u0113\x03\x02\x02\x02\x02\u0115\x03\x02\x02\x02\x02" + + "\u0117\x03\x02\x02\x02\x02\u0119\x03\x02\x02\x02\x02\u011B\x03\x02\x02" + + "\x02\x02\u011D\x03\x02\x02\x02\x02\u011F\x03\x02\x02\x02\x02\u0121\x03" + + "\x02\x02\x02\x02\u0123\x03\x02\x02\x02\x02\u0125\x03\x02\x02\x02\x02\u0127" + + "\x03\x02\x02\x02\x02\u0129\x03\x02\x02\x02\x02\u012B\x03\x02\x02\x02\x02" + + "\u012D\x03\x02\x02\x02\x02\u012F\x03\x02\x02\x02\x02\u0131\x03\x02\x02" + + "\x02\x02\u0133\x03\x02\x02\x02\x02\u0135\x03\x02\x02\x02\x02\u0137\x03" + + "\x02\x02\x02\x02\u0139\x03\x02\x02\x02\x02\u013B\x03\x02\x02\x02\x02\u013D" + + "\x03\x02\x02\x02\x02\u013F\x03\x02\x02\x02\x02\u0141\x03\x02\x02\x02\x02" + + "\u0143\x03\x02\x02\x02\x02\u0145\x03\x02\x02\x02\x02\u0147\x03\x02\x02" + + "\x02\x02\u0149\x03\x02\x02\x02\x02\u014B\x03\x02\x02\x02\x02\u014D\x03" + + "\x02\x02\x02\x02\u014F\x03\x02\x02\x02\x02\u0151\x03\x02\x02\x02\x02\u0153" + + "\x03\x02\x02\x02\x02\u0155\x03\x02\x02\x02\x02\u0157\x03\x02\x02\x02\x02" + + "\u0159\x03\x02\x02\x02\x02\u015B\x03\x02\x02\x02\x02\u015D\x03\x02\x02" + + "\x02\x02\u015F\x03\x02\x02\x02\x02\u0161\x03\x02\x02\x02\x02\u0163\x03" + + "\x02\x02\x02\x02\u0165\x03\x02\x02\x02\x02\u0167\x03\x02\x02\x02\x02\u0169" + + "\x03\x02\x02\x02\x02\u016B\x03\x02\x02\x02\x02\u016D\x03\x02\x02\x02\x02" + + "\u016F\x03\x02\x02\x02\x02\u0171\x03\x02\x02\x02\x02\u0173\x03\x02\x02" + + "\x02\x02\u0175\x03\x02\x02\x02\x02\u0177\x03\x02\x02\x02\x02\u0179\x03" + + "\x02\x02\x02\x02\u017B\x03\x02\x02\x02\x02\u017D\x03\x02\x02\x02\x02\u017F" + + "\x03\x02\x02\x02\x02\u0181\x03\x02\x02\x02\x02\u0183\x03\x02\x02\x02\x02" + + "\u0185\x03\x02\x02\x02\x02\u0187\x03\x02\x02\x02\x02\u0189\x03\x02\x02" + + "\x02\x02\u018B\x03\x02\x02\x02\x02\u018D\x03\x02\x02\x02\x02\u018F\x03" + + "\x02\x02\x02\x02\u0191\x03\x02\x02\x02\x02\u0193\x03\x02\x02\x02\x02\u0195" + + "\x03\x02\x02\x02\x02\u0197\x03\x02\x02\x02\x02\u0199\x03\x02\x02\x02\x02" + + "\u019B\x03\x02\x02\x02\x02\u019D\x03\x02\x02\x02\x02\u019F\x03\x02\x02" + + "\x02\x02\u01A1\x03\x02\x02\x02\x02\u01A3\x03\x02\x02\x02\x02\u01A5\x03" + + "\x02\x02\x02\x02\u01A7\x03\x02\x02\x02\x02\u01A9\x03\x02\x02\x02\x02\u01AB" + + "\x03\x02\x02\x02\x02\u01AD\x03\x02\x02\x02\x02\u01AF\x03\x02\x02\x02\x02" + + "\u01B1\x03\x02\x02\x02\x02\u01B3\x03\x02\x02\x02\x02\u01B5\x03\x02\x02" + + "\x02\x02\u01B7\x03\x02\x02\x02\x02\u01B9\x03\x02\x02\x02\x02\u01BB\x03" + + "\x02\x02\x02\x02\u01BD\x03\x02\x02\x02\x02\u01BF\x03\x02\x02\x02\x02\u01C1" + + "\x03\x02\x02\x02\x02\u01C3\x03\x02\x02\x02\x02\u01C5\x03\x02\x02\x02\x02" + + "\u01C7\x03\x02\x02\x02\x02\u01C9\x03\x02\x02\x02\x02\u01CB\x03\x02\x02" + + "\x02\x02\u01CD\x03\x02\x02\x02\x02\u01CF\x03\x02\x02\x02\x02\u01D1\x03" + + "\x02\x02\x02\x02\u01D3\x03\x02\x02\x02\x02\u01D5\x03\x02\x02\x02\x02\u01D7" + + "\x03\x02\x02\x02\x02\u01D9\x03\x02\x02\x02\x02\u01DB\x03\x02\x02\x02\x02" + + "\u01DD\x03\x02\x02\x02\x02\u01DF\x03\x02\x02\x02\x02\u01E1\x03\x02\x02" + + "\x02\x02\u01E3\x03\x02\x02\x02\x02\u01E5\x03\x02\x02\x02\x02\u01E7\x03" + + "\x02\x02\x02\x02\u01E9\x03\x02\x02\x02\x02\u01EB\x03\x02\x02\x02\x02\u01ED" + + "\x03\x02\x02\x02\x02\u01EF\x03\x02\x02\x02\x02\u01F1\x03\x02\x02\x02\x02" + + "\u01F3\x03\x02\x02\x02\x02\u01F5\x03\x02\x02\x02\x02\u01F7\x03\x02\x02" + + "\x02\x02\u01F9\x03\x02\x02\x02\x02\u01FB\x03\x02\x02\x02\x02\u01FD\x03" + + "\x02\x02\x02\x02\u01FF\x03\x02\x02\x02\x02\u0201\x03\x02\x02\x02\x02\u0203" + + "\x03\x02\x02\x02\x02\u0205\x03\x02\x02\x02\x02\u0207\x03\x02\x02\x02\x02" + + "\u0209\x03\x02\x02\x02\x02\u020B\x03\x02\x02\x02\x02\u020D\x03\x02\x02" + + "\x02\x02\u020F\x03\x02\x02\x02\x02\u0211\x03\x02\x02\x02\x02\u0213\x03" + + "\x02\x02\x02\x02\u0215\x03\x02\x02\x02\x02\u0217\x03\x02\x02\x02\x02\u0219" + + "\x03\x02\x02\x02\x02\u021B\x03\x02\x02\x02\x02\u021D\x03\x02\x02\x02\x02" + + "\u021F\x03\x02\x02\x02\x02\u0221\x03\x02\x02\x02\x02\u0223\x03\x02\x02" + + "\x02\x02\u0225\x03\x02\x02\x02\x02\u0227\x03\x02\x02\x02\x02\u0229\x03" + + "\x02\x02\x02\x02\u022B\x03\x02\x02\x02\x02\u022D\x03\x02\x02\x02\x02\u022F" + + "\x03\x02\x02\x02\x02\u0231\x03\x02\x02\x02\x02\u0233\x03\x02\x02\x02\x02" + + "\u0235\x03\x02\x02\x02\x02\u0237\x03\x02\x02\x02\x02\u0239\x03\x02\x02" + + "\x02\x02\u023B\x03\x02\x02\x02\x02\u023D\x03\x02\x02\x02\x02\u023F\x03" + + "\x02\x02\x02\x02\u0241\x03\x02\x02\x02\x02\u0243\x03\x02\x02\x02\x02\u0245" + + "\x03\x02\x02\x02\x02\u0247\x03\x02\x02\x02\x02\u0249\x03\x02\x02\x02\x02" + + "\u024B\x03\x02\x02\x02\x02\u024D\x03\x02\x02\x02\x02\u024F\x03\x02\x02" + + "\x02\x02\u0251\x03\x02\x02\x02\x02\u0253\x03\x02\x02\x02\x02\u0255\x03" + + "\x02\x02\x02\x02\u0257\x03\x02\x02\x02\x02\u0259\x03\x02\x02\x02\x02\u025B" + + "\x03\x02\x02\x02\x02\u025D\x03\x02\x02\x02\x02\u025F\x03\x02\x02\x02\x02" + + "\u0261\x03\x02\x02\x02\x02\u0263\x03\x02\x02\x02\x02\u0265\x03\x02\x02" + + "\x02\x02\u0267\x03\x02\x02\x02\x02\u0269\x03\x02\x02\x02\x02\u026B\x03" + + "\x02\x02\x02\x02\u026D\x03\x02\x02\x02\x02\u026F\x03\x02\x02\x02\x02\u0271" + + "\x03\x02\x02\x02\x02\u0273\x03\x02\x02\x02\x02\u0275\x03\x02\x02\x02\x02" + + "\u0277\x03\x02\x02\x02\x02\u0279\x03\x02\x02\x02\x02\u027B\x03\x02\x02" + + "\x02\x02\u027D\x03\x02\x02\x02\x02\u027F"; + private static readonly _serializedATNSegment3: string = "\x03\x02\x02\x02\x02\u0281\x03\x02\x02\x02\x02\u0283\x03\x02\x02\x02\x02" + "\u0285\x03\x02\x02\x02\x02\u0287\x03\x02\x02\x02\x02\u0289\x03\x02\x02" + "\x02\x02\u028B\x03\x02\x02\x02\x02\u028D\x03\x02\x02\x02\x02\u028F\x03" + @@ -1920,1893 +1868,1938 @@ export class PostgreSQLLexer extends PostgreSQLLexerBase { "\x03\x02\x02\x02\x02\u02D9\x03\x02\x02\x02\x02\u02DB\x03\x02\x02\x02\x02" + "\u02DD\x03\x02\x02\x02\x02\u02DF\x03\x02\x02\x02\x02\u02E1\x03\x02\x02" + "\x02\x02\u02E3\x03\x02\x02\x02\x02\u02E5\x03\x02\x02\x02\x02\u02E7\x03" + - "\x02\x02\x02\x02\u02E9"; - private static readonly _serializedATNSegment3: string = - "\x03\x02\x02\x02\x02\u02EB\x03\x02\x02\x02\x02\u02ED\x03\x02\x02\x02\x02" + - "\u02EF\x03\x02\x02\x02\x02\u02F1\x03\x02\x02\x02\x02\u02F3\x03\x02\x02" + - "\x02\x02\u02F5\x03\x02\x02\x02\x02\u02F7\x03\x02\x02\x02\x02\u02F9\x03" + - "\x02\x02\x02\x02\u02FB\x03\x02\x02\x02\x02\u02FD\x03\x02\x02\x02\x02\u02FF" + - "\x03\x02\x02\x02\x02\u0301\x03\x02\x02\x02\x02\u0303\x03\x02\x02\x02\x02" + - "\u0305\x03\x02\x02\x02\x02\u0307\x03\x02\x02\x02\x02\u0309\x03\x02\x02" + - "\x02\x02\u030B\x03\x02\x02\x02\x02\u030D\x03\x02\x02\x02\x02\u030F\x03" + - "\x02\x02\x02\x02\u0311\x03\x02\x02\x02\x02\u0313\x03\x02\x02\x02\x02\u0315" + - "\x03\x02\x02\x02\x02\u0317\x03\x02\x02\x02\x02\u0319\x03\x02\x02\x02\x02" + - "\u031B\x03\x02\x02\x02\x02\u031D\x03\x02\x02\x02\x02\u031F\x03\x02\x02" + - "\x02\x02\u0321\x03\x02\x02\x02\x02\u0323\x03\x02\x02\x02\x02\u0325\x03" + - "\x02\x02\x02\x02\u0327\x03\x02\x02\x02\x02\u0329\x03\x02\x02\x02\x02\u032B" + - "\x03\x02\x02\x02\x02\u032D\x03\x02\x02\x02\x02\u032F\x03\x02\x02\x02\x02" + - "\u0331\x03\x02\x02\x02\x02\u0333\x03\x02\x02\x02\x02\u0335\x03\x02\x02" + - "\x02\x02\u0337\x03\x02\x02\x02\x02\u0339\x03\x02\x02\x02\x02\u033B\x03" + - "\x02\x02\x02\x02\u033D\x03\x02\x02\x02\x02\u033F\x03\x02\x02\x02\x02\u0341" + - "\x03\x02\x02\x02\x02\u0343\x03\x02\x02\x02\x02\u0345\x03\x02\x02\x02\x02" + - "\u0347\x03\x02\x02\x02\x02\u0349\x03\x02\x02\x02\x02\u034B\x03\x02\x02" + - "\x02\x02\u034D\x03\x02\x02\x02\x02\u034F\x03\x02\x02\x02\x02\u0351\x03" + - "\x02\x02\x02\x02\u0353\x03\x02\x02\x02\x02\u0355\x03\x02\x02\x02\x02\u0357" + - "\x03\x02\x02\x02\x02\u0359\x03\x02\x02\x02\x02\u035B\x03\x02\x02\x02\x02" + - "\u035D\x03\x02\x02\x02\x02\u035F\x03\x02\x02\x02\x02\u0361\x03\x02\x02" + - "\x02\x02\u0363\x03\x02\x02\x02\x02\u0365\x03\x02\x02\x02\x02\u0367\x03" + - "\x02\x02\x02\x02\u0369\x03\x02\x02\x02\x02\u036B\x03\x02\x02\x02\x02\u036D" + - "\x03\x02\x02\x02\x02\u036F\x03\x02\x02\x02\x02\u0371\x03\x02\x02\x02\x02" + - "\u0373\x03\x02\x02\x02\x02\u0375\x03\x02\x02\x02\x02\u0377\x03\x02\x02" + - "\x02\x02\u0379\x03\x02\x02\x02\x02\u037B\x03\x02\x02\x02\x02\u037D\x03" + - "\x02\x02\x02\x02\u037F\x03\x02\x02\x02\x02\u0381\x03\x02\x02\x02\x02\u0383" + - "\x03\x02\x02\x02\x02\u0385\x03\x02\x02\x02\x02\u0387\x03\x02\x02\x02\x02" + - "\u0389\x03\x02\x02\x02\x02\u038B\x03\x02\x02\x02\x02\u038D\x03\x02\x02" + - "\x02\x02\u038F\x03\x02\x02\x02\x02\u0391\x03\x02\x02\x02\x02\u0393\x03" + - "\x02\x02\x02\x02\u0395\x03\x02\x02\x02\x02\u0397\x03\x02\x02\x02\x02\u0399" + - "\x03\x02\x02\x02\x02\u039B\x03\x02\x02\x02\x02\u039D\x03\x02\x02\x02\x02" + - "\u039F\x03\x02\x02\x02\x02\u03A1\x03\x02\x02\x02\x02\u03A3\x03\x02\x02" + - "\x02\x02\u03A5\x03\x02\x02\x02\x02\u03A7\x03\x02\x02\x02\x02\u03A9\x03" + - "\x02\x02\x02\x02\u03AB\x03\x02\x02\x02\x02\u03AD\x03\x02\x02\x02\x02\u03AF" + - "\x03\x02\x02\x02\x02\u03B1\x03\x02\x02\x02\x02\u03B3\x03\x02\x02\x02\x02" + - "\u03B5\x03\x02\x02\x02\x02\u03B7\x03\x02\x02\x02\x02\u03B9\x03\x02\x02" + - "\x02\x02\u03BB\x03\x02\x02\x02\x02\u03BD\x03\x02\x02\x02\x02\u03BF\x03" + - "\x02\x02\x02\x02\u03C1\x03\x02\x02\x02\x02\u03C3\x03\x02\x02\x02\x02\u03C5" + - "\x03\x02\x02\x02\x02\u03C7\x03\x02\x02\x02\x02\u03C9\x03\x02\x02\x02\x02" + - "\u03CB\x03\x02\x02\x02\x02\u03CD\x03\x02\x02\x02\x02\u03CF\x03\x02\x02" + - "\x02\x02\u03D1\x03\x02\x02\x02\x02\u03D3\x03\x02\x02\x02\x02\u03D5\x03" + - "\x02\x02\x02\x02\u03D7\x03\x02\x02\x02\x02\u03D9\x03\x02\x02\x02\x02\u03DB" + - "\x03\x02\x02\x02\x02\u03DD\x03\x02\x02\x02\x02\u03DF\x03\x02\x02\x02\x02" + - "\u03E1\x03\x02\x02\x02\x02\u03E3\x03\x02\x02\x02\x02\u03E5\x03\x02\x02" + - "\x02\x02\u03E7\x03\x02\x02\x02\x02\u03E9\x03\x02\x02\x02\x02\u03EB\x03" + - "\x02\x02\x02\x02\u03ED\x03\x02\x02\x02\x02\u03EF\x03\x02\x02\x02\x02\u03F1" + - "\x03\x02\x02\x02\x02\u03F3\x03\x02\x02\x02\x02\u03F5\x03\x02\x02\x02\x02" + - "\u03F7\x03\x02\x02\x02\x02\u03F9\x03\x02\x02\x02\x02\u03FB\x03\x02\x02" + - "\x02\x02\u03FD\x03\x02\x02\x02\x02\u03FF\x03\x02\x02\x02\x02\u0401\x03" + - "\x02\x02\x02\x02\u0403\x03\x02\x02\x02\x02\u0405\x03\x02\x02\x02\x02\u0407" + - "\x03\x02\x02\x02\x02\u0409\x03\x02\x02\x02\x02\u040B\x03\x02\x02\x02\x02" + - "\u040D\x03\x02\x02\x02\x02\u0415\x03\x02\x02\x02\x02\u0417\x03\x02\x02" + - "\x02\x02\u0419\x03\x02\x02\x02\x02\u041B\x03\x02\x02\x02\x02\u041D\x03" + - "\x02\x02\x02\x02\u041F\x03\x02\x02\x02\x02\u0421\x03\x02\x02\x02\x02\u0423" + - "\x03\x02\x02\x02\x02\u0425\x03\x02\x02\x02\x02\u0427\x03\x02\x02\x02\x02" + - "\u0429\x03\x02\x02\x02\x02\u042B\x03\x02\x02\x02\x02\u042D\x03\x02\x02" + - "\x02\x02\u042F\x03\x02\x02\x02\x02\u0433\x03\x02\x02\x02\x02\u0435\x03" + - "\x02\x02\x02\x02\u0437\x03\x02\x02\x02\x02\u0439\x03\x02\x02\x02\x02\u043B" + - "\x03\x02\x02\x02\x02\u043D\x03\x02\x02\x02\x02\u043F\x03\x02\x02\x02\x02" + - "\u0441\x03\x02\x02\x02\x02\u0443\x03\x02\x02\x02\x02\u0445\x03\x02\x02" + - "\x02\x02\u0447\x03\x02\x02\x02\x02\u044B\x03\x02\x02\x02\x02\u044D\x03" + - "\x02\x02\x02\x02\u044F\x03\x02\x02\x02\x02\u0451\x03\x02\x02\x02\x02\u0453" + - "\x03\x02\x02\x02\x02\u0455\x03\x02\x02\x02\x02\u0457\x03\x02\x02\x02\x02" + - "\u0459\x03\x02\x02\x02\x02\u045B\x03\x02\x02\x02\x02\u045D\x03\x02\x02" + - "\x02\x03\u045F\x03\x02\x02\x02\x03\u0461\x03\x02\x02\x02\x03\u0465\x03" + - "\x02\x02\x02\x03\u0467\x03\x02\x02\x02\x04\u046B\x03\x02\x02\x02\x04\u046D" + - "\x03\x02\x02\x02\x05\u046F\x03\x02\x02\x02\x05\u0471\x03\x02\x02\x02\x05" + - "\u0473\x03\x02\x02\x02\x06\u0475\x03\x02\x02\x02\x06\u0477\x03\x02\x02" + - "\x02\x07\u0479\x03\x02\x02\x02\t\u047B\x03\x02\x02\x02\v\u047D\x03\x02" + - "\x02\x02\r\u047F\x03\x02\x02\x02\x0F\u0481\x03\x02\x02\x02\x11\u0483\x03" + - "\x02\x02\x02\x13\u0485\x03\x02\x02\x02\x15\u0487\x03\x02\x02\x02\x17\u0489" + - "\x03\x02\x02\x02\x19\u048B\x03\x02\x02\x02\x1B\u048D\x03\x02\x02\x02\x1D" + - "\u048F\x03\x02\x02\x02\x1F\u0491\x03\x02\x02\x02!\u0493\x03\x02\x02\x02" + - "#\u0495\x03\x02\x02\x02%\u0497\x03\x02\x02\x02\'\u0499\x03\x02\x02\x02" + - ")\u049B\x03\x02\x02\x02+\u049E\x03\x02\x02\x02-\u04A1\x03\x02\x02\x02" + - "/\u04A4\x03\x02\x02\x021\u04A7\x03\x02\x02\x023\u04AA\x03\x02\x02\x02" + - "5\u04AD\x03\x02\x02\x027\u04B0\x03\x02\x02\x029\u04B3\x03\x02\x02\x02" + - ";\u04B6\x03\x02\x02\x02=\u04B8\x03\x02\x02\x02?\u04D2\x03\x02\x02\x02" + - "A\u04DD\x03\x02\x02\x02C\u04ED\x03\x02\x02\x02E\u04EF\x03\x02\x02\x02" + - "G\u04F1\x03\x02\x02\x02I\u04F3\x03\x02\x02\x02K\u04F7\x03\x02\x02\x02" + - "M\u04FF\x03\x02\x02\x02O\u0507\x03\x02\x02\x02Q\u050B\x03\x02\x02\x02" + - "S\u050F\x03\x02\x02\x02U\u0515\x03\x02\x02\x02W\u0518\x03\x02\x02\x02" + - "Y\u051C\x03\x02\x02\x02[\u0527\x03\x02\x02\x02]\u052C\x03\x02\x02\x02" + - "_\u0531\x03\x02\x02\x02a\u0536\x03\x02\x02\x02c\u053C\x03\x02\x02\x02" + - "e\u0544\x03\x02\x02\x02g\u054B\x03\x02\x02\x02i\u0556\x03\x02\x02\x02" + - "k\u055D\x03\x02\x02\x02m\u056D\x03\x02\x02\x02o\u057A\x03\x02\x02\x02" + - "q\u0587\x03\x02\x02\x02s\u0594\x03\x02\x02\x02u\u05A6\x03\x02\x02\x02" + - "w\u05B3\x03\x02\x02\x02y\u05BB\x03\x02\x02\x02{\u05C6\x03\x02\x02\x02" + - "}\u05CB\x03\x02\x02\x02\x7F\u05D4\x03\x02\x02\x02\x81\u05D7\x03\x02\x02" + - "\x02\x83\u05DC\x03\x02\x02\x02\x85\u05E3\x03\x02\x02\x02\x87\u05E9\x03" + - "\x02\x02\x02\x89\u05EF\x03\x02\x02\x02\x8B\u05F3\x03\x02\x02\x02\x8D\u05FB" + - "\x03\x02\x02\x02\x8F\u0600\x03\x02\x02\x02\x91\u0606\x03\x02\x02\x02\x93" + - "\u060C\x03\x02\x02\x02\x95\u0613\x03\x02\x02\x02\x97\u0616\x03\x02\x02" + - "\x02\x99\u0620\x03\x02\x02\x02\x9B\u062A\x03\x02\x02\x02\x9D\u062F\x03" + - "\x02\x02\x02\x9F\u0637\x03\x02\x02\x02\xA1\u063F\x03\x02\x02\x02\xA3\u0645" + - "\x03\x02\x02\x02\xA5\u064F\x03\x02\x02\x02\xA7\u065E\x03\x02\x02\x02\xA9" + - "\u0662\x03\x02\x02\x02\xAB\u0667\x03\x02\x02\x02\xAD\u066E\x03\x02\x02" + - "\x02\xAF\u0671\x03\x02\x02\x02\xB1\u0676\x03\x02\x02\x02\xB3\u0679\x03" + - "\x02\x02\x02\xB5\u067F\x03\x02\x02\x02\xB7\u0687\x03\x02\x02\x02\xB9\u068F" + - "\x03\x02\x02\x02\xBB\u069A\x03\x02\x02\x02\xBD\u06A4\x03\x02\x02\x02\xBF" + - "\u06AB\x03\x02\x02\x02\xC1\u06B8\x03\x02\x02\x02\xC3\u06BD\x03\x02\x02" + - "\x02\xC5\u06C7\x03\x02\x02\x02\xC7\u06CD\x03\x02\x02\x02\xC9\u06D2\x03" + - "\x02\x02\x02\xCB\u06D5\x03\x02\x02\x02\xCD\u06DE\x03\x02\x02\x02\xCF\u06E3" + - "\x03\x02\x02\x02\xD1\u06E9\x03\x02\x02\x02\xD3\u06F0\x03\x02\x02\x02\xD5" + - "\u06F5\x03\x02\x02\x02\xD7\u06FB\x03\x02\x02\x02\xD9\u0704\x03\x02\x02" + - "\x02\xDB\u0709\x03\x02\x02\x02\xDD\u070F\x03\x02\x02\x02\xDF\u0716\x03" + - "\x02\x02\x02\xE1\u071B\x03\x02\x02\x02\xE3\u0729\x03\x02\x02\x02\xE5\u0730" + - "\x03\x02\x02\x02\xE7\u073A\x03\x02\x02\x02\xE9\u0747\x03\x02\x02\x02\xEB" + - "\u074D\x03\x02\x02\x02\xED\u075C\x03\x02\x02\x02\xEF\u0763\x03\x02\x02" + - "\x02\xF1\u0768\x03\x02\x02\x02\xF3\u076E\x03\x02\x02\x02\xF5\u0774\x03" + - "\x02\x02\x02\xF7\u0777\x03\x02\x02\x02\xF9\u077E\x03\x02\x02\x02\xFB\u0783" + - "\x03\x02\x02\x02\xFD\u0788\x03\x02\x02\x02\xFF\u078D\x03\x02\x02\x02\u0101" + - "\u0795\x03\x02\x02\x02\u0103\u079D\x03\x02\x02\x02\u0105\u07A3\x03\x02" + - "\x02\x02\u0107\u07A8\x03\x02\x02\x02\u0109\u07B1\x03\x02\x02\x02\u010B" + - "\u07B7\x03\x02\x02\x02\u010D\u07BF\x03\x02\x02\x02\u010F\u07C7\x03\x02" + - "\x02\x02\u0111\u07CD\x03\x02\x02\x02\u0113\u07D6\x03\x02\x02\x02\u0115" + - "\u07DD\x03\x02\x02\x02\u0117\u07E4\x03\x02\x02\x02\u0119\u07E8\x03\x02" + - "\x02\x02\u011B\u07EE\x03\x02\x02\x02\u011D\u07F4\x03\x02\x02\x02\u011F" + - "\u07FE\x03\x02\x02\x02\u0121\u0803\x03\x02\x02\x02\u0123\u0809\x03\x02" + - "\x02\x02\u0125\u0810\x03\x02\x02\x02\u0127\u081A\x03\x02\x02\x02\u0129" + - "\u0825\x03\x02\x02\x02\u012B\u0828\x03\x02\x02\x02\u012D\u0832\x03\x02" + - "\x02\x02\u012F\u083B\x03\x02\x02\x02\u0131\u0842\x03\x02\x02\x02\u0133" + - "\u0848\x03\x02\x02\x02\u0135\u084B\x03\x02\x02\x02\u0137\u0851\x03\x02" + - "\x02\x02\u0139\u0858\x03\x02\x02\x02\u013B\u0860\x03\x02\x02\x02\u013D" + - "\u0869\x03\x02\x02\x02\u013F\u0871\x03\x02\x02\x02\u0141\u0877\x03\x02" + - "\x02\x02\u0143\u0887\x03\x02\x02\x02\u0145\u0892\x03\x02\x02\x02\u0147" + - "\u0898\x03\x02\x02\x02\u0149\u089E\x03\x02\x02\x02\u014B\u08A6\x03\x02" + - "\x02\x02\u014D\u08AE\x03\x02\x02\x02\u014F\u08B7\x03\x02\x02\x02\u0151" + - "\u08BE\x03\x02\x02\x02\u0153\u08C8\x03\x02\x02\x02\u0155\u08D6\x03\x02" + - "\x02\x02\u0157\u08E1\x03\x02\x02\x02\u0159\u08ED\x03\x02\x02\x02\u015B" + - "\u08F5\x03\x02\x02\x02\u015D\u08FE\x03\x02\x02\x02\u015F\u0909\x03\x02" + - "\x02\x02\u0161\u090E\x03\x02\x02\x02\u0163\u0913\x03\x02\x02\x02\u0165" + - "\u0917\x03\x02\x02\x02\u0167\u091E\x03\x02\x02\x02\u0169\u0924\x03\x02" + - "\x02\x02\u016B\u0929\x03\x02\x02\x02\u016D\u0932\x03\x02\x02\x02\u016F" + - "\u0936\x03\x02\x02\x02\u0171\u0941\x03\x02\x02\x02\u0173\u0949\x03\x02" + - "\x02\x02\u0175\u0952\x03\x02\x02\x02\u0177\u095B\x03\x02\x02\x02\u0179" + - "\u0963\x03\x02\x02\x02\u017B\u096A\x03\x02\x02\x02\u017D\u0974\x03\x02" + - "\x02\x02\u017F\u097F\x03\x02\x02\x02\u0181\u098A\x03\x02\x02\x02\u0183" + - "\u0992\x03\x02\x02\x02\u0185\u099A\x03\x02\x02\x02\u0187\u09A3\x03\x02" + - "\x02\x02\u0189\u09AA\x03\x02\x02\x02\u018B\u09B1\x03\x02\x02\x02\u018D" + - "\u09B6\x03\x02\x02\x02\u018F\u09BB\x03\x02\x02\x02\u0191\u09C2\x03\x02" + - "\x02\x02\u0193\u09CB\x03\x02\x02\x02\u0195\u09D5\x03\x02\x02\x02\u0197" + - "\u09DA\x03\x02\x02\x02\u0199\u09E1\x03\x02\x02\x02\u019B\u09E7\x03\x02" + - "\x02\x02\u019D\u09EF\x03\x02\x02\x02\u019F\u09F9\x03\x02\x02\x02\u01A1" + - "\u0A03\x03\x02\x02\x02\u01A3\u0A0B\x03\x02\x02\x02\u01A5\u0A13\x03\x02" + - "\x02\x02\u01A7\u0A1D\x03\x02\x02\x02\u01A9\u0A26\x03\x02\x02\x02\u01AB" + - "\u0A2D\x03\x02\x02\x02\u01AD\u0A33\x03\x02\x02\x02\u01AF\u0A3D\x03\x02" + - "\x02\x02\u01B1\u0A43\x03\x02\x02\x02\u01B3\u0A4B\x03\x02\x02\x02\u01B5" + - "\u0A54\x03\x02\x02\x02\u01B7\u0A5E\x03\x02\x02\x02\u01B9\u0A65\x03\x02" + - "\x02\x02\u01BB\u0A6D\x03\x02\x02\x02\u01BD\u0A75\x03\x02\x02\x02\u01BF" + - "\u0A7C\x03\x02\x02\x02\u01C1\u0A81\x03\x02\x02\x02\u01C3\u0A86\x03\x02" + - "\x02\x02\u01C5\u0A8F\x03\x02\x02\x02\u01C7\u0A92\x03\x02\x02\x02\u01C9" + - "\u0A9C\x03\x02\x02\x02\u01CB\u0AA6\x03\x02\x02\x02\u01CD\u0AAF\x03\x02" + - "\x02\x02\u01CF\u0AB9\x03\x02\x02\x02\u01D1\u0AC3\x03\x02\x02\x02\u01D3" + - "\u0AC9\x03\x02\x02\x02\u01D5\u0AD1\x03\x02\x02\x02\u01D7\u0AD9\x03\x02" + - "\x02\x02\u01D9\u0AE2\x03\x02\x02\x02\u01DB\u0AE9\x03\x02\x02\x02\u01DD" + - "\u0AF5\x03\x02\x02\x02\u01DF\u0AFC\x03\x02\x02\x02\u01E1\u0B04\x03\x02" + - "\x02\x02\u01E3\u0B0C\x03\x02\x02\x02\u01E5\u0B16\x03\x02\x02\x02\u01E7" + - "\u0B1A\x03\x02\x02\x02\u01E9\u0B20\x03\x02\x02\x02\u01EB\u0B29\x03\x02" + - "\x02\x02\u01ED\u0B2F\x03\x02\x02\x02\u01EF\u0B34\x03\x02\x02\x02\u01F1" + - "\u0B3E\x03\x02\x02\x02\u01F3\u0B44\x03\x02\x02\x02\u01F5\u0B4B\x03\x02" + - "\x02\x02\u01F7\u0B50\x03\x02\x02\x02\u01F9\u0B56\x03\x02\x02\x02\u01FB" + - "\u0B5F\x03\x02\x02\x02\u01FD\u0B64\x03\x02\x02\x02\u01FF\u0B6C\x03\x02" + - "\x02\x02\u0201\u0B72\x03\x02\x02\x02\u0203\u0B7F\x03\x02\x02\x02\u0205" + - "\u0B88\x03\x02\x02\x02\u0207\u0B8F\x03\x02\x02\x02\u0209\u0B98\x03\x02" + - "\x02\x02\u020B\u0B9D\x03\x02\x02\x02\u020D\u0BA3\x03\x02\x02\x02\u020F" + - "\u0BA8\x03\x02\x02\x02\u0211\u0BAD\x03\x02\x02\x02\u0213\u0BB3\x03\x02" + - "\x02\x02\u0215\u0BB8\x03\x02\x02\x02\u0217\u0BBB\x03\x02\x02\x02\u0219" + - "\u0BC3\x03\x02\x02\x02\u021B\u0BCA\x03\x02\x02\x02\u021D\u0BD1\x03\x02" + - "\x02\x02\u021F\u0BD7\x03\x02\x02\x02\u0221\u0BDE\x03\x02\x02\x02\u0223" + - "\u0BE1\x03\x02\x02\x02\u0225\u0BE5\x03\x02\x02\x02\u0227\u0BEA\x03\x02" + - "\x02\x02\u0229\u0BF3\x03\x02\x02\x02\u022B\u0BFA\x03\x02\x02\x02\u022D" + - "\u0C02\x03\x02\x02\x02\u022F\u0C08\x03\x02\x02\x02\u0231\u0C0E\x03\x02" + - "\x02\x02\u0233\u0C15\x03\x02\x02\x02\u0235\u0C1D\x03\x02\x02\x02\u0237" + - "\u0C27\x03\x02\x02\x02\u0239\u0C2F\x03\x02\x02\x02\u023B\u0C38\x03\x02" + - "\x02\x02\u023D\u0C3E\x03\x02\x02\x02\u023F\u0C48\x03\x02\x02\x02\u0241" + - "\u0C50\x03\x02\x02\x02\u0243\u0C59\x03\x02\x02\x02\u0245\u0C62\x03\x02" + - "\x02\x02\u0247\u0C68\x03\x02\x02\x02\u0249\u0C73\x03\x02\x02\x02\u024B" + - "\u0C7E\x03\x02\x02\x02\u024D\u0C88\x03\x02\x02\x02\u024F\u0C90\x03\x02" + - "\x02\x02\u0251\u0C96\x03\x02\x02\x02\u0253\u0C9C\x03\x02\x02\x02\u0255" + - "\u0CA1\x03\x02\x02\x02\u0257\u0CAA\x03\x02\x02\x02\u0259\u0CB2\x03\x02" + - "\x02\x02\u025B\u0CBC\x03\x02\x02\x02\u025D\u0CC0\x03\x02\x02\x02\u025F" + - "\u0CC8\x03\x02\x02\x02\u0261\u0CD0\x03\x02\x02\x02\u0263\u0CD9\x03\x02" + - "\x02\x02\u0265\u0CE1\x03\x02\x02\x02\u0267\u0CE8\x03\x02\x02\x02\u0269" + - "\u0CF3\x03\x02\x02\x02\u026B\u0CFB\x03\x02\x02\x02\u026D\u0D03\x03\x02" + - "\x02\x02\u026F\u0D09\x03\x02\x02\x02\u0271\u0D11\x03\x02\x02\x02\u0273" + - "\u0D1A\x03\x02\x02\x02\u0275\u0D22\x03\x02\x02\x02\u0277\u0D29\x03\x02" + - "\x02\x02\u0279\u0D2E\x03\x02\x02\x02\u027B\u0D37\x03\x02\x02\x02\u027D" + - "\u0D3C\x03\x02\x02\x02\u027F\u0D41\x03\x02\x02\x02\u0281\u0D4B\x03\x02" + - "\x02\x02\u0283\u0D52\x03\x02\x02\x02\u0285\u0D59\x03\x02\x02\x02\u0287" + - "\u0D60\x03\x02\x02\x02\u0289\u0D67\x03\x02\x02\x02\u028B\u0D70\x03\x02" + - "\x02\x02\u028D\u0D79\x03\x02\x02\x02\u028F\u0D83\x03\x02\x02\x02\u0291" + - "\u0D90\x03\x02\x02\x02\u0293\u0D97\x03\x02\x02\x02\u0295\u0D9F\x03\x02" + - "\x02\x02\u0297\u0DA3\x03\x02\x02\x02\u0299\u0DA9\x03\x02\x02\x02\u029B" + - "\u0DAE\x03\x02\x02\x02\u029D\u0DB5\x03\x02\x02\x02\u029F\u0DBE\x03\x02" + - "\x02\x02\u02A1\u0DC5\x03\x02\x02\x02\u02A3\u0DD0\x03\x02\x02\x02\u02A5" + - "\u0DD6\x03\x02\x02\x02\u02A7\u0DE0\x03\x02\x02\x02\u02A9\u0DEB\x03\x02" + - "\x02\x02\u02AB\u0DF1\x03\x02\x02\x02\u02AD\u0DF8\x03\x02\x02\x02\u02AF" + - "\u0E00\x03\x02\x02\x02\u02B1\u0E07\x03\x02\x02\x02\u02B3\u0E0D\x03\x02" + - "\x02\x02\u02B5\u0E13\x03\x02\x02\x02\u02B7\u0E1A\x03\x02\x02\x02\u02B9" + - "\u0E21\x03\x02\x02\x02\u02BB\u0E2C\x03\x02\x02\x02\u02BD\u0E31\x03\x02" + - "\x02\x02\u02BF\u0E3A\x03\x02\x02\x02\u02C1\u0E44\x03\x02\x02\x02\u02C3" + - "\u0E49\x03\x02\x02\x02\u02C5\u0E55\x03\x02\x02\x02\u02C7\u0E5D\x03\x02" + - "\x02\x02\u02C9\u0E66\x03\x02\x02\x02\u02CB\u0E6E\x03\x02\x02\x02\u02CD" + - "\u0E73\x03\x02\x02\x02\u02CF\u0E79\x03\x02\x02\x02\u02D1\u0E83\x03\x02" + - "\x02\x02\u02D3\u0E8F\x03\x02\x02\x02\u02D5\u0E9B\x03\x02\x02\x02\u02D7" + - "\u0EA3\x03\x02\x02\x02\u02D9\u0EAC\x03\x02\x02\x02\u02DB\u0EB5\x03\x02" + - "\x02\x02\u02DD\u0EBB\x03\x02\x02\x02\u02DF\u0EC2\x03\x02\x02\x02\u02E1" + - "\u0EC9\x03\x02\x02\x02\u02E3\u0ECF\x03\x02\x02\x02\u02E5\u0ED8\x03\x02" + - "\x02\x02\u02E7\u0EE2\x03\x02\x02\x02\u02E9\u0EEA\x03\x02\x02\x02\u02EB" + - "\u0EF2\x03\x02\x02\x02\u02ED\u0EF7\x03\x02\x02\x02\u02EF\u0F00\x03\x02" + - "\x02\x02\u02F1\u0F0B\x03\x02\x02\x02\u02F3\u0F13\x03\x02\x02\x02\u02F5" + - "\u0F18\x03\x02\x02\x02\u02F7\u0F20\x03\x02\x02\x02\u02F9\u0F26\x03\x02" + - "\x02\x02\u02FB\u0F2A\x03\x02\x02\x02\u02FD\u0F2F\x03\x02\x02\x02\u02FF" + - "\u0F33\x03\x02\x02\x02\u0301\u0F38\x03\x02\x02\x02\u0303\u0F40\x03\x02" + - "\x02\x02\u0305\u0F47\x03\x02\x02\x02\u0307\u0F4B\x03\x02\x02\x02\u0309" + - "\u0F53\x03\x02\x02\x02\u030B\u0F58\x03\x02\x02\x02\u030D\u0F62\x03\x02" + - "\x02\x02\u030F\u0F6B\x03\x02\x02\x02\u0311\u0F6F\x03\x02\x02\x02\u0313" + - "\u0F77\x03\x02\x02\x02\u0315\u0F7E\x03\x02\x02\x02\u0317\u0F86\x03\x02" + - "\x02\x02\u0319\u0F8C\x03\x02\x02\x02\u031B\u0F95\x03\x02\x02\x02\u031D" + - "\u0F9B\x03\x02\x02\x02\u031F\u0F9F\x03\x02\x02\x02\u0321\u0FA7\x03\x02" + - "\x02\x02\u0323\u0FB0\x03\x02\x02\x02\u0325\u0FB6\x03\x02\x02\x02\u0327" + - "\u0FBF\x03\x02\x02\x02\u0329\u0FC5\x03\x02\x02\x02\u032B\u0FCA\x03\x02" + - "\x02\x02\u032D\u0FD1\x03\x02\x02\x02\u032F\u0FD9\x03\x02\x02\x02\u0331" + - "\u0FE1\x03\x02\x02\x02\u0333\u0FEA\x03\x02\x02\x02\u0335\u0FF4\x03\x02" + - "\x02\x02\u0337\u0FF9\x03\x02\x02\x02\u0339\u0FFD\x03\x02\x02\x02\u033B" + - "\u1003\x03\x02\x02\x02\u033D\u100C\x03\x02\x02\x02\u033F\u1016\x03\x02" + - "\x02\x02\u0341\u101B\x03\x02\x02\x02\u0343\u1025\x03\x02\x02\x02\u0345" + - "\u102B\x03\x02\x02\x02\u0347\u1030\x03\x02\x02\x02\u0349\u1037\x03\x02" + - "\x02\x02\u034B\u103F\x03\x02\x02\x02\u034D\u104D\x03\x02\x02\x02\u034F" + - "\u1057\x03\x02\x02\x02\u0351\u1062\x03\x02\x02\x02\u0353\u106C\x03\x02" + - "\x02\x02\u0355\u1076\x03\x02\x02\x02\u0357\u107F\x03\x02\x02\x02\u0359" + - "\u1085\x03\x02\x02\x02\u035B\u108D\x03\x02\x02\x02\u035D\u109A\x03\x02" + - "\x02\x02\u035F\u109F\x03\x02\x02\x02\u0361\u10A7\x03\x02\x02\x02\u0363" + - "\u10AE\x03\x02\x02\x02\u0365\u10B5\x03\x02\x02\x02\u0367\u10C0\x03\x02" + - "\x02\x02\u0369\u10CA\x03\x02\x02\x02\u036B\u10D1\x03\x02\x02\x02\u036D" + - "\u10D8\x03\x02\x02\x02\u036F\u10E0\x03\x02\x02\x02\u0371\u10E8\x03\x02" + - "\x02\x02\u0373\u10F2\x03\x02\x02\x02\u0375\u10F9\x03\x02\x02\x02\u0377" + - "\u1100\x03\x02\x02\x02\u0379\u1107\x03\x02\x02\x02\u037B\u1113\x03\x02" + - "\x02\x02\u037D\u1117\x03\x02\x02\x02\u037F\u111B\x03\x02\x02\x02\u0381" + - "\u1121\x03\x02\x02\x02\u0383\u112E\x03\x02\x02\x02\u0385\u113A\x03\x02" + - "\x02\x02\u0387\u113E\x03\x02\x02\x02\u0389\u1142\x03\x02\x02\x02\u038B" + - "\u114B\x03\x02\x02\x02\u038D\u1153\x03\x02\x02\x02\u038F\u115E\x03\x02" + - "\x02\x02\u0391\u1164\x03\x02\x02\x02\u0393\u116C\x03\x02\x02\x02\u0395" + - "\u1175\x03\x02\x02\x02\u0397\u1179\x03\x02\x02\x02\u0399\u1181\x03\x02" + - "\x02\x02\u039B\u118C\x03\x02\x02\x02\u039D\u1195\x03\x02\x02\x02\u039F" + - "\u119A\x03\x02\x02\x02\u03A1\u11A1\x03\x02\x02\x02\u03A3\u11A6\x03\x02" + - "\x02\x02\u03A5\u11AD\x03\x02\x02\x02\u03A7\u11B2\x03\x02\x02\x02\u03A9" + - "\u11BB\x03\x02\x02\x02\u03AB\u11C0\x03\x02\x02\x02\u03AD\u11CC\x03\x02" + - "\x02\x02\u03AF\u11D7\x03\x02\x02\x02\u03B1\u11E0\x03\x02\x02\x02\u03B3" + - "\u11E8\x03\x02\x02\x02\u03B5\u11F6\x03\x02\x02\x02\u03B7\u11FE\x03\x02" + - "\x02\x02\u03B9\u1209\x03\x02\x02\x02\u03BB\u1210\x03\x02\x02\x02\u03BD" + - "\u1217\x03\x02\x02\x02\u03BF\u121E\x03\x02\x02\x02\u03C1\u1225\x03\x02" + - "\x02\x02\u03C3\u1229\x03\x02\x02\x02\u03C5\u122D\x03\x02\x02\x02\u03C7" + - "\u1232\x03\x02\x02\x02\u03C9\u1237\x03\x02\x02\x02\u03CB\u123F\x03\x02" + - "\x02\x02\u03CD\u1245\x03\x02\x02\x02\u03CF\u124F\x03\x02\x02\x02\u03D1" + - "\u1254\x03\x02\x02\x02\u03D3\u1268\x03\x02\x02\x02\u03D5\u127A\x03\x02" + - "\x02\x02\u03D7\u1280\x03\x02\x02\x02\u03D9\u128D\x03\x02\x02\x02\u03DB" + - "\u1298\x03\x02\x02\x02\u03DD\u129E\x03\x02\x02\x02\u03DF\u12A7\x03\x02" + - "\x02\x02\u03E1\u12AF\x03\x02\x02\x02\u03E3\u12B3\x03\x02\x02\x02\u03E5" + - "\u12BF\x03\x02\x02\x02\u03E7\u12C7\x03\x02\x02\x02\u03E9\u12CD\x03\x02" + - "\x02\x02\u03EB\u12D3\x03\x02\x02\x02\u03ED\u12DB\x03\x02\x02\x02\u03EF" + - "\u12E3\x03\x02\x02\x02\u03F1\u12E9\x03\x02\x02\x02\u03F3\u12EE\x03\x02" + - "\x02\x02\u03F5\u12F5\x03\x02\x02\x02\u03F7\u12FB\x03\x02\x02\x02\u03F9" + - "\u1301\x03\x02\x02\x02\u03FB\u130A\x03\x02\x02\x02\u03FD\u1310\x03\x02" + - "\x02\x02\u03FF\u1314\x03\x02\x02\x02\u0401\u1319\x03\x02\x02\x02\u0403" + - "\u1320\x03\x02\x02\x02\u0405\u1328\x03\x02\x02\x02\u0407\u1332\x03\x02" + - "\x02\x02\u0409\u1339\x03\x02\x02\x02\u040B\u133E\x03\x02\x02\x02\u040D" + - "\u1343\x03\x02\x02\x02\u040F\u1350\x03\x02\x02\x02\u0411\u1354\x03\x02" + - "\x02\x02\u0413\u1358\x03\x02\x02\x02\u0415\u135A\x03\x02\x02\x02\u0417" + - "\u135D\x03\x02\x02\x02\u0419\u1366\x03\x02\x02\x02\u041B\u1369\x03\x02" + - "\x02\x02\u041D\u1372\x03\x02\x02\x02\u041F\u1376\x03\x02\x02\x02\u0421" + - "\u137A\x03\x02\x02\x02\u0423\u137E\x03\x02\x02\x02\u0425\u1382\x03\x02" + - "\x02\x02\u0427\u1385\x03\x02\x02\x02\u0429\u138E\x03\x02\x02\x02\u042B" + - "\u1394\x03\x02\x02\x02\u042D\u1397\x03\x02\x02\x02\u042F\u139B\x03\x02" + - "\x02\x02\u0431\u13A4\x03\x02\x02\x02\u0433\u13AB\x03\x02\x02\x02\u0435" + - "\u13AE\x03\x02\x02\x02\u0437\u13B6\x03\x02\x02\x02\u0439\u13B9\x03\x02" + - "\x02\x02\u043B\u13BC\x03\x02\x02\x02\u043D\u13BF\x03\x02\x02\x02\u043F" + - "\u13C7\x03\x02\x02\x02\u0441\u13CA\x03\x02\x02\x02\u0443\u13CD\x03\x02" + - "\x02\x02\u0445\u13CF\x03\x02\x02\x02\u0447\u13F1\x03\x02\x02\x02\u0449" + - "\u13F4\x03\x02\x02\x02\u044B\u13F8\x03\x02\x02\x02\u044D\u1400\x03\x02" + - "\x02\x02\u044F\u1410\x03\x02\x02\x02\u0451\u141B\x03\x02\x02\x02\u0453" + - "\u141F\x03\x02\x02\x02\u0455\u142A\x03\x02\x02\x02\u0457\u1451\x03\x02" + - "\x02\x02\u0459\u1484\x03\x02\x02\x02\u045B\u149C\x03\x02\x02\x02\u045D" + - "\u149F\x03\x02\x02\x02\u045F\u14A1\x03\x02\x02\x02\u0461\u14A6\x03\x02" + - "\x02\x02\u0463\u14C5\x03\x02\x02\x02\u0465\u14C8\x03\x02\x02\x02\u0467" + - "\u14CD\x03\x02\x02\x02\u0469\u14DA\x03\x02\x02\x02\u046B\u14DD\x03\x02" + - "\x02\x02\u046D\u14E2\x03\x02\x02\x02\u046F\u14E8\x03\x02\x02\x02\u0471" + - "\u14ED\x03\x02\x02\x02\u0473\u14F2\x03\x02\x02\x02\u0475\u1503\x03\x02" + - "\x02\x02\u0477\u1505\x03\x02\x02\x02\u0479\u047A\x07&\x02\x02\u047A\b" + - "\x03\x02\x02\x02\u047B\u047C\x07*\x02\x02\u047C\n\x03\x02\x02\x02\u047D" + - "\u047E\x07+\x02\x02\u047E\f\x03\x02\x02\x02\u047F\u0480\x07]\x02\x02\u0480" + - "\x0E\x03\x02\x02\x02\u0481\u0482\x07_\x02\x02\u0482\x10\x03\x02\x02\x02" + - "\u0483\u0484\x07.\x02\x02\u0484\x12\x03\x02\x02\x02\u0485\u0486\x07=\x02" + - "\x02\u0486\x14\x03\x02\x02\x02\u0487\u0488\x07<\x02\x02\u0488\x16\x03" + - "\x02\x02\x02\u0489\u048A\x07,\x02\x02\u048A\x18\x03\x02\x02\x02\u048B" + - "\u048C\x07?\x02\x02\u048C\x1A\x03\x02\x02\x02\u048D\u048E\x070\x02\x02" + - "\u048E\x1C\x03\x02\x02\x02\u048F\u0490\x07-\x02\x02\u0490\x1E\x03\x02" + - "\x02\x02\u0491\u0492\x07/\x02\x02\u0492 \x03\x02\x02\x02\u0493\u0494\x07" + - "1\x02\x02\u0494\"\x03\x02\x02\x02\u0495\u0496\x07`\x02\x02\u0496$\x03" + - "\x02\x02\x02\u0497\u0498\x07>\x02\x02\u0498&\x03\x02\x02\x02\u0499\u049A" + - "\x07@\x02\x02\u049A(\x03\x02\x02\x02\u049B\u049C\x07>\x02\x02\u049C\u049D" + - "\x07>\x02\x02\u049D*\x03\x02\x02\x02\u049E\u049F\x07@\x02\x02\u049F\u04A0" + - "\x07@\x02\x02\u04A0,\x03\x02\x02\x02\u04A1\u04A2\x07<\x02\x02\u04A2\u04A3" + - "\x07?\x02\x02\u04A3.\x03\x02\x02\x02\u04A4\u04A5\x07>\x02\x02\u04A5\u04A6" + - "\x07?\x02\x02\u04A60\x03\x02\x02\x02\u04A7\u04A8\x07?\x02\x02\u04A8\u04A9" + - "\x07@\x02\x02\u04A92\x03\x02\x02\x02\u04AA\u04AB\x07@\x02\x02\u04AB\u04AC" + - "\x07?\x02\x02\u04AC4\x03\x02\x02\x02\u04AD\u04AE\x070\x02\x02\u04AE\u04AF" + - "\x070\x02\x02\u04AF6\x03\x02\x02\x02\u04B0\u04B1\x07>\x02\x02\u04B1\u04B2" + - "\x07@\x02\x02\u04B28\x03\x02\x02\x02\u04B3\u04B4\x07<\x02\x02\u04B4\u04B5" + - "\x07<\x02\x02\u04B5:\x03\x02\x02\x02\u04B6\u04B7\x07\'\x02\x02\u04B7<" + - "\x03\x02\x02\x02\u04B8\u04BA\x07&\x02\x02\u04B9\u04BB\t\x02\x02\x02\u04BA" + - "\u04B9\x03\x02\x02\x02\u04BB\u04BC\x03\x02\x02\x02\u04BC\u04BA\x03\x02" + - "\x02\x02\u04BC\u04BD\x03\x02\x02\x02\u04BD>\x03\x02\x02\x02\u04BE\u04CE" + - "\x05C \x02\u04BF\u04C3\x07-"; + "\x02\x02\x02\x02\u02E9\x03\x02\x02\x02\x02\u02EB\x03\x02\x02\x02\x02\u02ED" + + "\x03\x02\x02\x02\x02\u02EF\x03\x02\x02\x02\x02\u02F1\x03\x02\x02\x02\x02" + + "\u02F3\x03\x02\x02\x02\x02\u02F5\x03\x02\x02\x02\x02\u02F7\x03\x02\x02" + + "\x02\x02\u02F9\x03\x02\x02\x02\x02\u02FB\x03\x02\x02\x02\x02\u02FD\x03" + + "\x02\x02\x02\x02\u02FF\x03\x02\x02\x02\x02\u0301\x03\x02\x02\x02\x02\u0303" + + "\x03\x02\x02\x02\x02\u0305\x03\x02\x02\x02\x02\u0307\x03\x02\x02\x02\x02" + + "\u0309\x03\x02\x02\x02\x02\u030B\x03\x02\x02\x02\x02\u030D\x03\x02\x02" + + "\x02\x02\u030F\x03\x02\x02\x02\x02\u0311\x03\x02\x02\x02\x02\u0313\x03" + + "\x02\x02\x02\x02\u0315\x03\x02\x02\x02\x02\u0317\x03\x02\x02\x02\x02\u0319" + + "\x03\x02\x02\x02\x02\u031B\x03\x02\x02\x02\x02\u031D\x03\x02\x02\x02\x02" + + "\u031F\x03\x02\x02\x02\x02\u0321\x03\x02\x02\x02\x02\u0323\x03\x02\x02" + + "\x02\x02\u0325\x03\x02\x02\x02\x02\u0327\x03\x02\x02\x02\x02\u0329\x03" + + "\x02\x02\x02\x02\u032B\x03\x02\x02\x02\x02\u032D\x03\x02\x02\x02\x02\u032F" + + "\x03\x02\x02\x02\x02\u0331\x03\x02\x02\x02\x02\u0333\x03\x02\x02\x02\x02" + + "\u0335\x03\x02\x02\x02\x02\u0337\x03\x02\x02\x02\x02\u0339\x03\x02\x02" + + "\x02\x02\u033B\x03\x02\x02\x02\x02\u033D\x03\x02\x02\x02\x02\u033F\x03" + + "\x02\x02\x02\x02\u0341\x03\x02\x02\x02\x02\u0343\x03\x02\x02\x02\x02\u0345" + + "\x03\x02\x02\x02\x02\u0347\x03\x02\x02\x02\x02\u0349\x03\x02\x02\x02\x02" + + "\u034B\x03\x02\x02\x02\x02\u034D\x03\x02\x02\x02\x02\u034F\x03\x02\x02" + + "\x02\x02\u0351\x03\x02\x02\x02\x02\u0353\x03\x02\x02\x02\x02\u0355\x03" + + "\x02\x02\x02\x02\u0357\x03\x02\x02\x02\x02\u0359\x03\x02\x02\x02\x02\u035B" + + "\x03\x02\x02\x02\x02\u035D\x03\x02\x02\x02\x02\u035F\x03\x02\x02\x02\x02" + + "\u0361\x03\x02\x02\x02\x02\u0363\x03\x02\x02\x02\x02\u0365\x03\x02\x02" + + "\x02\x02\u0367\x03\x02\x02\x02\x02\u0369\x03\x02\x02\x02\x02\u036B\x03" + + "\x02\x02\x02\x02\u036D\x03\x02\x02\x02\x02\u036F\x03\x02\x02\x02\x02\u0371" + + "\x03\x02\x02\x02\x02\u0373\x03\x02\x02\x02\x02\u0375\x03\x02\x02\x02\x02" + + "\u0377\x03\x02\x02\x02\x02\u0379\x03\x02\x02\x02\x02\u037B\x03\x02\x02" + + "\x02\x02\u037D\x03\x02\x02\x02\x02\u037F\x03\x02\x02\x02\x02\u0381\x03" + + "\x02\x02\x02\x02\u0383\x03\x02\x02\x02\x02\u0385\x03\x02\x02\x02\x02\u0387" + + "\x03\x02\x02\x02\x02\u0389\x03\x02\x02\x02\x02\u038B\x03\x02\x02\x02\x02" + + "\u038D\x03\x02\x02\x02\x02\u038F\x03\x02\x02\x02\x02\u0391\x03\x02\x02" + + "\x02\x02\u0393\x03\x02\x02\x02\x02\u0395\x03\x02\x02\x02\x02\u0397\x03" + + "\x02\x02\x02\x02\u0399\x03\x02\x02\x02\x02\u039B\x03\x02\x02\x02\x02\u039D" + + "\x03\x02\x02\x02\x02\u039F\x03\x02\x02\x02\x02\u03A1\x03\x02\x02\x02\x02" + + "\u03A3\x03\x02\x02\x02\x02\u03A5\x03\x02\x02\x02\x02\u03A7\x03\x02\x02" + + "\x02\x02\u03A9\x03\x02\x02\x02\x02\u03AB\x03\x02\x02\x02\x02\u03AD\x03" + + "\x02\x02\x02\x02\u03AF\x03\x02\x02\x02\x02\u03B1\x03\x02\x02\x02\x02\u03B3" + + "\x03\x02\x02\x02\x02\u03B5\x03\x02\x02\x02\x02\u03B7\x03\x02\x02\x02\x02" + + "\u03B9\x03\x02\x02\x02\x02\u03BB\x03\x02\x02\x02\x02\u03BD\x03\x02\x02" + + "\x02\x02\u03BF\x03\x02\x02\x02\x02\u03C1\x03\x02\x02\x02\x02\u03C3\x03" + + "\x02\x02\x02\x02\u03C5\x03\x02\x02\x02\x02\u03C7\x03\x02\x02\x02\x02\u03C9" + + "\x03\x02\x02\x02\x02\u03CB\x03\x02\x02\x02\x02\u03CD\x03\x02\x02\x02\x02" + + "\u03CF\x03\x02\x02\x02\x02\u03D1\x03\x02\x02\x02\x02\u03D3\x03\x02\x02" + + "\x02\x02\u03D5\x03\x02\x02\x02\x02\u03D7\x03\x02\x02\x02\x02\u03D9\x03" + + "\x02\x02\x02\x02\u03DB\x03\x02\x02\x02\x02\u03DD\x03\x02\x02\x02\x02\u03DF" + + "\x03\x02\x02\x02\x02\u03E1\x03\x02\x02\x02\x02\u03E3\x03\x02\x02\x02\x02" + + "\u03E5\x03\x02\x02\x02\x02\u03E7\x03\x02\x02\x02\x02\u03E9\x03\x02\x02" + + "\x02\x02\u03EB\x03\x02\x02\x02\x02\u03ED\x03\x02\x02\x02\x02\u03EF\x03" + + "\x02\x02\x02\x02\u03F1\x03\x02\x02\x02\x02\u03F3\x03\x02\x02\x02\x02\u03F5" + + "\x03\x02\x02\x02\x02\u03F7\x03\x02\x02\x02\x02\u03F9\x03\x02\x02\x02\x02" + + "\u03FB\x03\x02\x02\x02\x02\u03FD\x03\x02\x02\x02\x02\u03FF\x03\x02\x02" + + "\x02\x02\u0401\x03\x02\x02\x02\x02\u0403\x03\x02\x02\x02\x02\u0405\x03" + + "\x02\x02\x02\x02\u0407\x03\x02\x02\x02\x02\u0409\x03\x02\x02\x02\x02\u040B" + + "\x03\x02\x02\x02\x02\u040D\x03\x02\x02\x02\x02\u040F\x03\x02\x02\x02\x02" + + "\u0411\x03\x02\x02\x02\x02\u0413\x03\x02\x02\x02\x02\u0415\x03\x02\x02" + + "\x02\x02\u0417\x03\x02\x02\x02\x02\u0419\x03\x02\x02\x02\x02\u041B\x03" + + "\x02\x02\x02\x02\u041D\x03\x02\x02\x02\x02\u041F\x03\x02\x02\x02\x02\u0421" + + "\x03\x02\x02\x02\x02\u0423\x03\x02\x02\x02\x02\u0425\x03\x02\x02\x02\x02" + + "\u0427\x03\x02\x02\x02\x02\u042F\x03\x02\x02\x02\x02\u0431\x03\x02\x02" + + "\x02\x02\u0433\x03\x02\x02\x02\x02\u0435\x03\x02\x02\x02\x02\u0437\x03" + + "\x02\x02\x02\x02\u0439\x03\x02\x02\x02\x02\u043B\x03\x02\x02\x02\x02\u043D" + + "\x03\x02\x02\x02\x02\u043F\x03\x02\x02\x02\x02\u0441\x03\x02\x02\x02\x02" + + "\u0443\x03\x02\x02\x02\x02\u0445\x03\x02\x02\x02\x02\u0447\x03\x02\x02" + + "\x02\x02\u0449\x03\x02\x02\x02\x02\u044D\x03\x02\x02\x02\x02\u044F\x03" + + "\x02\x02\x02\x02\u0451\x03\x02\x02\x02\x02\u0453\x03\x02\x02\x02\x02\u0455" + + "\x03\x02\x02\x02\x02\u0457\x03\x02\x02\x02\x02\u0459\x03\x02\x02\x02\x02" + + "\u045B\x03\x02\x02\x02\x02\u045D\x03\x02\x02\x02\x02\u045F\x03\x02\x02" + + "\x02\x02\u0461\x03\x02\x02\x02\x02\u0465\x03\x02\x02\x02\x02\u0467\x03" + + "\x02\x02\x02\x02\u0469\x03\x02\x02\x02\x02\u046B\x03\x02\x02\x02\x02\u046D" + + "\x03\x02\x02\x02\x02\u046F\x03\x02\x02\x02\x02\u0471\x03\x02\x02\x02\x02" + + "\u0473\x03\x02\x02\x02\x02\u0475\x03\x02\x02\x02\x02\u0477\x03\x02\x02" + + "\x02\x03\u0479\x03\x02\x02\x02\x03\u047B\x03\x02\x02\x02\x03\u047F\x03" + + "\x02\x02\x02\x03\u0481\x03\x02\x02\x02\x04\u0485\x03\x02\x02\x02\x04\u0487" + + "\x03\x02\x02\x02\x05\u0489\x03\x02\x02\x02\x05\u048B\x03\x02\x02\x02\x05" + + "\u048D\x03\x02\x02\x02\x06\u048F\x03\x02\x02\x02\x06\u0491\x03\x02\x02" + + "\x02\x07\u0493\x03\x02\x02\x02\t\u0495\x03\x02\x02\x02\v\u0497\x03\x02" + + "\x02\x02\r\u0499\x03\x02\x02\x02\x0F\u049B\x03\x02\x02\x02\x11\u049D\x03" + + "\x02\x02\x02\x13\u049F\x03\x02\x02\x02\x15\u04A1\x03\x02\x02\x02\x17\u04A3" + + "\x03\x02\x02\x02\x19\u04A5\x03\x02\x02\x02\x1B\u04A7\x03\x02\x02\x02\x1D" + + "\u04A9\x03\x02\x02\x02\x1F\u04AB\x03\x02\x02\x02!\u04AD\x03\x02\x02\x02" + + "#\u04AF\x03\x02\x02\x02%\u04B1\x03\x02\x02\x02\'\u04B3\x03\x02\x02\x02" + + ")\u04B5\x03\x02\x02\x02+\u04B8\x03\x02\x02\x02-\u04BB\x03\x02\x02\x02" + + "/\u04BE\x03\x02\x02\x021\u04C1\x03\x02\x02\x023\u04C4\x03\x02\x02\x02" + + "5\u04C7\x03\x02\x02\x027\u04CA\x03\x02\x02\x029\u04CD\x03\x02\x02\x02" + + ";\u04D0\x03\x02\x02\x02=\u04D2\x03\x02\x02\x02?\u04EA\x03\x02\x02\x02" + + "A\u04F0\x03\x02\x02\x02C\u04FE\x03\x02\x02\x02E\u0500\x03\x02\x02\x02" + + "G\u0502\x03\x02\x02\x02I\u0504\x03\x02\x02\x02K\u0508\x03\x02\x02\x02" + + "M\u0510\x03\x02\x02\x02O\u0518\x03\x02\x02\x02Q\u051C\x03\x02\x02\x02" + + "S\u0520\x03\x02\x02\x02U\u0526\x03\x02\x02\x02W\u0529\x03\x02\x02\x02" + + "Y\u052D\x03\x02\x02\x02[\u0538\x03\x02\x02\x02]\u053D\x03\x02\x02\x02" + + "_\u0542\x03\x02\x02\x02a\u0547\x03\x02\x02\x02c\u054D\x03\x02\x02\x02" + + "e\u0555\x03\x02\x02\x02g\u055C\x03\x02\x02\x02i\u0567\x03\x02\x02\x02" + + "k\u056E\x03\x02\x02\x02m\u057E\x03\x02\x02\x02o\u058B\x03\x02\x02\x02" + + "q\u0598\x03\x02\x02\x02s\u05A5\x03\x02\x02\x02u\u05B7\x03\x02\x02\x02" + + "w\u05C4\x03\x02\x02\x02y\u05CC\x03\x02\x02\x02{\u05D7\x03\x02\x02\x02" + + "}\u05DC\x03\x02\x02\x02\x7F\u05E5\x03\x02\x02\x02\x81\u05E8\x03\x02\x02" + + "\x02\x83\u05ED\x03\x02\x02\x02\x85\u05F4\x03\x02\x02\x02\x87\u05FA\x03" + + "\x02\x02\x02\x89\u0600\x03\x02\x02\x02\x8B\u0604\x03\x02\x02\x02\x8D\u060C" + + "\x03\x02\x02\x02\x8F\u0611\x03\x02\x02\x02\x91\u0617\x03\x02\x02\x02\x93" + + "\u061D\x03\x02\x02\x02\x95\u0624\x03\x02\x02\x02\x97\u0627\x03\x02\x02" + + "\x02\x99\u0631\x03\x02\x02\x02\x9B\u063B\x03\x02\x02\x02\x9D\u0640\x03" + + "\x02\x02\x02\x9F\u0648\x03\x02\x02\x02\xA1\u0650\x03\x02\x02\x02\xA3\u0656" + + "\x03\x02\x02\x02\xA5\u0660\x03\x02\x02\x02\xA7\u066F\x03\x02\x02\x02\xA9" + + "\u0673\x03\x02\x02\x02\xAB\u0678\x03\x02\x02\x02\xAD\u067F\x03\x02\x02" + + "\x02\xAF\u0682\x03\x02\x02\x02\xB1\u0687\x03\x02\x02\x02\xB3\u068A\x03" + + "\x02\x02\x02\xB5\u0690\x03\x02\x02\x02\xB7\u0698\x03\x02\x02\x02\xB9\u06A0" + + "\x03\x02\x02\x02\xBB\u06AB\x03\x02\x02\x02\xBD\u06B5\x03\x02\x02\x02\xBF" + + "\u06BC\x03\x02\x02\x02\xC1\u06C9\x03\x02\x02\x02\xC3\u06CE\x03\x02\x02" + + "\x02\xC5\u06D8\x03\x02\x02\x02\xC7\u06DE\x03\x02\x02\x02\xC9\u06E3\x03" + + "\x02\x02\x02\xCB\u06E6\x03\x02\x02\x02\xCD\u06EF\x03\x02\x02\x02\xCF\u06F4" + + "\x03\x02\x02\x02\xD1\u06FA\x03\x02\x02\x02\xD3\u0701\x03\x02\x02\x02\xD5" + + "\u0706\x03\x02\x02\x02\xD7\u070C\x03\x02\x02\x02\xD9\u0715\x03\x02\x02" + + "\x02\xDB\u071A\x03\x02\x02\x02\xDD\u0720\x03\x02\x02\x02\xDF\u0727\x03" + + "\x02\x02\x02\xE1\u072C\x03\x02\x02\x02\xE3\u073A\x03\x02\x02\x02\xE5\u0741" + + "\x03\x02\x02\x02\xE7\u074B\x03\x02\x02\x02\xE9\u0758\x03\x02\x02\x02\xEB" + + "\u075E\x03\x02\x02\x02\xED\u076D\x03\x02\x02\x02\xEF\u0774\x03\x02\x02" + + "\x02\xF1\u0779\x03\x02\x02\x02\xF3\u077F\x03\x02\x02\x02\xF5\u0785\x03" + + "\x02\x02\x02\xF7\u0788\x03\x02\x02\x02\xF9\u078F\x03\x02\x02\x02\xFB\u0794" + + "\x03\x02\x02\x02\xFD\u0799\x03\x02\x02\x02\xFF\u079E\x03\x02\x02\x02\u0101" + + "\u07A6\x03\x02\x02\x02\u0103\u07AE\x03\x02\x02\x02\u0105\u07B4\x03\x02" + + "\x02\x02\u0107\u07B9\x03\x02\x02\x02\u0109\u07C2\x03\x02\x02\x02\u010B" + + "\u07C8\x03\x02\x02\x02\u010D\u07D0\x03\x02\x02\x02\u010F\u07D8\x03\x02" + + "\x02\x02\u0111\u07DE\x03\x02\x02\x02\u0113\u07E7\x03\x02\x02\x02\u0115" + + "\u07EE\x03\x02\x02\x02\u0117\u07F5\x03\x02\x02\x02\u0119\u07F9\x03\x02" + + "\x02\x02\u011B\u07FF\x03\x02\x02\x02\u011D\u0805\x03\x02\x02\x02\u011F" + + "\u080F\x03\x02\x02\x02\u0121\u0814\x03\x02\x02\x02\u0123\u081A\x03\x02" + + "\x02\x02\u0125\u0821\x03\x02\x02\x02\u0127\u082B\x03\x02\x02\x02\u0129" + + "\u0836\x03\x02\x02\x02\u012B\u0839\x03\x02\x02\x02\u012D\u0843\x03\x02" + + "\x02\x02\u012F\u084C\x03\x02\x02\x02\u0131\u0853\x03\x02\x02\x02\u0133" + + "\u0859\x03\x02\x02\x02\u0135\u085C\x03\x02\x02\x02\u0137\u0862\x03\x02" + + "\x02\x02\u0139\u0869\x03\x02\x02\x02\u013B\u0871\x03\x02\x02\x02\u013D" + + "\u087A\x03\x02\x02\x02\u013F\u0882\x03\x02\x02\x02\u0141\u0888\x03\x02" + + "\x02\x02\u0143\u0898\x03\x02\x02\x02\u0145\u08A3\x03\x02\x02\x02\u0147" + + "\u08A9\x03\x02\x02\x02\u0149\u08AF\x03\x02\x02\x02\u014B\u08B7\x03\x02" + + "\x02\x02\u014D\u08BF\x03\x02\x02\x02\u014F\u08C8\x03\x02\x02\x02\u0151" + + "\u08CF\x03\x02\x02\x02\u0153\u08D9\x03\x02\x02\x02\u0155\u08E7\x03\x02" + + "\x02\x02\u0157\u08F2\x03\x02\x02\x02\u0159\u08FE\x03\x02\x02\x02\u015B" + + "\u0906\x03\x02\x02\x02\u015D\u090F\x03\x02\x02\x02\u015F\u091A\x03\x02" + + "\x02\x02\u0161\u091F\x03\x02\x02\x02\u0163\u0924\x03\x02\x02\x02\u0165" + + "\u0928\x03\x02\x02\x02\u0167\u092F\x03\x02\x02\x02\u0169\u0935\x03\x02" + + "\x02\x02\u016B\u093A\x03\x02\x02\x02\u016D\u0943\x03\x02\x02\x02\u016F" + + "\u0947\x03\x02\x02\x02\u0171\u0952\x03\x02\x02\x02\u0173\u095A\x03\x02" + + "\x02\x02\u0175\u0963\x03\x02\x02\x02\u0177\u096C\x03\x02\x02\x02\u0179" + + "\u0974\x03\x02\x02\x02\u017B\u097B\x03\x02\x02\x02\u017D\u0985\x03\x02" + + "\x02\x02\u017F\u0990\x03\x02\x02\x02\u0181\u099B\x03\x02\x02\x02\u0183" + + "\u09A3\x03\x02\x02\x02\u0185\u09AB\x03\x02\x02\x02\u0187\u09B4\x03\x02" + + "\x02\x02\u0189\u09BB\x03\x02\x02\x02\u018B\u09C2\x03\x02\x02\x02\u018D" + + "\u09C7\x03\x02\x02\x02\u018F\u09CC\x03\x02\x02\x02\u0191\u09D3\x03\x02" + + "\x02\x02\u0193\u09DC\x03\x02\x02\x02\u0195\u09E6\x03\x02\x02\x02\u0197" + + "\u09EB\x03\x02\x02\x02\u0199\u09F2\x03\x02\x02\x02\u019B\u09F8\x03\x02" + + "\x02\x02\u019D\u0A00\x03\x02\x02\x02\u019F\u0A0A\x03\x02\x02\x02\u01A1" + + "\u0A14\x03\x02\x02\x02\u01A3\u0A1C\x03\x02\x02\x02\u01A5\u0A24\x03\x02" + + "\x02\x02\u01A7\u0A2E\x03\x02\x02\x02\u01A9\u0A37\x03\x02\x02\x02\u01AB" + + "\u0A3E\x03\x02\x02\x02\u01AD\u0A44\x03\x02\x02\x02\u01AF\u0A4E\x03\x02" + + "\x02\x02\u01B1\u0A54\x03\x02\x02\x02\u01B3\u0A5C\x03\x02\x02\x02\u01B5" + + "\u0A65\x03\x02\x02\x02\u01B7\u0A6F\x03\x02\x02\x02\u01B9\u0A76\x03\x02" + + "\x02\x02\u01BB\u0A7E\x03\x02\x02\x02\u01BD\u0A86\x03\x02\x02\x02\u01BF" + + "\u0A8D\x03\x02\x02\x02\u01C1\u0A92\x03\x02\x02\x02\u01C3\u0A97\x03\x02" + + "\x02\x02\u01C5\u0AA0\x03\x02\x02\x02\u01C7\u0AA3\x03\x02\x02\x02\u01C9" + + "\u0AAD\x03\x02\x02\x02\u01CB\u0AB7\x03\x02\x02\x02\u01CD\u0AC0\x03\x02" + + "\x02\x02\u01CF\u0ACA\x03\x02\x02\x02\u01D1\u0AD4\x03\x02\x02\x02\u01D3" + + "\u0ADA\x03\x02\x02\x02\u01D5\u0AE2\x03\x02\x02\x02\u01D7\u0AEA\x03\x02" + + "\x02\x02\u01D9\u0AF4\x03\x02\x02\x02\u01DB\u0AFE\x03\x02\x02\x02\u01DD" + + "\u0B0A\x03\x02\x02\x02\u01DF\u0B13\x03\x02\x02\x02\u01E1\u0B1E\x03\x02" + + "\x02\x02\u01E3\u0B29\x03\x02\x02\x02\u01E5\u0B36\x03\x02\x02\x02\u01E7" + + "\u0B41\x03\x02\x02\x02\u01E9\u0B4E\x03\x02\x02\x02\u01EB\u0B57\x03\x02" + + "\x02\x02\u01ED\u0B5E\x03\x02\x02\x02\u01EF\u0B6A\x03\x02\x02\x02\u01F1" + + "\u0B71\x03\x02\x02\x02\u01F3\u0B79\x03\x02\x02\x02\u01F5\u0B81\x03\x02" + + "\x02\x02\u01F7\u0B8B\x03\x02\x02\x02\u01F9\u0B8F\x03\x02\x02\x02\u01FB" + + "\u0B95\x03\x02\x02\x02\u01FD\u0B9E\x03\x02\x02\x02\u01FF\u0BA4\x03\x02" + + "\x02\x02\u0201\u0BA9\x03\x02\x02\x02\u0203\u0BB3\x03\x02\x02\x02\u0205" + + "\u0BB9\x03\x02\x02\x02\u0207\u0BC0\x03\x02\x02\x02\u0209\u0BC5\x03\x02" + + "\x02\x02\u020B\u0BCB\x03\x02\x02\x02\u020D\u0BD4\x03\x02\x02\x02\u020F" + + "\u0BD9\x03\x02\x02\x02\u0211\u0BE1\x03\x02\x02\x02\u0213\u0BE7\x03\x02" + + "\x02\x02\u0215\u0BF4\x03\x02\x02\x02\u0217\u0BFD\x03\x02\x02\x02\u0219" + + "\u0C04\x03\x02\x02\x02\u021B\u0C0D\x03\x02\x02\x02\u021D\u0C12\x03\x02" + + "\x02\x02\u021F\u0C18\x03\x02\x02\x02\u0221\u0C1D\x03\x02\x02\x02\u0223" + + "\u0C22\x03\x02\x02\x02\u0225\u0C28\x03\x02\x02\x02\u0227\u0C2D\x03\x02" + + "\x02\x02\u0229\u0C30\x03\x02\x02\x02\u022B\u0C38\x03\x02\x02\x02\u022D" + + "\u0C3F\x03\x02\x02\x02\u022F\u0C46\x03\x02\x02\x02\u0231\u0C4C\x03\x02" + + "\x02\x02\u0233\u0C53\x03\x02\x02\x02\u0235\u0C56\x03\x02\x02\x02\u0237" + + "\u0C5A\x03\x02\x02\x02\u0239\u0C5F\x03\x02\x02\x02\u023B\u0C68\x03\x02" + + "\x02\x02\u023D\u0C6F\x03\x02\x02\x02\u023F\u0C77\x03\x02\x02\x02\u0241" + + "\u0C7D\x03\x02\x02\x02\u0243\u0C83\x03\x02\x02\x02\u0245\u0C8A\x03\x02" + + "\x02\x02\u0247\u0C92\x03\x02\x02\x02\u0249\u0C9C\x03\x02\x02\x02\u024B" + + "\u0CA4\x03\x02\x02\x02\u024D\u0CAD\x03\x02\x02\x02\u024F\u0CB3\x03\x02" + + "\x02\x02\u0251\u0CBD\x03\x02\x02\x02\u0253\u0CC5\x03\x02\x02\x02\u0255" + + "\u0CCE\x03\x02\x02\x02\u0257\u0CD7\x03\x02\x02\x02\u0259\u0CDD\x03\x02" + + "\x02\x02\u025B\u0CE8\x03\x02\x02\x02\u025D\u0CF3\x03\x02\x02\x02\u025F" + + "\u0CFD\x03\x02\x02\x02\u0261\u0D05\x03\x02\x02\x02\u0263\u0D0B\x03\x02" + + "\x02\x02\u0265\u0D11\x03\x02\x02\x02\u0267\u0D16\x03\x02\x02\x02\u0269" + + "\u0D1F\x03\x02\x02\x02\u026B\u0D27\x03\x02\x02\x02\u026D\u0D31\x03\x02" + + "\x02\x02\u026F\u0D35\x03\x02\x02\x02\u0271\u0D3D\x03\x02\x02\x02\u0273" + + "\u0D45\x03\x02\x02\x02\u0275\u0D4E\x03\x02\x02\x02\u0277\u0D56\x03\x02" + + "\x02\x02\u0279\u0D5D\x03\x02\x02\x02\u027B\u0D68\x03\x02\x02\x02\u027D" + + "\u0D70\x03\x02\x02\x02\u027F\u0D78\x03\x02\x02\x02\u0281\u0D7E\x03\x02" + + "\x02\x02\u0283\u0D86\x03\x02\x02\x02\u0285\u0D8F\x03\x02\x02\x02\u0287" + + "\u0D97\x03\x02\x02\x02\u0289\u0D9E\x03\x02\x02\x02\u028B\u0DA3\x03\x02" + + "\x02\x02\u028D\u0DAC\x03\x02\x02\x02\u028F\u0DB1\x03\x02\x02\x02\u0291" + + "\u0DB6\x03\x02\x02\x02\u0293\u0DC0\x03\x02\x02\x02\u0295\u0DC7\x03\x02" + + "\x02\x02\u0297\u0DCE\x03\x02\x02\x02\u0299\u0DD5\x03\x02\x02\x02\u029B" + + "\u0DDC\x03\x02\x02\x02\u029D\u0DE5\x03\x02\x02\x02\u029F\u0DEE\x03\x02" + + "\x02\x02\u02A1\u0DF8\x03\x02\x02\x02\u02A3\u0E05\x03\x02\x02\x02\u02A5" + + "\u0E0C\x03\x02\x02\x02\u02A7\u0E14\x03\x02\x02\x02\u02A9\u0E18\x03\x02" + + "\x02\x02\u02AB\u0E1E\x03\x02\x02\x02\u02AD\u0E23\x03\x02\x02\x02\u02AF" + + "\u0E2A\x03\x02\x02\x02\u02B1\u0E33\x03\x02\x02\x02\u02B3\u0E3A\x03\x02" + + "\x02\x02\u02B5\u0E45\x03\x02\x02\x02\u02B7\u0E4B\x03\x02\x02\x02\u02B9" + + "\u0E55\x03\x02\x02\x02\u02BB\u0E60\x03\x02\x02\x02\u02BD\u0E66\x03\x02" + + "\x02\x02\u02BF\u0E6D\x03\x02\x02\x02\u02C1\u0E75\x03\x02\x02\x02\u02C3" + + "\u0E7C\x03\x02\x02\x02\u02C5\u0E82\x03\x02\x02\x02\u02C7\u0E88\x03\x02" + + "\x02\x02\u02C9\u0E8F\x03\x02\x02\x02\u02CB\u0E96\x03\x02\x02\x02\u02CD" + + "\u0EA1\x03\x02\x02\x02\u02CF\u0EA6\x03\x02\x02\x02\u02D1\u0EAF\x03\x02" + + "\x02\x02\u02D3\u0EB9\x03\x02\x02\x02\u02D5\u0EBE\x03\x02\x02\x02\u02D7" + + "\u0ECA\x03\x02\x02\x02\u02D9\u0ED2\x03\x02\x02\x02\u02DB\u0EDB\x03\x02" + + "\x02\x02\u02DD\u0EE3\x03\x02\x02\x02\u02DF\u0EE8\x03\x02\x02\x02\u02E1" + + "\u0EEE\x03\x02\x02\x02\u02E3\u0EF8\x03\x02\x02\x02\u02E5\u0F04\x03\x02" + + "\x02\x02\u02E7\u0F10\x03\x02\x02\x02\u02E9\u0F18\x03\x02\x02\x02\u02EB" + + "\u0F21\x03\x02\x02\x02\u02ED\u0F2A\x03\x02\x02\x02\u02EF\u0F30\x03\x02" + + "\x02\x02\u02F1\u0F37\x03\x02\x02\x02\u02F3\u0F3E\x03\x02\x02\x02\u02F5" + + "\u0F44\x03\x02\x02\x02\u02F7\u0F4D\x03\x02\x02\x02\u02F9\u0F57\x03\x02" + + "\x02\x02\u02FB\u0F5F\x03\x02\x02\x02\u02FD\u0F67\x03\x02\x02\x02\u02FF" + + "\u0F6C\x03\x02\x02\x02\u0301\u0F75\x03\x02\x02\x02\u0303\u0F80\x03\x02" + + "\x02\x02\u0305\u0F88\x03\x02\x02\x02\u0307\u0F8D\x03\x02\x02\x02\u0309" + + "\u0F95\x03\x02\x02\x02\u030B\u0F9B\x03\x02\x02\x02\u030D\u0F9F\x03\x02" + + "\x02\x02\u030F\u0FA4\x03\x02\x02\x02\u0311\u0FA8\x03\x02\x02\x02\u0313" + + "\u0FAD\x03\x02\x02\x02\u0315\u0FB5\x03\x02\x02\x02\u0317\u0FBC\x03\x02" + + "\x02\x02\u0319\u0FC0\x03\x02\x02\x02\u031B\u0FC8\x03\x02\x02\x02\u031D" + + "\u0FCD\x03\x02\x02\x02\u031F\u0FD7\x03\x02\x02\x02\u0321\u0FE0\x03\x02" + + "\x02\x02\u0323\u0FE4\x03\x02\x02\x02\u0325\u0FEC\x03\x02\x02\x02\u0327" + + "\u0FF3\x03\x02\x02\x02\u0329\u0FFB\x03\x02\x02\x02\u032B\u1001\x03\x02" + + "\x02\x02\u032D\u100A\x03\x02\x02\x02\u032F\u1010\x03\x02\x02\x02\u0331" + + "\u1014\x03\x02\x02\x02\u0333\u101C\x03\x02\x02\x02\u0335\u1025\x03\x02" + + "\x02\x02\u0337\u102B\x03\x02\x02\x02\u0339\u1034\x03\x02\x02\x02\u033B" + + "\u103A\x03\x02\x02\x02\u033D\u103F\x03\x02\x02\x02\u033F\u1046\x03\x02" + + "\x02\x02\u0341\u104E\x03\x02\x02\x02\u0343\u1056\x03\x02\x02\x02\u0345" + + "\u105F\x03\x02\x02\x02\u0347\u1069\x03\x02\x02\x02\u0349\u106E\x03\x02" + + "\x02\x02\u034B\u1072\x03\x02\x02\x02\u034D\u1078\x03\x02\x02\x02\u034F" + + "\u1081\x03\x02\x02\x02\u0351\u108B\x03\x02\x02\x02\u0353\u1090\x03\x02" + + "\x02\x02\u0355\u109A\x03\x02\x02\x02\u0357\u10A0\x03\x02\x02\x02\u0359" + + "\u10A5\x03\x02\x02\x02\u035B\u10AC\x03\x02\x02\x02\u035D\u10B4\x03\x02" + + "\x02\x02\u035F\u10C2\x03\x02\x02\x02\u0361\u10CC\x03\x02\x02\x02\u0363" + + "\u10D7\x03\x02\x02\x02\u0365\u10E1\x03\x02\x02\x02\u0367\u10EB\x03\x02" + + "\x02\x02\u0369\u10F4\x03\x02\x02\x02\u036B\u10FA\x03\x02\x02\x02\u036D" + + "\u1102\x03\x02\x02\x02\u036F\u110F\x03\x02\x02\x02\u0371\u1114\x03\x02" + + "\x02\x02\u0373\u111C\x03\x02\x02\x02\u0375\u1123\x03\x02\x02\x02\u0377" + + "\u112A\x03\x02\x02\x02\u0379\u1135\x03\x02\x02\x02\u037B\u113F\x03\x02" + + "\x02\x02\u037D\u1146\x03\x02\x02\x02\u037F\u114D\x03\x02\x02\x02\u0381" + + "\u1155\x03\x02\x02\x02\u0383\u115D\x03\x02\x02\x02\u0385\u1167\x03\x02" + + "\x02\x02\u0387\u116E\x03\x02\x02\x02\u0389\u1175\x03\x02\x02\x02\u038B" + + "\u117C\x03\x02\x02\x02\u038D\u1188\x03\x02\x02\x02\u038F\u118C\x03\x02" + + "\x02\x02\u0391\u1190\x03\x02\x02\x02\u0393\u1196\x03\x02\x02\x02\u0395" + + "\u11A3\x03\x02\x02\x02\u0397\u11AF\x03\x02\x02\x02\u0399\u11B3\x03\x02" + + "\x02\x02\u039B\u11B7\x03\x02\x02\x02\u039D\u11C0\x03\x02\x02\x02\u039F" + + "\u11C8\x03\x02\x02\x02\u03A1\u11D3\x03\x02\x02\x02\u03A3\u11D9\x03\x02" + + "\x02\x02\u03A5\u11E1\x03\x02\x02\x02\u03A7\u11EA\x03\x02\x02\x02\u03A9" + + "\u11EE\x03\x02\x02\x02\u03AB\u11F6\x03\x02\x02\x02\u03AD\u1201\x03\x02" + + "\x02\x02\u03AF\u120A\x03\x02\x02\x02\u03B1\u120F\x03\x02\x02\x02\u03B3" + + "\u1216\x03\x02\x02\x02\u03B5\u121B\x03\x02\x02\x02\u03B7\u1222\x03\x02" + + "\x02\x02\u03B9\u1227\x03\x02\x02\x02\u03BB\u1230\x03\x02\x02\x02\u03BD" + + "\u1235\x03\x02\x02\x02\u03BF\u1241\x03\x02\x02\x02\u03C1\u124C\x03\x02" + + "\x02\x02\u03C3\u1255\x03\x02\x02\x02\u03C5\u125D\x03\x02\x02\x02\u03C7" + + "\u126B\x03\x02\x02\x02\u03C9\u1273\x03\x02\x02\x02\u03CB\u127E\x03\x02" + + "\x02\x02\u03CD\u1285\x03\x02\x02\x02\u03CF\u128C\x03\x02\x02\x02\u03D1" + + "\u1293\x03\x02\x02\x02\u03D3\u129A\x03\x02\x02\x02\u03D5\u129E\x03\x02" + + "\x02\x02\u03D7\u12A2\x03\x02\x02\x02\u03D9\u12A7\x03\x02\x02\x02\u03DB" + + "\u12AC\x03\x02\x02\x02\u03DD\u12B4\x03\x02\x02\x02\u03DF\u12BA\x03\x02" + + "\x02\x02\u03E1\u12C4\x03\x02\x02\x02\u03E3\u12C9\x03\x02\x02\x02\u03E5" + + "\u12DD\x03\x02\x02\x02\u03E7\u12EF\x03\x02\x02\x02\u03E9\u12F5\x03\x02" + + "\x02\x02\u03EB\u1302\x03\x02\x02\x02\u03ED\u130D\x03\x02\x02\x02\u03EF" + + "\u1313\x03\x02\x02\x02\u03F1\u131C\x03\x02\x02\x02\u03F3\u1324\x03\x02" + + "\x02\x02\u03F5\u1328\x03\x02\x02\x02\u03F7\u1334\x03\x02\x02\x02\u03F9" + + "\u133C\x03\x02\x02\x02\u03FB\u1342\x03\x02\x02\x02\u03FD\u1348\x03\x02" + + "\x02\x02\u03FF\u1350\x03\x02\x02\x02\u0401\u1358\x03\x02\x02\x02\u0403" + + "\u135E\x03\x02\x02\x02\u0405\u1363\x03\x02\x02\x02\u0407\u136A\x03\x02" + + "\x02\x02\u0409\u1370\x03\x02\x02\x02\u040B\u1376\x03\x02\x02\x02\u040D" + + "\u137F\x03\x02\x02\x02\u040F\u1385\x03\x02\x02\x02\u0411\u1389\x03\x02" + + "\x02\x02\u0413\u138E\x03\x02\x02\x02\u0415\u1395\x03\x02\x02\x02\u0417" + + "\u139D\x03\x02\x02\x02\u0419\u13A7\x03\x02\x02\x02\u041B\u13AE\x03\x02" + + "\x02\x02\u041D\u13B3\x03\x02\x02\x02\u041F\u13B8\x03\x02\x02\x02\u0421" + + "\u13C3\x03\x02\x02\x02\u0423\u13C9\x03\x02\x02\x02\u0425\u13D1\x03\x02" + + "\x02\x02\u0427\u13D8\x03\x02\x02\x02\u0429\u13E2\x03\x02\x02\x02\u042B" + + "\u13E6\x03\x02\x02\x02\u042D\u13EA\x03\x02\x02\x02\u042F\u13EC\x03\x02" + + "\x02\x02\u0431\u13EF\x03\x02\x02\x02\u0433\u13F8\x03\x02\x02\x02\u0435" + + "\u13FB\x03\x02\x02\x02\u0437\u1404\x03\x02\x02\x02\u0439\u1408\x03\x02" + + "\x02\x02\u043B\u140C\x03\x02\x02\x02\u043D\u1410\x03\x02\x02\x02\u043F" + + "\u1414\x03\x02\x02\x02\u0441\u1417\x03\x02\x02\x02\u0443\u1420\x03\x02" + + "\x02\x02\u0445\u1426\x03\x02\x02\x02\u0447\u1429\x03\x02\x02\x02\u0449" + + "\u142D\x03\x02\x02\x02\u044B\u1435\x03\x02\x02\x02\u044D\u143C\x03\x02" + + "\x02\x02\u044F\u143F\x03\x02\x02\x02\u0451\u1447\x03\x02\x02\x02\u0453" + + "\u144A\x03\x02\x02\x02\u0455\u144D\x03\x02\x02\x02\u0457\u1450\x03\x02" + + "\x02\x02\u0459\u1458\x03\x02\x02\x02\u045B\u145B\x03\x02\x02\x02\u045D" + + "\u145E\x03\x02\x02\x02\u045F\u1460\x03\x02\x02\x02\u0461\u1480\x03\x02" + + "\x02\x02\u0463\u1483\x03\x02\x02\x02\u0465\u1487\x03\x02\x02\x02\u0467" + + "\u148F\x03\x02\x02\x02\u0469\u149F\x03\x02\x02\x02\u046B\u14AA\x03\x02" + + "\x02\x02\u046D\u14AE\x03\x02\x02\x02\u046F\u14B9\x03\x02\x02\x02\u0471" + + "\u14E0\x03\x02\x02\x02\u0473\u1511\x03\x02\x02\x02\u0475\u1529\x03\x02" + + "\x02\x02\u0477\u152C\x03\x02\x02\x02\u0479\u152E\x03\x02\x02\x02\u047B" + + "\u1533\x03\x02\x02\x02\u047D\u1552\x03\x02\x02\x02\u047F\u1555\x03\x02" + + "\x02\x02\u0481\u155A\x03\x02\x02\x02\u0483\u1567\x03\x02"; private static readonly _serializedATNSegment4: string = - "\x02\x02\u04C0\u04C1\x07/\x02\x02\u04C1\u04C3\x06\x1E\x02\x02\u04C2\u04BF" + - "\x03\x02\x02\x02\u04C2\u04C0\x03\x02\x02\x02\u04C3\u04C4\x03\x02\x02\x02" + - "\u04C4\u04C2\x03\x02\x02\x02\u04C4\u04C5\x03\x02\x02\x02\u04C5\u04C9\x03" + - "\x02\x02\x02\u04C6\u04CA\x05C \x02\u04C7\u04C8\x071\x02\x02\u04C8\u04CA" + - "\x06\x1E\x03\x02\u04C9\u04C6\x03\x02\x02\x02\u04C9\u04C7\x03\x02\x02\x02" + - "\u04CA\u04CE\x03\x02\x02\x02\u04CB\u04CC\x071\x02\x02\u04CC\u04CE\x06" + - "\x1E\x04\x02\u04CD\u04BE\x03\x02\x02\x02\u04CD\u04C2\x03\x02\x02\x02\u04CD" + - "\u04CB\x03\x02\x02\x02\u04CE\u04CF\x03\x02\x02\x02\u04CF\u04CD\x03\x02" + - "\x02\x02\u04CF\u04D0\x03\x02\x02\x02\u04D0\u04D3\x03\x02\x02\x02\u04D1" + - "\u04D3\t\x03\x02\x02\u04D2\u04CD\x03\x02\x02\x02\u04D2\u04D1\x03\x02\x02" + - "\x02\u04D3\u04D4\x03\x02\x02\x02\u04D4\u04D5\b\x1E\x02\x02\u04D5@\x03" + - "\x02\x02\x02\u04D6\u04DC\x05E!\x02\u04D7\u04D8\x07/\x02\x02\u04D8\u04DC" + - "\x06\x1F\x05\x02\u04D9\u04DA\x071\x02\x02\u04DA\u04DC\x06\x1F\x06\x02" + - "\u04DB\u04D6\x03\x02\x02\x02\u04DB\u04D7\x03\x02\x02\x02\u04DB\u04D9\x03" + - "\x02\x02\x02\u04DC\u04DF\x03\x02\x02\x02\u04DD\u04DB\x03\x02\x02\x02\u04DD" + - "\u04DE\x03\x02\x02\x02\u04DE\u04E0\x03\x02\x02\x02\u04DF\u04DD\x03\x02" + - "\x02\x02\u04E0\u04E2\x05G\"\x02\u04E1\u04E3\x05?\x1E\x02\u04E2\u04E1\x03" + - "\x02\x02\x02\u04E2\u04E3\x03\x02\x02\x02\u04E3\u04E7\x03\x02\x02\x02\u04E4" + - "\u04E8\x07-\x02\x02\u04E5\u04E6\x07/\x02\x02\u04E6\u04E8\x06\x1F\x07\x02" + - "\u04E7\u04E4\x03\x02\x02\x02\u04E7\u04E5\x03\x02\x02\x02\u04E8\u04E9\x03" + - "\x02\x02\x02\u04E9\u04E7\x03\x02\x02\x02\u04E9\u04EA\x03\x02\x02\x02\u04EA" + - "\u04EB\x03\x02\x02\x02\u04EB\u04EC\b\x1F\x03\x02\u04ECB\x03\x02\x02\x02" + - "\u04ED\u04EE\t\x04\x02\x02\u04EED\x03\x02\x02\x02\u04EF\u04F0\t\x05\x02" + - "\x02\u04F0F\x03\x02\x02\x02\u04F1\u04F2\t\x06\x02\x02\u04F2H\x03\x02\x02" + - "\x02\u04F3\u04F4\x07C\x02\x02\u04F4\u04F5\x07N\x02\x02\u04F5\u04F6\x07" + - "N\x02\x02\u04F6J\x03\x02\x02\x02\u04F7\u04F8\x07C\x02\x02\u04F8\u04F9" + - "\x07P\x02\x02\u04F9\u04FA\x07C\x02\x02\u04FA\u04FB\x07N\x02\x02\u04FB" + - "\u04FC\x07[\x02\x02\u04FC\u04FD\x07U\x02\x02\u04FD\u04FE\x07G\x02\x02" + - "\u04FEL\x03\x02\x02\x02\u04FF\u0500\x07C\x02\x02\u0500\u0501\x07P\x02" + - "\x02\u0501\u0502\x07C\x02\x02\u0502\u0503\x07N\x02\x02\u0503\u0504\x07" + - "[\x02\x02\u0504\u0505\x07\\\x02\x02\u0505\u0506\x07G\x02\x02\u0506N\x03" + - "\x02\x02\x02\u0507\u0508\x07C\x02\x02\u0508\u0509\x07P\x02\x02\u0509\u050A" + - "\x07F\x02\x02\u050AP\x03\x02\x02\x02\u050B\u050C\x07C\x02\x02\u050C\u050D" + - "\x07P\x02\x02\u050D\u050E\x07[\x02\x02\u050ER\x03\x02\x02\x02\u050F\u0510" + - "\x07C\x02\x02\u0510\u0511\x07T\x02\x02\u0511\u0512\x07T\x02\x02\u0512" + - "\u0513\x07C\x02\x02\u0513\u0514\x07[\x02\x02\u0514T\x03\x02\x02\x02\u0515" + - "\u0516\x07C\x02\x02\u0516\u0517\x07U\x02\x02\u0517V\x03\x02\x02\x02\u0518" + - "\u0519\x07C\x02\x02\u0519\u051A\x07U\x02\x02\u051A\u051B\x07E\x02\x02" + - "\u051BX\x03\x02\x02\x02\u051C\u051D\x07C\x02\x02\u051D\u051E\x07U\x02" + - "\x02\u051E\u051F\x07[\x02\x02\u051F\u0520\x07O\x02\x02\u0520\u0521\x07" + - "O\x02\x02\u0521\u0522\x07G\x02\x02\u0522\u0523\x07V\x02\x02\u0523\u0524" + - "\x07T\x02\x02\u0524\u0525\x07K\x02\x02\u0525\u0526\x07E\x02\x02\u0526" + - "Z\x03\x02\x02\x02\u0527\u0528\x07D\x02\x02\u0528\u0529\x07Q\x02\x02\u0529" + - "\u052A\x07V\x02\x02\u052A\u052B\x07J\x02\x02\u052B\\\x03\x02\x02\x02\u052C" + - "\u052D\x07E\x02\x02\u052D\u052E\x07C\x02\x02\u052E\u052F\x07U\x02\x02" + - "\u052F\u0530\x07G\x02\x02\u0530^\x03\x02\x02\x02\u0531\u0532\x07E\x02" + - "\x02\u0532\u0533\x07C\x02\x02\u0533\u0534\x07U\x02\x02\u0534\u0535\x07" + - "V\x02\x02\u0535`\x03\x02\x02\x02\u0536\u0537\x07E\x02\x02\u0537\u0538" + - "\x07J\x02\x02\u0538\u0539\x07G\x02\x02\u0539\u053A\x07E\x02\x02\u053A" + - "\u053B\x07M\x02\x02\u053Bb\x03\x02\x02\x02\u053C\u053D\x07E\x02\x02\u053D" + - "\u053E\x07Q\x02\x02\u053E\u053F\x07N\x02\x02\u053F\u0540\x07N\x02\x02" + - "\u0540\u0541\x07C\x02\x02\u0541\u0542\x07V\x02\x02\u0542\u0543\x07G\x02" + - "\x02\u0543d\x03\x02\x02\x02\u0544\u0545\x07E\x02\x02\u0545\u0546\x07Q" + - "\x02\x02\u0546\u0547\x07N\x02\x02\u0547\u0548\x07W\x02\x02\u0548\u0549" + - "\x07O\x02\x02\u0549\u054A\x07P\x02\x02\u054Af\x03\x02\x02\x02\u054B\u054C" + - "\x07E\x02\x02\u054C\u054D\x07Q\x02\x02\u054D\u054E\x07P\x02\x02\u054E" + - "\u054F\x07U\x02\x02\u054F\u0550\x07V\x02\x02\u0550\u0551\x07T\x02\x02" + - "\u0551\u0552\x07C\x02\x02\u0552\u0553\x07K\x02\x02\u0553\u0554\x07P\x02" + - "\x02\u0554\u0555\x07V\x02\x02\u0555h\x03\x02\x02\x02\u0556\u0557\x07E" + - "\x02\x02\u0557\u0558\x07T\x02\x02\u0558\u0559\x07G\x02\x02\u0559\u055A" + - "\x07C\x02\x02\u055A\u055B\x07V\x02\x02\u055B\u055C\x07G\x02\x02\u055C" + - "j\x03\x02\x02\x02\u055D\u055E\x07E\x02\x02\u055E\u055F\x07W\x02\x02\u055F" + - "\u0560\x07T\x02\x02\u0560\u0561\x07T\x02\x02\u0561\u0562\x07G\x02\x02" + - "\u0562\u0563\x07P\x02\x02\u0563\u0564\x07V\x02\x02\u0564\u0565\x07a\x02" + - "\x02\u0565\u0566\x07E\x02\x02\u0566\u0567\x07C\x02\x02\u0567\u0568\x07" + - "V\x02\x02\u0568\u0569\x07C\x02\x02\u0569\u056A\x07N\x02\x02\u056A\u056B" + - "\x07Q\x02\x02\u056B\u056C\x07I\x02\x02\u056Cl\x03\x02\x02\x02\u056D\u056E" + - "\x07E\x02\x02\u056E\u056F\x07W\x02\x02\u056F\u0570\x07T\x02\x02\u0570" + - "\u0571\x07T\x02\x02\u0571\u0572\x07G\x02\x02\u0572\u0573\x07P\x02\x02" + - "\u0573\u0574\x07V\x02\x02\u0574\u0575\x07a\x02\x02\u0575\u0576\x07F\x02" + - "\x02\u0576\u0577\x07C\x02\x02\u0577\u0578\x07V\x02\x02\u0578\u0579\x07" + - "G\x02\x02\u0579n\x03\x02\x02\x02\u057A\u057B\x07E\x02\x02\u057B\u057C" + - "\x07W\x02\x02\u057C\u057D\x07T\x02\x02\u057D\u057E\x07T\x02\x02\u057E" + - "\u057F\x07G\x02\x02\u057F\u0580\x07P\x02\x02\u0580\u0581\x07V\x02\x02" + - "\u0581\u0582\x07a\x02\x02\u0582\u0583\x07T\x02\x02\u0583\u0584\x07Q\x02" + - "\x02\u0584\u0585\x07N\x02\x02\u0585\u0586\x07G\x02\x02\u0586p\x03\x02" + - "\x02\x02\u0587\u0588\x07E\x02\x02\u0588\u0589\x07W\x02\x02\u0589\u058A" + - "\x07T\x02\x02\u058A\u058B\x07T\x02\x02\u058B\u058C\x07G\x02\x02\u058C" + - "\u058D\x07P\x02\x02\u058D\u058E\x07V\x02\x02\u058E\u058F\x07a\x02\x02" + - "\u058F\u0590\x07V\x02\x02\u0590\u0591\x07K\x02\x02\u0591\u0592\x07O\x02" + - "\x02\u0592\u0593\x07G\x02\x02\u0593r\x03\x02\x02\x02\u0594\u0595\x07E" + - "\x02\x02\u0595\u0596\x07W\x02\x02\u0596\u0597\x07T\x02\x02\u0597\u0598" + - "\x07T\x02\x02\u0598\u0599\x07G\x02\x02\u0599\u059A\x07P\x02\x02\u059A" + - "\u059B\x07V\x02\x02\u059B\u059C\x07a\x02\x02\u059C\u059D\x07V\x02\x02" + - "\u059D\u059E\x07K\x02\x02\u059E\u059F\x07O\x02\x02\u059F\u05A0\x07G\x02" + - "\x02\u05A0\u05A1\x07U\x02\x02\u05A1\u05A2\x07V\x02\x02\u05A2\u05A3\x07" + - "C\x02\x02\u05A3\u05A4\x07O\x02\x02\u05A4\u05A5\x07R\x02\x02\u05A5t\x03" + - "\x02\x02\x02\u05A6\u05A7\x07E\x02\x02\u05A7\u05A8\x07W\x02\x02\u05A8\u05A9" + - "\x07T\x02\x02\u05A9\u05AA\x07T\x02\x02\u05AA\u05AB\x07G\x02\x02\u05AB" + - "\u05AC\x07P\x02\x02\u05AC\u05AD\x07V\x02\x02\u05AD\u05AE\x07a\x02\x02" + - "\u05AE\u05AF\x07W\x02\x02\u05AF\u05B0\x07U\x02\x02\u05B0\u05B1\x07G\x02" + - "\x02\u05B1\u05B2\x07T\x02\x02\u05B2v\x03\x02\x02\x02\u05B3\u05B4\x07F" + - "\x02\x02\u05B4\u05B5\x07G\x02\x02\u05B5\u05B6\x07H\x02\x02\u05B6\u05B7" + - "\x07C\x02\x02\u05B7\u05B8\x07W\x02\x02\u05B8\u05B9\x07N\x02\x02\u05B9" + - "\u05BA\x07V\x02\x02\u05BAx\x03\x02\x02\x02\u05BB\u05BC\x07F\x02\x02\u05BC" + - "\u05BD\x07G\x02\x02\u05BD\u05BE\x07H\x02\x02\u05BE\u05BF\x07G\x02\x02" + - "\u05BF\u05C0\x07T\x02\x02\u05C0\u05C1\x07T\x02\x02\u05C1\u05C2\x07C\x02" + - "\x02\u05C2\u05C3\x07D\x02\x02\u05C3\u05C4\x07N\x02\x02\u05C4\u05C5\x07" + - "G\x02\x02\u05C5z\x03\x02\x02\x02\u05C6\u05C7\x07F\x02\x02\u05C7\u05C8" + - "\x07G\x02\x02\u05C8\u05C9\x07U\x02\x02\u05C9\u05CA\x07E\x02\x02\u05CA" + - "|\x03\x02\x02\x02\u05CB\u05CC\x07F\x02\x02\u05CC\u05CD\x07K\x02\x02\u05CD" + - "\u05CE\x07U\x02\x02\u05CE\u05CF\x07V\x02\x02\u05CF\u05D0\x07K\x02\x02" + - "\u05D0\u05D1\x07P\x02\x02\u05D1\u05D2\x07E\x02\x02\u05D2\u05D3\x07V\x02" + - "\x02\u05D3~\x03\x02\x02\x02\u05D4\u05D5\x07F\x02\x02\u05D5\u05D6\x07Q" + - "\x02\x02\u05D6\x80\x03\x02\x02\x02\u05D7\u05D8\x07G\x02\x02\u05D8\u05D9" + - "\x07N\x02\x02\u05D9\u05DA\x07U\x02\x02\u05DA\u05DB\x07G\x02\x02\u05DB" + - "\x82\x03\x02\x02\x02\u05DC\u05DD\x07G\x02\x02\u05DD\u05DE\x07Z\x02\x02" + - "\u05DE\u05DF\x07E\x02\x02\u05DF\u05E0\x07G\x02\x02\u05E0\u05E1\x07R\x02" + - "\x02\u05E1\u05E2\x07V\x02\x02\u05E2\x84\x03\x02\x02\x02\u05E3\u05E4\x07" + - "H\x02\x02\u05E4\u05E5\x07C\x02\x02\u05E5\u05E6\x07N\x02\x02\u05E6\u05E7" + - "\x07U\x02\x02\u05E7\u05E8\x07G\x02\x02\u05E8\x86\x03\x02\x02\x02\u05E9" + - "\u05EA\x07H\x02\x02\u05EA\u05EB\x07G\x02\x02\u05EB\u05EC\x07V\x02\x02" + - "\u05EC\u05ED\x07E\x02\x02\u05ED\u05EE\x07J\x02\x02\u05EE\x88\x03\x02\x02" + - "\x02\u05EF\u05F0\x07H\x02\x02\u05F0\u05F1\x07Q\x02\x02\u05F1\u05F2\x07" + - "T\x02\x02\u05F2\x8A\x03\x02\x02\x02\u05F3\u05F4\x07H\x02\x02\u05F4\u05F5" + - "\x07Q\x02\x02\u05F5\u05F6\x07T\x02\x02\u05F6\u05F7\x07G\x02\x02\u05F7" + - "\u05F8\x07K\x02\x02\u05F8\u05F9\x07I\x02\x02\u05F9\u05FA\x07P\x02\x02" + - "\u05FA\x8C\x03\x02\x02\x02\u05FB\u05FC\x07H\x02\x02\u05FC\u05FD\x07T\x02" + - "\x02\u05FD\u05FE\x07Q\x02\x02\u05FE\u05FF\x07O\x02\x02\u05FF\x8E\x03\x02" + - "\x02\x02\u0600\u0601\x07I\x02\x02\u0601\u0602\x07T\x02\x02\u0602\u0603" + - "\x07C\x02\x02\u0603\u0604\x07P\x02\x02\u0604\u0605\x07V\x02\x02\u0605" + - "\x90\x03\x02\x02\x02\u0606\u0607\x07I\x02\x02\u0607\u0608\x07T\x02\x02" + - "\u0608\u0609\x07Q\x02\x02\u0609\u060A\x07W\x02\x02\u060A\u060B\x07R\x02" + - "\x02\u060B\x92\x03\x02\x02\x02\u060C\u060D\x07J\x02\x02\u060D\u060E\x07" + - "C\x02\x02\u060E\u060F\x07X\x02\x02\u060F\u0610\x07K\x02\x02\u0610\u0611" + - "\x07P\x02\x02\u0611\u0612\x07I\x02\x02\u0612\x94\x03\x02\x02\x02\u0613" + - "\u0614\x07K\x02\x02\u0614\u0615\x07P\x02\x02\u0615\x96\x03\x02\x02\x02" + - "\u0616\u0617\x07K\x02\x02\u0617\u0618\x07P\x02\x02\u0618\u0619\x07K\x02" + - "\x02\u0619\u061A\x07V\x02\x02\u061A\u061B\x07K\x02\x02\u061B\u061C\x07" + - "C\x02\x02\u061C\u061D\x07N\x02\x02\u061D\u061E\x07N\x02\x02\u061E\u061F" + - "\x07[\x02\x02\u061F\x98\x03\x02\x02\x02\u0620\u0621\x07K\x02\x02\u0621" + - "\u0622\x07P\x02\x02\u0622\u0623\x07V\x02\x02\u0623\u0624\x07G\x02\x02" + - "\u0624\u0625\x07T\x02\x02\u0625\u0626\x07U\x02\x02\u0626\u0627\x07G\x02" + - "\x02\u0627\u0628\x07E\x02\x02\u0628\u0629\x07V\x02\x02\u0629\x9A\x03\x02" + - "\x02\x02\u062A\u062B\x07K\x02\x02\u062B\u062C\x07P\x02\x02\u062C\u062D" + - "\x07V\x02\x02\u062D\u062E\x07Q\x02\x02\u062E\x9C\x03\x02\x02\x02\u062F" + - "\u0630\x07N\x02\x02\u0630\u0631\x07C\x02\x02\u0631\u0632\x07V\x02\x02" + - "\u0632\u0633\x07G\x02\x02\u0633\u0634\x07T\x02\x02\u0634\u0635\x07C\x02" + - "\x02\u0635\u0636\x07N\x02\x02\u0636\x9E\x03\x02\x02\x02\u0637\u0638\x07" + - "N\x02\x02\u0638\u0639\x07G\x02\x02\u0639\u063A\x07C\x02\x02\u063A\u063B" + - "\x07F\x02\x02\u063B\u063C\x07K\x02\x02\u063C\u063D\x07P\x02\x02\u063D" + - "\u063E\x07I\x02\x02\u063E\xA0\x03\x02\x02\x02\u063F\u0640\x07N\x02\x02" + - "\u0640\u0641\x07K\x02\x02\u0641\u0642\x07O\x02\x02\u0642\u0643\x07K\x02" + - "\x02\u0643\u0644\x07V\x02\x02\u0644\xA2\x03\x02\x02\x02\u0645\u0646\x07" + - "N\x02\x02\u0646\u0647\x07Q\x02\x02\u0647\u0648\x07E\x02\x02\u0648\u0649" + - "\x07C\x02\x02\u0649\u064A\x07N\x02\x02\u064A\u064B\x07V\x02\x02\u064B" + - "\u064C\x07K\x02\x02\u064C\u064D\x07O\x02\x02\u064D\u064E\x07G\x02\x02" + - "\u064E\xA4\x03\x02\x02\x02\u064F\u0650\x07N\x02\x02\u0650\u0651\x07Q\x02" + - "\x02\u0651\u0652\x07E\x02\x02\u0652\u0653\x07C\x02\x02\u0653\u0654\x07" + - "N\x02\x02\u0654\u0655\x07V\x02\x02\u0655\u0656\x07K\x02\x02\u0656\u0657" + - "\x07O\x02\x02\u0657\u0658\x07G\x02\x02\u0658\u0659\x07U\x02\x02\u0659" + - "\u065A\x07V\x02\x02\u065A\u065B\x07C\x02\x02\u065B\u065C\x07O\x02\x02" + - "\u065C\u065D\x07R\x02\x02\u065D\xA6\x03\x02\x02\x02\u065E\u065F\x07P\x02" + - "\x02\u065F\u0660\x07Q\x02\x02\u0660\u0661\x07V\x02\x02\u0661\xA8\x03\x02" + - "\x02\x02\u0662\u0663\x07P\x02\x02\u0663\u0664\x07W\x02\x02\u0664\u0665" + - "\x07N\x02\x02\u0665\u0666\x07N\x02\x02\u0666\xAA\x03\x02\x02\x02\u0667" + - "\u0668\x07Q\x02\x02\u0668\u0669\x07H\x02\x02\u0669\u066A\x07H\x02\x02" + - "\u066A\u066B\x07U\x02\x02\u066B\u066C\x07G\x02\x02\u066C\u066D\x07V\x02" + - "\x02\u066D\xAC\x03\x02\x02\x02\u066E\u066F\x07Q\x02\x02\u066F\u0670\x07" + - "P\x02\x02\u0670\xAE\x03\x02\x02\x02\u0671\u0672\x07Q\x02\x02\u0672\u0673" + - "\x07P\x02\x02\u0673\u0674\x07N\x02\x02\u0674\u0675\x07[\x02\x02\u0675" + - "\xB0\x03\x02\x02\x02\u0676\u0677\x07Q\x02\x02\u0677\u0678\x07T\x02\x02" + - "\u0678\xB2\x03\x02\x02\x02\u0679\u067A\x07Q\x02\x02\u067A\u067B\x07T\x02" + - "\x02\u067B\u067C\x07F\x02\x02\u067C\u067D\x07G\x02\x02\u067D\u067E\x07" + - "T\x02\x02\u067E\xB4\x03\x02\x02\x02\u067F\u0680\x07R\x02\x02\u0680\u0681" + - "\x07N\x02\x02\u0681\u0682\x07C\x02\x02\u0682\u0683\x07E\x02\x02\u0683" + - "\u0684\x07K\x02\x02\u0684\u0685\x07P\x02\x02\u0685\u0686\x07I\x02\x02" + - "\u0686\xB6\x03\x02\x02\x02\u0687\u0688\x07R\x02\x02\u0688\u0689\x07T\x02" + - "\x02\u0689\u068A\x07K\x02\x02\u068A\u068B\x07O\x02\x02\u068B\u068C\x07" + - "C\x02\x02\u068C\u068D\x07T\x02\x02\u068D\u068E\x07[\x02\x02\u068E\xB8" + - "\x03\x02\x02\x02\u068F\u0690\x07T\x02\x02\u0690\u0691\x07G\x02\x02\u0691" + - "\u0692\x07H\x02\x02\u0692\u0693\x07G\x02\x02\u0693\u0694\x07T\x02\x02" + - "\u0694\u0695\x07G\x02\x02\u0695\u0696\x07P\x02\x02\u0696\u0697\x07E\x02" + - "\x02\u0697\u0698\x07G\x02\x02\u0698\u0699\x07U\x02\x02\u0699\xBA\x03\x02" + - "\x02\x02\u069A\u069B\x07T\x02\x02\u069B\u069C\x07G\x02\x02\u069C\u069D" + - "\x07V\x02\x02\u069D\u069E\x07W\x02\x02\u069E\u069F\x07T\x02\x02\u069F" + - "\u06A0\x07P\x02\x02\u06A0\u06A1\x07K\x02\x02\u06A1\u06A2\x07P\x02\x02" + - "\u06A2\u06A3\x07I\x02\x02\u06A3\xBC\x03\x02\x02\x02\u06A4\u06A5\x07U\x02" + - "\x02\u06A5\u06A6\x07G\x02\x02\u06A6\u06A7\x07N\x02\x02\u06A7\u06A8\x07" + - "G\x02\x02\u06A8\u06A9\x07E\x02\x02\u06A9\u06AA\x07V\x02\x02\u06AA\xBE" + - "\x03\x02\x02\x02\u06AB\u06AC\x07U\x02\x02\u06AC\u06AD\x07G\x02\x02\u06AD" + - "\u06AE\x07U\x02\x02\u06AE\u06AF\x07U\x02\x02\u06AF\u06B0\x07K\x02\x02" + - "\u06B0\u06B1\x07Q\x02\x02\u06B1\u06B2\x07P\x02\x02\u06B2\u06B3\x07a\x02" + - "\x02\u06B3\u06B4\x07W\x02\x02\u06B4\u06B5\x07U\x02\x02\u06B5\u06B6\x07" + - "G\x02\x02\u06B6\u06B7\x07T\x02\x02\u06B7\xC0\x03\x02\x02\x02\u06B8\u06B9" + - "\x07U\x02\x02\u06B9\u06BA\x07Q\x02\x02\u06BA\u06BB\x07O\x02\x02\u06BB" + - "\u06BC\x07G\x02\x02\u06BC\xC2\x03\x02\x02\x02\u06BD\u06BE\x07U\x02\x02" + - "\u06BE\u06BF\x07[\x02\x02\u06BF\u06C0\x07O\x02\x02\u06C0\u06C1\x07O\x02" + - "\x02\u06C1\u06C2\x07G\x02\x02\u06C2\u06C3\x07V\x02\x02\u06C3\u06C4\x07" + - "T\x02\x02\u06C4\u06C5\x07K\x02\x02\u06C5\u06C6\x07E\x02\x02\u06C6\xC4" + - "\x03\x02\x02\x02\u06C7\u06C8\x07V\x02\x02\u06C8\u06C9\x07C\x02\x02\u06C9" + - "\u06CA\x07D\x02\x02\u06CA\u06CB\x07N\x02\x02\u06CB\u06CC\x07G\x02\x02" + - "\u06CC\xC6\x03\x02\x02\x02\u06CD\u06CE\x07V\x02\x02\u06CE\u06CF\x07J\x02" + - "\x02\u06CF\u06D0\x07G\x02\x02\u06D0\u06D1\x07P\x02\x02\u06D1\xC8\x03\x02" + - "\x02\x02\u06D2\u06D3\x07V\x02\x02\u06D3\u06D4\x07Q\x02\x02\u06D4\xCA\x03" + - "\x02\x02\x02\u06D5\u06D6\x07V\x02\x02\u06D6\u06D7\x07T\x02\x02\u06D7\u06D8" + - "\x07C\x02\x02\u06D8\u06D9\x07K\x02\x02\u06D9\u06DA\x07N\x02\x02\u06DA" + - "\u06DB\x07K\x02\x02\u06DB\u06DC\x07P\x02\x02\u06DC\u06DD\x07I\x02\x02" + - "\u06DD\xCC\x03\x02\x02\x02\u06DE\u06DF\x07V\x02\x02\u06DF\u06E0\x07T\x02" + - "\x02\u06E0\u06E1\x07W\x02\x02\u06E1\u06E2\x07G\x02\x02\u06E2\xCE\x03\x02" + - "\x02\x02\u06E3\u06E4\x07W\x02\x02\u06E4\u06E5\x07P\x02\x02\u06E5\u06E6" + - "\x07K\x02\x02\u06E6\u06E7\x07Q\x02\x02\u06E7\u06E8\x07P\x02\x02\u06E8" + - "\xD0\x03\x02\x02\x02\u06E9\u06EA\x07W\x02\x02\u06EA\u06EB\x07P\x02\x02" + - "\u06EB\u06EC\x07K\x02\x02\u06EC\u06ED\x07S\x02\x02\u06ED\u06EE\x07W\x02" + - "\x02\u06EE\u06EF\x07G\x02\x02\u06EF\xD2\x03\x02\x02\x02\u06F0\u06F1\x07" + - "W\x02\x02\u06F1\u06F2\x07U\x02\x02\u06F2\u06F3\x07G\x02\x02\u06F3\u06F4" + - "\x07T\x02\x02\u06F4\xD4\x03\x02\x02\x02\u06F5\u06F6\x07W\x02\x02\u06F6" + - "\u06F7\x07U\x02\x02\u06F7\u06F8\x07K\x02\x02\u06F8\u06F9\x07P\x02\x02" + - "\u06F9\u06FA\x07I\x02\x02\u06FA\xD6\x03\x02\x02\x02\u06FB\u06FC\x07X\x02" + - "\x02\u06FC\u06FD\x07C\x02\x02\u06FD\u06FE\x07T\x02\x02\u06FE\u06FF\x07" + - "K\x02\x02\u06FF\u0700\x07C\x02\x02\u0700\u0701\x07F\x02\x02\u0701\u0702" + - "\x07K\x02\x02\u0702\u0703\x07E\x02\x02\u0703\xD8\x03\x02\x02\x02\u0704" + - "\u0705\x07Y\x02\x02\u0705\u0706\x07J\x02\x02\u0706\u0707\x07G\x02\x02" + - "\u0707\u0708\x07P\x02\x02\u0708\xDA\x03\x02\x02\x02\u0709\u070A\x07Y\x02" + - "\x02\u070A\u070B\x07J\x02\x02\u070B\u070C\x07G\x02\x02\u070C\u070D\x07" + - "T\x02\x02\u070D\u070E\x07G\x02\x02\u070E\xDC\x03\x02\x02\x02\u070F\u0710" + - "\x07Y\x02\x02\u0710\u0711\x07K\x02\x02\u0711\u0712\x07P\x02\x02\u0712" + - "\u0713\x07F\x02\x02\u0713\u0714\x07Q\x02\x02\u0714\u0715\x07Y\x02\x02" + - "\u0715\xDE\x03\x02\x02\x02\u0716\u0717\x07Y\x02\x02\u0717\u0718\x07K\x02" + - "\x02\u0718\u0719\x07V\x02\x02\u0719\u071A\x07J\x02\x02\u071A\xE0\x03\x02" + - "\x02\x02\u071B\u071C\x07C\x02\x02\u071C\u071D\x07W\x02\x02\u071D\u071E" + - "\x07V\x02\x02\u071E\u071F\x07J\x02\x02\u071F\u0720\x07Q\x02\x02\u0720" + - "\u0721\x07T\x02\x02\u0721\u0722\x07K\x02\x02\u0722\u0723\x07\\\x02\x02" + - "\u0723\u0724\x07C\x02\x02\u0724\u0725\x07V\x02\x02\u0725\u0726\x07K\x02" + - "\x02\u0726\u0727\x07Q\x02\x02\u0727\u0728\x07P\x02\x02\u0728\xE2\x03\x02" + - "\x02\x02\u0729\u072A\x07D\x02\x02\u072A\u072B\x07K\x02\x02\u072B\u072C" + - "\x07P\x02\x02\u072C\u072D\x07C\x02\x02\u072D\u072E\x07T\x02\x02\u072E" + - "\u072F\x07[\x02\x02\u072F\xE4\x03\x02\x02\x02\u0730\u0731\x07E\x02\x02" + - "\u0731\u0732\x07Q\x02\x02\u0732\u0733\x07N\x02\x02\u0733\u0734\x07N\x02" + - "\x02\u0734\u0735\x07C\x02\x02\u0735\u0736\x07V\x02\x02\u0736\u0737\x07" + - "K\x02\x02\u0737\u0738\x07Q\x02\x02\u0738\u0739\x07P\x02\x02\u0739\xE6" + - "\x03\x02\x02\x02\u073A\u073B\x07E\x02\x02\u073B\u073C\x07Q\x02\x02\u073C" + - "\u073D\x07P\x02\x02\u073D\u073E\x07E\x02\x02\u073E\u073F\x07W\x02\x02" + - "\u073F\u0740\x07T\x02\x02\u0740\u0741\x07T\x02\x02\u0741\u0742\x07G\x02" + - "\x02\u0742\u0743\x07P\x02\x02\u0743\u0744\x07V\x02\x02\u0744\u0745\x07" + - "N\x02\x02\u0745\u0746\x07[\x02\x02\u0746\xE8\x03\x02\x02\x02\u0747\u0748" + - "\x07E\x02\x02\u0748\u0749\x07T\x02\x02\u0749\u074A\x07Q\x02\x02\u074A" + - "\u074B\x07U\x02\x02\u074B\u074C\x07U\x02\x02\u074C\xEA\x03\x02\x02\x02" + - "\u074D\u074E\x07E\x02\x02\u074E\u074F\x07W\x02\x02\u074F\u0750\x07T\x02" + - "\x02\u0750\u0751\x07T\x02\x02\u0751\u0752\x07G\x02\x02\u0752\u0753\x07" + - "P\x02\x02\u0753\u0754\x07V\x02\x02\u0754\u0755\x07a\x02\x02\u0755\u0756" + - "\x07U\x02\x02\u0756\u0757\x07E\x02\x02\u0757\u0758\x07J\x02\x02\u0758" + - "\u0759\x07G\x02\x02\u0759\u075A\x07O\x02\x02\u075A\u075B\x07C\x02\x02" + - "\u075B\xEC\x03\x02\x02\x02\u075C\u075D\x07H\x02\x02\u075D\u075E\x07T\x02" + - "\x02\u075E\u075F\x07G\x02\x02\u075F\u0760\x07G\x02\x02\u0760\u0761\x07" + - "\\\x02\x02\u0761\u0762\x07G\x02\x02\u0762\xEE\x03\x02\x02\x02\u0763\u0764" + - "\x07H\x02\x02\u0764\u0765\x07W\x02\x02\u0765\u0766\x07N\x02\x02\u0766" + - "\u0767\x07N\x02\x02\u0767\xF0\x03\x02\x02\x02\u0768\u0769\x07K\x02\x02" + - "\u0769\u076A\x07N\x02\x02\u076A\u076B\x07K\x02\x02\u076B\u076C\x07M\x02" + - "\x02\u076C\u076D\x07G\x02\x02\u076D\xF2\x03\x02\x02\x02\u076E\u076F\x07" + - "K\x02\x02\u076F\u0770\x07P\x02\x02\u0770\u0771\x07P\x02\x02\u0771\u0772" + - "\x07G\x02\x02\u0772\u0773\x07T\x02\x02\u0773\xF4\x03\x02\x02\x02\u0774" + - "\u0775\x07K\x02\x02\u0775\u0776\x07U\x02\x02\u0776\xF6\x03\x02\x02\x02" + - "\u0777\u0778\x07K\x02\x02\u0778\u0779\x07U\x02\x02\u0779\u077A\x07P\x02" + - "\x02\u077A\u077B\x07W\x02\x02\u077B\u077C\x07N\x02\x02\u077C\u077D\x07" + - "N\x02\x02\u077D\xF8\x03\x02\x02\x02\u077E\u077F\x07L\x02\x02\u077F\u0780" + - "\x07Q\x02\x02\u0780\u0781\x07K\x02\x02\u0781\u0782\x07P\x02\x02\u0782" + - "\xFA\x03\x02\x02\x02\u0783\u0784\x07N\x02\x02\u0784\u0785\x07G\x02\x02" + - "\u0785\u0786\x07H\x02\x02\u0786\u0787\x07V\x02\x02\u0787\xFC\x03\x02\x02" + - "\x02\u0788\u0789\x07N\x02\x02\u0789\u078A\x07K\x02\x02\u078A\u078B\x07" + - "M\x02\x02\u078B\u078C\x07G\x02\x02\u078C\xFE\x03\x02\x02\x02\u078D\u078E" + - "\x07P\x02\x02\u078E\u078F\x07C\x02\x02\u078F\u0790\x07V\x02\x02\u0790" + - "\u0791\x07W\x02\x02\u0791\u0792\x07T\x02\x02\u0792\u0793\x07C\x02\x02" + - "\u0793\u0794\x07N\x02\x02\u0794\u0100\x03\x02\x02\x02\u0795\u0796\x07" + - "P\x02\x02\u0796\u0797\x07Q\x02\x02\u0797\u0798\x07V\x02\x02\u0798\u0799" + - "\x07P\x02\x02\u0799\u079A\x07W\x02\x02\u079A\u079B\x07N\x02\x02\u079B" + - "\u079C\x07N\x02\x02\u079C\u0102\x03\x02\x02\x02\u079D\u079E\x07Q\x02\x02" + - "\u079E\u079F\x07W\x02\x02\u079F\u07A0\x07V\x02\x02\u07A0\u07A1\x07G\x02" + - "\x02\u07A1\u07A2\x07T\x02\x02\u07A2\u0104\x03\x02\x02\x02\u07A3\u07A4" + - "\x07Q\x02\x02\u07A4\u07A5\x07X\x02\x02\u07A5\u07A6\x07G\x02\x02\u07A6" + - "\u07A7\x07T\x02\x02\u07A7\u0106\x03\x02\x02\x02\u07A8\u07A9\x07Q\x02\x02" + - "\u07A9\u07AA\x07X\x02\x02\u07AA\u07AB\x07G\x02\x02\u07AB\u07AC\x07T\x02" + - "\x02\u07AC\u07AD\x07N\x02\x02\u07AD\u07AE\x07C\x02\x02\u07AE\u07AF\x07" + - "R\x02\x02\u07AF\u07B0\x07U\x02\x02\u07B0\u0108\x03\x02\x02\x02\u07B1\u07B2" + - "\x07T\x02\x02\u07B2\u07B3\x07K\x02\x02\u07B3\u07B4\x07I\x02\x02\u07B4" + - "\u07B5\x07J\x02\x02\u07B5\u07B6\x07V\x02\x02\u07B6\u010A\x03\x02\x02\x02" + - "\u07B7\u07B8\x07U\x02\x02\u07B8\u07B9\x07K\x02\x02\u07B9\u07BA\x07O\x02" + - "\x02\u07BA\u07BB\x07K\x02\x02\u07BB\u07BC\x07N\x02\x02\u07BC\u07BD\x07" + - "C\x02\x02\u07BD\u07BE\x07T\x02\x02\u07BE\u010C\x03\x02\x02\x02\u07BF\u07C0" + - "\x07X\x02\x02\u07C0\u07C1\x07G\x02\x02\u07C1\u07C2\x07T\x02\x02\u07C2" + - "\u07C3\x07D\x02\x02\u07C3\u07C4\x07Q\x02\x02\u07C4\u07C5\x07U\x02\x02" + - "\u07C5\u07C6\x07G\x02\x02\u07C6\u010E\x03\x02\x02\x02\u07C7\u07C8\x07" + - "C\x02\x02\u07C8\u07C9\x07D\x02\x02\u07C9\u07CA\x07Q\x02\x02\u07CA\u07CB" + - "\x07T\x02\x02\u07CB\u07CC\x07V\x02\x02\u07CC\u0110\x03\x02\x02\x02\u07CD" + - "\u07CE\x07C\x02\x02\u07CE\u07CF\x07D\x02\x02\u07CF\u07D0\x07U\x02\x02" + - "\u07D0\u07D1\x07Q\x02\x02\u07D1\u07D2\x07N\x02\x02\u07D2\u07D3\x07W\x02" + - "\x02\u07D3\u07D4\x07V\x02\x02\u07D4\u07D5\x07G\x02\x02\u07D5\u0112\x03" + - "\x02\x02\x02\u07D6\u07D7\x07C\x02\x02\u07D7\u07D8\x07E\x02\x02\u07D8\u07D9" + - "\x07E\x02\x02\u07D9\u07DA\x07G\x02\x02\u07DA\u07DB\x07U\x02\x02\u07DB" + - "\u07DC\x07U\x02\x02\u07DC\u0114\x03\x02\x02\x02\u07DD\u07DE\x07C\x02\x02" + - "\u07DE\u07DF\x07E\x02\x02\u07DF\u07E0\x07V\x02\x02\u07E0\u07E1\x07K\x02" + - "\x02\u07E1\u07E2\x07Q\x02\x02\u07E2\u07E3\x07P\x02\x02\u07E3\u0116\x03" + - "\x02\x02\x02\u07E4\u07E5\x07C\x02\x02\u07E5\u07E6\x07F\x02\x02\u07E6\u07E7" + - "\x07F\x02\x02\u07E7\u0118\x03\x02\x02\x02\u07E8\u07E9\x07C\x02\x02\u07E9" + - "\u07EA\x07F\x02\x02\u07EA\u07EB\x07O\x02\x02\u07EB\u07EC\x07K\x02\x02" + - "\u07EC\u07ED\x07P\x02\x02\u07ED\u011A\x03\x02\x02\x02\u07EE\u07EF\x07" + - "C\x02\x02\u07EF\u07F0\x07H\x02\x02\u07F0\u07F1\x07V\x02\x02\u07F1\u07F2" + - "\x07G\x02\x02\u07F2\u07F3\x07T\x02\x02\u07F3\u011C\x03\x02\x02\x02"; + "\x02\x02\u0485\u156A\x03\x02\x02\x02\u0487\u156F\x03\x02\x02\x02\u0489" + + "\u1575\x03\x02\x02\x02\u048B\u157A\x03\x02\x02\x02\u048D\u157F\x03\x02" + + "\x02\x02\u048F\u1590\x03\x02\x02\x02\u0491\u1592\x03\x02\x02\x02\u0493" + + "\u0494\x07&\x02\x02\u0494\b\x03\x02\x02\x02\u0495\u0496\x07*\x02\x02\u0496" + + "\n\x03\x02\x02\x02\u0497\u0498\x07+\x02\x02\u0498\f\x03\x02\x02\x02\u0499" + + "\u049A\x07]\x02\x02\u049A\x0E\x03\x02\x02\x02\u049B\u049C\x07_\x02\x02" + + "\u049C\x10\x03\x02\x02\x02\u049D\u049E\x07.\x02\x02\u049E\x12\x03\x02" + + "\x02\x02\u049F\u04A0\x07=\x02\x02\u04A0\x14\x03\x02\x02\x02\u04A1\u04A2" + + "\x07<\x02\x02\u04A2\x16\x03\x02\x02\x02\u04A3\u04A4\x07,\x02\x02\u04A4" + + "\x18\x03\x02\x02\x02\u04A5\u04A6\x07?\x02\x02\u04A6\x1A\x03\x02\x02\x02" + + "\u04A7\u04A8\x070\x02\x02\u04A8\x1C\x03\x02\x02\x02\u04A9\u04AA\x07-\x02" + + "\x02\u04AA\x1E\x03\x02\x02\x02\u04AB\u04AC\x07/\x02\x02\u04AC \x03\x02" + + "\x02\x02\u04AD\u04AE\x071\x02\x02\u04AE\"\x03\x02\x02\x02\u04AF\u04B0" + + "\x07`\x02\x02\u04B0$\x03\x02\x02\x02\u04B1\u04B2\x07>\x02\x02\u04B2&\x03" + + "\x02\x02\x02\u04B3\u04B4\x07@\x02\x02\u04B4(\x03\x02\x02\x02\u04B5\u04B6" + + "\x07>\x02\x02\u04B6\u04B7\x07>\x02\x02\u04B7*\x03\x02\x02\x02\u04B8\u04B9" + + "\x07@\x02\x02\u04B9\u04BA\x07@\x02\x02\u04BA,\x03\x02\x02\x02\u04BB\u04BC" + + "\x07<\x02\x02\u04BC\u04BD\x07?\x02\x02\u04BD.\x03\x02\x02\x02\u04BE\u04BF" + + "\x07>\x02\x02\u04BF\u04C0\x07?\x02\x02\u04C00\x03\x02\x02\x02\u04C1\u04C2" + + "\x07?\x02\x02\u04C2\u04C3\x07@\x02\x02\u04C32\x03\x02\x02\x02\u04C4\u04C5" + + "\x07@\x02\x02\u04C5\u04C6\x07?\x02\x02\u04C64\x03\x02\x02\x02\u04C7\u04C8" + + "\x070\x02\x02\u04C8\u04C9\x070\x02\x02\u04C96\x03\x02\x02\x02\u04CA\u04CB" + + "\x07>\x02\x02\u04CB\u04CC\x07@\x02\x02\u04CC8\x03\x02\x02\x02\u04CD\u04CE" + + "\x07<\x02\x02\u04CE\u04CF\x07<\x02\x02\u04CF:\x03\x02\x02\x02\u04D0\u04D1" + + "\x07\'\x02\x02\u04D1<\x03\x02\x02\x02\u04D2\u04D4\x07&\x02\x02\u04D3\u04D5" + + "\t\x02\x02\x02\u04D4\u04D3\x03\x02\x02\x02\u04D5\u04D6\x03\x02\x02\x02" + + "\u04D6\u04D4\x03\x02\x02\x02\u04D6\u04D7\x03\x02\x02\x02\u04D7>\x03\x02" + + "\x02\x02\u04D8\u04E6\x05C \x02\u04D9\u04DB\t\x03\x02\x02\u04DA\u04D9\x03" + + "\x02\x02\x02\u04DB\u04DC\x03\x02\x02\x02\u04DC\u04DA\x03\x02\x02\x02\u04DC" + + "\u04DD\x03\x02\x02\x02\u04DD\u04E2\x03\x02\x02\x02\u04DE\u04E3\x05C \x02" + + "\u04DF\u04E1\x071\x02\x02\u04E0\u04DF\x03\x02\x02\x02\u04E0\u04E1\x03" + + "\x02\x02\x02\u04E1\u04E3\x03\x02\x02\x02\u04E2\u04DE\x03\x02\x02\x02\u04E2" + + "\u04E0\x03\x02\x02\x02\u04E3\u04E6\x03\x02\x02\x02\u04E4\u04E6\x071\x02" + + "\x02\u04E5\u04D8\x03\x02\x02\x02\u04E5\u04DA\x03\x02\x02\x02\u04E5\u04E4" + + "\x03\x02\x02\x02\u04E6\u04E7\x03\x02\x02\x02\u04E7\u04E5\x03\x02\x02\x02" + + "\u04E7\u04E8\x03\x02\x02\x02\u04E8\u04EB\x03\x02\x02\x02\u04E9\u04EB\t" + + "\x03\x02\x02\u04EA\u04E5\x03\x02\x02\x02\u04EA\u04E9\x03\x02\x02\x02\u04EB" + + "@\x03\x02\x02\x02\u04EC\u04EF\x05E!\x02\u04ED\u04EF\t\x04\x02\x02\u04EE" + + "\u04EC\x03\x02\x02\x02\u04EE\u04ED\x03\x02\x02\x02\u04EF\u04F2\x03\x02" + + "\x02\x02\u04F0\u04EE\x03\x02\x02\x02\u04F0\u04F1\x03\x02\x02\x02\u04F1" + + "\u04F3\x03\x02\x02\x02\u04F2\u04F0\x03\x02\x02\x02\u04F3\u04F5\x05G\"" + + "\x02\u04F4\u04F6\x05?\x1E\x02\u04F5\u04F4\x03\x02\x02\x02\u04F5\u04F6" + + "\x03\x02\x02\x02\u04F6\u04F8\x03\x02\x02\x02\u04F7\u04F9\t\x03\x02\x02" + + "\u04F8\u04F7\x03\x02\x02\x02\u04F9\u04FA\x03\x02\x02\x02\u04FA\u04F8\x03" + + "\x02\x02\x02\u04FA\u04FB\x03\x02\x02\x02\u04FB\u04FC\x03\x02\x02\x02\u04FC" + + "\u04FD\b\x1F\x02\x02\u04FDB\x03\x02\x02\x02\u04FE\u04FF\t\x05\x02\x02" + + "\u04FFD\x03\x02\x02\x02\u0500\u0501\t\x06\x02\x02\u0501F\x03\x02\x02\x02" + + "\u0502\u0503\t\x07\x02\x02\u0503H\x03\x02\x02\x02\u0504\u0505\x07C\x02" + + "\x02\u0505\u0506\x07N\x02\x02\u0506\u0507\x07N\x02\x02\u0507J\x03\x02" + + "\x02\x02\u0508\u0509\x07C\x02\x02\u0509\u050A\x07P\x02\x02\u050A\u050B" + + "\x07C\x02\x02\u050B\u050C\x07N\x02\x02\u050C\u050D\x07[\x02\x02\u050D" + + "\u050E\x07U\x02\x02\u050E\u050F\x07G\x02\x02\u050FL\x03\x02\x02\x02\u0510" + + "\u0511\x07C\x02\x02\u0511\u0512\x07P\x02\x02\u0512\u0513\x07C\x02\x02" + + "\u0513\u0514\x07N\x02\x02\u0514\u0515\x07[\x02\x02\u0515\u0516\x07\\\x02" + + "\x02\u0516\u0517\x07G\x02\x02\u0517N\x03\x02\x02\x02\u0518\u0519\x07C" + + "\x02\x02\u0519\u051A\x07P\x02\x02\u051A\u051B\x07F\x02\x02\u051BP\x03" + + "\x02\x02\x02\u051C\u051D\x07C\x02\x02\u051D\u051E\x07P\x02\x02\u051E\u051F" + + "\x07[\x02\x02\u051FR\x03\x02\x02\x02\u0520\u0521\x07C\x02\x02\u0521\u0522" + + "\x07T\x02\x02\u0522\u0523\x07T\x02\x02\u0523\u0524\x07C\x02\x02\u0524" + + "\u0525\x07[\x02\x02\u0525T\x03\x02\x02\x02\u0526\u0527\x07C\x02\x02\u0527" + + "\u0528\x07U\x02\x02\u0528V\x03\x02\x02\x02\u0529\u052A\x07C\x02\x02\u052A" + + "\u052B\x07U\x02\x02\u052B\u052C\x07E\x02\x02\u052CX\x03\x02\x02\x02\u052D" + + "\u052E\x07C\x02\x02\u052E\u052F\x07U\x02\x02\u052F\u0530\x07[\x02\x02" + + "\u0530\u0531\x07O\x02\x02\u0531\u0532\x07O\x02\x02\u0532\u0533\x07G\x02" + + "\x02\u0533\u0534\x07V\x02\x02\u0534\u0535\x07T\x02\x02\u0535\u0536\x07" + + "K\x02\x02\u0536\u0537\x07E\x02\x02\u0537Z\x03\x02\x02\x02\u0538\u0539" + + "\x07D\x02\x02\u0539\u053A\x07Q\x02\x02\u053A\u053B\x07V\x02\x02\u053B" + + "\u053C\x07J\x02\x02\u053C\\\x03\x02\x02\x02\u053D\u053E\x07E\x02\x02\u053E" + + "\u053F\x07C\x02\x02\u053F\u0540\x07U\x02\x02\u0540\u0541\x07G\x02\x02" + + "\u0541^\x03\x02\x02\x02\u0542\u0543\x07E\x02\x02\u0543\u0544\x07C\x02" + + "\x02\u0544\u0545\x07U\x02\x02\u0545\u0546\x07V\x02\x02\u0546`\x03\x02" + + "\x02\x02\u0547\u0548\x07E\x02\x02\u0548\u0549\x07J\x02\x02\u0549\u054A" + + "\x07G\x02\x02\u054A\u054B\x07E\x02\x02\u054B\u054C\x07M\x02\x02\u054C" + + "b\x03\x02\x02\x02\u054D\u054E\x07E\x02\x02\u054E\u054F\x07Q\x02\x02\u054F" + + "\u0550\x07N\x02\x02\u0550\u0551\x07N\x02\x02\u0551\u0552\x07C\x02\x02" + + "\u0552\u0553\x07V\x02\x02\u0553\u0554\x07G\x02\x02\u0554d\x03\x02\x02" + + "\x02\u0555\u0556\x07E\x02\x02\u0556\u0557\x07Q\x02\x02\u0557\u0558\x07" + + "N\x02\x02\u0558\u0559\x07W\x02\x02\u0559\u055A\x07O\x02\x02\u055A\u055B" + + "\x07P\x02\x02\u055Bf\x03\x02\x02\x02\u055C\u055D\x07E\x02\x02\u055D\u055E" + + "\x07Q\x02\x02\u055E\u055F\x07P\x02\x02\u055F\u0560\x07U\x02\x02\u0560" + + "\u0561\x07V\x02\x02\u0561\u0562\x07T\x02\x02\u0562\u0563\x07C\x02\x02" + + "\u0563\u0564\x07K\x02\x02\u0564\u0565\x07P\x02\x02\u0565\u0566\x07V\x02" + + "\x02\u0566h\x03\x02\x02\x02\u0567\u0568\x07E\x02\x02\u0568\u0569\x07T" + + "\x02\x02\u0569\u056A\x07G\x02\x02\u056A\u056B\x07C\x02\x02\u056B\u056C" + + "\x07V\x02\x02\u056C\u056D\x07G\x02\x02\u056Dj\x03\x02\x02\x02\u056E\u056F" + + "\x07E\x02\x02\u056F\u0570\x07W\x02\x02\u0570\u0571\x07T\x02\x02\u0571" + + "\u0572\x07T\x02\x02\u0572\u0573\x07G\x02\x02\u0573\u0574\x07P\x02\x02" + + "\u0574\u0575\x07V\x02\x02\u0575\u0576\x07a\x02\x02\u0576\u0577\x07E\x02" + + "\x02\u0577\u0578\x07C\x02\x02\u0578\u0579\x07V\x02\x02\u0579\u057A\x07" + + "C\x02\x02\u057A\u057B\x07N\x02\x02\u057B\u057C\x07Q\x02\x02\u057C\u057D" + + "\x07I\x02\x02\u057Dl\x03\x02\x02\x02\u057E\u057F\x07E\x02\x02\u057F\u0580" + + "\x07W\x02\x02\u0580\u0581\x07T\x02\x02\u0581\u0582\x07T\x02\x02\u0582" + + "\u0583\x07G\x02\x02\u0583\u0584\x07P\x02\x02\u0584\u0585\x07V\x02\x02" + + "\u0585\u0586\x07a\x02\x02\u0586\u0587\x07F\x02\x02\u0587\u0588\x07C\x02" + + "\x02\u0588\u0589\x07V\x02\x02\u0589\u058A\x07G\x02\x02\u058An\x03\x02" + + "\x02\x02\u058B\u058C\x07E\x02\x02\u058C\u058D\x07W\x02\x02\u058D\u058E" + + "\x07T\x02\x02\u058E\u058F\x07T\x02\x02\u058F\u0590\x07G\x02\x02\u0590" + + "\u0591\x07P\x02\x02\u0591\u0592\x07V\x02\x02\u0592\u0593\x07a\x02\x02" + + "\u0593\u0594\x07T\x02\x02\u0594\u0595\x07Q\x02\x02\u0595\u0596\x07N\x02" + + "\x02\u0596\u0597\x07G\x02\x02\u0597p\x03\x02\x02\x02\u0598\u0599\x07E" + + "\x02\x02\u0599\u059A\x07W\x02\x02\u059A\u059B\x07T\x02\x02\u059B\u059C" + + "\x07T\x02\x02\u059C\u059D\x07G\x02\x02\u059D\u059E\x07P\x02\x02\u059E" + + "\u059F\x07V\x02\x02\u059F\u05A0\x07a\x02\x02\u05A0\u05A1\x07V\x02\x02" + + "\u05A1\u05A2\x07K\x02\x02\u05A2\u05A3\x07O\x02\x02\u05A3\u05A4\x07G\x02" + + "\x02\u05A4r\x03\x02\x02\x02\u05A5\u05A6\x07E\x02\x02\u05A6\u05A7\x07W" + + "\x02\x02\u05A7\u05A8\x07T\x02\x02\u05A8\u05A9\x07T\x02\x02\u05A9\u05AA" + + "\x07G\x02\x02\u05AA\u05AB\x07P\x02\x02\u05AB\u05AC\x07V\x02\x02\u05AC" + + "\u05AD\x07a\x02\x02\u05AD\u05AE\x07V\x02\x02\u05AE\u05AF\x07K\x02\x02" + + "\u05AF\u05B0\x07O\x02\x02\u05B0\u05B1\x07G\x02\x02\u05B1\u05B2\x07U\x02" + + "\x02\u05B2\u05B3\x07V\x02\x02\u05B3\u05B4\x07C\x02\x02\u05B4\u05B5\x07" + + "O\x02\x02\u05B5\u05B6\x07R\x02\x02\u05B6t\x03\x02\x02\x02\u05B7\u05B8" + + "\x07E\x02\x02\u05B8\u05B9\x07W\x02\x02\u05B9\u05BA\x07T\x02\x02\u05BA" + + "\u05BB\x07T\x02\x02\u05BB\u05BC\x07G\x02\x02\u05BC\u05BD\x07P\x02\x02" + + "\u05BD\u05BE\x07V\x02\x02\u05BE\u05BF\x07a\x02\x02\u05BF\u05C0\x07W\x02" + + "\x02\u05C0\u05C1\x07U\x02\x02\u05C1\u05C2\x07G\x02\x02\u05C2\u05C3\x07" + + "T\x02\x02\u05C3v\x03\x02\x02\x02\u05C4\u05C5\x07F\x02\x02\u05C5\u05C6" + + "\x07G\x02\x02\u05C6\u05C7\x07H\x02\x02\u05C7\u05C8\x07C\x02\x02\u05C8" + + "\u05C9\x07W\x02\x02\u05C9\u05CA\x07N\x02\x02\u05CA\u05CB\x07V\x02\x02" + + "\u05CBx\x03\x02\x02\x02\u05CC\u05CD\x07F\x02\x02\u05CD\u05CE\x07G\x02" + + "\x02\u05CE\u05CF\x07H\x02\x02\u05CF\u05D0\x07G\x02\x02\u05D0\u05D1\x07" + + "T\x02\x02\u05D1\u05D2\x07T\x02\x02\u05D2\u05D3\x07C\x02\x02\u05D3\u05D4" + + "\x07D\x02\x02\u05D4\u05D5\x07N\x02\x02\u05D5\u05D6\x07G\x02\x02\u05D6" + + "z\x03\x02\x02\x02\u05D7\u05D8\x07F\x02\x02\u05D8\u05D9\x07G\x02\x02\u05D9" + + "\u05DA\x07U\x02\x02\u05DA\u05DB\x07E\x02\x02\u05DB|\x03\x02\x02\x02\u05DC" + + "\u05DD\x07F\x02\x02\u05DD\u05DE\x07K\x02\x02\u05DE\u05DF\x07U\x02\x02" + + "\u05DF\u05E0\x07V\x02\x02\u05E0\u05E1\x07K\x02\x02\u05E1\u05E2\x07P\x02" + + "\x02\u05E2\u05E3\x07E\x02\x02\u05E3\u05E4\x07V\x02\x02\u05E4~\x03\x02" + + "\x02\x02\u05E5\u05E6\x07F\x02\x02\u05E6\u05E7\x07Q\x02\x02\u05E7\x80\x03" + + "\x02\x02\x02\u05E8\u05E9\x07G\x02\x02\u05E9\u05EA\x07N\x02\x02\u05EA\u05EB" + + "\x07U\x02\x02\u05EB\u05EC\x07G\x02\x02\u05EC\x82\x03\x02\x02\x02\u05ED" + + "\u05EE\x07G\x02\x02\u05EE\u05EF\x07Z\x02\x02\u05EF\u05F0\x07E\x02\x02" + + "\u05F0\u05F1\x07G\x02\x02\u05F1\u05F2\x07R\x02\x02\u05F2\u05F3\x07V\x02" + + "\x02\u05F3\x84\x03\x02\x02\x02\u05F4\u05F5\x07H\x02\x02\u05F5\u05F6\x07" + + "C\x02\x02\u05F6\u05F7\x07N\x02\x02\u05F7\u05F8\x07U\x02\x02\u05F8\u05F9" + + "\x07G\x02\x02\u05F9\x86\x03\x02\x02\x02\u05FA\u05FB\x07H\x02\x02\u05FB" + + "\u05FC\x07G\x02\x02\u05FC\u05FD\x07V\x02\x02\u05FD\u05FE\x07E\x02\x02" + + "\u05FE\u05FF\x07J\x02\x02\u05FF\x88\x03\x02\x02\x02\u0600\u0601\x07H\x02" + + "\x02\u0601\u0602\x07Q\x02\x02\u0602\u0603\x07T\x02\x02\u0603\x8A\x03\x02" + + "\x02\x02\u0604\u0605\x07H\x02\x02\u0605\u0606\x07Q\x02\x02\u0606\u0607" + + "\x07T\x02\x02\u0607\u0608\x07G\x02\x02\u0608\u0609\x07K\x02\x02\u0609" + + "\u060A\x07I\x02\x02\u060A\u060B\x07P\x02\x02\u060B\x8C\x03\x02\x02\x02" + + "\u060C\u060D\x07H\x02\x02\u060D\u060E\x07T\x02\x02\u060E\u060F\x07Q\x02" + + "\x02\u060F\u0610\x07O\x02\x02\u0610\x8E\x03\x02\x02\x02\u0611\u0612\x07" + + "I\x02\x02\u0612\u0613\x07T\x02\x02\u0613\u0614\x07C\x02\x02\u0614\u0615" + + "\x07P\x02\x02\u0615\u0616\x07V\x02\x02\u0616\x90\x03\x02\x02\x02\u0617" + + "\u0618\x07I\x02\x02\u0618\u0619\x07T\x02\x02\u0619\u061A\x07Q\x02\x02" + + "\u061A\u061B\x07W\x02\x02\u061B\u061C\x07R\x02\x02\u061C\x92\x03\x02\x02" + + "\x02\u061D\u061E\x07J\x02\x02\u061E\u061F\x07C\x02\x02\u061F\u0620\x07" + + "X\x02\x02\u0620\u0621\x07K\x02\x02\u0621\u0622\x07P\x02\x02\u0622\u0623" + + "\x07I\x02\x02\u0623\x94\x03\x02\x02\x02\u0624\u0625\x07K\x02\x02\u0625" + + "\u0626\x07P\x02\x02\u0626\x96\x03\x02\x02\x02\u0627\u0628\x07K\x02\x02" + + "\u0628\u0629\x07P\x02\x02\u0629\u062A\x07K\x02\x02\u062A\u062B\x07V\x02" + + "\x02\u062B\u062C\x07K\x02\x02\u062C\u062D\x07C\x02\x02\u062D\u062E\x07" + + "N\x02\x02\u062E\u062F\x07N\x02\x02\u062F\u0630\x07[\x02\x02\u0630\x98" + + "\x03\x02\x02\x02\u0631\u0632\x07K\x02\x02\u0632\u0633\x07P\x02\x02\u0633" + + "\u0634\x07V\x02\x02\u0634\u0635\x07G\x02\x02\u0635\u0636\x07T\x02\x02" + + "\u0636\u0637\x07U\x02\x02\u0637\u0638\x07G\x02\x02\u0638\u0639\x07E\x02" + + "\x02\u0639\u063A\x07V\x02\x02\u063A\x9A\x03\x02\x02\x02\u063B\u063C\x07" + + "K\x02\x02\u063C\u063D\x07P\x02\x02\u063D\u063E\x07V\x02\x02\u063E\u063F" + + "\x07Q\x02\x02\u063F\x9C\x03\x02\x02\x02\u0640\u0641\x07N\x02\x02\u0641" + + "\u0642\x07C\x02\x02\u0642\u0643\x07V\x02\x02\u0643\u0644\x07G\x02\x02" + + "\u0644\u0645\x07T\x02\x02\u0645\u0646\x07C\x02\x02\u0646\u0647\x07N\x02" + + "\x02\u0647\x9E\x03\x02\x02\x02\u0648\u0649\x07N\x02\x02\u0649\u064A\x07" + + "G\x02\x02\u064A\u064B\x07C\x02\x02\u064B\u064C\x07F\x02\x02\u064C\u064D" + + "\x07K\x02\x02\u064D\u064E\x07P\x02\x02\u064E\u064F\x07I\x02\x02\u064F" + + "\xA0\x03\x02\x02\x02\u0650\u0651\x07N\x02\x02\u0651\u0652\x07K\x02\x02" + + "\u0652\u0653\x07O\x02\x02\u0653\u0654\x07K\x02\x02\u0654\u0655\x07V\x02" + + "\x02\u0655\xA2\x03\x02\x02\x02\u0656\u0657\x07N\x02\x02\u0657\u0658\x07" + + "Q\x02\x02\u0658\u0659\x07E\x02\x02\u0659\u065A\x07C\x02\x02\u065A\u065B" + + "\x07N\x02\x02\u065B\u065C\x07V\x02\x02\u065C\u065D\x07K\x02\x02\u065D" + + "\u065E\x07O\x02\x02\u065E\u065F\x07G\x02\x02\u065F\xA4\x03\x02\x02\x02" + + "\u0660\u0661\x07N\x02\x02\u0661\u0662\x07Q\x02\x02\u0662\u0663\x07E\x02" + + "\x02\u0663\u0664\x07C\x02\x02\u0664\u0665\x07N\x02\x02\u0665\u0666\x07" + + "V\x02\x02\u0666\u0667\x07K\x02\x02\u0667\u0668\x07O\x02\x02\u0668\u0669" + + "\x07G\x02\x02\u0669\u066A\x07U\x02\x02\u066A\u066B\x07V\x02\x02\u066B" + + "\u066C\x07C\x02\x02\u066C\u066D\x07O\x02\x02\u066D\u066E\x07R\x02\x02" + + "\u066E\xA6\x03\x02\x02\x02\u066F\u0670\x07P\x02\x02\u0670\u0671\x07Q\x02" + + "\x02\u0671\u0672\x07V\x02\x02\u0672\xA8\x03\x02\x02\x02\u0673\u0674\x07" + + "P\x02\x02\u0674\u0675\x07W\x02\x02\u0675\u0676\x07N\x02\x02\u0676\u0677" + + "\x07N\x02\x02\u0677\xAA\x03\x02\x02\x02\u0678\u0679\x07Q\x02\x02\u0679" + + "\u067A\x07H\x02\x02\u067A\u067B\x07H\x02\x02\u067B\u067C\x07U\x02\x02" + + "\u067C\u067D\x07G\x02\x02\u067D\u067E\x07V\x02\x02\u067E\xAC\x03\x02\x02" + + "\x02\u067F\u0680\x07Q\x02\x02\u0680\u0681\x07P\x02\x02\u0681\xAE\x03\x02" + + "\x02\x02\u0682\u0683\x07Q\x02\x02\u0683\u0684\x07P\x02\x02\u0684\u0685" + + "\x07N\x02\x02\u0685\u0686\x07[\x02\x02\u0686\xB0\x03\x02\x02\x02\u0687" + + "\u0688\x07Q\x02\x02\u0688\u0689\x07T\x02\x02\u0689\xB2\x03\x02\x02\x02" + + "\u068A\u068B\x07Q\x02\x02\u068B\u068C\x07T\x02\x02\u068C\u068D\x07F\x02" + + "\x02\u068D\u068E\x07G\x02\x02\u068E\u068F\x07T\x02\x02\u068F\xB4\x03\x02" + + "\x02\x02\u0690\u0691\x07R\x02\x02\u0691\u0692\x07N\x02\x02\u0692\u0693" + + "\x07C\x02\x02\u0693\u0694\x07E\x02\x02\u0694\u0695\x07K\x02\x02\u0695" + + "\u0696\x07P\x02\x02\u0696\u0697\x07I\x02\x02\u0697\xB6\x03\x02\x02\x02" + + "\u0698\u0699\x07R\x02\x02\u0699\u069A\x07T\x02\x02\u069A\u069B\x07K\x02" + + "\x02\u069B\u069C\x07O\x02\x02\u069C\u069D\x07C\x02\x02\u069D\u069E\x07" + + "T\x02\x02\u069E\u069F\x07[\x02\x02\u069F\xB8\x03\x02\x02\x02\u06A0\u06A1" + + "\x07T\x02\x02\u06A1\u06A2\x07G\x02\x02\u06A2\u06A3\x07H\x02\x02\u06A3" + + "\u06A4\x07G\x02\x02\u06A4\u06A5\x07T\x02\x02\u06A5\u06A6\x07G\x02\x02" + + "\u06A6\u06A7\x07P\x02\x02\u06A7\u06A8\x07E\x02\x02\u06A8\u06A9\x07G\x02" + + "\x02\u06A9\u06AA\x07U\x02\x02\u06AA\xBA\x03\x02\x02\x02\u06AB\u06AC\x07" + + "T\x02\x02\u06AC\u06AD\x07G\x02\x02\u06AD\u06AE\x07V\x02\x02\u06AE\u06AF" + + "\x07W\x02\x02\u06AF\u06B0\x07T\x02\x02\u06B0\u06B1\x07P\x02\x02\u06B1" + + "\u06B2\x07K\x02\x02\u06B2\u06B3\x07P\x02\x02\u06B3\u06B4\x07I\x02\x02" + + "\u06B4\xBC\x03\x02\x02\x02\u06B5\u06B6\x07U\x02\x02\u06B6\u06B7\x07G\x02" + + "\x02\u06B7\u06B8\x07N\x02\x02\u06B8\u06B9\x07G\x02\x02\u06B9\u06BA\x07" + + "E\x02\x02\u06BA\u06BB\x07V\x02\x02\u06BB\xBE\x03\x02\x02\x02\u06BC\u06BD" + + "\x07U\x02\x02\u06BD\u06BE\x07G\x02\x02\u06BE\u06BF\x07U\x02\x02\u06BF" + + "\u06C0\x07U\x02\x02\u06C0\u06C1\x07K\x02\x02\u06C1\u06C2\x07Q\x02\x02" + + "\u06C2\u06C3\x07P\x02\x02\u06C3\u06C4\x07a\x02\x02\u06C4\u06C5\x07W\x02" + + "\x02\u06C5\u06C6\x07U\x02\x02\u06C6\u06C7\x07G\x02\x02\u06C7\u06C8\x07" + + "T\x02\x02\u06C8\xC0\x03\x02\x02\x02\u06C9\u06CA\x07U\x02\x02\u06CA\u06CB" + + "\x07Q\x02\x02\u06CB\u06CC\x07O\x02\x02\u06CC\u06CD\x07G\x02\x02\u06CD" + + "\xC2\x03\x02\x02\x02\u06CE\u06CF\x07U\x02\x02\u06CF\u06D0\x07[\x02\x02" + + "\u06D0\u06D1\x07O\x02\x02\u06D1\u06D2\x07O\x02\x02\u06D2\u06D3\x07G\x02" + + "\x02\u06D3\u06D4\x07V\x02\x02\u06D4\u06D5\x07T\x02\x02\u06D5\u06D6\x07" + + "K\x02\x02\u06D6\u06D7\x07E\x02\x02\u06D7\xC4\x03\x02\x02\x02\u06D8\u06D9" + + "\x07V\x02\x02\u06D9\u06DA\x07C\x02\x02\u06DA\u06DB\x07D\x02\x02\u06DB" + + "\u06DC\x07N\x02\x02\u06DC\u06DD\x07G\x02\x02\u06DD\xC6\x03\x02\x02\x02" + + "\u06DE\u06DF\x07V\x02\x02\u06DF\u06E0\x07J\x02\x02\u06E0\u06E1\x07G\x02" + + "\x02\u06E1\u06E2\x07P\x02\x02\u06E2\xC8\x03\x02\x02\x02\u06E3\u06E4\x07" + + "V\x02\x02\u06E4\u06E5\x07Q\x02\x02\u06E5\xCA\x03\x02\x02\x02\u06E6\u06E7" + + "\x07V\x02\x02\u06E7\u06E8\x07T\x02\x02\u06E8\u06E9\x07C\x02\x02\u06E9" + + "\u06EA\x07K\x02\x02\u06EA\u06EB\x07N\x02\x02\u06EB\u06EC\x07K\x02\x02" + + "\u06EC\u06ED\x07P\x02\x02\u06ED\u06EE\x07I\x02\x02\u06EE\xCC\x03\x02\x02" + + "\x02\u06EF\u06F0\x07V\x02\x02\u06F0\u06F1\x07T\x02\x02\u06F1\u06F2\x07" + + "W\x02\x02\u06F2\u06F3\x07G\x02\x02\u06F3\xCE\x03\x02\x02\x02\u06F4\u06F5" + + "\x07W\x02\x02\u06F5\u06F6\x07P\x02\x02\u06F6\u06F7\x07K\x02\x02\u06F7" + + "\u06F8\x07Q\x02\x02\u06F8\u06F9\x07P\x02\x02\u06F9\xD0\x03\x02\x02\x02" + + "\u06FA\u06FB\x07W\x02\x02\u06FB\u06FC\x07P\x02\x02\u06FC\u06FD\x07K\x02" + + "\x02\u06FD\u06FE\x07S\x02\x02\u06FE\u06FF\x07W\x02\x02\u06FF\u0700\x07" + + "G\x02\x02\u0700\xD2\x03\x02\x02\x02\u0701\u0702\x07W\x02\x02\u0702\u0703" + + "\x07U\x02\x02\u0703\u0704\x07G\x02\x02\u0704\u0705\x07T\x02\x02\u0705" + + "\xD4\x03\x02\x02\x02\u0706\u0707\x07W\x02\x02\u0707\u0708\x07U\x02\x02" + + "\u0708\u0709\x07K\x02\x02\u0709\u070A\x07P\x02\x02\u070A\u070B\x07I\x02" + + "\x02\u070B\xD6\x03\x02\x02\x02\u070C\u070D\x07X\x02\x02\u070D\u070E\x07" + + "C\x02\x02\u070E\u070F\x07T\x02\x02\u070F\u0710\x07K\x02\x02\u0710\u0711" + + "\x07C\x02\x02\u0711\u0712\x07F\x02\x02\u0712\u0713\x07K\x02\x02\u0713" + + "\u0714\x07E\x02\x02\u0714\xD8\x03\x02\x02\x02\u0715\u0716\x07Y\x02\x02" + + "\u0716\u0717\x07J\x02\x02\u0717\u0718\x07G\x02\x02\u0718\u0719\x07P\x02" + + "\x02\u0719\xDA\x03\x02\x02\x02\u071A\u071B\x07Y\x02\x02\u071B\u071C\x07" + + "J\x02\x02\u071C\u071D\x07G\x02\x02\u071D\u071E\x07T\x02\x02\u071E\u071F" + + "\x07G\x02\x02\u071F\xDC\x03\x02\x02\x02\u0720\u0721\x07Y\x02\x02\u0721" + + "\u0722\x07K\x02\x02\u0722\u0723\x07P\x02\x02\u0723\u0724\x07F\x02\x02" + + "\u0724\u0725\x07Q\x02\x02\u0725\u0726\x07Y\x02\x02\u0726\xDE\x03\x02\x02" + + "\x02\u0727\u0728\x07Y\x02\x02\u0728\u0729\x07K\x02\x02\u0729\u072A\x07" + + "V\x02\x02\u072A\u072B\x07J\x02\x02\u072B\xE0\x03\x02\x02\x02\u072C\u072D" + + "\x07C\x02\x02\u072D\u072E\x07W\x02\x02\u072E\u072F\x07V\x02\x02\u072F" + + "\u0730\x07J\x02\x02\u0730\u0731\x07Q\x02\x02\u0731\u0732\x07T\x02\x02" + + "\u0732\u0733\x07K\x02\x02\u0733\u0734\x07\\\x02\x02\u0734\u0735\x07C\x02" + + "\x02\u0735\u0736\x07V\x02\x02\u0736\u0737\x07K\x02\x02\u0737\u0738\x07" + + "Q\x02\x02\u0738\u0739\x07P\x02\x02\u0739\xE2\x03\x02\x02\x02\u073A\u073B" + + "\x07D\x02\x02\u073B\u073C\x07K\x02\x02\u073C\u073D\x07P\x02\x02\u073D" + + "\u073E\x07C\x02\x02\u073E\u073F\x07T\x02\x02\u073F\u0740\x07[\x02\x02" + + "\u0740\xE4\x03\x02\x02\x02\u0741\u0742\x07E\x02\x02\u0742\u0743\x07Q\x02" + + "\x02\u0743\u0744\x07N\x02\x02\u0744\u0745\x07N\x02\x02\u0745\u0746\x07" + + "C\x02\x02\u0746\u0747\x07V\x02\x02\u0747\u0748\x07K\x02\x02\u0748\u0749" + + "\x07Q\x02\x02\u0749\u074A\x07P\x02\x02\u074A\xE6\x03\x02\x02\x02\u074B" + + "\u074C\x07E\x02\x02\u074C\u074D\x07Q\x02\x02\u074D\u074E\x07P\x02\x02" + + "\u074E\u074F\x07E\x02\x02\u074F\u0750\x07W\x02\x02\u0750\u0751\x07T\x02" + + "\x02\u0751\u0752\x07T\x02\x02\u0752\u0753\x07G\x02\x02\u0753\u0754\x07" + + "P\x02\x02\u0754\u0755\x07V\x02\x02\u0755\u0756\x07N\x02\x02\u0756\u0757" + + "\x07[\x02\x02\u0757\xE8\x03\x02\x02\x02\u0758\u0759\x07E\x02\x02\u0759" + + "\u075A\x07T\x02\x02\u075A\u075B\x07Q\x02\x02\u075B\u075C\x07U\x02\x02" + + "\u075C\u075D\x07U\x02\x02\u075D\xEA\x03\x02\x02\x02\u075E\u075F\x07E\x02" + + "\x02\u075F\u0760\x07W\x02\x02\u0760\u0761\x07T\x02\x02\u0761\u0762\x07" + + "T\x02\x02\u0762\u0763\x07G\x02\x02\u0763\u0764\x07P\x02\x02\u0764\u0765" + + "\x07V\x02\x02\u0765\u0766\x07a\x02\x02\u0766\u0767\x07U\x02\x02\u0767" + + "\u0768\x07E\x02\x02\u0768\u0769\x07J\x02\x02\u0769\u076A\x07G\x02\x02" + + "\u076A\u076B\x07O\x02\x02\u076B\u076C\x07C\x02\x02\u076C\xEC\x03\x02\x02" + + "\x02\u076D\u076E\x07H\x02\x02\u076E\u076F\x07T\x02\x02\u076F\u0770\x07" + + "G\x02\x02\u0770\u0771\x07G\x02\x02\u0771\u0772\x07\\\x02\x02\u0772\u0773" + + "\x07G\x02\x02\u0773\xEE\x03\x02\x02\x02\u0774\u0775\x07H\x02\x02\u0775" + + "\u0776\x07W\x02\x02\u0776\u0777\x07N\x02\x02\u0777\u0778\x07N\x02\x02" + + "\u0778\xF0\x03\x02\x02\x02\u0779\u077A\x07K\x02\x02\u077A\u077B\x07N\x02" + + "\x02\u077B\u077C\x07K\x02\x02\u077C\u077D\x07M\x02\x02\u077D\u077E\x07" + + "G\x02\x02\u077E\xF2\x03\x02\x02\x02\u077F\u0780\x07K\x02\x02\u0780\u0781" + + "\x07P\x02\x02\u0781\u0782\x07P\x02\x02\u0782\u0783\x07G\x02\x02\u0783" + + "\u0784\x07T\x02\x02\u0784\xF4\x03\x02\x02\x02\u0785\u0786\x07K\x02\x02" + + "\u0786\u0787\x07U\x02\x02\u0787\xF6\x03\x02\x02\x02\u0788\u0789\x07K\x02" + + "\x02\u0789\u078A\x07U\x02\x02\u078A\u078B\x07P\x02\x02\u078B\u078C\x07" + + "W\x02\x02\u078C\u078D\x07N\x02\x02\u078D\u078E\x07N\x02\x02\u078E\xF8" + + "\x03\x02\x02\x02\u078F\u0790\x07L\x02\x02\u0790\u0791\x07Q\x02\x02\u0791" + + "\u0792\x07K\x02\x02\u0792\u0793\x07P\x02\x02\u0793\xFA\x03\x02\x02\x02" + + "\u0794\u0795\x07N\x02\x02\u0795\u0796\x07G\x02\x02\u0796\u0797\x07H\x02" + + "\x02\u0797\u0798\x07V\x02\x02\u0798\xFC\x03\x02\x02\x02\u0799\u079A\x07" + + "N\x02\x02\u079A\u079B\x07K\x02\x02\u079B\u079C\x07M\x02\x02\u079C\u079D" + + "\x07G\x02\x02\u079D\xFE\x03\x02\x02\x02\u079E\u079F\x07P\x02\x02\u079F" + + "\u07A0\x07C\x02\x02\u07A0\u07A1\x07V\x02\x02\u07A1\u07A2\x07W\x02\x02" + + "\u07A2\u07A3\x07T\x02\x02\u07A3\u07A4\x07C\x02\x02\u07A4\u07A5\x07N\x02" + + "\x02\u07A5\u0100\x03\x02\x02\x02\u07A6\u07A7\x07P\x02\x02\u07A7\u07A8" + + "\x07Q\x02\x02\u07A8\u07A9\x07V\x02\x02\u07A9\u07AA\x07P\x02\x02\u07AA" + + "\u07AB\x07W\x02\x02\u07AB\u07AC\x07N\x02\x02\u07AC\u07AD\x07N\x02\x02" + + "\u07AD\u0102\x03\x02\x02\x02\u07AE\u07AF\x07Q\x02\x02\u07AF\u07B0\x07" + + "W\x02\x02\u07B0\u07B1\x07V\x02\x02\u07B1\u07B2\x07G\x02\x02\u07B2\u07B3" + + "\x07T\x02\x02\u07B3\u0104\x03\x02\x02\x02\u07B4\u07B5\x07Q\x02\x02\u07B5" + + "\u07B6\x07X\x02\x02\u07B6\u07B7\x07G\x02\x02\u07B7\u07B8\x07T\x02\x02" + + "\u07B8\u0106\x03\x02\x02\x02\u07B9\u07BA\x07Q\x02\x02\u07BA\u07BB\x07" + + "X\x02\x02\u07BB\u07BC\x07G\x02\x02\u07BC\u07BD\x07T\x02\x02\u07BD\u07BE" + + "\x07N\x02\x02\u07BE\u07BF\x07C\x02\x02\u07BF\u07C0\x07R\x02\x02\u07C0" + + "\u07C1\x07U\x02\x02"; private static readonly _serializedATNSegment5: string = - "\u07F4\u07F5\x07C\x02\x02\u07F5\u07F6\x07I\x02\x02\u07F6\u07F7\x07I\x02" + - "\x02\u07F7\u07F8\x07T\x02\x02\u07F8\u07F9\x07G\x02\x02\u07F9\u07FA\x07" + - "I\x02\x02\u07FA\u07FB\x07C\x02\x02\u07FB\u07FC\x07V\x02\x02\u07FC\u07FD" + - "\x07G\x02\x02\u07FD\u011E\x03\x02\x02\x02\u07FE\u07FF\x07C\x02\x02\u07FF" + - "\u0800\x07N\x02\x02\u0800\u0801\x07U\x02\x02\u0801\u0802\x07Q\x02\x02" + - "\u0802\u0120\x03\x02\x02\x02\u0803\u0804\x07C\x02\x02\u0804\u0805\x07" + - "N\x02\x02\u0805\u0806\x07V\x02\x02\u0806\u0807\x07G\x02\x02\u0807\u0808" + - "\x07T\x02\x02\u0808\u0122\x03\x02\x02\x02\u0809\u080A\x07C\x02\x02\u080A" + - "\u080B\x07N\x02\x02\u080B\u080C\x07Y\x02\x02\u080C\u080D\x07C\x02\x02" + - "\u080D\u080E\x07[\x02\x02\u080E\u080F\x07U\x02\x02\u080F\u0124\x03\x02" + - "\x02\x02\u0810\u0811\x07C\x02\x02\u0811\u0812\x07U\x02\x02\u0812\u0813" + - "\x07U\x02\x02\u0813\u0814\x07G\x02\x02\u0814\u0815\x07T\x02\x02\u0815" + - "\u0816\x07V\x02\x02\u0816\u0817\x07K\x02\x02\u0817\u0818\x07Q\x02\x02" + - "\u0818\u0819\x07P\x02\x02\u0819\u0126\x03\x02\x02\x02\u081A\u081B\x07" + - "C\x02\x02\u081B\u081C\x07U\x02\x02\u081C\u081D\x07U\x02\x02\u081D\u081E" + - "\x07K\x02\x02\u081E\u081F\x07I\x02\x02\u081F\u0820\x07P\x02\x02\u0820" + - "\u0821\x07O\x02\x02\u0821\u0822\x07G\x02\x02\u0822\u0823\x07P\x02\x02" + - "\u0823\u0824\x07V\x02\x02\u0824\u0128\x03\x02\x02\x02\u0825\u0826\x07" + - "C\x02\x02\u0826\u0827\x07V\x02\x02\u0827\u012A\x03\x02\x02\x02\u0828\u0829" + - "\x07C\x02\x02\u0829\u082A\x07V\x02\x02\u082A\u082B\x07V\x02\x02\u082B" + - "\u082C\x07T\x02\x02\u082C\u082D\x07K\x02\x02\u082D\u082E\x07D\x02\x02" + - "\u082E\u082F\x07W\x02\x02\u082F\u0830\x07V\x02\x02\u0830\u0831\x07G\x02" + - "\x02\u0831\u012C\x03\x02\x02\x02\u0832\u0833\x07D\x02\x02\u0833\u0834" + - "\x07C\x02\x02\u0834\u0835\x07E\x02\x02\u0835\u0836\x07M\x02\x02\u0836" + - "\u0837\x07Y\x02\x02\u0837\u0838\x07C\x02\x02\u0838\u0839\x07T\x02\x02" + - "\u0839\u083A\x07F\x02\x02\u083A\u012E\x03\x02\x02\x02\u083B\u083C\x07" + - "D\x02\x02\u083C\u083D\x07G\x02\x02\u083D\u083E\x07H\x02\x02\u083E\u083F" + - "\x07Q\x02\x02\u083F\u0840\x07T\x02\x02\u0840\u0841\x07G\x02\x02\u0841" + - "\u0130\x03\x02\x02\x02\u0842\u0843\x07D\x02\x02\u0843\u0844\x07G\x02\x02" + - "\u0844\u0845\x07I\x02\x02\u0845\u0846\x07K\x02\x02\u0846\u0847\x07P\x02" + - "\x02\u0847\u0132\x03\x02\x02\x02\u0848\u0849\x07D\x02\x02\u0849\u084A" + - "\x07[\x02\x02\u084A\u0134\x03\x02\x02\x02\u084B\u084C\x07E\x02\x02\u084C" + - "\u084D\x07C\x02\x02\u084D\u084E\x07E\x02\x02\u084E\u084F\x07J\x02\x02" + - "\u084F\u0850\x07G\x02\x02\u0850\u0136\x03\x02\x02\x02\u0851\u0852\x07" + - "E\x02\x02\u0852\u0853\x07C\x02\x02\u0853\u0854\x07N\x02\x02\u0854\u0855" + - "\x07N\x02\x02\u0855\u0856\x07G\x02\x02\u0856\u0857\x07F\x02\x02\u0857" + - "\u0138\x03\x02\x02\x02\u0858\u0859\x07E\x02\x02\u0859\u085A\x07C\x02\x02" + - "\u085A\u085B\x07U\x02\x02\u085B\u085C\x07E\x02\x02\u085C\u085D\x07C\x02" + - "\x02\u085D\u085E\x07F\x02\x02\u085E\u085F\x07G\x02\x02\u085F\u013A\x03" + - "\x02\x02\x02\u0860\u0861\x07E\x02\x02\u0861\u0862\x07C\x02\x02\u0862\u0863" + - "\x07U\x02\x02\u0863\u0864\x07E\x02\x02\u0864\u0865\x07C\x02\x02\u0865" + - "\u0866\x07F\x02\x02\u0866\u0867\x07G\x02\x02\u0867\u0868\x07F\x02\x02" + - "\u0868\u013C\x03\x02\x02\x02\u0869\u086A\x07E\x02\x02\u086A\u086B\x07" + - "C\x02\x02\u086B\u086C\x07V\x02\x02\u086C\u086D\x07C\x02\x02\u086D\u086E" + - "\x07N\x02\x02\u086E\u086F\x07Q\x02\x02\u086F\u0870\x07I\x02\x02\u0870" + - "\u013E\x03\x02\x02\x02\u0871\u0872\x07E\x02\x02\u0872\u0873\x07J\x02\x02" + - "\u0873\u0874\x07C\x02\x02\u0874\u0875\x07K\x02\x02\u0875\u0876\x07P\x02" + - "\x02\u0876\u0140\x03\x02\x02\x02\u0877\u0878\x07E\x02\x02\u0878\u0879" + - "\x07J\x02\x02\u0879\u087A\x07C\x02\x02\u087A\u087B\x07T\x02\x02\u087B" + - "\u087C\x07C\x02\x02\u087C\u087D\x07E\x02\x02\u087D\u087E\x07V\x02\x02" + - "\u087E\u087F\x07G\x02\x02\u087F\u0880\x07T\x02\x02\u0880\u0881\x07K\x02" + - "\x02\u0881\u0882\x07U\x02\x02\u0882\u0883\x07V\x02\x02\u0883\u0884\x07" + - "K\x02\x02\u0884\u0885\x07E\x02\x02\u0885\u0886\x07U\x02\x02\u0886\u0142" + - "\x03\x02\x02\x02\u0887\u0888\x07E\x02\x02\u0888\u0889\x07J\x02\x02\u0889" + - "\u088A\x07G\x02\x02\u088A\u088B\x07E\x02\x02\u088B\u088C\x07M\x02\x02" + - "\u088C\u088D\x07R\x02\x02\u088D\u088E\x07Q\x02\x02\u088E\u088F\x07K\x02" + - "\x02\u088F\u0890\x07P\x02\x02\u0890\u0891\x07V\x02\x02\u0891\u0144\x03" + - "\x02\x02\x02\u0892\u0893\x07E\x02\x02\u0893\u0894\x07N\x02\x02\u0894\u0895" + - "\x07C\x02\x02\u0895\u0896\x07U\x02\x02\u0896\u0897\x07U\x02\x02\u0897" + - "\u0146\x03\x02\x02\x02\u0898\u0899\x07E\x02\x02\u0899\u089A\x07N\x02\x02" + - "\u089A\u089B\x07Q\x02\x02\u089B\u089C\x07U\x02\x02\u089C\u089D\x07G\x02" + - "\x02\u089D\u0148\x03\x02\x02\x02\u089E\u089F\x07E\x02\x02\u089F\u08A0" + - "\x07N\x02\x02\u08A0\u08A1\x07W\x02\x02\u08A1\u08A2\x07U\x02\x02\u08A2" + - "\u08A3\x07V\x02\x02\u08A3\u08A4\x07G\x02\x02\u08A4\u08A5\x07T\x02\x02" + - "\u08A5\u014A\x03\x02\x02\x02\u08A6\u08A7\x07E\x02\x02\u08A7\u08A8\x07" + - "Q\x02\x02\u08A8\u08A9\x07O\x02\x02\u08A9\u08AA\x07O\x02\x02\u08AA\u08AB" + - "\x07G\x02\x02\u08AB\u08AC\x07P\x02\x02\u08AC\u08AD\x07V\x02\x02\u08AD" + - "\u014C\x03\x02\x02\x02\u08AE\u08AF\x07E\x02\x02\u08AF\u08B0\x07Q\x02\x02" + - "\u08B0\u08B1\x07O\x02\x02\u08B1\u08B2\x07O\x02\x02\u08B2\u08B3\x07G\x02" + - "\x02\u08B3\u08B4\x07P\x02\x02\u08B4\u08B5\x07V\x02\x02\u08B5\u08B6\x07" + - "U\x02\x02\u08B6\u014E\x03\x02\x02\x02\u08B7\u08B8\x07E\x02\x02\u08B8\u08B9" + - "\x07Q\x02\x02\u08B9\u08BA\x07O\x02\x02\u08BA\u08BB\x07O\x02\x02\u08BB" + - "\u08BC\x07K\x02\x02\u08BC\u08BD\x07V\x02\x02\u08BD\u0150\x03\x02\x02\x02" + - "\u08BE\u08BF\x07E\x02\x02\u08BF\u08C0\x07Q\x02\x02\u08C0\u08C1\x07O\x02" + - "\x02\u08C1\u08C2\x07O\x02\x02\u08C2\u08C3\x07K\x02\x02\u08C3\u08C4\x07" + - "V\x02\x02\u08C4\u08C5\x07V\x02\x02\u08C5\u08C6\x07G\x02\x02\u08C6\u08C7" + - "\x07F\x02\x02\u08C7\u0152\x03\x02\x02\x02\u08C8\u08C9\x07E\x02\x02\u08C9" + - "\u08CA\x07Q\x02\x02\u08CA\u08CB\x07P\x02\x02\u08CB\u08CC\x07H\x02\x02" + - "\u08CC\u08CD\x07K\x02\x02\u08CD\u08CE\x07I\x02\x02\u08CE\u08CF\x07W\x02" + - "\x02\u08CF\u08D0\x07T\x02\x02\u08D0\u08D1\x07C\x02\x02\u08D1\u08D2\x07" + - "V\x02\x02\u08D2\u08D3\x07K\x02\x02\u08D3\u08D4\x07Q\x02\x02\u08D4\u08D5" + - "\x07P\x02\x02\u08D5\u0154\x03\x02\x02\x02\u08D6\u08D7\x07E\x02\x02\u08D7" + - "\u08D8\x07Q\x02\x02\u08D8\u08D9\x07P\x02\x02\u08D9\u08DA\x07P\x02\x02" + - "\u08DA\u08DB\x07G\x02\x02\u08DB\u08DC\x07E\x02\x02\u08DC\u08DD\x07V\x02" + - "\x02\u08DD\u08DE\x07K\x02\x02\u08DE\u08DF\x07Q\x02\x02\u08DF\u08E0\x07" + - "P\x02\x02\u08E0\u0156\x03\x02\x02\x02\u08E1\u08E2\x07E\x02\x02\u08E2\u08E3" + - "\x07Q\x02\x02\u08E3\u08E4\x07P\x02\x02\u08E4\u08E5\x07U\x02\x02\u08E5" + - "\u08E6\x07V\x02\x02\u08E6\u08E7\x07T\x02\x02\u08E7\u08E8\x07C\x02\x02" + - "\u08E8\u08E9\x07K\x02\x02\u08E9\u08EA\x07P\x02\x02\u08EA\u08EB\x07V\x02" + - "\x02\u08EB\u08EC\x07U\x02\x02\u08EC\u0158\x03\x02\x02\x02\u08ED\u08EE" + - "\x07E\x02\x02\u08EE\u08EF\x07Q\x02\x02\u08EF\u08F0\x07P\x02\x02\u08F0" + - "\u08F1\x07V\x02\x02\u08F1\u08F2\x07G\x02\x02\u08F2\u08F3\x07P\x02\x02" + - "\u08F3\u08F4\x07V\x02\x02\u08F4\u015A\x03\x02\x02\x02\u08F5\u08F6\x07" + - "E\x02\x02\u08F6\u08F7\x07Q\x02\x02\u08F7\u08F8\x07P\x02\x02\u08F8\u08F9" + - "\x07V\x02\x02\u08F9\u08FA\x07K\x02\x02\u08FA\u08FB\x07P\x02\x02\u08FB" + - "\u08FC\x07W\x02\x02\u08FC\u08FD\x07G\x02\x02\u08FD\u015C\x03\x02\x02\x02" + - "\u08FE\u08FF\x07E\x02\x02\u08FF\u0900\x07Q\x02\x02\u0900\u0901\x07P\x02" + - "\x02\u0901\u0902\x07X\x02\x02\u0902\u0903\x07G\x02\x02\u0903\u0904\x07" + - "T\x02\x02\u0904\u0905\x07U\x02\x02\u0905\u0906\x07K\x02\x02\u0906\u0907" + - "\x07Q\x02\x02\u0907\u0908\x07P\x02\x02\u0908\u015E\x03\x02\x02\x02\u0909" + - "\u090A\x07E\x02\x02\u090A\u090B\x07Q\x02\x02\u090B\u090C\x07R\x02\x02" + - "\u090C\u090D\x07[\x02\x02\u090D\u0160\x03\x02\x02\x02\u090E\u090F\x07" + - "E\x02\x02\u090F\u0910\x07Q\x02\x02\u0910\u0911\x07U\x02\x02\u0911\u0912" + - "\x07V\x02\x02\u0912\u0162\x03\x02\x02\x02\u0913\u0914\x07E\x02\x02\u0914" + - "\u0915\x07U\x02\x02\u0915\u0916\x07X\x02\x02\u0916\u0164\x03\x02\x02\x02" + - "\u0917\u0918\x07E\x02\x02\u0918\u0919\x07W\x02\x02\u0919\u091A\x07T\x02" + - "\x02\u091A\u091B\x07U\x02\x02\u091B\u091C\x07Q\x02\x02\u091C\u091D\x07" + - "T\x02\x02\u091D\u0166\x03\x02\x02\x02\u091E\u091F\x07E\x02\x02\u091F\u0920" + - "\x07[\x02\x02\u0920\u0921\x07E\x02\x02\u0921\u0922\x07N\x02\x02\u0922" + - "\u0923\x07G\x02\x02\u0923\u0168\x03\x02\x02\x02\u0924\u0925\x07F\x02\x02" + - "\u0925\u0926\x07C\x02\x02\u0926\u0927\x07V\x02\x02\u0927\u0928\x07C\x02" + - "\x02\u0928\u016A\x03\x02\x02\x02\u0929\u092A\x07F\x02\x02\u092A\u092B" + - "\x07C\x02\x02\u092B\u092C\x07V\x02\x02\u092C\u092D\x07C\x02\x02\u092D" + - "\u092E\x07D\x02\x02\u092E\u092F\x07C\x02\x02\u092F\u0930\x07U\x02\x02" + - "\u0930\u0931\x07G\x02\x02\u0931\u016C\x03\x02\x02\x02\u0932\u0933\x07" + - "F\x02\x02\u0933\u0934\x07C\x02\x02\u0934\u0935\x07[\x02\x02\u0935\u016E" + - "\x03\x02\x02\x02\u0936\u0937\x07F\x02\x02\u0937\u0938\x07G\x02\x02\u0938" + - "\u0939\x07C\x02\x02\u0939\u093A\x07N\x02\x02\u093A\u093B\x07N\x02\x02" + - "\u093B\u093C\x07Q\x02\x02\u093C\u093D\x07E\x02\x02\u093D\u093E\x07C\x02" + - "\x02\u093E\u093F\x07V\x02\x02\u093F\u0940\x07G\x02\x02\u0940\u0170\x03" + - "\x02\x02\x02\u0941\u0942\x07F\x02\x02\u0942\u0943\x07G\x02\x02\u0943\u0944" + - "\x07E\x02\x02\u0944\u0945\x07N\x02\x02\u0945\u0946\x07C\x02\x02\u0946" + - "\u0947\x07T\x02\x02\u0947\u0948\x07G\x02\x02\u0948\u0172\x03\x02\x02\x02" + - "\u0949\u094A\x07F\x02\x02\u094A\u094B\x07G\x02\x02\u094B\u094C\x07H\x02" + - "\x02\u094C\u094D\x07C\x02\x02\u094D\u094E\x07W\x02\x02\u094E\u094F\x07" + - "N\x02\x02\u094F\u0950\x07V\x02\x02\u0950\u0951\x07U\x02\x02\u0951\u0174" + - "\x03\x02\x02\x02\u0952\u0953\x07F\x02\x02\u0953\u0954\x07G\x02\x02\u0954" + - "\u0955\x07H\x02\x02\u0955\u0956\x07G\x02\x02\u0956\u0957\x07T\x02\x02" + - "\u0957\u0958\x07T\x02\x02\u0958\u0959\x07G\x02\x02\u0959\u095A\x07F\x02" + - "\x02\u095A\u0176\x03\x02\x02\x02\u095B\u095C\x07F\x02\x02\u095C\u095D" + - "\x07G\x02\x02\u095D\u095E\x07H\x02\x02\u095E\u095F\x07K\x02\x02\u095F" + - "\u0960\x07P\x02\x02\u0960\u0961\x07G\x02\x02\u0961\u0962\x07T\x02\x02" + - "\u0962\u0178\x03\x02\x02\x02\u0963\u0964\x07F\x02\x02\u0964\u0965\x07" + - "G\x02\x02\u0965\u0966\x07N\x02\x02\u0966\u0967\x07G\x02\x02\u0967\u0968" + - "\x07V\x02\x02\u0968\u0969\x07G\x02\x02\u0969\u017A\x03\x02\x02\x02\u096A" + - "\u096B\x07F\x02\x02\u096B\u096C\x07G\x02\x02\u096C\u096D\x07N\x02\x02" + - "\u096D\u096E\x07K\x02\x02\u096E\u096F\x07O\x02\x02\u096F\u0970\x07K\x02" + - "\x02\u0970\u0971\x07V\x02\x02\u0971\u0972\x07G\x02\x02\u0972\u0973\x07" + - "T\x02\x02\u0973\u017C\x03\x02\x02\x02\u0974\u0975\x07F\x02\x02\u0975\u0976" + - "\x07G\x02\x02\u0976\u0977\x07N\x02\x02\u0977\u0978\x07K\x02\x02\u0978" + - "\u0979\x07O\x02\x02\u0979\u097A\x07K\x02\x02\u097A\u097B\x07V\x02\x02" + - "\u097B\u097C\x07G\x02\x02\u097C\u097D\x07T\x02\x02\u097D\u097E\x07U\x02" + - "\x02\u097E\u017E\x03\x02\x02\x02\u097F\u0980\x07F\x02\x02\u0980\u0981" + - "\x07K\x02\x02\u0981\u0982\x07E\x02\x02\u0982\u0983\x07V\x02\x02\u0983" + - "\u0984\x07K\x02\x02\u0984\u0985\x07Q\x02\x02\u0985\u0986\x07P\x02\x02" + - "\u0986\u0987\x07C\x02\x02\u0987\u0988\x07T\x02\x02\u0988\u0989\x07[\x02" + - "\x02\u0989\u0180\x03\x02\x02\x02\u098A\u098B\x07F\x02\x02\u098B\u098C" + - "\x07K\x02\x02\u098C\u098D\x07U\x02\x02\u098D\u098E\x07C\x02\x02\u098E" + - "\u098F\x07D\x02\x02\u098F\u0990\x07N\x02\x02\u0990\u0991\x07G\x02\x02" + - "\u0991\u0182\x03\x02\x02\x02\u0992\u0993\x07F\x02\x02\u0993\u0994\x07" + - "K\x02\x02\u0994\u0995\x07U\x02\x02\u0995\u0996\x07E\x02\x02\u0996\u0997" + - "\x07C\x02\x02\u0997\u0998\x07T\x02\x02\u0998\u0999\x07F\x02\x02\u0999" + - "\u0184\x03\x02\x02\x02\u099A\u099B\x07F\x02\x02\u099B\u099C\x07Q\x02\x02" + - "\u099C\u099D\x07E\x02\x02\u099D\u099E\x07W\x02\x02\u099E\u099F\x07O\x02" + - "\x02\u099F\u09A0\x07G\x02\x02\u09A0\u09A1\x07P\x02\x02\u09A1\u09A2\x07" + - "V\x02\x02\u09A2\u0186\x03\x02\x02\x02\u09A3\u09A4\x07F\x02\x02\u09A4\u09A5" + - "\x07Q\x02\x02\u09A5\u09A6\x07O\x02\x02\u09A6\u09A7\x07C\x02\x02\u09A7" + - "\u09A8\x07K\x02\x02\u09A8\u09A9\x07P\x02\x02\u09A9\u0188\x03\x02\x02\x02" + - "\u09AA\u09AB\x07F\x02\x02\u09AB\u09AC\x07Q\x02\x02\u09AC\u09AD\x07W\x02" + - "\x02\u09AD\u09AE\x07D\x02\x02\u09AE\u09AF\x07N\x02\x02\u09AF\u09B0\x07" + - "G\x02\x02\u09B0\u018A\x03\x02\x02\x02\u09B1\u09B2\x07F\x02\x02\u09B2\u09B3" + - "\x07T\x02\x02\u09B3\u09B4\x07Q\x02\x02\u09B4\u09B5\x07R\x02\x02\u09B5" + - "\u018C\x03\x02\x02\x02\u09B6\u09B7\x07G\x02\x02\u09B7\u09B8\x07C\x02\x02" + - "\u09B8\u09B9\x07E\x02\x02\u09B9\u09BA\x07J\x02\x02\u09BA\u018E\x03\x02" + - "\x02\x02\u09BB\u09BC\x07G\x02\x02\u09BC\u09BD\x07P\x02\x02\u09BD\u09BE" + - "\x07C\x02\x02\u09BE\u09BF\x07D\x02\x02\u09BF\u09C0\x07N\x02\x02\u09C0" + - "\u09C1\x07G\x02\x02\u09C1\u0190\x03\x02\x02\x02\u09C2\u09C3\x07G\x02\x02" + - "\u09C3\u09C4\x07P\x02\x02\u09C4\u09C5\x07E\x02\x02\u09C5\u09C6\x07Q\x02" + - "\x02\u09C6\u09C7\x07F\x02\x02\u09C7\u09C8\x07K\x02\x02\u09C8\u09C9\x07" + - "P\x02\x02\u09C9\u09CA\x07I\x02\x02\u09CA\u0192\x03\x02\x02\x02\u09CB\u09CC" + - "\x07G\x02\x02\u09CC\u09CD\x07P\x02\x02\u09CD\u09CE\x07E\x02\x02\u09CE" + - "\u09CF\x07T\x02\x02\u09CF\u09D0\x07[\x02\x02\u09D0\u09D1\x07R\x02\x02" + - "\u09D1\u09D2\x07V\x02\x02\u09D2\u09D3\x07G\x02\x02\u09D3\u09D4\x07F\x02" + - "\x02\u09D4\u0194\x03\x02\x02\x02\u09D5\u09D6\x07G\x02\x02\u09D6\u09D7" + - "\x07P\x02\x02\u09D7\u09D8\x07W\x02\x02\u09D8\u09D9\x07O\x02\x02\u09D9" + - "\u0196\x03\x02\x02\x02\u09DA\u09DB\x07G\x02\x02\u09DB\u09DC\x07U\x02\x02" + - "\u09DC\u09DD\x07E\x02\x02\u09DD\u09DE\x07C\x02\x02\u09DE\u09DF\x07R\x02" + - "\x02\u09DF\u09E0\x07G\x02\x02\u09E0\u0198\x03\x02\x02\x02\u09E1\u09E2" + - "\x07G\x02\x02\u09E2\u09E3\x07X\x02\x02\u09E3\u09E4\x07G\x02\x02\u09E4" + - "\u09E5\x07P\x02\x02\u09E5\u09E6\x07V\x02\x02\u09E6\u019A\x03\x02\x02\x02" + - "\u09E7\u09E8\x07G\x02\x02\u09E8\u09E9\x07Z\x02\x02\u09E9\u09EA\x07E\x02" + - "\x02\u09EA\u09EB\x07N\x02\x02\u09EB\u09EC\x07W\x02\x02\u09EC\u09ED\x07" + - "F\x02\x02\u09ED\u09EE\x07G\x02\x02\u09EE\u019C\x03\x02\x02\x02\u09EF\u09F0" + - "\x07G\x02\x02\u09F0\u09F1\x07Z\x02\x02\u09F1\u09F2\x07E\x02\x02\u09F2" + - "\u09F3\x07N\x02\x02\u09F3\u09F4\x07W\x02\x02\u09F4\u09F5\x07F\x02\x02" + - "\u09F5\u09F6\x07K\x02\x02\u09F6\u09F7\x07P\x02\x02\u09F7\u09F8\x07I\x02" + - "\x02\u09F8\u019E\x03\x02\x02\x02\u09F9\u09FA\x07G\x02\x02\u09FA\u09FB" + - "\x07Z\x02\x02\u09FB\u09FC\x07E\x02\x02\u09FC\u09FD\x07N\x02\x02\u09FD" + - "\u09FE\x07W\x02\x02\u09FE\u09FF\x07U\x02\x02\u09FF\u0A00\x07K\x02\x02" + - "\u0A00\u0A01\x07X\x02\x02\u0A01\u0A02\x07G\x02\x02\u0A02\u01A0\x03\x02" + - "\x02\x02\u0A03\u0A04\x07G\x02\x02\u0A04\u0A05\x07Z\x02\x02\u0A05\u0A06" + - "\x07G\x02\x02\u0A06\u0A07\x07E\x02\x02\u0A07\u0A08\x07W\x02\x02\u0A08" + - "\u0A09\x07V\x02\x02\u0A09\u0A0A\x07G\x02\x02\u0A0A\u01A2\x03\x02\x02\x02" + - "\u0A0B\u0A0C\x07G\x02\x02\u0A0C\u0A0D\x07Z\x02\x02\u0A0D\u0A0E\x07R\x02" + - "\x02\u0A0E\u0A0F\x07N\x02\x02\u0A0F\u0A10\x07C\x02\x02\u0A10\u0A11\x07" + - "K\x02\x02\u0A11\u0A12\x07P\x02\x02\u0A12\u01A4\x03\x02\x02\x02\u0A13\u0A14" + - "\x07G\x02\x02\u0A14\u0A15\x07Z\x02\x02\u0A15\u0A16\x07V\x02\x02\u0A16" + - "\u0A17\x07G\x02\x02\u0A17\u0A18\x07P\x02\x02\u0A18\u0A19\x07U\x02\x02" + - "\u0A19\u0A1A\x07K\x02\x02\u0A1A\u0A1B\x07Q\x02\x02\u0A1B\u0A1C\x07P\x02" + - "\x02\u0A1C\u01A6\x03\x02\x02\x02\u0A1D\u0A1E\x07G\x02\x02\u0A1E\u0A1F" + - "\x07Z\x02\x02\u0A1F\u0A20\x07V\x02\x02\u0A20\u0A21\x07G\x02\x02\u0A21" + - "\u0A22\x07T\x02\x02\u0A22\u0A23\x07P\x02\x02\u0A23\u0A24\x07C\x02\x02" + - "\u0A24\u0A25\x07N\x02\x02\u0A25\u01A8\x03\x02\x02\x02\u0A26\u0A27\x07" + - "H\x02\x02\u0A27\u0A28\x07C\x02\x02\u0A28\u0A29\x07O\x02\x02\u0A29\u0A2A" + - "\x07K\x02\x02\u0A2A\u0A2B\x07N\x02\x02\u0A2B\u0A2C\x07[\x02\x02\u0A2C" + - "\u01AA\x03\x02\x02\x02\u0A2D\u0A2E\x07H\x02\x02\u0A2E\u0A2F\x07K\x02\x02" + - "\u0A2F\u0A30\x07T\x02\x02\u0A30\u0A31\x07U\x02\x02\u0A31\u0A32\x07V\x02" + - "\x02\u0A32\u01AC\x03\x02\x02\x02\u0A33\u0A34\x07H\x02\x02\u0A34\u0A35" + - "\x07Q\x02\x02\u0A35\u0A36\x07N\x02\x02\u0A36\u0A37\x07N\x02\x02\u0A37" + - "\u0A38\x07Q\x02\x02\u0A38\u0A39\x07Y\x02\x02\u0A39\u0A3A\x07K\x02\x02" + - "\u0A3A\u0A3B\x07P\x02\x02\u0A3B\u0A3C\x07I\x02\x02\u0A3C\u01AE\x03\x02" + - "\x02\x02\u0A3D\u0A3E\x07H\x02\x02\u0A3E\u0A3F\x07Q\x02\x02\u0A3F\u0A40" + - "\x07T\x02\x02\u0A40\u0A41\x07E\x02\x02\u0A41\u0A42\x07G\x02\x02\u0A42" + - "\u01B0\x03\x02\x02\x02\u0A43\u0A44\x07H\x02\x02\u0A44\u0A45\x07Q\x02\x02" + - "\u0A45\u0A46\x07T\x02\x02\u0A46\u0A47\x07Y\x02\x02\u0A47\u0A48\x07C\x02" + - "\x02\u0A48\u0A49\x07T\x02\x02\u0A49\u0A4A\x07F\x02\x02\u0A4A\u01B2\x03" + - "\x02\x02\x02\u0A4B\u0A4C\x07H\x02\x02\u0A4C\u0A4D\x07W\x02\x02\u0A4D\u0A4E" + - "\x07P\x02\x02\u0A4E\u0A4F\x07E\x02\x02\u0A4F\u0A50\x07V\x02\x02\u0A50" + - "\u0A51\x07K\x02\x02\u0A51\u0A52\x07Q\x02\x02\u0A52\u0A53\x07P\x02\x02" + - "\u0A53\u01B4\x03\x02\x02\x02\u0A54\u0A55\x07H\x02\x02\u0A55\u0A56\x07" + - "W\x02\x02\u0A56\u0A57\x07P\x02\x02\u0A57\u0A58\x07E\x02\x02\u0A58\u0A59" + - "\x07V\x02\x02\u0A59\u0A5A\x07K\x02\x02\u0A5A\u0A5B\x07Q\x02\x02\u0A5B" + - "\u0A5C\x07P\x02\x02\u0A5C\u0A5D\x07U\x02\x02\u0A5D\u01B6\x03\x02\x02\x02" + - "\u0A5E\u0A5F\x07I\x02\x02\u0A5F\u0A60\x07N\x02\x02\u0A60\u0A61\x07Q\x02" + - "\x02\u0A61\u0A62\x07D\x02\x02\u0A62\u0A63\x07C\x02\x02\u0A63\u0A64\x07" + - "N\x02\x02\u0A64\u01B8\x03\x02\x02\x02\u0A65\u0A66\x07I\x02\x02\u0A66\u0A67" + - "\x07T\x02\x02\u0A67\u0A68\x07C\x02\x02\u0A68\u0A69\x07P\x02\x02\u0A69" + - "\u0A6A\x07V\x02\x02\u0A6A\u0A6B\x07G\x02\x02\u0A6B\u0A6C\x07F\x02\x02" + - "\u0A6C\u01BA\x03\x02\x02\x02\u0A6D\u0A6E\x07J\x02\x02\u0A6E\u0A6F\x07" + - "C\x02\x02\u0A6F\u0A70\x07P\x02\x02\u0A70\u0A71\x07F\x02\x02\u0A71\u0A72" + - "\x07N\x02\x02\u0A72\u0A73\x07G\x02\x02\u0A73\u0A74\x07T\x02\x02\u0A74" + - "\u01BC\x03\x02\x02\x02\u0A75\u0A76\x07J\x02\x02\u0A76\u0A77\x07G\x02\x02" + - "\u0A77\u0A78\x07C\x02\x02\u0A78\u0A79\x07F\x02\x02\u0A79\u0A7A\x07G\x02" + - "\x02\u0A7A\u0A7B\x07T\x02\x02\u0A7B\u01BE\x03\x02\x02\x02\u0A7C\u0A7D" + - "\x07J\x02\x02\u0A7D\u0A7E\x07Q\x02\x02\u0A7E\u0A7F\x07N\x02\x02\u0A7F" + - "\u0A80\x07F\x02\x02\u0A80\u01C0\x03\x02\x02\x02\u0A81\u0A82\x07J\x02\x02" + - "\u0A82\u0A83\x07Q\x02\x02\u0A83\u0A84\x07W\x02\x02\u0A84\u0A85\x07T\x02" + - "\x02\u0A85\u01C2\x03\x02\x02\x02\u0A86\u0A87\x07K\x02\x02\u0A87\u0A88" + - "\x07F\x02\x02\u0A88\u0A89\x07G\x02\x02\u0A89\u0A8A\x07P\x02\x02\u0A8A" + - "\u0A8B\x07V\x02\x02\u0A8B\u0A8C\x07K\x02\x02\u0A8C\u0A8D\x07V\x02\x02" + - "\u0A8D\u0A8E\x07[\x02\x02\u0A8E\u01C4\x03\x02\x02\x02\u0A8F\u0A90\x07" + - "K\x02\x02\u0A90\u0A91\x07H\x02\x02\u0A91\u01C6\x03\x02\x02\x02\u0A92\u0A93" + - "\x07K\x02\x02\u0A93\u0A94\x07O\x02\x02\u0A94\u0A95\x07O\x02\x02\u0A95" + - "\u0A96\x07G\x02\x02\u0A96\u0A97\x07F\x02\x02\u0A97\u0A98\x07K\x02\x02" + - "\u0A98\u0A99\x07C\x02\x02\u0A99\u0A9A\x07V\x02\x02\u0A9A\u0A9B\x07G\x02" + - "\x02\u0A9B\u01C8\x03\x02\x02\x02\u0A9C\u0A9D\x07K\x02\x02\u0A9D\u0A9E" + - "\x07O\x02\x02\u0A9E\u0A9F\x07O\x02\x02\u0A9F\u0AA0\x07W\x02\x02\u0AA0" + - "\u0AA1\x07V\x02\x02\u0AA1\u0AA2\x07C\x02\x02\u0AA2\u0AA3\x07D\x02\x02" + - "\u0AA3\u0AA4\x07N\x02\x02\u0AA4\u0AA5\x07G\x02\x02\u0AA5\u01CA\x03\x02" + - "\x02\x02\u0AA6\u0AA7\x07K\x02\x02\u0AA7\u0AA8\x07O\x02\x02\u0AA8\u0AA9" + - "\x07R\x02\x02\u0AA9\u0AAA\x07N\x02\x02\u0AAA\u0AAB\x07K\x02\x02\u0AAB" + - "\u0AAC\x07E\x02\x02\u0AAC\u0AAD\x07K\x02\x02\u0AAD\u0AAE\x07V\x02\x02" + - "\u0AAE\u01CC\x03\x02\x02\x02\u0AAF\u0AB0\x07K\x02\x02\u0AB0\u0AB1\x07" + - "P\x02\x02\u0AB1\u0AB2\x07E\x02\x02\u0AB2\u0AB3\x07N\x02\x02\u0AB3\u0AB4" + - "\x07W\x02\x02\u0AB4\u0AB5\x07F\x02\x02\u0AB5\u0AB6\x07K\x02\x02\u0AB6" + - "\u0AB7\x07P\x02\x02\u0AB7\u0AB8\x07I\x02\x02\u0AB8\u01CE\x03\x02\x02\x02" + - "\u0AB9\u0ABA\x07K\x02\x02\u0ABA\u0ABB\x07P\x02\x02\u0ABB\u0ABC\x07E\x02" + - "\x02\u0ABC\u0ABD\x07T\x02\x02\u0ABD\u0ABE\x07G\x02\x02\u0ABE\u0ABF\x07" + - "O\x02\x02\u0ABF\u0AC0\x07G\x02\x02\u0AC0\u0AC1\x07P\x02\x02\u0AC1\u0AC2" + - "\x07V\x02\x02\u0AC2\u01D0\x03\x02\x02\x02\u0AC3\u0AC4\x07K\x02\x02\u0AC4" + - "\u0AC5\x07P\x02\x02\u0AC5\u0AC6\x07F\x02\x02\u0AC6\u0AC7\x07G\x02\x02" + - "\u0AC7\u0AC8\x07Z\x02\x02\u0AC8\u01D2\x03\x02\x02\x02\u0AC9\u0ACA\x07" + - "K\x02\x02\u0ACA\u0ACB\x07P\x02\x02\u0ACB\u0ACC\x07F\x02\x02\u0ACC\u0ACD" + - "\x07G\x02\x02\u0ACD\u0ACE\x07Z\x02\x02\u0ACE\u0ACF\x07G\x02\x02\u0ACF" + - "\u0AD0\x07U\x02\x02\u0AD0\u01D4\x03\x02\x02\x02\u0AD1\u0AD2\x07K\x02\x02" + - "\u0AD2\u0AD3\x07P\x02\x02\u0AD3\u0AD4\x07J\x02\x02\u0AD4\u0AD5\x07G\x02" + - "\x02\u0AD5\u0AD6\x07T\x02\x02\u0AD6\u0AD7\x07K\x02\x02\u0AD7\u0AD8\x07" + - "V\x02\x02\u0AD8\u01D6\x03\x02\x02\x02\u0AD9\u0ADA\x07K\x02\x02\u0ADA\u0ADB" + - "\x07P\x02\x02\u0ADB\u0ADC\x07J\x02\x02\u0ADC\u0ADD\x07G\x02\x02\u0ADD" + - "\u0ADE\x07T\x02\x02\u0ADE\u0ADF\x07K\x02\x02\u0ADF\u0AE0\x07V\x02\x02" + - "\u0AE0\u0AE1\x07U\x02\x02\u0AE1\u01D8\x03\x02\x02\x02\u0AE2\u0AE3\x07" + - "K\x02\x02\u0AE3\u0AE4\x07P\x02\x02\u0AE4\u0AE5\x07N\x02\x02\u0AE5\u0AE6" + - "\x07K\x02\x02\u0AE6\u0AE7\x07P\x02\x02\u0AE7\u0AE8\x07G\x02\x02\u0AE8" + - "\u01DA\x03\x02\x02\x02\u0AE9\u0AEA\x07K\x02\x02\u0AEA\u0AEB\x07P\x02\x02" + - "\u0AEB\u0AEC\x07U\x02\x02\u0AEC\u0AED\x07G\x02\x02\u0AED\u0AEE\x07P\x02" + - "\x02\u0AEE\u0AEF\x07U\x02\x02\u0AEF\u0AF0\x07K\x02\x02\u0AF0\u0AF1\x07" + - "V\x02\x02\u0AF1\u0AF2\x07K\x02\x02\u0AF2\u0AF3\x07X\x02\x02\u0AF3\u0AF4" + - "\x07G\x02\x02\u0AF4\u01DC\x03\x02\x02\x02\u0AF5\u0AF6\x07K\x02\x02\u0AF6" + - "\u0AF7\x07P\x02\x02\u0AF7\u0AF8\x07U\x02\x02\u0AF8\u0AF9\x07G\x02\x02" + - "\u0AF9\u0AFA\x07T\x02\x02\u0AFA\u0AFB\x07V\x02\x02\u0AFB\u01DE\x03\x02" + - "\x02\x02\u0AFC\u0AFD\x07K\x02\x02\u0AFD\u0AFE\x07P\x02\x02\u0AFE\u0AFF" + - "\x07U\x02\x02\u0AFF\u0B00\x07V\x02\x02\u0B00\u0B01\x07G\x02\x02\u0B01" + - "\u0B02\x07C\x02\x02\u0B02\u0B03\x07F\x02\x02\u0B03\u01E0\x03\x02\x02\x02" + - "\u0B04\u0B05\x07K\x02\x02\u0B05\u0B06\x07P\x02\x02\u0B06\u0B07\x07X\x02" + - "\x02\u0B07\u0B08\x07Q\x02\x02\u0B08\u0B09\x07M\x02\x02\u0B09\u0B0A\x07" + - "G\x02\x02\u0B0A\u0B0B\x07T\x02\x02\u0B0B\u01E2\x03\x02\x02\x02\u0B0C\u0B0D" + - "\x07K\x02\x02\u0B0D\u0B0E\x07U\x02\x02\u0B0E\u0B0F\x07Q\x02\x02\u0B0F" + - "\u0B10\x07N\x02\x02\u0B10\u0B11\x07C\x02\x02\u0B11\u0B12\x07V\x02\x02" + - "\u0B12\u0B13\x07K\x02\x02\u0B13\u0B14\x07Q\x02\x02\u0B14\u0B15\x07P\x02" + - "\x02\u0B15\u01E4\x03\x02\x02\x02\u0B16\u0B17\x07M\x02\x02\u0B17\u0B18" + - "\x07G\x02\x02\u0B18\u0B19\x07[\x02\x02\u0B19\u01E6\x03\x02\x02\x02\u0B1A" + - "\u0B1B\x07N\x02\x02\u0B1B\u0B1C\x07C\x02\x02\u0B1C\u0B1D\x07D\x02\x02" + - "\u0B1D\u0B1E\x07G\x02\x02\u0B1E\u0B1F\x07N\x02\x02\u0B1F\u01E8\x03\x02" + - "\x02\x02\u0B20\u0B21\x07N\x02\x02\u0B21\u0B22\x07C\x02\x02\u0B22\u0B23" + - "\x07P\x02\x02\u0B23\u0B24\x07I\x02\x02\u0B24\u0B25\x07W\x02\x02\u0B25" + - "\u0B26\x07C\x02\x02\u0B26\u0B27\x07I\x02\x02\u0B27\u0B28\x07G\x02\x02" + - "\u0B28\u01EA\x03\x02\x02\x02\u0B29\u0B2A\x07N\x02\x02\u0B2A\u0B2B\x07" + - "C\x02\x02\u0B2B\u0B2C\x07T\x02\x02\u0B2C\u0B2D\x07I\x02\x02\u0B2D\u0B2E" + - "\x07G\x02\x02\u0B2E\u01EC\x03\x02\x02\x02\u0B2F\u0B30\x07N\x02\x02\u0B30" + - "\u0B31\x07C\x02\x02\u0B31\u0B32\x07U\x02\x02\u0B32\u0B33\x07V\x02\x02" + - "\u0B33\u01EE\x03\x02\x02\x02\u0B34\u0B35\x07N\x02\x02\u0B35\u0B36"; + "\u07C1\u0108\x03\x02\x02\x02\u07C2\u07C3\x07T\x02\x02\u07C3\u07C4\x07" + + "K\x02\x02\u07C4\u07C5\x07I\x02\x02\u07C5\u07C6\x07J\x02\x02\u07C6\u07C7" + + "\x07V\x02\x02\u07C7\u010A\x03\x02\x02\x02\u07C8\u07C9\x07U\x02\x02\u07C9" + + "\u07CA\x07K\x02\x02\u07CA\u07CB\x07O\x02\x02\u07CB\u07CC\x07K\x02\x02" + + "\u07CC\u07CD\x07N\x02\x02\u07CD\u07CE\x07C\x02\x02\u07CE\u07CF\x07T\x02" + + "\x02\u07CF\u010C\x03\x02\x02\x02\u07D0\u07D1\x07X\x02\x02\u07D1\u07D2" + + "\x07G\x02\x02\u07D2\u07D3\x07T\x02\x02\u07D3\u07D4\x07D\x02\x02\u07D4" + + "\u07D5\x07Q\x02\x02\u07D5\u07D6\x07U\x02\x02\u07D6\u07D7\x07G\x02\x02" + + "\u07D7\u010E\x03\x02\x02\x02\u07D8\u07D9\x07C\x02\x02\u07D9\u07DA\x07" + + "D\x02\x02\u07DA\u07DB\x07Q\x02\x02\u07DB\u07DC\x07T\x02\x02\u07DC\u07DD" + + "\x07V\x02\x02\u07DD\u0110\x03\x02\x02\x02\u07DE\u07DF\x07C\x02\x02\u07DF" + + "\u07E0\x07D\x02\x02\u07E0\u07E1\x07U\x02\x02\u07E1\u07E2\x07Q\x02\x02" + + "\u07E2\u07E3\x07N\x02\x02\u07E3\u07E4\x07W\x02\x02\u07E4\u07E5\x07V\x02" + + "\x02\u07E5\u07E6\x07G\x02\x02\u07E6\u0112\x03\x02\x02\x02\u07E7\u07E8" + + "\x07C\x02\x02\u07E8\u07E9\x07E\x02\x02\u07E9\u07EA\x07E\x02\x02\u07EA" + + "\u07EB\x07G\x02\x02\u07EB\u07EC\x07U\x02\x02\u07EC\u07ED\x07U\x02\x02" + + "\u07ED\u0114\x03\x02\x02\x02\u07EE\u07EF\x07C\x02\x02\u07EF\u07F0\x07" + + "E\x02\x02\u07F0\u07F1\x07V\x02\x02\u07F1\u07F2\x07K\x02\x02\u07F2\u07F3" + + "\x07Q\x02\x02\u07F3\u07F4\x07P\x02\x02\u07F4\u0116\x03\x02\x02\x02\u07F5" + + "\u07F6\x07C\x02\x02\u07F6\u07F7\x07F\x02\x02\u07F7\u07F8\x07F\x02\x02" + + "\u07F8\u0118\x03\x02\x02\x02\u07F9\u07FA\x07C\x02\x02\u07FA\u07FB\x07" + + "F\x02\x02\u07FB\u07FC\x07O\x02\x02\u07FC\u07FD\x07K\x02\x02\u07FD\u07FE" + + "\x07P\x02\x02\u07FE\u011A\x03\x02\x02\x02\u07FF\u0800\x07C\x02\x02\u0800" + + "\u0801\x07H\x02\x02\u0801\u0802\x07V\x02\x02\u0802\u0803\x07G\x02\x02" + + "\u0803\u0804\x07T\x02\x02\u0804\u011C\x03\x02\x02\x02\u0805\u0806\x07" + + "C\x02\x02\u0806\u0807\x07I\x02\x02\u0807\u0808\x07I\x02\x02\u0808\u0809" + + "\x07T\x02\x02\u0809\u080A\x07G\x02\x02\u080A\u080B\x07I\x02\x02\u080B" + + "\u080C\x07C\x02\x02\u080C\u080D\x07V\x02\x02\u080D\u080E\x07G\x02\x02" + + "\u080E\u011E\x03\x02\x02\x02\u080F\u0810\x07C\x02\x02\u0810\u0811\x07" + + "N\x02\x02\u0811\u0812\x07U\x02\x02\u0812\u0813\x07Q\x02\x02\u0813\u0120" + + "\x03\x02\x02\x02\u0814\u0815\x07C\x02\x02\u0815\u0816\x07N\x02\x02\u0816" + + "\u0817\x07V\x02\x02\u0817\u0818\x07G\x02\x02\u0818\u0819\x07T\x02\x02" + + "\u0819\u0122\x03\x02\x02\x02\u081A\u081B\x07C\x02\x02\u081B\u081C\x07" + + "N\x02\x02\u081C\u081D\x07Y\x02\x02\u081D\u081E\x07C\x02\x02\u081E\u081F" + + "\x07[\x02\x02\u081F\u0820\x07U\x02\x02\u0820\u0124\x03\x02\x02\x02\u0821" + + "\u0822\x07C\x02\x02\u0822\u0823\x07U\x02\x02\u0823\u0824\x07U\x02\x02" + + "\u0824\u0825\x07G\x02\x02\u0825\u0826\x07T\x02\x02\u0826\u0827\x07V\x02" + + "\x02\u0827\u0828\x07K\x02\x02\u0828\u0829\x07Q\x02\x02\u0829\u082A\x07" + + "P\x02\x02\u082A\u0126\x03\x02\x02\x02\u082B\u082C\x07C\x02\x02\u082C\u082D" + + "\x07U\x02\x02\u082D\u082E\x07U\x02\x02\u082E\u082F\x07K\x02\x02\u082F" + + "\u0830\x07I\x02\x02\u0830\u0831\x07P\x02\x02\u0831\u0832\x07O\x02\x02" + + "\u0832\u0833\x07G\x02\x02\u0833\u0834\x07P\x02\x02\u0834\u0835\x07V\x02" + + "\x02\u0835\u0128\x03\x02\x02\x02\u0836\u0837\x07C\x02\x02\u0837\u0838" + + "\x07V\x02\x02\u0838\u012A\x03\x02\x02\x02\u0839\u083A\x07C\x02\x02\u083A" + + "\u083B\x07V\x02\x02\u083B\u083C\x07V\x02\x02\u083C\u083D\x07T\x02\x02" + + "\u083D\u083E\x07K\x02\x02\u083E\u083F\x07D\x02\x02\u083F\u0840\x07W\x02" + + "\x02\u0840\u0841\x07V\x02\x02\u0841\u0842\x07G\x02\x02\u0842\u012C\x03" + + "\x02\x02\x02\u0843\u0844\x07D\x02\x02\u0844\u0845\x07C\x02\x02\u0845\u0846" + + "\x07E\x02\x02\u0846\u0847\x07M\x02\x02\u0847\u0848\x07Y\x02\x02\u0848" + + "\u0849\x07C\x02\x02\u0849\u084A\x07T\x02\x02\u084A\u084B\x07F\x02\x02" + + "\u084B\u012E\x03\x02\x02\x02\u084C\u084D\x07D\x02\x02\u084D\u084E\x07" + + "G\x02\x02\u084E\u084F\x07H\x02\x02\u084F\u0850\x07Q\x02\x02\u0850\u0851" + + "\x07T\x02\x02\u0851\u0852\x07G\x02\x02\u0852\u0130\x03\x02\x02\x02\u0853" + + "\u0854\x07D\x02\x02\u0854\u0855\x07G\x02\x02\u0855\u0856\x07I\x02\x02" + + "\u0856\u0857\x07K\x02\x02\u0857\u0858\x07P\x02\x02\u0858\u0132\x03\x02" + + "\x02\x02\u0859\u085A\x07D\x02\x02\u085A\u085B\x07[\x02\x02\u085B\u0134" + + "\x03\x02\x02\x02\u085C\u085D\x07E\x02\x02\u085D\u085E\x07C\x02\x02\u085E" + + "\u085F\x07E\x02\x02\u085F\u0860\x07J\x02\x02\u0860\u0861\x07G\x02\x02" + + "\u0861\u0136\x03\x02\x02\x02\u0862\u0863\x07E\x02\x02\u0863\u0864\x07" + + "C\x02\x02\u0864\u0865\x07N\x02\x02\u0865\u0866\x07N\x02\x02\u0866\u0867" + + "\x07G\x02\x02\u0867\u0868\x07F\x02\x02\u0868\u0138\x03\x02\x02\x02\u0869" + + "\u086A\x07E\x02\x02\u086A\u086B\x07C\x02\x02\u086B\u086C\x07U\x02\x02" + + "\u086C\u086D\x07E\x02\x02\u086D\u086E\x07C\x02\x02\u086E\u086F\x07F\x02" + + "\x02\u086F\u0870\x07G\x02\x02\u0870\u013A\x03\x02\x02\x02\u0871\u0872" + + "\x07E\x02\x02\u0872\u0873\x07C\x02\x02\u0873\u0874\x07U\x02\x02\u0874" + + "\u0875\x07E\x02\x02\u0875\u0876\x07C\x02\x02\u0876\u0877\x07F\x02\x02" + + "\u0877\u0878\x07G\x02\x02\u0878\u0879\x07F\x02\x02\u0879\u013C\x03\x02" + + "\x02\x02\u087A\u087B\x07E\x02\x02\u087B\u087C\x07C\x02\x02\u087C\u087D" + + "\x07V\x02\x02\u087D\u087E\x07C\x02\x02\u087E\u087F\x07N\x02\x02\u087F" + + "\u0880\x07Q\x02\x02\u0880\u0881\x07I\x02\x02\u0881\u013E\x03\x02\x02\x02" + + "\u0882\u0883\x07E\x02\x02\u0883\u0884\x07J\x02\x02\u0884\u0885\x07C\x02" + + "\x02\u0885\u0886\x07K\x02\x02\u0886\u0887\x07P\x02\x02\u0887\u0140\x03" + + "\x02\x02\x02\u0888\u0889\x07E\x02\x02\u0889\u088A\x07J\x02\x02\u088A\u088B" + + "\x07C\x02\x02\u088B\u088C\x07T\x02\x02\u088C\u088D\x07C\x02\x02\u088D" + + "\u088E\x07E\x02\x02\u088E\u088F\x07V\x02\x02\u088F\u0890\x07G\x02\x02" + + "\u0890\u0891\x07T\x02\x02\u0891\u0892\x07K\x02\x02\u0892\u0893\x07U\x02" + + "\x02\u0893\u0894\x07V\x02\x02\u0894\u0895\x07K\x02\x02\u0895\u0896\x07" + + "E\x02\x02\u0896\u0897\x07U\x02\x02\u0897\u0142\x03\x02\x02\x02\u0898\u0899" + + "\x07E\x02\x02\u0899\u089A\x07J\x02\x02\u089A\u089B\x07G\x02\x02\u089B" + + "\u089C\x07E\x02\x02\u089C\u089D\x07M\x02\x02\u089D\u089E\x07R\x02\x02" + + "\u089E\u089F\x07Q\x02\x02\u089F\u08A0\x07K\x02\x02\u08A0\u08A1\x07P\x02" + + "\x02\u08A1\u08A2\x07V\x02\x02\u08A2\u0144\x03\x02\x02\x02\u08A3\u08A4" + + "\x07E\x02\x02\u08A4\u08A5\x07N\x02\x02\u08A5\u08A6\x07C\x02\x02\u08A6" + + "\u08A7\x07U\x02\x02\u08A7\u08A8\x07U\x02\x02\u08A8\u0146\x03\x02\x02\x02" + + "\u08A9\u08AA\x07E\x02\x02\u08AA\u08AB\x07N\x02\x02\u08AB\u08AC\x07Q\x02" + + "\x02\u08AC\u08AD\x07U\x02\x02\u08AD\u08AE\x07G\x02\x02\u08AE\u0148\x03" + + "\x02\x02\x02\u08AF\u08B0\x07E\x02\x02\u08B0\u08B1\x07N\x02\x02\u08B1\u08B2" + + "\x07W\x02\x02\u08B2\u08B3\x07U\x02\x02\u08B3\u08B4\x07V\x02\x02\u08B4" + + "\u08B5\x07G\x02\x02\u08B5\u08B6\x07T\x02\x02\u08B6\u014A\x03\x02\x02\x02" + + "\u08B7\u08B8\x07E\x02\x02\u08B8\u08B9\x07Q\x02\x02\u08B9\u08BA\x07O\x02" + + "\x02\u08BA\u08BB\x07O\x02\x02\u08BB\u08BC\x07G\x02\x02\u08BC\u08BD\x07" + + "P\x02\x02\u08BD\u08BE\x07V\x02\x02\u08BE\u014C\x03\x02\x02\x02\u08BF\u08C0" + + "\x07E\x02\x02\u08C0\u08C1\x07Q\x02\x02\u08C1\u08C2\x07O\x02\x02\u08C2" + + "\u08C3\x07O\x02\x02\u08C3\u08C4\x07G\x02\x02\u08C4\u08C5\x07P\x02\x02" + + "\u08C5\u08C6\x07V\x02\x02\u08C6\u08C7\x07U\x02\x02\u08C7\u014E\x03\x02" + + "\x02\x02\u08C8\u08C9\x07E\x02\x02\u08C9\u08CA\x07Q\x02\x02\u08CA\u08CB" + + "\x07O\x02\x02\u08CB\u08CC\x07O\x02\x02\u08CC\u08CD\x07K\x02\x02\u08CD" + + "\u08CE\x07V\x02\x02\u08CE\u0150\x03\x02\x02\x02\u08CF\u08D0\x07E\x02\x02" + + "\u08D0\u08D1\x07Q\x02\x02\u08D1\u08D2\x07O\x02\x02\u08D2\u08D3\x07O\x02" + + "\x02\u08D3\u08D4\x07K\x02\x02\u08D4\u08D5\x07V\x02\x02\u08D5\u08D6\x07" + + "V\x02\x02\u08D6\u08D7\x07G\x02\x02\u08D7\u08D8\x07F\x02\x02\u08D8\u0152" + + "\x03\x02\x02\x02\u08D9\u08DA\x07E\x02\x02\u08DA\u08DB\x07Q\x02\x02\u08DB" + + "\u08DC\x07P\x02\x02\u08DC\u08DD\x07H\x02\x02\u08DD\u08DE\x07K\x02\x02" + + "\u08DE\u08DF\x07I\x02\x02\u08DF\u08E0\x07W\x02\x02\u08E0\u08E1\x07T\x02" + + "\x02\u08E1\u08E2\x07C\x02\x02\u08E2\u08E3\x07V\x02\x02\u08E3\u08E4\x07" + + "K\x02\x02\u08E4\u08E5\x07Q\x02\x02\u08E5\u08E6\x07P\x02\x02\u08E6\u0154" + + "\x03\x02\x02\x02\u08E7\u08E8\x07E\x02\x02\u08E8\u08E9\x07Q\x02\x02\u08E9" + + "\u08EA\x07P\x02\x02\u08EA\u08EB\x07P\x02\x02\u08EB\u08EC\x07G\x02\x02" + + "\u08EC\u08ED\x07E\x02\x02\u08ED\u08EE\x07V\x02\x02\u08EE\u08EF\x07K\x02" + + "\x02\u08EF\u08F0\x07Q\x02\x02\u08F0\u08F1\x07P\x02\x02\u08F1\u0156\x03" + + "\x02\x02\x02\u08F2\u08F3\x07E\x02\x02\u08F3\u08F4\x07Q\x02\x02\u08F4\u08F5" + + "\x07P\x02\x02\u08F5\u08F6\x07U\x02\x02\u08F6\u08F7\x07V\x02\x02\u08F7" + + "\u08F8\x07T\x02\x02\u08F8\u08F9\x07C\x02\x02\u08F9\u08FA\x07K\x02\x02" + + "\u08FA\u08FB\x07P\x02\x02\u08FB\u08FC\x07V\x02\x02\u08FC\u08FD\x07U\x02" + + "\x02\u08FD\u0158\x03\x02\x02\x02\u08FE\u08FF\x07E\x02\x02\u08FF\u0900" + + "\x07Q\x02\x02\u0900\u0901\x07P\x02\x02\u0901\u0902\x07V\x02\x02\u0902" + + "\u0903\x07G\x02\x02\u0903\u0904\x07P\x02\x02\u0904\u0905\x07V\x02\x02" + + "\u0905\u015A\x03\x02\x02\x02\u0906\u0907\x07E\x02\x02\u0907\u0908\x07" + + "Q\x02\x02\u0908\u0909\x07P\x02\x02\u0909\u090A\x07V\x02\x02\u090A\u090B" + + "\x07K\x02\x02\u090B\u090C\x07P\x02\x02\u090C\u090D\x07W\x02\x02\u090D" + + "\u090E\x07G\x02\x02\u090E\u015C\x03\x02\x02\x02\u090F\u0910\x07E\x02\x02" + + "\u0910\u0911\x07Q\x02\x02\u0911\u0912\x07P\x02\x02\u0912\u0913\x07X\x02" + + "\x02\u0913\u0914\x07G\x02\x02\u0914\u0915\x07T\x02\x02\u0915\u0916\x07" + + "U\x02\x02\u0916\u0917\x07K\x02\x02\u0917\u0918\x07Q\x02\x02\u0918\u0919" + + "\x07P\x02\x02\u0919\u015E\x03\x02\x02\x02\u091A\u091B\x07E\x02\x02\u091B" + + "\u091C\x07Q\x02\x02\u091C\u091D\x07R\x02\x02\u091D\u091E\x07[\x02\x02" + + "\u091E\u0160\x03\x02\x02\x02\u091F\u0920\x07E\x02\x02\u0920\u0921\x07" + + "Q\x02\x02\u0921\u0922\x07U\x02\x02\u0922\u0923\x07V\x02\x02\u0923\u0162" + + "\x03\x02\x02\x02\u0924\u0925\x07E\x02\x02\u0925\u0926\x07U\x02\x02\u0926" + + "\u0927\x07X\x02\x02\u0927\u0164\x03\x02\x02\x02\u0928\u0929\x07E\x02\x02" + + "\u0929\u092A\x07W\x02\x02\u092A\u092B\x07T\x02\x02\u092B\u092C\x07U\x02" + + "\x02\u092C\u092D\x07Q\x02\x02\u092D\u092E\x07T\x02\x02\u092E\u0166\x03" + + "\x02\x02\x02\u092F\u0930\x07E\x02\x02\u0930\u0931\x07[\x02\x02\u0931\u0932" + + "\x07E\x02\x02\u0932\u0933\x07N\x02\x02\u0933\u0934\x07G\x02\x02\u0934" + + "\u0168\x03\x02\x02\x02\u0935\u0936\x07F\x02\x02\u0936\u0937\x07C\x02\x02" + + "\u0937\u0938\x07V\x02\x02\u0938\u0939\x07C\x02\x02\u0939\u016A\x03\x02" + + "\x02\x02\u093A\u093B\x07F\x02\x02\u093B\u093C\x07C\x02\x02\u093C\u093D" + + "\x07V\x02\x02\u093D\u093E\x07C\x02\x02\u093E\u093F\x07D\x02\x02\u093F" + + "\u0940\x07C\x02\x02\u0940\u0941\x07U\x02\x02\u0941\u0942\x07G\x02\x02" + + "\u0942\u016C\x03\x02\x02\x02\u0943\u0944\x07F\x02\x02\u0944\u0945\x07" + + "C\x02\x02\u0945\u0946\x07[\x02\x02\u0946\u016E\x03\x02\x02\x02\u0947\u0948" + + "\x07F\x02\x02\u0948\u0949\x07G\x02\x02\u0949\u094A\x07C\x02\x02\u094A" + + "\u094B\x07N\x02\x02\u094B\u094C\x07N\x02\x02\u094C\u094D\x07Q\x02\x02" + + "\u094D\u094E\x07E\x02\x02\u094E\u094F\x07C\x02\x02\u094F\u0950\x07V\x02" + + "\x02\u0950\u0951\x07G\x02\x02\u0951\u0170\x03\x02\x02\x02\u0952\u0953" + + "\x07F\x02\x02\u0953\u0954\x07G\x02\x02\u0954\u0955\x07E\x02\x02\u0955" + + "\u0956\x07N\x02\x02\u0956\u0957\x07C\x02\x02\u0957\u0958\x07T\x02\x02" + + "\u0958\u0959\x07G\x02\x02\u0959\u0172\x03\x02\x02\x02\u095A\u095B\x07" + + "F\x02\x02\u095B\u095C\x07G\x02\x02\u095C\u095D\x07H\x02\x02\u095D\u095E" + + "\x07C\x02\x02\u095E\u095F\x07W\x02\x02\u095F\u0960\x07N\x02\x02\u0960" + + "\u0961\x07V\x02\x02\u0961\u0962\x07U\x02\x02\u0962\u0174\x03\x02\x02\x02" + + "\u0963\u0964\x07F\x02\x02\u0964\u0965\x07G\x02\x02\u0965\u0966\x07H\x02" + + "\x02\u0966\u0967\x07G\x02\x02\u0967\u0968\x07T\x02\x02\u0968\u0969\x07" + + "T\x02\x02\u0969\u096A\x07G\x02\x02\u096A\u096B\x07F\x02\x02\u096B\u0176" + + "\x03\x02\x02\x02\u096C\u096D\x07F\x02\x02\u096D\u096E\x07G\x02\x02\u096E" + + "\u096F\x07H\x02\x02\u096F\u0970\x07K\x02\x02\u0970\u0971\x07P\x02\x02" + + "\u0971\u0972\x07G\x02\x02\u0972\u0973\x07T\x02\x02\u0973\u0178\x03\x02" + + "\x02\x02\u0974\u0975\x07F\x02\x02\u0975\u0976\x07G\x02\x02\u0976\u0977" + + "\x07N\x02\x02\u0977\u0978\x07G\x02\x02\u0978\u0979\x07V\x02\x02\u0979" + + "\u097A\x07G\x02\x02\u097A\u017A\x03\x02\x02\x02\u097B\u097C\x07F\x02\x02" + + "\u097C\u097D\x07G\x02\x02\u097D\u097E\x07N\x02\x02\u097E\u097F\x07K\x02" + + "\x02\u097F\u0980\x07O\x02\x02\u0980\u0981\x07K\x02\x02\u0981\u0982\x07" + + "V\x02\x02\u0982\u0983\x07G\x02\x02\u0983\u0984\x07T\x02\x02\u0984\u017C" + + "\x03\x02\x02\x02\u0985\u0986\x07F\x02\x02\u0986\u0987\x07G\x02\x02\u0987" + + "\u0988\x07N\x02\x02\u0988\u0989\x07K\x02\x02\u0989\u098A\x07O\x02\x02" + + "\u098A\u098B\x07K\x02\x02\u098B\u098C\x07V\x02\x02\u098C\u098D\x07G\x02" + + "\x02\u098D\u098E\x07T\x02\x02\u098E\u098F\x07U\x02\x02\u098F\u017E\x03" + + "\x02\x02\x02\u0990\u0991\x07F\x02\x02\u0991\u0992\x07K\x02\x02\u0992\u0993" + + "\x07E\x02\x02\u0993\u0994\x07V\x02\x02\u0994\u0995\x07K\x02\x02\u0995" + + "\u0996\x07Q\x02\x02\u0996\u0997\x07P\x02\x02\u0997\u0998\x07C\x02\x02" + + "\u0998\u0999\x07T\x02\x02\u0999\u099A\x07[\x02\x02\u099A\u0180\x03\x02" + + "\x02\x02\u099B\u099C\x07F\x02\x02\u099C\u099D\x07K\x02\x02\u099D\u099E" + + "\x07U\x02\x02\u099E\u099F\x07C\x02\x02\u099F\u09A0\x07D\x02\x02\u09A0" + + "\u09A1\x07N\x02\x02\u09A1\u09A2\x07G\x02\x02\u09A2\u0182\x03\x02\x02\x02" + + "\u09A3\u09A4\x07F\x02\x02\u09A4\u09A5\x07K\x02\x02\u09A5\u09A6\x07U\x02" + + "\x02\u09A6\u09A7\x07E\x02\x02\u09A7\u09A8\x07C\x02\x02\u09A8\u09A9\x07" + + "T\x02\x02\u09A9\u09AA\x07F\x02\x02\u09AA\u0184\x03\x02\x02\x02\u09AB\u09AC" + + "\x07F\x02\x02\u09AC\u09AD\x07Q\x02\x02\u09AD\u09AE\x07E\x02\x02\u09AE" + + "\u09AF\x07W\x02\x02\u09AF\u09B0\x07O\x02\x02\u09B0\u09B1\x07G\x02\x02" + + "\u09B1\u09B2\x07P\x02\x02\u09B2\u09B3\x07V\x02\x02\u09B3\u0186\x03\x02" + + "\x02\x02\u09B4\u09B5\x07F\x02\x02\u09B5\u09B6\x07Q\x02\x02\u09B6\u09B7" + + "\x07O\x02\x02\u09B7\u09B8\x07C\x02\x02\u09B8\u09B9\x07K\x02\x02\u09B9" + + "\u09BA\x07P\x02\x02\u09BA\u0188\x03\x02\x02\x02\u09BB\u09BC\x07F\x02\x02" + + "\u09BC\u09BD\x07Q\x02\x02\u09BD\u09BE\x07W\x02\x02\u09BE\u09BF\x07D\x02" + + "\x02\u09BF\u09C0\x07N\x02\x02\u09C0\u09C1\x07G\x02\x02\u09C1\u018A\x03" + + "\x02\x02\x02\u09C2\u09C3\x07F\x02\x02\u09C3\u09C4\x07T\x02\x02\u09C4\u09C5" + + "\x07Q\x02\x02\u09C5\u09C6\x07R\x02\x02\u09C6\u018C\x03\x02\x02\x02\u09C7" + + "\u09C8\x07G\x02\x02\u09C8\u09C9\x07C\x02\x02\u09C9\u09CA\x07E\x02\x02" + + "\u09CA\u09CB\x07J\x02\x02\u09CB\u018E\x03\x02\x02\x02\u09CC\u09CD\x07" + + "G\x02\x02\u09CD\u09CE\x07P\x02\x02\u09CE\u09CF\x07C\x02\x02\u09CF\u09D0" + + "\x07D\x02\x02\u09D0\u09D1\x07N\x02\x02\u09D1\u09D2\x07G\x02\x02\u09D2" + + "\u0190\x03\x02\x02\x02\u09D3\u09D4\x07G\x02\x02\u09D4\u09D5\x07P\x02\x02" + + "\u09D5\u09D6\x07E\x02\x02\u09D6\u09D7\x07Q\x02\x02\u09D7\u09D8\x07F\x02" + + "\x02\u09D8\u09D9\x07K\x02\x02\u09D9\u09DA\x07P\x02\x02\u09DA\u09DB\x07" + + "I\x02\x02\u09DB\u0192\x03\x02\x02\x02\u09DC\u09DD\x07G\x02\x02\u09DD\u09DE" + + "\x07P\x02\x02\u09DE\u09DF\x07E\x02\x02\u09DF\u09E0\x07T\x02\x02\u09E0" + + "\u09E1\x07[\x02\x02\u09E1\u09E2\x07R\x02\x02\u09E2\u09E3\x07V\x02\x02" + + "\u09E3\u09E4\x07G\x02\x02\u09E4\u09E5\x07F\x02\x02\u09E5\u0194\x03\x02" + + "\x02\x02\u09E6\u09E7\x07G\x02\x02\u09E7\u09E8\x07P\x02\x02\u09E8\u09E9" + + "\x07W\x02\x02\u09E9\u09EA\x07O\x02\x02\u09EA\u0196\x03\x02\x02\x02\u09EB" + + "\u09EC\x07G\x02\x02\u09EC\u09ED\x07U\x02\x02\u09ED\u09EE\x07E\x02\x02" + + "\u09EE\u09EF\x07C\x02\x02\u09EF\u09F0\x07R\x02\x02\u09F0\u09F1\x07G\x02" + + "\x02\u09F1\u0198\x03\x02\x02\x02\u09F2\u09F3\x07G\x02\x02\u09F3\u09F4" + + "\x07X\x02\x02\u09F4\u09F5\x07G\x02\x02\u09F5\u09F6\x07P\x02\x02\u09F6" + + "\u09F7\x07V\x02\x02\u09F7\u019A\x03\x02\x02\x02\u09F8\u09F9\x07G\x02\x02" + + "\u09F9\u09FA\x07Z\x02\x02\u09FA\u09FB\x07E\x02\x02\u09FB\u09FC\x07N\x02" + + "\x02\u09FC\u09FD\x07W\x02\x02\u09FD\u09FE\x07F\x02\x02\u09FE\u09FF\x07" + + "G\x02\x02\u09FF\u019C\x03\x02\x02\x02\u0A00\u0A01\x07G\x02\x02\u0A01\u0A02" + + "\x07Z\x02\x02\u0A02\u0A03\x07E\x02\x02\u0A03\u0A04\x07N\x02\x02\u0A04" + + "\u0A05\x07W\x02\x02\u0A05\u0A06\x07F\x02\x02\u0A06\u0A07\x07K\x02\x02" + + "\u0A07\u0A08\x07P\x02\x02\u0A08\u0A09\x07I\x02\x02\u0A09\u019E\x03\x02" + + "\x02\x02\u0A0A\u0A0B\x07G\x02\x02\u0A0B\u0A0C\x07Z\x02\x02\u0A0C\u0A0D" + + "\x07E\x02\x02\u0A0D\u0A0E\x07N\x02\x02\u0A0E\u0A0F\x07W\x02\x02\u0A0F" + + "\u0A10\x07U\x02\x02\u0A10\u0A11\x07K\x02\x02\u0A11\u0A12\x07X\x02\x02" + + "\u0A12\u0A13\x07G\x02\x02\u0A13\u01A0\x03\x02\x02\x02\u0A14\u0A15\x07" + + "G\x02\x02\u0A15\u0A16\x07Z\x02\x02\u0A16\u0A17\x07G\x02\x02\u0A17\u0A18" + + "\x07E\x02\x02\u0A18\u0A19\x07W\x02\x02\u0A19\u0A1A\x07V\x02\x02\u0A1A" + + "\u0A1B\x07G\x02\x02\u0A1B\u01A2\x03\x02\x02\x02\u0A1C\u0A1D\x07G\x02\x02" + + "\u0A1D\u0A1E\x07Z\x02\x02\u0A1E\u0A1F\x07R\x02\x02\u0A1F\u0A20\x07N\x02" + + "\x02\u0A20\u0A21\x07C\x02\x02\u0A21\u0A22\x07K\x02\x02\u0A22\u0A23\x07" + + "P\x02\x02\u0A23\u01A4\x03\x02\x02\x02\u0A24\u0A25\x07G\x02\x02\u0A25\u0A26" + + "\x07Z\x02\x02\u0A26\u0A27\x07V\x02\x02\u0A27\u0A28\x07G\x02\x02\u0A28" + + "\u0A29\x07P\x02\x02\u0A29\u0A2A\x07U\x02\x02\u0A2A\u0A2B\x07K\x02\x02" + + "\u0A2B\u0A2C\x07Q\x02\x02\u0A2C\u0A2D\x07P\x02\x02\u0A2D\u01A6\x03\x02" + + "\x02\x02\u0A2E\u0A2F\x07G\x02\x02\u0A2F\u0A30\x07Z\x02\x02\u0A30\u0A31" + + "\x07V\x02\x02\u0A31\u0A32\x07G\x02\x02\u0A32\u0A33\x07T\x02\x02\u0A33" + + "\u0A34\x07P\x02\x02\u0A34\u0A35\x07C\x02\x02\u0A35\u0A36\x07N\x02\x02" + + "\u0A36\u01A8\x03\x02\x02\x02\u0A37\u0A38\x07H\x02\x02\u0A38\u0A39\x07" + + "C\x02\x02\u0A39\u0A3A\x07O\x02\x02\u0A3A\u0A3B\x07K\x02\x02\u0A3B\u0A3C" + + "\x07N\x02\x02\u0A3C\u0A3D\x07[\x02\x02\u0A3D\u01AA\x03\x02\x02\x02\u0A3E" + + "\u0A3F\x07H\x02\x02\u0A3F\u0A40\x07K\x02\x02\u0A40\u0A41\x07T\x02\x02" + + "\u0A41\u0A42\x07U\x02\x02\u0A42\u0A43\x07V\x02\x02\u0A43\u01AC\x03\x02" + + "\x02\x02\u0A44\u0A45\x07H\x02\x02\u0A45\u0A46\x07Q\x02\x02\u0A46\u0A47" + + "\x07N\x02\x02\u0A47\u0A48\x07N\x02\x02\u0A48\u0A49\x07Q\x02\x02\u0A49" + + "\u0A4A\x07Y\x02\x02\u0A4A\u0A4B\x07K\x02\x02\u0A4B\u0A4C\x07P\x02\x02" + + "\u0A4C\u0A4D\x07I\x02\x02\u0A4D\u01AE\x03\x02\x02\x02\u0A4E\u0A4F\x07" + + "H\x02\x02\u0A4F\u0A50\x07Q\x02\x02\u0A50\u0A51\x07T\x02\x02\u0A51\u0A52" + + "\x07E\x02\x02\u0A52\u0A53\x07G\x02\x02\u0A53\u01B0\x03\x02\x02\x02\u0A54" + + "\u0A55\x07H\x02\x02\u0A55\u0A56\x07Q\x02\x02\u0A56\u0A57\x07T\x02\x02" + + "\u0A57\u0A58\x07Y\x02\x02\u0A58\u0A59\x07C\x02\x02\u0A59\u0A5A\x07T\x02" + + "\x02\u0A5A\u0A5B\x07F\x02\x02\u0A5B\u01B2\x03\x02\x02\x02\u0A5C\u0A5D" + + "\x07H\x02\x02\u0A5D\u0A5E\x07W\x02\x02\u0A5E\u0A5F\x07P\x02\x02\u0A5F" + + "\u0A60\x07E\x02\x02\u0A60\u0A61\x07V\x02\x02\u0A61\u0A62\x07K\x02\x02" + + "\u0A62\u0A63\x07Q\x02\x02\u0A63\u0A64\x07P\x02\x02\u0A64\u01B4\x03\x02" + + "\x02\x02\u0A65\u0A66\x07H\x02\x02\u0A66\u0A67\x07W\x02\x02\u0A67\u0A68" + + "\x07P\x02\x02\u0A68\u0A69\x07E\x02\x02\u0A69\u0A6A\x07V\x02\x02\u0A6A" + + "\u0A6B\x07K\x02\x02\u0A6B\u0A6C\x07Q\x02\x02\u0A6C\u0A6D\x07P\x02\x02" + + "\u0A6D\u0A6E\x07U\x02\x02\u0A6E\u01B6\x03\x02\x02\x02\u0A6F\u0A70\x07" + + "I\x02\x02\u0A70\u0A71\x07N\x02\x02\u0A71\u0A72\x07Q\x02\x02\u0A72\u0A73" + + "\x07D\x02\x02\u0A73\u0A74\x07C\x02\x02\u0A74\u0A75\x07N\x02\x02\u0A75" + + "\u01B8\x03\x02\x02\x02\u0A76\u0A77\x07I\x02\x02\u0A77\u0A78\x07T\x02\x02" + + "\u0A78\u0A79\x07C\x02\x02\u0A79\u0A7A\x07P\x02\x02\u0A7A\u0A7B\x07V\x02" + + "\x02\u0A7B\u0A7C\x07G\x02\x02\u0A7C\u0A7D\x07F\x02\x02\u0A7D\u01BA\x03" + + "\x02\x02\x02\u0A7E\u0A7F\x07J\x02\x02\u0A7F\u0A80\x07C\x02\x02\u0A80\u0A81" + + "\x07P\x02\x02\u0A81\u0A82\x07F\x02\x02\u0A82\u0A83\x07N\x02\x02\u0A83" + + "\u0A84\x07G\x02\x02\u0A84\u0A85\x07T\x02\x02\u0A85\u01BC\x03\x02\x02\x02" + + "\u0A86\u0A87\x07J\x02\x02\u0A87\u0A88\x07G\x02\x02\u0A88\u0A89\x07C\x02" + + "\x02\u0A89\u0A8A\x07F\x02\x02\u0A8A\u0A8B\x07G\x02\x02\u0A8B\u0A8C\x07" + + "T\x02\x02\u0A8C\u01BE\x03\x02\x02\x02\u0A8D\u0A8E\x07J\x02\x02\u0A8E\u0A8F" + + "\x07Q\x02\x02\u0A8F\u0A90\x07N\x02\x02\u0A90\u0A91\x07F\x02\x02\u0A91" + + "\u01C0\x03\x02\x02\x02\u0A92\u0A93\x07J\x02\x02\u0A93\u0A94\x07Q\x02\x02" + + "\u0A94\u0A95\x07W\x02\x02\u0A95\u0A96\x07T\x02\x02\u0A96\u01C2\x03\x02" + + "\x02\x02\u0A97\u0A98\x07K\x02\x02\u0A98\u0A99\x07F\x02\x02\u0A99\u0A9A" + + "\x07G\x02\x02\u0A9A\u0A9B\x07P\x02\x02\u0A9B\u0A9C\x07V\x02\x02\u0A9C" + + "\u0A9D\x07K\x02\x02\u0A9D\u0A9E\x07V\x02\x02\u0A9E\u0A9F\x07[\x02\x02" + + "\u0A9F\u01C4\x03\x02\x02\x02\u0AA0\u0AA1\x07K\x02\x02\u0AA1\u0AA2\x07" + + "H\x02\x02\u0AA2\u01C6\x03\x02\x02\x02\u0AA3\u0AA4\x07K\x02\x02\u0AA4\u0AA5" + + "\x07O\x02\x02\u0AA5\u0AA6\x07O\x02\x02\u0AA6\u0AA7\x07G\x02\x02\u0AA7" + + "\u0AA8\x07F\x02\x02\u0AA8\u0AA9\x07K\x02\x02\u0AA9\u0AAA\x07C\x02\x02" + + "\u0AAA\u0AAB\x07V\x02\x02\u0AAB\u0AAC\x07G\x02\x02\u0AAC\u01C8\x03\x02" + + "\x02\x02\u0AAD\u0AAE\x07K\x02\x02\u0AAE\u0AAF\x07O\x02\x02\u0AAF\u0AB0" + + "\x07O\x02\x02\u0AB0\u0AB1\x07W\x02\x02\u0AB1\u0AB2\x07V\x02\x02\u0AB2" + + "\u0AB3\x07C\x02\x02\u0AB3\u0AB4\x07D\x02\x02\u0AB4\u0AB5\x07N\x02\x02" + + "\u0AB5\u0AB6\x07G\x02\x02\u0AB6\u01CA\x03\x02\x02\x02\u0AB7\u0AB8\x07" + + "K\x02\x02\u0AB8\u0AB9\x07O\x02\x02\u0AB9\u0ABA\x07R\x02\x02\u0ABA\u0ABB" + + "\x07N\x02\x02\u0ABB\u0ABC\x07K\x02\x02\u0ABC\u0ABD\x07E\x02\x02\u0ABD" + + "\u0ABE\x07K\x02\x02\u0ABE\u0ABF\x07V\x02\x02\u0ABF\u01CC\x03\x02\x02\x02" + + "\u0AC0\u0AC1\x07K\x02\x02\u0AC1\u0AC2\x07P\x02\x02\u0AC2\u0AC3\x07E\x02" + + "\x02\u0AC3\u0AC4\x07N\x02\x02\u0AC4\u0AC5\x07W\x02\x02\u0AC5\u0AC6\x07" + + "F\x02\x02\u0AC6\u0AC7\x07K\x02\x02\u0AC7\u0AC8\x07P\x02\x02\u0AC8\u0AC9" + + "\x07I\x02\x02\u0AC9\u01CE\x03\x02\x02\x02\u0ACA\u0ACB\x07K\x02\x02\u0ACB" + + "\u0ACC\x07P\x02\x02\u0ACC\u0ACD\x07E\x02\x02\u0ACD\u0ACE\x07T\x02\x02" + + "\u0ACE\u0ACF\x07G\x02\x02\u0ACF\u0AD0\x07O\x02\x02\u0AD0\u0AD1\x07G\x02" + + "\x02\u0AD1\u0AD2\x07P\x02\x02\u0AD2\u0AD3\x07V\x02\x02\u0AD3\u01D0\x03" + + "\x02\x02\x02\u0AD4\u0AD5\x07K\x02\x02\u0AD5\u0AD6\x07P\x02\x02\u0AD6\u0AD7" + + "\x07F\x02\x02\u0AD7\u0AD8\x07G\x02\x02\u0AD8\u0AD9\x07Z\x02\x02\u0AD9" + + "\u01D2\x03\x02\x02\x02\u0ADA\u0ADB\x07K\x02\x02\u0ADB\u0ADC\x07P\x02\x02" + + "\u0ADC\u0ADD\x07F\x02\x02\u0ADD\u0ADE\x07G\x02\x02\u0ADE\u0ADF\x07Z\x02" + + "\x02\u0ADF\u0AE0\x07G\x02\x02\u0AE0\u0AE1\x07U\x02\x02\u0AE1\u01D4\x03" + + "\x02\x02\x02\u0AE2\u0AE3\x07K\x02\x02\u0AE3\u0AE4\x07P\x02\x02\u0AE4\u0AE5" + + "\x07J\x02\x02\u0AE5\u0AE6\x07G\x02\x02\u0AE6\u0AE7\x07T\x02\x02\u0AE7" + + "\u0AE8\x07K\x02\x02\u0AE8\u0AE9\x07V\x02\x02\u0AE9\u01D6\x03\x02\x02\x02" + + "\u0AEA\u0AEB\x07P\x02\x02\u0AEB\u0AEC\x07Q\x02\x02\u0AEC\u0AED\x07K\x02" + + "\x02\u0AED\u0AEE\x07P\x02\x02\u0AEE\u0AEF\x07J\x02\x02\u0AEF\u0AF0\x07" + + "G\x02\x02\u0AF0\u0AF1\x07T\x02\x02\u0AF1\u0AF2\x07K\x02\x02\u0AF2\u0AF3" + + "\x07V\x02\x02\u0AF3\u01D8\x03\x02\x02\x02\u0AF4\u0AF5\x07U\x02\x02\u0AF5" + + "\u0AF6\x07W\x02\x02\u0AF6\u0AF7\x07R\x02\x02\u0AF7\u0AF8\x07G\x02\x02" + + "\u0AF8\u0AF9\x07T\x02\x02\u0AF9\u0AFA\x07W\x02\x02\u0AFA\u0AFB\x07U\x02" + + "\x02\u0AFB\u0AFC\x07G\x02\x02\u0AFC\u0AFD\x07T\x02\x02\u0AFD\u01DA\x03" + + "\x02\x02\x02\u0AFE\u0AFF\x07P\x02\x02\u0AFF\u0B00\x07Q\x02\x02\u0B00\u0B01" + + "\x07U\x02\x02\u0B01\u0B02\x07W\x02\x02\u0B02\u0B03"; private static readonly _serializedATNSegment6: string = - "\x07G\x02\x02\u0B36\u0B37\x07C\x02\x02\u0B37\u0B38\x07M\x02\x02\u0B38" + - "\u0B39\x07R\x02\x02\u0B39\u0B3A\x07T\x02\x02\u0B3A\u0B3B\x07Q\x02\x02" + - "\u0B3B\u0B3C\x07Q\x02\x02\u0B3C\u0B3D\x07H\x02\x02\u0B3D\u01F0\x03\x02" + - "\x02\x02\u0B3E\u0B3F\x07N\x02\x02\u0B3F\u0B40\x07G\x02\x02\u0B40\u0B41" + - "\x07X\x02\x02\u0B41\u0B42\x07G\x02\x02\u0B42\u0B43\x07N\x02\x02\u0B43" + - "\u01F2\x03\x02\x02\x02\u0B44\u0B45\x07N\x02\x02\u0B45\u0B46\x07K\x02\x02" + - "\u0B46\u0B47\x07U\x02\x02\u0B47\u0B48\x07V\x02\x02\u0B48\u0B49\x07G\x02" + - "\x02\u0B49\u0B4A\x07P\x02\x02\u0B4A\u01F4\x03\x02\x02\x02\u0B4B\u0B4C" + - "\x07N\x02\x02\u0B4C\u0B4D\x07Q\x02\x02\u0B4D\u0B4E\x07C\x02\x02\u0B4E" + - "\u0B4F\x07F\x02\x02\u0B4F\u01F6\x03\x02\x02\x02\u0B50\u0B51\x07N\x02\x02" + - "\u0B51\u0B52\x07Q\x02\x02\u0B52\u0B53\x07E\x02\x02\u0B53\u0B54\x07C\x02" + - "\x02\u0B54\u0B55\x07N\x02\x02\u0B55\u01F8\x03\x02\x02\x02\u0B56\u0B57" + - "\x07N\x02\x02\u0B57\u0B58\x07Q\x02\x02\u0B58\u0B59\x07E\x02\x02\u0B59" + - "\u0B5A\x07C\x02\x02\u0B5A\u0B5B\x07V\x02\x02\u0B5B\u0B5C\x07K\x02\x02" + - "\u0B5C\u0B5D\x07Q\x02\x02\u0B5D\u0B5E\x07P\x02\x02\u0B5E\u01FA\x03\x02" + - "\x02\x02\u0B5F\u0B60\x07N\x02\x02\u0B60\u0B61\x07Q\x02\x02\u0B61\u0B62" + - "\x07E\x02\x02\u0B62\u0B63\x07M\x02\x02\u0B63\u01FC\x03\x02\x02\x02\u0B64" + - "\u0B65\x07O\x02\x02\u0B65\u0B66\x07C\x02\x02\u0B66\u0B67\x07R\x02\x02" + - "\u0B67\u0B68\x07R\x02\x02\u0B68\u0B69\x07K\x02\x02\u0B69\u0B6A\x07P\x02" + - "\x02\u0B6A\u0B6B\x07I\x02\x02\u0B6B\u01FE\x03\x02\x02\x02\u0B6C\u0B6D" + - "\x07O\x02\x02\u0B6D\u0B6E\x07C\x02\x02\u0B6E\u0B6F\x07V\x02\x02\u0B6F" + - "\u0B70\x07E\x02\x02\u0B70\u0B71\x07J\x02\x02\u0B71\u0200\x03\x02\x02\x02" + - "\u0B72\u0B73\x07O\x02\x02\u0B73\u0B74\x07C\x02\x02\u0B74\u0B75\x07V\x02" + - "\x02\u0B75\u0B76\x07G\x02\x02\u0B76\u0B77\x07T\x02\x02\u0B77\u0B78\x07" + - "K\x02\x02\u0B78\u0B79\x07C\x02\x02\u0B79\u0B7A\x07N\x02\x02\u0B7A\u0B7B" + - "\x07K\x02\x02\u0B7B\u0B7C\x07\\\x02\x02\u0B7C\u0B7D\x07G\x02\x02\u0B7D" + - "\u0B7E\x07F\x02\x02\u0B7E\u0202\x03\x02\x02\x02\u0B7F\u0B80\x07O\x02\x02" + - "\u0B80\u0B81\x07C\x02\x02\u0B81\u0B82\x07Z\x02\x02\u0B82\u0B83\x07X\x02" + - "\x02\u0B83\u0B84\x07C\x02\x02\u0B84\u0B85\x07N\x02\x02\u0B85\u0B86\x07" + - "W\x02\x02\u0B86\u0B87\x07G\x02\x02\u0B87\u0204\x03\x02\x02\x02\u0B88\u0B89" + - "\x07O\x02\x02\u0B89\u0B8A\x07K\x02\x02\u0B8A\u0B8B\x07P\x02\x02\u0B8B" + - "\u0B8C\x07W\x02\x02\u0B8C\u0B8D\x07V\x02\x02\u0B8D\u0B8E\x07G\x02\x02" + - "\u0B8E\u0206\x03\x02\x02\x02\u0B8F\u0B90\x07O\x02\x02\u0B90\u0B91\x07" + - "K\x02\x02\u0B91\u0B92\x07P\x02\x02\u0B92\u0B93\x07X\x02\x02\u0B93\u0B94" + - "\x07C\x02\x02\u0B94\u0B95\x07N\x02\x02\u0B95\u0B96\x07W\x02\x02\u0B96" + - "\u0B97\x07G\x02\x02\u0B97\u0208\x03\x02\x02\x02\u0B98\u0B99\x07O\x02\x02" + - "\u0B99\u0B9A\x07Q\x02\x02\u0B9A\u0B9B\x07F\x02\x02\u0B9B\u0B9C\x07G\x02" + - "\x02\u0B9C\u020A\x03\x02\x02\x02\u0B9D\u0B9E\x07O\x02\x02\u0B9E\u0B9F" + - "\x07Q\x02\x02\u0B9F\u0BA0\x07P\x02\x02\u0BA0\u0BA1\x07V\x02\x02\u0BA1" + - "\u0BA2\x07J\x02\x02\u0BA2\u020C\x03\x02\x02\x02\u0BA3\u0BA4\x07O\x02\x02" + - "\u0BA4\u0BA5\x07Q\x02\x02\u0BA5\u0BA6\x07X\x02\x02\u0BA6\u0BA7\x07G\x02" + - "\x02\u0BA7\u020E\x03\x02\x02\x02\u0BA8\u0BA9\x07P\x02\x02\u0BA9\u0BAA" + - "\x07C\x02\x02\u0BAA\u0BAB\x07O\x02\x02\u0BAB\u0BAC\x07G\x02\x02\u0BAC" + - "\u0210\x03\x02\x02\x02\u0BAD\u0BAE\x07P\x02\x02\u0BAE\u0BAF\x07C\x02\x02" + - "\u0BAF\u0BB0\x07O\x02\x02\u0BB0\u0BB1\x07G\x02\x02\u0BB1\u0BB2\x07U\x02" + - "\x02\u0BB2\u0212\x03\x02\x02\x02\u0BB3\u0BB4\x07P\x02\x02\u0BB4\u0BB5" + - "\x07G\x02\x02\u0BB5\u0BB6\x07Z\x02\x02\u0BB6\u0BB7\x07V\x02\x02\u0BB7" + - "\u0214\x03\x02\x02\x02\u0BB8\u0BB9\x07P\x02\x02\u0BB9\u0BBA\x07Q\x02\x02" + - "\u0BBA\u0216\x03\x02\x02\x02\u0BBB\u0BBC\x07P\x02\x02\u0BBC\u0BBD\x07" + - "Q\x02\x02\u0BBD\u0BBE\x07V\x02\x02\u0BBE\u0BBF\x07J\x02\x02\u0BBF\u0BC0" + - "\x07K\x02\x02\u0BC0\u0BC1\x07P\x02\x02\u0BC1\u0BC2\x07I\x02\x02\u0BC2" + - "\u0218\x03\x02\x02\x02\u0BC3\u0BC4\x07P\x02\x02\u0BC4\u0BC5\x07Q\x02\x02" + - "\u0BC5\u0BC6\x07V\x02\x02\u0BC6\u0BC7\x07K\x02\x02\u0BC7\u0BC8\x07H\x02" + - "\x02\u0BC8\u0BC9\x07[\x02\x02\u0BC9\u021A\x03\x02\x02\x02\u0BCA\u0BCB" + - "\x07P\x02\x02\u0BCB\u0BCC\x07Q\x02\x02\u0BCC\u0BCD\x07Y\x02\x02\u0BCD" + - "\u0BCE\x07C\x02\x02\u0BCE\u0BCF\x07K\x02\x02\u0BCF\u0BD0\x07V\x02\x02" + - "\u0BD0\u021C\x03\x02\x02\x02\u0BD1\u0BD2\x07P\x02\x02\u0BD2\u0BD3\x07" + - "W\x02\x02\u0BD3\u0BD4\x07N\x02\x02\u0BD4\u0BD5\x07N\x02\x02\u0BD5\u0BD6" + - "\x07U\x02\x02\u0BD6\u021E\x03\x02\x02\x02\u0BD7\u0BD8\x07Q\x02\x02\u0BD8" + - "\u0BD9\x07D\x02\x02\u0BD9\u0BDA\x07L\x02\x02\u0BDA\u0BDB\x07G\x02\x02" + - "\u0BDB\u0BDC\x07E\x02\x02\u0BDC\u0BDD\x07V\x02\x02\u0BDD\u0220\x03\x02" + - "\x02\x02\u0BDE\u0BDF\x07Q\x02\x02\u0BDF\u0BE0\x07H\x02\x02\u0BE0\u0222" + - "\x03\x02\x02\x02\u0BE1\u0BE2\x07Q\x02\x02\u0BE2\u0BE3\x07H\x02\x02\u0BE3" + - "\u0BE4\x07H\x02\x02\u0BE4\u0224\x03\x02\x02\x02\u0BE5\u0BE6\x07Q\x02\x02" + - "\u0BE6\u0BE7\x07K\x02\x02\u0BE7\u0BE8\x07F\x02\x02\u0BE8\u0BE9\x07U\x02" + - "\x02\u0BE9\u0226\x03\x02\x02\x02\u0BEA\u0BEB\x07Q\x02\x02\u0BEB\u0BEC" + - "\x07R\x02\x02\u0BEC\u0BED\x07G\x02\x02\u0BED\u0BEE\x07T\x02\x02\u0BEE" + - "\u0BEF\x07C\x02\x02\u0BEF\u0BF0\x07V\x02\x02\u0BF0\u0BF1\x07Q\x02\x02" + - "\u0BF1\u0BF2\x07T\x02\x02\u0BF2\u0228\x03\x02\x02\x02\u0BF3\u0BF4\x07" + - "Q\x02\x02\u0BF4\u0BF5\x07R\x02\x02\u0BF5\u0BF6\x07V\x02\x02\u0BF6\u0BF7" + - "\x07K\x02\x02\u0BF7\u0BF8\x07Q\x02\x02\u0BF8\u0BF9\x07P\x02\x02\u0BF9" + - "\u022A\x03\x02\x02\x02\u0BFA\u0BFB\x07Q\x02\x02\u0BFB\u0BFC\x07R\x02\x02" + - "\u0BFC\u0BFD\x07V\x02\x02\u0BFD\u0BFE\x07K\x02\x02\u0BFE\u0BFF\x07Q\x02" + - "\x02\u0BFF\u0C00\x07P\x02\x02\u0C00\u0C01\x07U\x02\x02\u0C01\u022C\x03" + - "\x02\x02\x02\u0C02\u0C03\x07Q\x02\x02\u0C03\u0C04\x07Y\x02\x02\u0C04\u0C05" + - "\x07P\x02\x02\u0C05\u0C06\x07G\x02\x02\u0C06\u0C07\x07F\x02\x02\u0C07" + - "\u022E\x03\x02\x02\x02\u0C08\u0C09\x07Q\x02\x02\u0C09\u0C0A\x07Y\x02\x02" + - "\u0C0A\u0C0B\x07P\x02\x02\u0C0B\u0C0C\x07G\x02\x02\u0C0C\u0C0D\x07T\x02" + - "\x02\u0C0D\u0230\x03\x02\x02\x02\u0C0E\u0C0F\x07R\x02\x02\u0C0F\u0C10" + - "\x07C\x02\x02\u0C10\u0C11\x07T\x02\x02\u0C11\u0C12\x07U\x02\x02\u0C12" + - "\u0C13\x07G\x02\x02\u0C13\u0C14\x07T\x02\x02\u0C14\u0232\x03\x02\x02\x02" + - "\u0C15\u0C16\x07R\x02\x02\u0C16\u0C17\x07C\x02\x02\u0C17\u0C18\x07T\x02" + - "\x02\u0C18\u0C19\x07V\x02\x02\u0C19\u0C1A\x07K\x02\x02\u0C1A\u0C1B\x07" + - "C\x02\x02\u0C1B\u0C1C\x07N\x02\x02\u0C1C\u0234\x03\x02\x02\x02\u0C1D\u0C1E" + - "\x07R\x02\x02\u0C1E\u0C1F\x07C\x02\x02\u0C1F\u0C20\x07T\x02\x02\u0C20" + - "\u0C21\x07V\x02\x02\u0C21\u0C22\x07K\x02\x02\u0C22\u0C23\x07V\x02\x02" + - "\u0C23\u0C24\x07K\x02\x02\u0C24\u0C25\x07Q\x02\x02\u0C25\u0C26\x07P\x02" + - "\x02\u0C26\u0236\x03\x02\x02\x02\u0C27\u0C28\x07R\x02\x02\u0C28\u0C29" + - "\x07C\x02\x02\u0C29\u0C2A\x07U\x02\x02\u0C2A\u0C2B\x07U\x02\x02\u0C2B" + - "\u0C2C\x07K\x02\x02\u0C2C\u0C2D\x07P\x02\x02\u0C2D\u0C2E\x07I\x02\x02" + - "\u0C2E\u0238\x03\x02\x02\x02\u0C2F\u0C30\x07R\x02\x02\u0C30\u0C31\x07" + - "C\x02\x02\u0C31\u0C32\x07U\x02\x02\u0C32\u0C33\x07U\x02\x02\u0C33\u0C34" + - "\x07Y\x02\x02\u0C34\u0C35\x07Q\x02\x02\u0C35\u0C36\x07T\x02\x02\u0C36" + - "\u0C37\x07F\x02\x02\u0C37\u023A\x03\x02\x02\x02\u0C38\u0C39\x07R\x02\x02" + - "\u0C39\u0C3A\x07N\x02\x02\u0C3A\u0C3B\x07C\x02\x02\u0C3B\u0C3C\x07P\x02" + - "\x02\u0C3C\u0C3D\x07U\x02\x02\u0C3D\u023C\x03\x02\x02\x02\u0C3E\u0C3F" + - "\x07R\x02\x02\u0C3F\u0C40\x07T\x02\x02\u0C40\u0C41\x07G\x02\x02\u0C41" + - "\u0C42\x07E\x02\x02\u0C42\u0C43\x07G\x02\x02\u0C43\u0C44\x07F\x02\x02" + - "\u0C44\u0C45\x07K\x02\x02\u0C45\u0C46\x07P\x02\x02\u0C46\u0C47\x07I\x02" + - "\x02\u0C47\u023E\x03\x02\x02\x02\u0C48\u0C49\x07R\x02\x02\u0C49\u0C4A" + - "\x07T\x02\x02\u0C4A\u0C4B\x07G\x02\x02\u0C4B\u0C4C\x07R\x02\x02\u0C4C" + - "\u0C4D\x07C\x02\x02\u0C4D\u0C4E\x07T\x02\x02\u0C4E\u0C4F\x07G\x02\x02" + - "\u0C4F\u0240\x03\x02\x02\x02\u0C50\u0C51\x07R\x02\x02\u0C51\u0C52\x07" + - "T\x02\x02\u0C52\u0C53\x07G\x02\x02\u0C53\u0C54\x07R\x02\x02\u0C54\u0C55" + - "\x07C\x02\x02\u0C55\u0C56\x07T\x02\x02\u0C56\u0C57\x07G\x02\x02\u0C57" + - "\u0C58\x07F\x02\x02\u0C58\u0242\x03\x02\x02\x02\u0C59\u0C5A\x07R\x02\x02" + - "\u0C5A\u0C5B\x07T\x02\x02\u0C5B\u0C5C\x07G\x02\x02\u0C5C\u0C5D\x07U\x02" + - "\x02\u0C5D\u0C5E\x07G\x02\x02\u0C5E\u0C5F\x07T\x02\x02\u0C5F\u0C60\x07" + - "X\x02\x02\u0C60\u0C61\x07G\x02\x02\u0C61\u0244\x03\x02\x02\x02\u0C62\u0C63" + - "\x07R\x02\x02\u0C63\u0C64\x07T\x02\x02\u0C64\u0C65\x07K\x02\x02\u0C65" + - "\u0C66\x07Q\x02\x02\u0C66\u0C67\x07T\x02\x02\u0C67\u0246\x03\x02\x02\x02" + - "\u0C68\u0C69\x07R\x02\x02\u0C69\u0C6A\x07T\x02\x02\u0C6A\u0C6B\x07K\x02" + - "\x02\u0C6B\u0C6C\x07X\x02\x02\u0C6C\u0C6D\x07K\x02\x02\u0C6D\u0C6E\x07" + - "N\x02\x02\u0C6E\u0C6F\x07G\x02\x02\u0C6F\u0C70\x07I\x02\x02\u0C70\u0C71" + - "\x07G\x02\x02\u0C71\u0C72\x07U\x02\x02\u0C72\u0248\x03\x02\x02\x02\u0C73" + - "\u0C74\x07R\x02\x02\u0C74\u0C75\x07T\x02\x02\u0C75\u0C76\x07Q\x02\x02" + - "\u0C76\u0C77\x07E\x02\x02\u0C77\u0C78\x07G\x02\x02\u0C78\u0C79\x07F\x02" + - "\x02\u0C79\u0C7A\x07W\x02\x02\u0C7A\u0C7B\x07T\x02\x02\u0C7B\u0C7C\x07" + - "C\x02\x02\u0C7C\u0C7D\x07N\x02\x02\u0C7D\u024A\x03\x02\x02\x02\u0C7E\u0C7F" + - "\x07R\x02\x02\u0C7F\u0C80\x07T\x02\x02\u0C80\u0C81\x07Q\x02\x02\u0C81" + - "\u0C82\x07E\x02\x02\u0C82\u0C83\x07G\x02\x02\u0C83\u0C84\x07F\x02\x02" + - "\u0C84\u0C85\x07W\x02\x02\u0C85\u0C86\x07T\x02\x02\u0C86\u0C87\x07G\x02" + - "\x02\u0C87\u024C\x03\x02\x02\x02\u0C88\u0C89\x07R\x02\x02\u0C89\u0C8A" + - "\x07T\x02\x02\u0C8A\u0C8B\x07Q\x02\x02\u0C8B\u0C8C\x07I\x02\x02\u0C8C" + - "\u0C8D\x07T\x02\x02\u0C8D\u0C8E\x07C\x02\x02\u0C8E\u0C8F\x07O\x02\x02" + - "\u0C8F\u024E\x03\x02\x02\x02\u0C90\u0C91\x07S\x02\x02\u0C91\u0C92\x07" + - "W\x02\x02\u0C92\u0C93\x07Q\x02\x02\u0C93\u0C94\x07V\x02\x02\u0C94\u0C95" + - "\x07G\x02\x02\u0C95\u0250\x03\x02\x02\x02\u0C96\u0C97\x07T\x02\x02\u0C97" + - "\u0C98\x07C\x02\x02\u0C98\u0C99\x07P\x02\x02\u0C99\u0C9A\x07I\x02\x02" + - "\u0C9A\u0C9B\x07G\x02\x02\u0C9B\u0252\x03\x02\x02\x02\u0C9C\u0C9D\x07" + - "T\x02\x02\u0C9D\u0C9E\x07G\x02\x02\u0C9E\u0C9F\x07C\x02\x02\u0C9F\u0CA0" + - "\x07F\x02\x02\u0CA0\u0254\x03\x02\x02\x02\u0CA1\u0CA2\x07T\x02\x02\u0CA2" + - "\u0CA3\x07G\x02\x02\u0CA3\u0CA4\x07C\x02\x02\u0CA4\u0CA5\x07U\x02\x02" + - "\u0CA5\u0CA6\x07U\x02\x02\u0CA6\u0CA7\x07K\x02\x02\u0CA7\u0CA8\x07I\x02" + - "\x02\u0CA8\u0CA9\x07P\x02\x02\u0CA9\u0256\x03\x02\x02\x02\u0CAA\u0CAB" + - "\x07T\x02\x02\u0CAB\u0CAC\x07G\x02\x02\u0CAC\u0CAD\x07E\x02\x02\u0CAD" + - "\u0CAE\x07J\x02\x02\u0CAE\u0CAF\x07G\x02\x02\u0CAF\u0CB0\x07E\x02\x02" + - "\u0CB0\u0CB1\x07M\x02\x02\u0CB1\u0258\x03\x02\x02\x02\u0CB2\u0CB3\x07" + - "T\x02\x02\u0CB3\u0CB4\x07G\x02\x02\u0CB4\u0CB5\x07E\x02\x02\u0CB5\u0CB6" + - "\x07W\x02\x02\u0CB6\u0CB7\x07T\x02\x02\u0CB7\u0CB8\x07U\x02\x02\u0CB8" + - "\u0CB9\x07K\x02\x02\u0CB9\u0CBA\x07X\x02\x02\u0CBA\u0CBB\x07G\x02\x02" + - "\u0CBB\u025A\x03\x02\x02\x02\u0CBC\u0CBD\x07T\x02\x02\u0CBD\u0CBE\x07" + - "G\x02\x02\u0CBE\u0CBF\x07H\x02\x02\u0CBF\u025C\x03\x02\x02\x02\u0CC0\u0CC1" + - "\x07T\x02\x02\u0CC1\u0CC2\x07G\x02\x02\u0CC2\u0CC3\x07H\x02\x02\u0CC3" + - "\u0CC4\x07T\x02\x02\u0CC4\u0CC5\x07G\x02\x02\u0CC5\u0CC6\x07U\x02\x02" + - "\u0CC6\u0CC7\x07J\x02\x02\u0CC7\u025E\x03\x02\x02\x02\u0CC8\u0CC9\x07" + - "T\x02\x02\u0CC9\u0CCA\x07G\x02\x02\u0CCA\u0CCB\x07K\x02\x02\u0CCB\u0CCC" + - "\x07P\x02\x02\u0CCC\u0CCD\x07F\x02\x02\u0CCD\u0CCE\x07G\x02\x02\u0CCE" + - "\u0CCF\x07Z\x02\x02\u0CCF\u0260\x03\x02\x02\x02\u0CD0\u0CD1\x07T\x02\x02" + - "\u0CD1\u0CD2\x07G\x02\x02\u0CD2\u0CD3\x07N\x02\x02\u0CD3\u0CD4\x07C\x02" + - "\x02\u0CD4\u0CD5\x07V\x02\x02\u0CD5\u0CD6\x07K\x02\x02\u0CD6\u0CD7\x07" + - "X\x02\x02\u0CD7\u0CD8\x07G\x02\x02\u0CD8\u0262\x03\x02\x02\x02\u0CD9\u0CDA" + - "\x07T\x02\x02\u0CDA\u0CDB\x07G\x02\x02\u0CDB\u0CDC\x07N\x02\x02\u0CDC" + - "\u0CDD\x07G\x02\x02\u0CDD\u0CDE\x07C\x02\x02\u0CDE\u0CDF\x07U\x02\x02" + - "\u0CDF\u0CE0\x07G\x02\x02\u0CE0\u0264\x03\x02\x02\x02\u0CE1\u0CE2\x07" + - "T\x02\x02\u0CE2\u0CE3\x07G\x02\x02\u0CE3\u0CE4\x07P\x02\x02\u0CE4\u0CE5" + - "\x07C\x02\x02\u0CE5\u0CE6\x07O\x02\x02\u0CE6\u0CE7\x07G\x02\x02\u0CE7" + - "\u0266\x03\x02\x02\x02\u0CE8\u0CE9\x07T\x02\x02\u0CE9\u0CEA\x07G\x02\x02" + - "\u0CEA\u0CEB\x07R\x02\x02\u0CEB\u0CEC\x07G\x02\x02\u0CEC\u0CED\x07C\x02" + - "\x02\u0CED\u0CEE\x07V\x02\x02\u0CEE\u0CEF\x07C\x02\x02\u0CEF\u0CF0\x07" + - "D\x02\x02\u0CF0\u0CF1\x07N\x02\x02\u0CF1\u0CF2\x07G\x02\x02\u0CF2\u0268" + - "\x03\x02\x02\x02\u0CF3\u0CF4\x07T\x02\x02\u0CF4\u0CF5\x07G\x02\x02\u0CF5" + - "\u0CF6\x07R\x02\x02\u0CF6\u0CF7\x07N\x02\x02\u0CF7\u0CF8\x07C\x02\x02" + - "\u0CF8\u0CF9\x07E\x02\x02\u0CF9\u0CFA\x07G\x02\x02\u0CFA\u026A\x03\x02" + - "\x02\x02\u0CFB\u0CFC\x07T\x02\x02\u0CFC\u0CFD\x07G\x02\x02\u0CFD\u0CFE" + - "\x07R\x02\x02\u0CFE\u0CFF\x07N\x02\x02\u0CFF\u0D00\x07K\x02\x02\u0D00" + - "\u0D01\x07E\x02\x02\u0D01\u0D02\x07C\x02\x02\u0D02\u026C\x03\x02\x02\x02" + - "\u0D03\u0D04\x07T\x02\x02\u0D04\u0D05\x07G\x02\x02\u0D05\u0D06\x07U\x02" + - "\x02\u0D06\u0D07\x07G\x02\x02\u0D07\u0D08\x07V\x02\x02\u0D08\u026E\x03" + - "\x02\x02\x02\u0D09\u0D0A\x07T\x02\x02\u0D0A\u0D0B\x07G\x02\x02\u0D0B\u0D0C" + - "\x07U\x02\x02\u0D0C\u0D0D\x07V\x02\x02\u0D0D\u0D0E\x07C\x02\x02\u0D0E" + - "\u0D0F\x07T\x02\x02\u0D0F\u0D10\x07V\x02\x02\u0D10\u0270\x03\x02\x02\x02" + - "\u0D11\u0D12\x07T\x02\x02\u0D12\u0D13\x07G\x02\x02\u0D13\u0D14\x07U\x02" + - "\x02\u0D14\u0D15\x07V\x02\x02\u0D15\u0D16\x07T\x02\x02\u0D16\u0D17\x07" + - "K\x02\x02\u0D17\u0D18\x07E\x02\x02\u0D18\u0D19\x07V\x02\x02\u0D19\u0272" + - "\x03\x02\x02\x02\u0D1A\u0D1B\x07T\x02\x02\u0D1B\u0D1C\x07G\x02\x02\u0D1C" + - "\u0D1D\x07V\x02\x02\u0D1D\u0D1E\x07W\x02\x02\u0D1E\u0D1F\x07T\x02\x02" + - "\u0D1F\u0D20\x07P\x02\x02\u0D20\u0D21\x07U\x02\x02\u0D21\u0274\x03\x02" + - "\x02\x02\u0D22\u0D23\x07T\x02\x02\u0D23\u0D24\x07G\x02\x02\u0D24\u0D25" + - "\x07X\x02\x02\u0D25\u0D26\x07Q\x02\x02\u0D26\u0D27\x07M\x02\x02\u0D27" + - "\u0D28\x07G\x02\x02\u0D28\u0276\x03\x02\x02\x02\u0D29\u0D2A\x07T\x02\x02" + - "\u0D2A\u0D2B\x07Q\x02\x02\u0D2B\u0D2C\x07N\x02\x02\u0D2C\u0D2D\x07G\x02" + - "\x02\u0D2D\u0278\x03\x02\x02\x02\u0D2E\u0D2F\x07T\x02\x02\u0D2F\u0D30" + - "\x07Q\x02\x02\u0D30\u0D31\x07N\x02\x02\u0D31\u0D32\x07N\x02\x02\u0D32" + - "\u0D33\x07D\x02\x02\u0D33\u0D34\x07C\x02\x02\u0D34\u0D35\x07E\x02\x02" + - "\u0D35\u0D36\x07M\x02\x02\u0D36\u027A\x03\x02\x02\x02\u0D37\u0D38\x07" + - "T\x02\x02\u0D38\u0D39\x07Q\x02\x02\u0D39\u0D3A\x07Y\x02\x02\u0D3A\u0D3B" + - "\x07U\x02\x02\u0D3B\u027C\x03\x02\x02\x02\u0D3C\u0D3D\x07T\x02\x02\u0D3D" + - "\u0D3E\x07W\x02\x02\u0D3E\u0D3F\x07N\x02\x02\u0D3F\u0D40\x07G\x02\x02" + - "\u0D40\u027E\x03\x02\x02\x02\u0D41\u0D42\x07U\x02\x02\u0D42\u0D43\x07" + - "C\x02\x02\u0D43\u0D44\x07X\x02\x02\u0D44\u0D45\x07G\x02\x02\u0D45\u0D46" + - "\x07R\x02\x02\u0D46\u0D47\x07Q\x02\x02\u0D47\u0D48\x07K\x02\x02\u0D48" + - "\u0D49\x07P\x02\x02\u0D49\u0D4A\x07V\x02\x02\u0D4A\u0280\x03\x02\x02\x02" + - "\u0D4B\u0D4C\x07U\x02\x02\u0D4C\u0D4D\x07E\x02\x02\u0D4D\u0D4E\x07J\x02" + - "\x02\u0D4E\u0D4F\x07G\x02\x02\u0D4F\u0D50\x07O\x02\x02\u0D50\u0D51\x07" + - "C\x02\x02\u0D51\u0282\x03\x02\x02\x02\u0D52\u0D53\x07U\x02\x02\u0D53\u0D54" + - "\x07E\x02\x02\u0D54\u0D55\x07T\x02\x02\u0D55\u0D56\x07Q\x02\x02\u0D56" + - "\u0D57\x07N\x02\x02\u0D57\u0D58\x07N\x02\x02\u0D58\u0284\x03\x02\x02\x02" + - "\u0D59\u0D5A\x07U\x02\x02\u0D5A\u0D5B\x07G\x02\x02\u0D5B\u0D5C\x07C\x02" + - "\x02\u0D5C\u0D5D\x07T\x02\x02\u0D5D\u0D5E\x07E\x02\x02\u0D5E\u0D5F\x07" + - "J\x02\x02\u0D5F\u0286\x03\x02\x02\x02\u0D60\u0D61\x07U\x02\x02\u0D61\u0D62" + - "\x07G\x02\x02\u0D62\u0D63\x07E\x02\x02\u0D63\u0D64\x07Q\x02\x02\u0D64" + - "\u0D65\x07P\x02\x02\u0D65\u0D66\x07F\x02\x02\u0D66\u0288\x03\x02\x02\x02" + - "\u0D67\u0D68\x07U\x02\x02\u0D68\u0D69\x07G\x02\x02\u0D69\u0D6A\x07E\x02" + - "\x02\u0D6A\u0D6B\x07W\x02\x02\u0D6B\u0D6C\x07T\x02\x02\u0D6C\u0D6D\x07" + - "K\x02\x02\u0D6D\u0D6E\x07V\x02\x02\u0D6E\u0D6F\x07[\x02\x02\u0D6F\u028A" + - "\x03\x02\x02\x02\u0D70\u0D71\x07U\x02\x02\u0D71\u0D72\x07G\x02\x02\u0D72" + - "\u0D73\x07S\x02\x02\u0D73\u0D74\x07W\x02\x02\u0D74\u0D75\x07G\x02\x02" + - "\u0D75\u0D76\x07P\x02\x02\u0D76\u0D77\x07E\x02\x02\u0D77\u0D78\x07G\x02" + - "\x02\u0D78\u028C\x03\x02\x02\x02\u0D79\u0D7A\x07U\x02\x02\u0D7A\u0D7B" + - "\x07G\x02\x02\u0D7B\u0D7C\x07S\x02\x02\u0D7C\u0D7D\x07W\x02\x02\u0D7D" + - "\u0D7E\x07G\x02\x02\u0D7E\u0D7F\x07P\x02\x02\u0D7F\u0D80\x07E\x02\x02" + - "\u0D80\u0D81\x07G\x02\x02\u0D81\u0D82\x07U\x02\x02\u0D82\u028E\x03\x02" + - "\x02\x02\u0D83\u0D84\x07U\x02\x02\u0D84\u0D85\x07G\x02\x02\u0D85\u0D86" + - "\x07T\x02\x02\u0D86\u0D87\x07K\x02\x02\u0D87\u0D88\x07C\x02\x02\u0D88" + - "\u0D89\x07N\x02\x02\u0D89\u0D8A\x07K\x02\x02\u0D8A\u0D8B\x07\\\x02\x02" + - "\u0D8B\u0D8C\x07C\x02\x02\u0D8C\u0D8D\x07D\x02\x02\u0D8D\u0D8E\x07N\x02" + - "\x02\u0D8E\u0D8F\x07G\x02\x02\u0D8F\u0290\x03\x02\x02\x02\u0D90\u0D91" + - "\x07U\x02\x02\u0D91\u0D92\x07G\x02\x02\u0D92\u0D93\x07T\x02\x02\u0D93" + - "\u0D94\x07X\x02\x02\u0D94\u0D95\x07G\x02\x02\u0D95\u0D96\x07T\x02\x02" + - "\u0D96\u0292\x03\x02\x02\x02\u0D97\u0D98\x07U\x02\x02\u0D98\u0D99\x07" + - "G\x02\x02\u0D99\u0D9A\x07U\x02\x02\u0D9A\u0D9B\x07U\x02\x02\u0D9B\u0D9C" + - "\x07K\x02\x02\u0D9C\u0D9D\x07Q\x02\x02\u0D9D\u0D9E\x07P\x02\x02\u0D9E" + - "\u0294\x03\x02\x02\x02\u0D9F\u0DA0\x07U\x02\x02\u0DA0\u0DA1\x07G\x02\x02" + - "\u0DA1\u0DA2\x07V\x02\x02\u0DA2\u0296\x03\x02\x02\x02\u0DA3\u0DA4\x07" + - "U\x02\x02\u0DA4\u0DA5\x07J\x02\x02\u0DA5\u0DA6\x07C\x02\x02\u0DA6\u0DA7" + - "\x07T\x02\x02\u0DA7\u0DA8\x07G\x02\x02\u0DA8\u0298\x03\x02\x02\x02\u0DA9" + - "\u0DAA\x07U\x02\x02\u0DAA\u0DAB\x07J\x02\x02\u0DAB\u0DAC\x07Q\x02\x02" + - "\u0DAC\u0DAD\x07Y\x02\x02\u0DAD\u029A\x03\x02\x02\x02\u0DAE\u0DAF\x07" + - "U\x02\x02\u0DAF\u0DB0\x07K\x02\x02\u0DB0\u0DB1\x07O\x02\x02\u0DB1\u0DB2" + - "\x07R\x02\x02\u0DB2\u0DB3\x07N\x02\x02\u0DB3\u0DB4\x07G\x02\x02\u0DB4" + - "\u029C\x03\x02\x02\x02\u0DB5\u0DB6\x07U\x02\x02\u0DB6\u0DB7\x07P\x02\x02" + - "\u0DB7\u0DB8\x07C\x02\x02\u0DB8\u0DB9\x07R\x02\x02\u0DB9\u0DBA\x07U\x02" + - "\x02\u0DBA\u0DBB\x07J\x02\x02\u0DBB\u0DBC\x07Q\x02\x02\u0DBC\u0DBD\x07" + - "V\x02\x02\u0DBD\u029E\x03\x02\x02\x02\u0DBE\u0DBF\x07U\x02\x02\u0DBF\u0DC0" + - "\x07V\x02\x02\u0DC0\u0DC1\x07C\x02\x02\u0DC1\u0DC2\x07D\x02\x02\u0DC2" + - "\u0DC3\x07N\x02\x02\u0DC3\u0DC4\x07G\x02\x02\u0DC4\u02A0\x03\x02\x02\x02" + - "\u0DC5\u0DC6\x07U\x02\x02\u0DC6\u0DC7\x07V\x02\x02\u0DC7\u0DC8\x07C\x02" + - "\x02\u0DC8\u0DC9\x07P\x02\x02\u0DC9\u0DCA\x07F\x02\x02\u0DCA\u0DCB\x07" + - "C\x02\x02\u0DCB\u0DCC\x07N\x02\x02\u0DCC\u0DCD\x07Q\x02\x02\u0DCD\u0DCE" + - "\x07P\x02\x02\u0DCE\u0DCF\x07G\x02\x02\u0DCF\u02A2\x03\x02\x02\x02\u0DD0" + - "\u0DD1\x07U\x02\x02\u0DD1\u0DD2\x07V\x02\x02\u0DD2\u0DD3\x07C\x02\x02" + - "\u0DD3\u0DD4\x07T\x02\x02\u0DD4\u0DD5\x07V\x02\x02\u0DD5\u02A4\x03\x02" + - "\x02\x02\u0DD6\u0DD7\x07U\x02\x02\u0DD7\u0DD8\x07V\x02\x02\u0DD8\u0DD9" + - "\x07C\x02\x02\u0DD9\u0DDA\x07V\x02\x02\u0DDA\u0DDB\x07G\x02\x02\u0DDB" + - "\u0DDC\x07O\x02\x02\u0DDC\u0DDD\x07G\x02\x02\u0DDD\u0DDE\x07P\x02\x02" + - "\u0DDE\u0DDF\x07V\x02\x02\u0DDF\u02A6\x03\x02\x02\x02\u0DE0\u0DE1\x07" + - "U\x02\x02\u0DE1\u0DE2\x07V\x02\x02\u0DE2\u0DE3\x07C\x02\x02\u0DE3\u0DE4" + - "\x07V\x02\x02\u0DE4\u0DE5\x07K\x02\x02\u0DE5\u0DE6\x07U\x02\x02\u0DE6" + - "\u0DE7\x07V\x02\x02\u0DE7\u0DE8\x07K\x02\x02\u0DE8\u0DE9\x07E\x02\x02" + - "\u0DE9\u0DEA\x07U\x02\x02\u0DEA\u02A8\x03\x02\x02\x02\u0DEB\u0DEC\x07" + - "U\x02\x02\u0DEC\u0DED\x07V\x02\x02\u0DED\u0DEE\x07F\x02\x02\u0DEE\u0DEF" + - "\x07K\x02\x02\u0DEF\u0DF0\x07P\x02\x02\u0DF0\u02AA\x03\x02\x02\x02\u0DF1" + - "\u0DF2\x07U\x02\x02\u0DF2\u0DF3\x07V\x02\x02\u0DF3\u0DF4\x07F\x02\x02" + - "\u0DF4\u0DF5\x07Q\x02\x02\u0DF5\u0DF6\x07W\x02\x02\u0DF6\u0DF7\x07V\x02" + - "\x02\u0DF7\u02AC\x03\x02\x02\x02\u0DF8\u0DF9\x07U\x02\x02\u0DF9\u0DFA" + - "\x07V\x02\x02\u0DFA\u0DFB\x07Q\x02\x02\u0DFB\u0DFC\x07T\x02\x02\u0DFC" + - "\u0DFD\x07C\x02\x02\u0DFD\u0DFE\x07I\x02\x02\u0DFE\u0DFF\x07G\x02\x02" + - "\u0DFF\u02AE\x03\x02\x02\x02\u0E00\u0E01\x07U\x02\x02\u0E01\u0E02\x07" + - "V\x02\x02\u0E02\u0E03\x07T\x02\x02\u0E03\u0E04\x07K\x02\x02\u0E04\u0E05" + - "\x07E\x02\x02\u0E05\u0E06\x07V\x02\x02\u0E06\u02B0\x03\x02\x02\x02\u0E07" + - "\u0E08\x07U\x02\x02\u0E08\u0E09\x07V\x02\x02\u0E09\u0E0A\x07T\x02\x02" + - "\u0E0A\u0E0B\x07K\x02\x02\u0E0B\u0E0C\x07R\x02\x02\u0E0C\u02B2\x03\x02" + - "\x02\x02\u0E0D\u0E0E\x07U\x02\x02\u0E0E\u0E0F\x07[\x02\x02\u0E0F\u0E10" + - "\x07U\x02\x02\u0E10\u0E11\x07K\x02\x02\u0E11\u0E12\x07F\x02\x02\u0E12" + - "\u02B4\x03\x02\x02\x02\u0E13\u0E14\x07U\x02\x02\u0E14\u0E15\x07[\x02\x02" + - "\u0E15\u0E16\x07U\x02\x02\u0E16\u0E17\x07V\x02\x02\u0E17\u0E18\x07G\x02" + - "\x02\u0E18\u0E19\x07O\x02\x02\u0E19\u02B6\x03\x02\x02\x02\u0E1A\u0E1B" + - "\x07V\x02\x02\u0E1B\u0E1C\x07C\x02\x02\u0E1C\u0E1D\x07D\x02\x02\u0E1D" + - "\u0E1E\x07N\x02\x02\u0E1E\u0E1F\x07G\x02\x02\u0E1F\u0E20\x07U\x02\x02" + - "\u0E20\u02B8\x03\x02\x02\x02\u0E21\u0E22\x07V\x02\x02\u0E22\u0E23\x07" + - "C\x02\x02\u0E23\u0E24\x07D\x02\x02\u0E24\u0E25\x07N\x02\x02\u0E25\u0E26" + - "\x07G\x02\x02\u0E26\u0E27\x07U\x02\x02\u0E27\u0E28\x07R\x02\x02\u0E28" + - "\u0E29\x07C\x02\x02\u0E29\u0E2A\x07E\x02\x02\u0E2A\u0E2B\x07G\x02\x02" + - "\u0E2B\u02BA\x03\x02\x02\x02\u0E2C\u0E2D\x07V\x02\x02\u0E2D\u0E2E\x07" + - "G\x02\x02\u0E2E\u0E2F\x07O\x02\x02\u0E2F\u0E30\x07R\x02\x02\u0E30\u02BC" + - "\x03\x02\x02\x02\u0E31\u0E32\x07V\x02\x02\u0E32\u0E33\x07G\x02\x02\u0E33" + - "\u0E34\x07O\x02\x02\u0E34\u0E35\x07R\x02\x02\u0E35\u0E36\x07N\x02\x02" + - "\u0E36\u0E37\x07C\x02\x02\u0E37\u0E38\x07V\x02\x02\u0E38\u0E39\x07G\x02" + - "\x02\u0E39\u02BE\x03\x02\x02\x02\u0E3A\u0E3B\x07V\x02\x02\u0E3B\u0E3C" + - "\x07G\x02\x02\u0E3C\u0E3D\x07O\x02\x02\u0E3D\u0E3E\x07R\x02\x02\u0E3E" + - "\u0E3F\x07Q\x02\x02\u0E3F\u0E40\x07T\x02\x02\u0E40\u0E41\x07C\x02\x02" + - "\u0E41\u0E42\x07T\x02\x02\u0E42\u0E43\x07[\x02\x02\u0E43\u02C0\x03\x02" + - "\x02\x02\u0E44\u0E45\x07V\x02\x02\u0E45\u0E46\x07G\x02\x02\u0E46\u0E47" + - "\x07Z\x02\x02\u0E47\u0E48\x07V\x02\x02\u0E48\u02C2\x03\x02\x02\x02\u0E49" + - "\u0E4A\x07V\x02\x02\u0E4A\u0E4B\x07T\x02\x02\u0E4B\u0E4C\x07C\x02\x02" + - "\u0E4C\u0E4D\x07P\x02\x02\u0E4D\u0E4E\x07U\x02\x02\u0E4E\u0E4F\x07C\x02" + - "\x02\u0E4F\u0E50\x07E\x02\x02\u0E50\u0E51\x07V\x02\x02\u0E51\u0E52\x07" + - "K\x02\x02\u0E52\u0E53\x07Q\x02\x02\u0E53\u0E54\x07P\x02\x02\u0E54\u02C4" + - "\x03\x02\x02\x02\u0E55\u0E56\x07V\x02\x02\u0E56\u0E57\x07T\x02\x02\u0E57" + - "\u0E58\x07K\x02\x02\u0E58\u0E59\x07I\x02\x02\u0E59\u0E5A\x07I\x02\x02" + - "\u0E5A\u0E5B\x07G\x02\x02\u0E5B\u0E5C\x07T\x02\x02\u0E5C\u02C6\x03\x02" + - "\x02\x02\u0E5D\u0E5E\x07V\x02\x02\u0E5E\u0E5F\x07T\x02\x02\u0E5F\u0E60" + - "\x07W\x02\x02\u0E60\u0E61\x07P\x02\x02\u0E61\u0E62\x07E\x02\x02\u0E62" + - "\u0E63\x07C\x02\x02\u0E63\u0E64\x07V\x02\x02\u0E64\u0E65\x07G\x02\x02" + - "\u0E65\u02C8\x03\x02\x02\x02\u0E66\u0E67\x07V\x02\x02\u0E67\u0E68\x07" + - "T\x02\x02\u0E68\u0E69\x07W\x02\x02\u0E69\u0E6A\x07U\x02\x02\u0E6A\u0E6B" + - "\x07V\x02\x02\u0E6B\u0E6C\x07G\x02\x02\u0E6C\u0E6D\x07F\x02\x02\u0E6D" + - "\u02CA\x03\x02\x02\x02\u0E6E\u0E6F\x07V\x02\x02\u0E6F\u0E70\x07[\x02\x02" + - "\u0E70\u0E71\x07R\x02\x02\u0E71\u0E72\x07G\x02\x02\u0E72\u02CC\x03\x02" + - "\x02\x02\u0E73\u0E74\x07V\x02\x02\u0E74\u0E75\x07[\x02\x02\u0E75\u0E76" + - "\x07R\x02\x02\u0E76\u0E77\x07G"; + "\x07R\x02\x02\u0B03\u0B04\x07G\x02\x02\u0B04\u0B05\x07T\x02\x02\u0B05" + + "\u0B06\x07W\x02\x02\u0B06\u0B07\x07U\x02\x02\u0B07\u0B08\x07G\x02\x02" + + "\u0B08\u0B09\x07T\x02\x02\u0B09\u01DC\x03\x02\x02\x02\u0B0A\u0B0B\x07" + + "E\x02\x02\u0B0B\u0B0C\x07T\x02\x02\u0B0C\u0B0D\x07G\x02\x02\u0B0D\u0B0E" + + "\x07C\x02\x02\u0B0E\u0B0F\x07V\x02\x02\u0B0F\u0B10\x07G\x02\x02\u0B10" + + "\u0B11\x07F\x02\x02\u0B11\u0B12\x07D\x02\x02\u0B12\u01DE\x03\x02\x02\x02" + + "\u0B13\u0B14\x07P\x02\x02\u0B14\u0B15\x07Q\x02\x02\u0B15\u0B16\x07E\x02" + + "\x02\u0B16\u0B17\x07T\x02\x02\u0B17\u0B18\x07G\x02\x02\u0B18\u0B19\x07" + + "C\x02\x02\u0B19\u0B1A\x07V\x02\x02\u0B1A\u0B1B\x07G\x02\x02\u0B1B\u0B1C" + + "\x07F\x02\x02\u0B1C\u0B1D\x07D\x02\x02\u0B1D\u01E0\x03\x02\x02\x02\u0B1E" + + "\u0B1F\x07E\x02\x02\u0B1F\u0B20\x07T\x02\x02\u0B20\u0B21\x07G\x02\x02" + + "\u0B21\u0B22\x07C\x02\x02\u0B22\u0B23\x07V\x02\x02\u0B23\u0B24\x07G\x02" + + "\x02\u0B24\u0B25\x07T\x02\x02\u0B25\u0B26\x07Q\x02\x02\u0B26\u0B27\x07" + + "N\x02\x02\u0B27\u0B28\x07G\x02\x02\u0B28\u01E2\x03\x02\x02\x02\u0B29\u0B2A" + + "\x07P\x02\x02\u0B2A\u0B2B\x07Q\x02\x02\u0B2B\u0B2C\x07E\x02\x02\u0B2C" + + "\u0B2D\x07T\x02\x02\u0B2D\u0B2E\x07G\x02\x02\u0B2E\u0B2F\x07C\x02\x02" + + "\u0B2F\u0B30\x07V\x02\x02\u0B30\u0B31\x07G\x02\x02\u0B31\u0B32\x07T\x02" + + "\x02\u0B32\u0B33\x07Q\x02\x02\u0B33\u0B34\x07N\x02\x02\u0B34\u0B35\x07" + + "G\x02\x02\u0B35\u01E4\x03\x02\x02\x02\u0B36\u0B37\x07E\x02\x02\u0B37\u0B38" + + "\x07T\x02\x02\u0B38\u0B39\x07G\x02\x02\u0B39\u0B3A\x07C\x02\x02\u0B3A" + + "\u0B3B\x07V\x02\x02\u0B3B\u0B3C\x07G\x02\x02\u0B3C\u0B3D\x07W\x02\x02" + + "\u0B3D\u0B3E\x07U\x02\x02\u0B3E\u0B3F\x07G\x02\x02\u0B3F\u0B40\x07T\x02" + + "\x02\u0B40\u01E6\x03\x02\x02\x02\u0B41\u0B42\x07P\x02\x02\u0B42\u0B43" + + "\x07Q\x02\x02\u0B43\u0B44\x07E\x02\x02\u0B44\u0B45\x07T\x02\x02\u0B45" + + "\u0B46\x07G\x02\x02\u0B46\u0B47\x07C\x02\x02\u0B47\u0B48\x07V\x02\x02" + + "\u0B48\u0B49\x07G\x02\x02\u0B49\u0B4A\x07W\x02\x02\u0B4A\u0B4B\x07U\x02" + + "\x02\u0B4B\u0B4C\x07G\x02\x02\u0B4C\u0B4D\x07T\x02\x02\u0B4D\u01E8\x03" + + "\x02\x02\x02\u0B4E\u0B4F\x07K\x02\x02\u0B4F\u0B50\x07P\x02\x02\u0B50\u0B51" + + "\x07J\x02\x02\u0B51\u0B52\x07G\x02\x02\u0B52\u0B53\x07T\x02\x02\u0B53" + + "\u0B54\x07K\x02\x02\u0B54\u0B55\x07V\x02\x02\u0B55\u0B56\x07U\x02\x02" + + "\u0B56\u01EA\x03\x02\x02\x02\u0B57\u0B58\x07K\x02\x02\u0B58\u0B59\x07" + + "P\x02\x02\u0B59\u0B5A\x07N\x02\x02\u0B5A\u0B5B\x07K\x02\x02\u0B5B\u0B5C" + + "\x07P\x02\x02\u0B5C\u0B5D\x07G\x02\x02\u0B5D\u01EC\x03\x02\x02\x02\u0B5E" + + "\u0B5F\x07K\x02\x02\u0B5F\u0B60\x07P\x02\x02\u0B60\u0B61\x07U\x02\x02" + + "\u0B61\u0B62\x07G\x02\x02\u0B62\u0B63\x07P\x02\x02\u0B63\u0B64\x07U\x02" + + "\x02\u0B64\u0B65\x07K\x02\x02\u0B65\u0B66\x07V\x02\x02\u0B66\u0B67\x07" + + "K\x02\x02\u0B67\u0B68\x07X\x02\x02\u0B68\u0B69\x07G\x02\x02\u0B69\u01EE" + + "\x03\x02\x02\x02\u0B6A\u0B6B\x07K\x02\x02\u0B6B\u0B6C\x07P\x02\x02\u0B6C" + + "\u0B6D\x07U\x02\x02\u0B6D\u0B6E\x07G\x02\x02\u0B6E\u0B6F\x07T\x02\x02" + + "\u0B6F\u0B70\x07V\x02\x02\u0B70\u01F0\x03\x02\x02\x02\u0B71\u0B72\x07" + + "K\x02\x02\u0B72\u0B73\x07P\x02\x02\u0B73\u0B74\x07U\x02\x02\u0B74\u0B75" + + "\x07V\x02\x02\u0B75\u0B76\x07G\x02\x02\u0B76\u0B77\x07C\x02\x02\u0B77" + + "\u0B78\x07F\x02\x02\u0B78\u01F2\x03\x02\x02\x02\u0B79\u0B7A\x07K\x02\x02" + + "\u0B7A\u0B7B\x07P\x02\x02\u0B7B\u0B7C\x07X\x02\x02\u0B7C\u0B7D\x07Q\x02" + + "\x02\u0B7D\u0B7E\x07M\x02\x02\u0B7E\u0B7F\x07G\x02\x02\u0B7F\u0B80\x07" + + "T\x02\x02\u0B80\u01F4\x03\x02\x02\x02\u0B81\u0B82\x07K\x02\x02\u0B82\u0B83" + + "\x07U\x02\x02\u0B83\u0B84\x07Q\x02\x02\u0B84\u0B85\x07N\x02\x02\u0B85" + + "\u0B86\x07C\x02\x02\u0B86\u0B87\x07V\x02\x02\u0B87\u0B88\x07K\x02\x02" + + "\u0B88\u0B89\x07Q\x02\x02\u0B89\u0B8A\x07P\x02\x02\u0B8A\u01F6\x03\x02" + + "\x02\x02\u0B8B\u0B8C\x07M\x02\x02\u0B8C\u0B8D\x07G\x02\x02\u0B8D\u0B8E" + + "\x07[\x02\x02\u0B8E\u01F8\x03\x02\x02\x02\u0B8F\u0B90\x07N\x02\x02\u0B90" + + "\u0B91\x07C\x02\x02\u0B91\u0B92\x07D\x02\x02\u0B92\u0B93\x07G\x02\x02" + + "\u0B93\u0B94\x07N\x02\x02\u0B94\u01FA\x03\x02\x02\x02\u0B95\u0B96\x07" + + "N\x02\x02\u0B96\u0B97\x07C\x02\x02\u0B97\u0B98\x07P\x02\x02\u0B98\u0B99" + + "\x07I\x02\x02\u0B99\u0B9A\x07W\x02\x02\u0B9A\u0B9B\x07C\x02\x02\u0B9B" + + "\u0B9C\x07I\x02\x02\u0B9C\u0B9D\x07G\x02\x02\u0B9D\u01FC\x03\x02\x02\x02" + + "\u0B9E\u0B9F\x07N\x02\x02\u0B9F\u0BA0\x07C\x02\x02\u0BA0\u0BA1\x07T\x02" + + "\x02\u0BA1\u0BA2\x07I\x02\x02\u0BA2\u0BA3\x07G\x02\x02\u0BA3\u01FE\x03" + + "\x02\x02\x02\u0BA4\u0BA5\x07N\x02\x02\u0BA5\u0BA6\x07C\x02\x02\u0BA6\u0BA7" + + "\x07U\x02\x02\u0BA7\u0BA8\x07V\x02\x02\u0BA8\u0200\x03\x02\x02\x02\u0BA9" + + "\u0BAA\x07N\x02\x02\u0BAA\u0BAB\x07G\x02\x02\u0BAB\u0BAC\x07C\x02\x02" + + "\u0BAC\u0BAD\x07M\x02\x02\u0BAD\u0BAE\x07R\x02\x02\u0BAE\u0BAF\x07T\x02" + + "\x02\u0BAF\u0BB0\x07Q\x02\x02\u0BB0\u0BB1\x07Q\x02\x02\u0BB1\u0BB2\x07" + + "H\x02\x02\u0BB2\u0202\x03\x02\x02\x02\u0BB3\u0BB4\x07N\x02\x02\u0BB4\u0BB5" + + "\x07G\x02\x02\u0BB5\u0BB6\x07X\x02\x02\u0BB6\u0BB7\x07G\x02\x02\u0BB7" + + "\u0BB8\x07N\x02\x02\u0BB8\u0204\x03\x02\x02\x02\u0BB9\u0BBA\x07N\x02\x02" + + "\u0BBA\u0BBB\x07K\x02\x02\u0BBB\u0BBC\x07U\x02\x02\u0BBC\u0BBD\x07V\x02" + + "\x02\u0BBD\u0BBE\x07G\x02\x02\u0BBE\u0BBF\x07P\x02\x02\u0BBF\u0206\x03" + + "\x02\x02\x02\u0BC0\u0BC1\x07N\x02\x02\u0BC1\u0BC2\x07Q\x02\x02\u0BC2\u0BC3" + + "\x07C\x02\x02\u0BC3\u0BC4\x07F\x02\x02\u0BC4\u0208\x03\x02\x02\x02\u0BC5" + + "\u0BC6\x07N\x02\x02\u0BC6\u0BC7\x07Q\x02\x02\u0BC7\u0BC8\x07E\x02\x02" + + "\u0BC8\u0BC9\x07C\x02\x02\u0BC9\u0BCA\x07N\x02\x02\u0BCA\u020A\x03\x02" + + "\x02\x02\u0BCB\u0BCC\x07N\x02\x02\u0BCC\u0BCD\x07Q\x02\x02\u0BCD\u0BCE" + + "\x07E\x02\x02\u0BCE\u0BCF\x07C\x02\x02\u0BCF\u0BD0\x07V\x02\x02\u0BD0" + + "\u0BD1\x07K\x02\x02\u0BD1\u0BD2\x07Q\x02\x02\u0BD2\u0BD3\x07P\x02\x02" + + "\u0BD3\u020C\x03\x02\x02\x02\u0BD4\u0BD5\x07N\x02\x02\u0BD5\u0BD6\x07" + + "Q\x02\x02\u0BD6\u0BD7\x07E\x02\x02\u0BD7\u0BD8\x07M\x02\x02\u0BD8\u020E" + + "\x03\x02\x02\x02\u0BD9\u0BDA\x07O\x02\x02\u0BDA\u0BDB\x07C\x02\x02\u0BDB" + + "\u0BDC\x07R\x02\x02\u0BDC\u0BDD\x07R\x02\x02\u0BDD\u0BDE\x07K\x02\x02" + + "\u0BDE\u0BDF\x07P\x02\x02\u0BDF\u0BE0\x07I\x02\x02\u0BE0\u0210\x03\x02" + + "\x02\x02\u0BE1\u0BE2\x07O\x02\x02\u0BE2\u0BE3\x07C\x02\x02\u0BE3\u0BE4" + + "\x07V\x02\x02\u0BE4\u0BE5\x07E\x02\x02\u0BE5\u0BE6\x07J\x02\x02\u0BE6" + + "\u0212\x03\x02\x02\x02\u0BE7\u0BE8\x07O\x02\x02\u0BE8\u0BE9\x07C\x02\x02" + + "\u0BE9\u0BEA\x07V\x02\x02\u0BEA\u0BEB\x07G\x02\x02\u0BEB\u0BEC\x07T\x02" + + "\x02\u0BEC\u0BED\x07K\x02\x02\u0BED\u0BEE\x07C\x02\x02\u0BEE\u0BEF\x07" + + "N\x02\x02\u0BEF\u0BF0\x07K\x02\x02\u0BF0\u0BF1\x07\\\x02\x02\u0BF1\u0BF2" + + "\x07G\x02\x02\u0BF2\u0BF3\x07F\x02\x02\u0BF3\u0214\x03\x02\x02\x02\u0BF4" + + "\u0BF5\x07O\x02\x02\u0BF5\u0BF6\x07C\x02\x02\u0BF6\u0BF7\x07Z\x02\x02" + + "\u0BF7\u0BF8\x07X\x02\x02\u0BF8\u0BF9\x07C\x02\x02\u0BF9\u0BFA\x07N\x02" + + "\x02\u0BFA\u0BFB\x07W\x02\x02\u0BFB\u0BFC\x07G\x02\x02\u0BFC\u0216\x03" + + "\x02\x02\x02\u0BFD\u0BFE\x07O\x02\x02\u0BFE\u0BFF\x07K\x02\x02\u0BFF\u0C00" + + "\x07P\x02\x02\u0C00\u0C01\x07W\x02\x02\u0C01\u0C02\x07V\x02\x02\u0C02" + + "\u0C03\x07G\x02\x02\u0C03\u0218\x03\x02\x02\x02\u0C04\u0C05\x07O\x02\x02" + + "\u0C05\u0C06\x07K\x02\x02\u0C06\u0C07\x07P\x02\x02\u0C07\u0C08\x07X\x02" + + "\x02\u0C08\u0C09\x07C\x02\x02\u0C09\u0C0A\x07N\x02\x02\u0C0A\u0C0B\x07" + + "W\x02\x02\u0C0B\u0C0C\x07G\x02\x02\u0C0C\u021A\x03\x02\x02\x02\u0C0D\u0C0E" + + "\x07O\x02\x02\u0C0E\u0C0F\x07Q\x02\x02\u0C0F\u0C10\x07F\x02\x02\u0C10" + + "\u0C11\x07G\x02\x02\u0C11\u021C\x03\x02\x02\x02\u0C12\u0C13\x07O\x02\x02" + + "\u0C13\u0C14\x07Q\x02\x02\u0C14\u0C15\x07P\x02\x02\u0C15\u0C16\x07V\x02" + + "\x02\u0C16\u0C17\x07J\x02\x02\u0C17\u021E\x03\x02\x02\x02\u0C18\u0C19" + + "\x07O\x02\x02\u0C19\u0C1A\x07Q\x02\x02\u0C1A\u0C1B\x07X\x02\x02\u0C1B" + + "\u0C1C\x07G\x02\x02\u0C1C\u0220\x03\x02\x02\x02\u0C1D\u0C1E\x07P\x02\x02" + + "\u0C1E\u0C1F\x07C\x02\x02\u0C1F\u0C20\x07O\x02\x02\u0C20\u0C21\x07G\x02" + + "\x02\u0C21\u0222\x03\x02\x02\x02\u0C22\u0C23\x07P\x02\x02\u0C23\u0C24" + + "\x07C\x02\x02\u0C24\u0C25\x07O\x02\x02\u0C25\u0C26\x07G\x02\x02\u0C26" + + "\u0C27\x07U\x02\x02\u0C27\u0224\x03\x02\x02\x02\u0C28\u0C29\x07P\x02\x02" + + "\u0C29\u0C2A\x07G\x02\x02\u0C2A\u0C2B\x07Z\x02\x02\u0C2B\u0C2C\x07V\x02" + + "\x02\u0C2C\u0226\x03\x02\x02\x02\u0C2D\u0C2E\x07P\x02\x02\u0C2E\u0C2F" + + "\x07Q\x02\x02\u0C2F\u0228\x03\x02\x02\x02\u0C30\u0C31\x07P\x02\x02\u0C31" + + "\u0C32\x07Q\x02\x02\u0C32\u0C33\x07V\x02\x02\u0C33\u0C34\x07J\x02\x02" + + "\u0C34\u0C35\x07K\x02\x02\u0C35\u0C36\x07P\x02\x02\u0C36\u0C37\x07I\x02" + + "\x02\u0C37\u022A\x03\x02\x02\x02\u0C38\u0C39\x07P\x02\x02\u0C39\u0C3A" + + "\x07Q\x02\x02\u0C3A\u0C3B\x07V\x02\x02\u0C3B\u0C3C\x07K\x02\x02\u0C3C" + + "\u0C3D\x07H\x02\x02\u0C3D\u0C3E\x07[\x02\x02\u0C3E\u022C\x03\x02\x02\x02" + + "\u0C3F\u0C40\x07P\x02\x02\u0C40\u0C41\x07Q\x02\x02\u0C41\u0C42\x07Y\x02" + + "\x02\u0C42\u0C43\x07C\x02\x02\u0C43\u0C44\x07K\x02\x02\u0C44\u0C45\x07" + + "V\x02\x02\u0C45\u022E\x03\x02\x02\x02\u0C46\u0C47\x07P\x02\x02\u0C47\u0C48" + + "\x07W\x02\x02\u0C48\u0C49\x07N\x02\x02\u0C49\u0C4A\x07N\x02\x02\u0C4A" + + "\u0C4B\x07U\x02\x02\u0C4B\u0230\x03\x02\x02\x02\u0C4C\u0C4D\x07Q\x02\x02" + + "\u0C4D\u0C4E\x07D\x02\x02\u0C4E\u0C4F\x07L\x02\x02\u0C4F\u0C50\x07G\x02" + + "\x02\u0C50\u0C51\x07E\x02\x02\u0C51\u0C52\x07V\x02\x02\u0C52\u0232\x03" + + "\x02\x02\x02\u0C53\u0C54\x07Q\x02\x02\u0C54\u0C55\x07H\x02\x02\u0C55\u0234" + + "\x03\x02\x02\x02\u0C56\u0C57\x07Q\x02\x02\u0C57\u0C58\x07H\x02\x02\u0C58" + + "\u0C59\x07H\x02\x02\u0C59\u0236\x03\x02\x02\x02\u0C5A\u0C5B\x07Q\x02\x02" + + "\u0C5B\u0C5C\x07K\x02\x02\u0C5C\u0C5D\x07F\x02\x02\u0C5D\u0C5E\x07U\x02" + + "\x02\u0C5E\u0238\x03\x02\x02\x02\u0C5F\u0C60\x07Q\x02\x02\u0C60\u0C61" + + "\x07R\x02\x02\u0C61\u0C62\x07G\x02\x02\u0C62\u0C63\x07T\x02\x02\u0C63" + + "\u0C64\x07C\x02\x02\u0C64\u0C65\x07V\x02\x02\u0C65\u0C66\x07Q\x02\x02" + + "\u0C66\u0C67\x07T\x02\x02\u0C67\u023A\x03\x02\x02\x02\u0C68\u0C69\x07" + + "Q\x02\x02\u0C69\u0C6A\x07R\x02\x02\u0C6A\u0C6B\x07V\x02\x02\u0C6B\u0C6C" + + "\x07K\x02\x02\u0C6C\u0C6D\x07Q\x02\x02\u0C6D\u0C6E\x07P\x02\x02\u0C6E" + + "\u023C\x03\x02\x02\x02\u0C6F\u0C70\x07Q\x02\x02\u0C70\u0C71\x07R\x02\x02" + + "\u0C71\u0C72\x07V\x02\x02\u0C72\u0C73\x07K\x02\x02\u0C73\u0C74\x07Q\x02" + + "\x02\u0C74\u0C75\x07P\x02\x02\u0C75\u0C76\x07U\x02\x02\u0C76\u023E\x03" + + "\x02\x02\x02\u0C77\u0C78\x07Q\x02\x02\u0C78\u0C79\x07Y\x02\x02\u0C79\u0C7A" + + "\x07P\x02\x02\u0C7A\u0C7B\x07G\x02\x02\u0C7B\u0C7C\x07F\x02\x02\u0C7C" + + "\u0240\x03\x02\x02\x02\u0C7D\u0C7E\x07Q\x02\x02\u0C7E\u0C7F\x07Y\x02\x02" + + "\u0C7F\u0C80\x07P\x02\x02\u0C80\u0C81\x07G\x02\x02\u0C81\u0C82\x07T\x02" + + "\x02\u0C82\u0242\x03\x02\x02\x02\u0C83\u0C84\x07R\x02\x02\u0C84\u0C85" + + "\x07C\x02\x02\u0C85\u0C86\x07T\x02\x02\u0C86\u0C87\x07U\x02\x02\u0C87" + + "\u0C88\x07G\x02\x02\u0C88\u0C89\x07T\x02\x02\u0C89\u0244\x03\x02\x02\x02" + + "\u0C8A\u0C8B\x07R\x02\x02\u0C8B\u0C8C\x07C\x02\x02\u0C8C\u0C8D\x07T\x02" + + "\x02\u0C8D\u0C8E\x07V\x02\x02\u0C8E\u0C8F\x07K\x02\x02\u0C8F\u0C90\x07" + + "C\x02\x02\u0C90\u0C91\x07N\x02\x02\u0C91\u0246\x03\x02\x02\x02\u0C92\u0C93" + + "\x07R\x02\x02\u0C93\u0C94\x07C\x02\x02\u0C94\u0C95\x07T\x02\x02\u0C95" + + "\u0C96\x07V\x02\x02\u0C96\u0C97\x07K\x02\x02\u0C97\u0C98\x07V\x02\x02" + + "\u0C98\u0C99\x07K\x02\x02\u0C99\u0C9A\x07Q\x02\x02\u0C9A\u0C9B\x07P\x02" + + "\x02\u0C9B\u0248\x03\x02\x02\x02\u0C9C\u0C9D\x07R\x02\x02\u0C9D\u0C9E" + + "\x07C\x02\x02\u0C9E\u0C9F\x07U\x02\x02\u0C9F\u0CA0\x07U\x02\x02\u0CA0" + + "\u0CA1\x07K\x02\x02\u0CA1\u0CA2\x07P\x02\x02\u0CA2\u0CA3\x07I\x02\x02" + + "\u0CA3\u024A\x03\x02\x02\x02\u0CA4\u0CA5\x07R\x02\x02\u0CA5\u0CA6\x07" + + "C\x02\x02\u0CA6\u0CA7\x07U\x02\x02\u0CA7\u0CA8\x07U\x02\x02\u0CA8\u0CA9" + + "\x07Y\x02\x02\u0CA9\u0CAA\x07Q\x02\x02\u0CAA\u0CAB\x07T\x02\x02\u0CAB" + + "\u0CAC\x07F\x02\x02\u0CAC\u024C\x03\x02\x02\x02\u0CAD\u0CAE\x07R\x02\x02" + + "\u0CAE\u0CAF\x07N\x02\x02\u0CAF\u0CB0\x07C\x02\x02\u0CB0\u0CB1\x07P\x02" + + "\x02\u0CB1\u0CB2\x07U\x02\x02\u0CB2\u024E\x03\x02\x02\x02\u0CB3\u0CB4" + + "\x07R\x02\x02\u0CB4\u0CB5\x07T\x02\x02\u0CB5\u0CB6\x07G\x02\x02\u0CB6" + + "\u0CB7\x07E\x02\x02\u0CB7\u0CB8\x07G\x02\x02\u0CB8\u0CB9\x07F\x02\x02" + + "\u0CB9\u0CBA\x07K\x02\x02\u0CBA\u0CBB\x07P\x02\x02\u0CBB\u0CBC\x07I\x02" + + "\x02\u0CBC\u0250\x03\x02\x02\x02\u0CBD\u0CBE\x07R\x02\x02\u0CBE\u0CBF" + + "\x07T\x02\x02\u0CBF\u0CC0\x07G\x02\x02\u0CC0\u0CC1\x07R\x02\x02\u0CC1" + + "\u0CC2\x07C\x02\x02\u0CC2\u0CC3\x07T\x02\x02\u0CC3\u0CC4\x07G\x02\x02" + + "\u0CC4\u0252\x03\x02\x02\x02\u0CC5\u0CC6\x07R\x02\x02\u0CC6\u0CC7\x07" + + "T\x02\x02\u0CC7\u0CC8\x07G\x02\x02\u0CC8\u0CC9\x07R\x02\x02\u0CC9\u0CCA" + + "\x07C\x02\x02\u0CCA\u0CCB\x07T\x02\x02\u0CCB\u0CCC\x07G\x02\x02\u0CCC" + + "\u0CCD\x07F\x02\x02\u0CCD\u0254\x03\x02\x02\x02\u0CCE\u0CCF\x07R\x02\x02" + + "\u0CCF\u0CD0\x07T\x02\x02\u0CD0\u0CD1\x07G\x02\x02\u0CD1\u0CD2\x07U\x02" + + "\x02\u0CD2\u0CD3\x07G\x02\x02\u0CD3\u0CD4\x07T\x02\x02\u0CD4\u0CD5\x07" + + "X\x02\x02\u0CD5\u0CD6\x07G\x02\x02\u0CD6\u0256\x03\x02\x02\x02\u0CD7\u0CD8" + + "\x07R\x02\x02\u0CD8\u0CD9\x07T\x02\x02\u0CD9\u0CDA\x07K\x02\x02\u0CDA" + + "\u0CDB\x07Q\x02\x02\u0CDB\u0CDC\x07T\x02\x02\u0CDC\u0258\x03\x02\x02\x02" + + "\u0CDD\u0CDE\x07R\x02\x02\u0CDE\u0CDF\x07T\x02\x02\u0CDF\u0CE0\x07K\x02" + + "\x02\u0CE0\u0CE1\x07X\x02\x02\u0CE1\u0CE2\x07K\x02\x02\u0CE2\u0CE3\x07" + + "N\x02\x02\u0CE3\u0CE4\x07G\x02\x02\u0CE4\u0CE5\x07I\x02\x02\u0CE5\u0CE6" + + "\x07G\x02\x02\u0CE6\u0CE7\x07U\x02\x02\u0CE7\u025A\x03\x02\x02\x02\u0CE8" + + "\u0CE9\x07R\x02\x02\u0CE9\u0CEA\x07T\x02\x02\u0CEA\u0CEB\x07Q\x02\x02" + + "\u0CEB\u0CEC\x07E\x02\x02\u0CEC\u0CED\x07G\x02\x02\u0CED\u0CEE\x07F\x02" + + "\x02\u0CEE\u0CEF\x07W\x02\x02\u0CEF\u0CF0\x07T\x02\x02\u0CF0\u0CF1\x07" + + "C\x02\x02\u0CF1\u0CF2\x07N\x02\x02\u0CF2\u025C\x03\x02\x02\x02\u0CF3\u0CF4" + + "\x07R\x02\x02\u0CF4\u0CF5\x07T\x02\x02\u0CF5\u0CF6\x07Q\x02\x02\u0CF6" + + "\u0CF7\x07E\x02\x02\u0CF7\u0CF8\x07G\x02\x02\u0CF8\u0CF9\x07F\x02\x02" + + "\u0CF9\u0CFA\x07W\x02\x02\u0CFA\u0CFB\x07T\x02\x02\u0CFB\u0CFC\x07G\x02" + + "\x02\u0CFC\u025E\x03\x02\x02\x02\u0CFD\u0CFE\x07R\x02\x02\u0CFE\u0CFF" + + "\x07T\x02\x02\u0CFF\u0D00\x07Q\x02\x02\u0D00\u0D01\x07I\x02\x02\u0D01" + + "\u0D02\x07T\x02\x02\u0D02\u0D03\x07C\x02\x02\u0D03\u0D04\x07O\x02\x02" + + "\u0D04\u0260\x03\x02\x02\x02\u0D05\u0D06\x07S\x02\x02\u0D06\u0D07\x07" + + "W\x02\x02\u0D07\u0D08\x07Q\x02\x02\u0D08\u0D09\x07V\x02\x02\u0D09\u0D0A" + + "\x07G\x02\x02\u0D0A\u0262\x03\x02\x02\x02\u0D0B\u0D0C\x07T\x02\x02\u0D0C" + + "\u0D0D\x07C\x02\x02\u0D0D\u0D0E\x07P\x02\x02\u0D0E\u0D0F\x07I\x02\x02" + + "\u0D0F\u0D10\x07G\x02\x02\u0D10\u0264\x03\x02\x02\x02\u0D11\u0D12\x07" + + "T\x02\x02\u0D12\u0D13\x07G\x02\x02\u0D13\u0D14\x07C\x02\x02\u0D14\u0D15" + + "\x07F\x02\x02\u0D15\u0266\x03\x02\x02\x02\u0D16\u0D17\x07T\x02\x02\u0D17" + + "\u0D18\x07G\x02\x02\u0D18\u0D19\x07C\x02\x02\u0D19\u0D1A\x07U\x02\x02" + + "\u0D1A\u0D1B\x07U\x02\x02\u0D1B\u0D1C\x07K\x02\x02\u0D1C\u0D1D\x07I\x02" + + "\x02\u0D1D\u0D1E\x07P\x02\x02\u0D1E\u0268\x03\x02\x02\x02\u0D1F\u0D20" + + "\x07T\x02\x02\u0D20\u0D21\x07G\x02\x02\u0D21\u0D22\x07E\x02\x02\u0D22" + + "\u0D23\x07J\x02\x02\u0D23\u0D24\x07G\x02\x02\u0D24\u0D25\x07E\x02\x02" + + "\u0D25\u0D26\x07M\x02\x02\u0D26\u026A\x03\x02\x02\x02\u0D27\u0D28\x07" + + "T\x02\x02\u0D28\u0D29\x07G\x02\x02\u0D29\u0D2A\x07E\x02\x02\u0D2A\u0D2B" + + "\x07W\x02\x02\u0D2B\u0D2C\x07T\x02\x02\u0D2C\u0D2D\x07U\x02\x02\u0D2D" + + "\u0D2E\x07K\x02\x02\u0D2E\u0D2F\x07X\x02\x02\u0D2F\u0D30\x07G\x02\x02" + + "\u0D30\u026C\x03\x02\x02\x02\u0D31\u0D32\x07T\x02\x02\u0D32\u0D33\x07" + + "G\x02\x02\u0D33\u0D34\x07H\x02\x02\u0D34\u026E\x03\x02\x02\x02\u0D35\u0D36" + + "\x07T\x02\x02\u0D36\u0D37\x07G\x02\x02\u0D37\u0D38\x07H\x02\x02\u0D38" + + "\u0D39\x07T\x02\x02\u0D39\u0D3A\x07G\x02\x02\u0D3A\u0D3B\x07U\x02\x02" + + "\u0D3B\u0D3C\x07J\x02\x02\u0D3C\u0270\x03\x02\x02\x02\u0D3D\u0D3E\x07" + + "T\x02\x02\u0D3E\u0D3F\x07G\x02\x02\u0D3F\u0D40\x07K\x02\x02\u0D40\u0D41" + + "\x07P\x02\x02\u0D41\u0D42\x07F\x02\x02\u0D42\u0D43\x07G\x02\x02\u0D43" + + "\u0D44\x07Z\x02\x02\u0D44\u0272\x03\x02\x02\x02\u0D45\u0D46\x07T\x02\x02" + + "\u0D46\u0D47\x07G\x02\x02\u0D47\u0D48\x07N\x02\x02\u0D48\u0D49\x07C\x02" + + "\x02\u0D49\u0D4A\x07V\x02\x02\u0D4A\u0D4B\x07K\x02\x02\u0D4B\u0D4C\x07" + + "X\x02\x02\u0D4C\u0D4D\x07G\x02\x02\u0D4D\u0274\x03\x02\x02\x02\u0D4E\u0D4F" + + "\x07T\x02\x02\u0D4F\u0D50\x07G\x02\x02\u0D50\u0D51\x07N\x02\x02\u0D51" + + "\u0D52\x07G\x02\x02\u0D52\u0D53\x07C\x02\x02\u0D53\u0D54\x07U\x02\x02" + + "\u0D54\u0D55\x07G\x02\x02\u0D55\u0276\x03\x02\x02\x02\u0D56\u0D57\x07" + + "T\x02\x02\u0D57\u0D58\x07G\x02\x02\u0D58\u0D59\x07P\x02\x02\u0D59\u0D5A" + + "\x07C\x02\x02\u0D5A\u0D5B\x07O\x02\x02\u0D5B\u0D5C\x07G\x02\x02\u0D5C" + + "\u0278\x03\x02\x02\x02\u0D5D\u0D5E\x07T\x02\x02\u0D5E\u0D5F\x07G\x02\x02" + + "\u0D5F\u0D60\x07R\x02\x02\u0D60\u0D61\x07G\x02\x02\u0D61\u0D62\x07C\x02" + + "\x02\u0D62\u0D63\x07V\x02\x02\u0D63\u0D64\x07C\x02\x02\u0D64\u0D65\x07" + + "D\x02\x02\u0D65\u0D66\x07N\x02\x02\u0D66\u0D67\x07G\x02\x02\u0D67\u027A" + + "\x03\x02\x02\x02\u0D68\u0D69\x07T\x02\x02\u0D69\u0D6A\x07G\x02\x02\u0D6A" + + "\u0D6B\x07R\x02\x02\u0D6B\u0D6C\x07N\x02\x02\u0D6C\u0D6D\x07C\x02\x02" + + "\u0D6D\u0D6E\x07E\x02\x02\u0D6E\u0D6F\x07G\x02\x02\u0D6F\u027C\x03\x02" + + "\x02\x02\u0D70\u0D71\x07T\x02\x02\u0D71\u0D72\x07G\x02\x02\u0D72\u0D73" + + "\x07R\x02\x02\u0D73\u0D74\x07N\x02\x02\u0D74\u0D75\x07K\x02\x02\u0D75" + + "\u0D76\x07E\x02\x02\u0D76\u0D77\x07C\x02\x02\u0D77\u027E\x03\x02\x02\x02" + + "\u0D78\u0D79\x07T\x02\x02\u0D79\u0D7A\x07G\x02\x02\u0D7A\u0D7B\x07U\x02" + + "\x02\u0D7B\u0D7C\x07G\x02\x02\u0D7C\u0D7D\x07V\x02\x02\u0D7D\u0280\x03" + + "\x02\x02\x02\u0D7E\u0D7F\x07T\x02\x02\u0D7F\u0D80\x07G\x02\x02\u0D80\u0D81" + + "\x07U\x02\x02\u0D81\u0D82\x07V\x02\x02\u0D82\u0D83\x07C\x02\x02\u0D83" + + "\u0D84\x07T\x02\x02\u0D84\u0D85\x07V\x02\x02\u0D85\u0282\x03\x02\x02\x02" + + "\u0D86\u0D87\x07T\x02\x02\u0D87\u0D88\x07G\x02\x02\u0D88\u0D89\x07U\x02" + + "\x02\u0D89\u0D8A\x07V\x02\x02\u0D8A\u0D8B\x07T\x02\x02\u0D8B\u0D8C\x07" + + "K\x02\x02\u0D8C\u0D8D\x07E\x02\x02\u0D8D\u0D8E\x07V\x02\x02\u0D8E\u0284" + + "\x03\x02\x02\x02\u0D8F\u0D90\x07T\x02\x02\u0D90\u0D91\x07G\x02\x02\u0D91" + + "\u0D92\x07V\x02\x02\u0D92\u0D93\x07W\x02\x02\u0D93\u0D94\x07T\x02\x02" + + "\u0D94\u0D95\x07P\x02\x02\u0D95\u0D96\x07U\x02\x02\u0D96\u0286\x03\x02" + + "\x02\x02\u0D97\u0D98\x07T\x02\x02\u0D98\u0D99\x07G\x02\x02\u0D99\u0D9A" + + "\x07X\x02\x02\u0D9A\u0D9B\x07Q\x02\x02\u0D9B\u0D9C\x07M\x02\x02\u0D9C" + + "\u0D9D\x07G\x02\x02\u0D9D\u0288\x03\x02\x02\x02\u0D9E\u0D9F\x07T\x02\x02" + + "\u0D9F\u0DA0\x07Q\x02\x02\u0DA0\u0DA1\x07N\x02\x02\u0DA1\u0DA2\x07G\x02" + + "\x02\u0DA2\u028A\x03\x02\x02\x02\u0DA3\u0DA4\x07T\x02\x02\u0DA4\u0DA5" + + "\x07Q\x02\x02\u0DA5\u0DA6\x07N\x02\x02\u0DA6\u0DA7\x07N\x02\x02\u0DA7" + + "\u0DA8\x07D\x02\x02\u0DA8\u0DA9\x07C\x02\x02\u0DA9\u0DAA\x07E\x02\x02" + + "\u0DAA\u0DAB\x07M\x02\x02\u0DAB\u028C\x03\x02\x02\x02\u0DAC\u0DAD\x07" + + "T\x02\x02\u0DAD\u0DAE\x07Q\x02\x02\u0DAE\u0DAF\x07Y\x02\x02\u0DAF\u0DB0" + + "\x07U\x02\x02\u0DB0\u028E\x03\x02\x02\x02\u0DB1\u0DB2\x07T\x02\x02\u0DB2" + + "\u0DB3\x07W\x02\x02\u0DB3\u0DB4\x07N\x02\x02\u0DB4\u0DB5\x07G\x02\x02" + + "\u0DB5\u0290\x03\x02\x02\x02\u0DB6\u0DB7\x07U\x02\x02\u0DB7\u0DB8\x07" + + "C\x02\x02\u0DB8\u0DB9\x07X\x02\x02\u0DB9\u0DBA\x07G\x02\x02\u0DBA\u0DBB" + + "\x07R\x02\x02\u0DBB\u0DBC\x07Q\x02\x02\u0DBC\u0DBD\x07K\x02\x02\u0DBD" + + "\u0DBE\x07P\x02\x02\u0DBE\u0DBF\x07V\x02\x02\u0DBF\u0292\x03\x02\x02\x02" + + "\u0DC0\u0DC1\x07U\x02\x02\u0DC1\u0DC2\x07E\x02\x02\u0DC2\u0DC3\x07J\x02" + + "\x02\u0DC3\u0DC4\x07G\x02\x02\u0DC4\u0DC5\x07O\x02\x02\u0DC5\u0DC6\x07" + + "C\x02\x02\u0DC6\u0294\x03\x02\x02\x02\u0DC7\u0DC8\x07U\x02\x02\u0DC8\u0DC9" + + "\x07E\x02\x02\u0DC9\u0DCA\x07T\x02\x02\u0DCA\u0DCB\x07Q\x02\x02\u0DCB" + + "\u0DCC\x07N\x02\x02\u0DCC\u0DCD\x07N\x02\x02\u0DCD\u0296\x03\x02\x02\x02" + + "\u0DCE\u0DCF\x07U\x02\x02\u0DCF\u0DD0\x07G\x02\x02\u0DD0\u0DD1\x07C\x02" + + "\x02\u0DD1\u0DD2\x07T\x02\x02\u0DD2\u0DD3\x07E\x02\x02\u0DD3\u0DD4\x07" + + "J\x02\x02\u0DD4\u0298\x03\x02\x02\x02\u0DD5\u0DD6\x07U\x02\x02\u0DD6\u0DD7" + + "\x07G\x02\x02\u0DD7\u0DD8\x07E\x02\x02\u0DD8\u0DD9\x07Q\x02\x02\u0DD9" + + "\u0DDA\x07P\x02\x02\u0DDA\u0DDB\x07F\x02\x02\u0DDB\u029A\x03\x02\x02\x02" + + "\u0DDC\u0DDD\x07U\x02\x02\u0DDD\u0DDE\x07G\x02\x02\u0DDE\u0DDF\x07E\x02" + + "\x02\u0DDF\u0DE0\x07W\x02\x02\u0DE0\u0DE1\x07T\x02\x02\u0DE1\u0DE2\x07" + + "K\x02\x02\u0DE2\u0DE3\x07V\x02\x02\u0DE3\u0DE4\x07[\x02\x02\u0DE4\u029C" + + "\x03\x02\x02\x02\u0DE5\u0DE6\x07U\x02\x02\u0DE6\u0DE7\x07G\x02\x02\u0DE7" + + "\u0DE8\x07S\x02\x02\u0DE8\u0DE9\x07W\x02\x02\u0DE9\u0DEA\x07G\x02\x02" + + "\u0DEA\u0DEB\x07P\x02\x02\u0DEB\u0DEC\x07E\x02\x02\u0DEC\u0DED\x07G\x02" + + "\x02\u0DED\u029E\x03\x02\x02\x02\u0DEE\u0DEF\x07U\x02\x02\u0DEF\u0DF0" + + "\x07G\x02\x02\u0DF0\u0DF1\x07S\x02\x02\u0DF1\u0DF2\x07W\x02\x02\u0DF2" + + "\u0DF3\x07G\x02\x02\u0DF3\u0DF4\x07P\x02\x02\u0DF4\u0DF5\x07E\x02\x02" + + "\u0DF5\u0DF6\x07G\x02\x02\u0DF6\u0DF7\x07U\x02\x02\u0DF7\u02A0\x03\x02" + + "\x02\x02\u0DF8\u0DF9\x07U\x02\x02\u0DF9\u0DFA\x07G\x02\x02\u0DFA\u0DFB" + + "\x07T\x02\x02\u0DFB\u0DFC\x07K\x02\x02\u0DFC\u0DFD\x07C\x02\x02\u0DFD" + + "\u0DFE\x07N\x02\x02\u0DFE\u0DFF\x07K\x02\x02\u0DFF\u0E00\x07\\\x02\x02" + + "\u0E00\u0E01\x07C\x02\x02\u0E01\u0E02\x07D\x02\x02\u0E02\u0E03\x07N\x02" + + "\x02\u0E03\u0E04\x07G\x02\x02\u0E04\u02A2\x03\x02\x02\x02\u0E05\u0E06" + + "\x07U\x02\x02\u0E06\u0E07\x07G\x02\x02\u0E07\u0E08\x07T\x02\x02\u0E08" + + "\u0E09\x07X\x02\x02\u0E09\u0E0A\x07G\x02\x02\u0E0A\u0E0B\x07T\x02\x02" + + "\u0E0B\u02A4\x03\x02\x02\x02\u0E0C\u0E0D\x07U\x02\x02\u0E0D\u0E0E\x07" + + "G\x02\x02\u0E0E\u0E0F\x07U\x02\x02\u0E0F\u0E10\x07U\x02\x02\u0E10\u0E11" + + "\x07K\x02\x02\u0E11\u0E12\x07Q\x02\x02\u0E12\u0E13\x07P\x02\x02\u0E13" + + "\u02A6\x03\x02\x02\x02\u0E14\u0E15\x07U\x02\x02\u0E15\u0E16\x07G\x02\x02" + + "\u0E16\u0E17\x07V\x02\x02\u0E17\u02A8\x03\x02\x02\x02\u0E18\u0E19\x07" + + "U\x02\x02\u0E19\u0E1A\x07J\x02\x02\u0E1A\u0E1B\x07C\x02\x02\u0E1B\u0E1C" + + "\x07T\x02\x02\u0E1C\u0E1D\x07G\x02\x02\u0E1D\u02AA\x03\x02\x02\x02\u0E1E" + + "\u0E1F\x07U\x02\x02\u0E1F\u0E20\x07J\x02\x02\u0E20\u0E21\x07Q\x02\x02" + + "\u0E21\u0E22\x07Y\x02\x02\u0E22\u02AC\x03\x02\x02\x02\u0E23\u0E24\x07" + + "U\x02\x02\u0E24\u0E25\x07K\x02\x02\u0E25\u0E26\x07O\x02\x02\u0E26\u0E27" + + "\x07R\x02\x02\u0E27\u0E28\x07N\x02\x02\u0E28\u0E29\x07G\x02\x02\u0E29" + + "\u02AE\x03\x02\x02\x02\u0E2A\u0E2B\x07U\x02\x02\u0E2B\u0E2C\x07P\x02\x02" + + "\u0E2C\u0E2D\x07C\x02\x02\u0E2D\u0E2E\x07R\x02\x02\u0E2E\u0E2F\x07U\x02" + + "\x02\u0E2F\u0E30\x07J\x02\x02\u0E30\u0E31\x07Q\x02\x02\u0E31\u0E32\x07" + + "V\x02\x02\u0E32\u02B0\x03\x02\x02\x02\u0E33\u0E34\x07U\x02\x02\u0E34\u0E35" + + "\x07V\x02\x02\u0E35\u0E36\x07C\x02\x02\u0E36\u0E37\x07D\x02\x02\u0E37" + + "\u0E38\x07N\x02\x02\u0E38\u0E39\x07G\x02\x02\u0E39\u02B2\x03\x02\x02\x02" + + "\u0E3A\u0E3B\x07U\x02\x02\u0E3B\u0E3C\x07V\x02\x02\u0E3C\u0E3D\x07C\x02" + + "\x02\u0E3D\u0E3E\x07P\x02\x02\u0E3E\u0E3F\x07F\x02\x02\u0E3F\u0E40\x07" + + "C\x02\x02\u0E40\u0E41\x07N\x02\x02\u0E41\u0E42\x07Q\x02\x02\u0E42\u0E43" + + "\x07P\x02\x02\u0E43\u0E44\x07G"; private static readonly _serializedATNSegment7: string = - "\x02\x02\u0E77\u0E78\x07U\x02\x02\u0E78\u02CE\x03\x02\x02\x02\u0E79\u0E7A" + - "\x07W\x02\x02\u0E7A\u0E7B\x07P\x02\x02\u0E7B\u0E7C\x07D\x02\x02\u0E7C" + - "\u0E7D\x07Q\x02\x02\u0E7D\u0E7E\x07W\x02\x02\u0E7E\u0E7F\x07P\x02\x02" + - "\u0E7F\u0E80\x07F\x02\x02\u0E80\u0E81\x07G\x02\x02\u0E81\u0E82\x07F\x02" + - "\x02\u0E82\u02D0\x03\x02\x02\x02\u0E83\u0E84\x07W\x02\x02\u0E84\u0E85" + - "\x07P\x02\x02\u0E85\u0E86\x07E\x02\x02\u0E86\u0E87\x07Q\x02\x02\u0E87" + - "\u0E88\x07O\x02\x02\u0E88\u0E89\x07O\x02\x02\u0E89\u0E8A\x07K\x02\x02" + - "\u0E8A\u0E8B\x07V\x02\x02\u0E8B\u0E8C\x07V\x02\x02\u0E8C\u0E8D\x07G\x02" + - "\x02\u0E8D\u0E8E\x07F\x02\x02\u0E8E\u02D2\x03\x02\x02\x02\u0E8F\u0E90" + - "\x07W\x02\x02\u0E90\u0E91\x07P\x02\x02\u0E91\u0E92\x07G\x02\x02\u0E92" + - "\u0E93\x07P\x02\x02\u0E93\u0E94\x07E\x02\x02\u0E94\u0E95\x07T\x02\x02" + - "\u0E95\u0E96\x07[\x02\x02\u0E96\u0E97\x07R\x02\x02\u0E97\u0E98\x07V\x02" + - "\x02\u0E98\u0E99\x07G\x02\x02\u0E99\u0E9A\x07F\x02\x02\u0E9A\u02D4\x03" + - "\x02\x02\x02\u0E9B\u0E9C\x07W\x02\x02\u0E9C\u0E9D\x07P\x02\x02\u0E9D\u0E9E" + - "\x07M\x02\x02\u0E9E\u0E9F\x07P\x02\x02\u0E9F\u0EA0\x07Q\x02\x02\u0EA0" + - "\u0EA1\x07Y\x02\x02\u0EA1\u0EA2\x07P\x02\x02\u0EA2\u02D6\x03\x02\x02\x02" + - "\u0EA3\u0EA4\x07W\x02\x02\u0EA4\u0EA5\x07P\x02\x02\u0EA5\u0EA6\x07N\x02" + - "\x02\u0EA6\u0EA7\x07K\x02\x02\u0EA7\u0EA8\x07U\x02\x02\u0EA8\u0EA9\x07" + - "V\x02\x02\u0EA9\u0EAA\x07G\x02\x02\u0EAA\u0EAB\x07P\x02\x02\u0EAB\u02D8" + - "\x03\x02\x02\x02\u0EAC\u0EAD\x07W\x02\x02\u0EAD\u0EAE\x07P\x02\x02\u0EAE" + - "\u0EAF\x07N\x02\x02\u0EAF\u0EB0\x07Q\x02\x02\u0EB0\u0EB1\x07I\x02\x02" + - "\u0EB1\u0EB2\x07I\x02\x02\u0EB2\u0EB3\x07G\x02\x02\u0EB3\u0EB4\x07F\x02" + - "\x02\u0EB4\u02DA\x03\x02\x02\x02\u0EB5\u0EB6\x07W\x02\x02\u0EB6\u0EB7" + - "\x07P\x02\x02\u0EB7\u0EB8\x07V\x02\x02\u0EB8\u0EB9\x07K\x02\x02\u0EB9" + - "\u0EBA\x07N\x02\x02\u0EBA\u02DC\x03\x02\x02\x02\u0EBB\u0EBC\x07W\x02\x02" + - "\u0EBC\u0EBD\x07R\x02\x02\u0EBD\u0EBE\x07F\x02\x02\u0EBE\u0EBF\x07C\x02" + - "\x02\u0EBF\u0EC0\x07V\x02\x02\u0EC0\u0EC1\x07G\x02\x02\u0EC1\u02DE\x03" + - "\x02\x02\x02\u0EC2\u0EC3\x07X\x02\x02\u0EC3\u0EC4\x07C\x02\x02\u0EC4\u0EC5" + - "\x07E\x02\x02\u0EC5\u0EC6\x07W\x02\x02\u0EC6\u0EC7\x07W\x02\x02\u0EC7" + - "\u0EC8\x07O\x02\x02\u0EC8\u02E0\x03\x02\x02\x02\u0EC9\u0ECA\x07X\x02\x02" + - "\u0ECA\u0ECB\x07C\x02\x02\u0ECB\u0ECC\x07N\x02\x02\u0ECC\u0ECD\x07K\x02" + - "\x02\u0ECD\u0ECE\x07F\x02\x02\u0ECE\u02E2\x03\x02\x02\x02\u0ECF\u0ED0" + - "\x07X\x02\x02\u0ED0\u0ED1\x07C\x02\x02\u0ED1\u0ED2\x07N\x02\x02\u0ED2" + - "\u0ED3\x07K\x02\x02\u0ED3\u0ED4\x07F\x02\x02\u0ED4\u0ED5\x07C\x02\x02" + - "\u0ED5\u0ED6\x07V\x02\x02\u0ED6\u0ED7\x07G\x02\x02\u0ED7\u02E4\x03\x02" + - "\x02\x02\u0ED8\u0ED9\x07X\x02\x02\u0ED9\u0EDA\x07C\x02\x02\u0EDA\u0EDB" + - "\x07N\x02\x02\u0EDB\u0EDC\x07K\x02\x02\u0EDC\u0EDD\x07F\x02\x02\u0EDD" + - "\u0EDE\x07C\x02\x02\u0EDE\u0EDF\x07V\x02\x02\u0EDF\u0EE0\x07Q\x02\x02" + - "\u0EE0\u0EE1\x07T\x02\x02\u0EE1\u02E6\x03\x02\x02\x02\u0EE2\u0EE3\x07" + - "X\x02\x02\u0EE3\u0EE4\x07C\x02\x02\u0EE4\u0EE5\x07T\x02\x02\u0EE5\u0EE6" + - "\x07[\x02\x02\u0EE6\u0EE7\x07K\x02\x02\u0EE7\u0EE8\x07P\x02\x02\u0EE8" + - "\u0EE9\x07I\x02\x02\u0EE9\u02E8\x03\x02\x02\x02\u0EEA\u0EEB\x07X\x02\x02" + - "\u0EEB\u0EEC\x07G\x02\x02\u0EEC\u0EED\x07T\x02\x02\u0EED\u0EEE\x07U\x02" + - "\x02\u0EEE\u0EEF\x07K\x02\x02\u0EEF\u0EF0\x07Q\x02\x02\u0EF0\u0EF1\x07" + - "P\x02\x02\u0EF1\u02EA\x03\x02\x02\x02\u0EF2\u0EF3\x07X\x02\x02\u0EF3\u0EF4" + - "\x07K\x02\x02\u0EF4\u0EF5\x07G\x02\x02\u0EF5\u0EF6\x07Y\x02\x02\u0EF6" + - "\u02EC\x03\x02\x02\x02\u0EF7\u0EF8\x07X\x02\x02\u0EF8\u0EF9\x07Q\x02\x02" + - "\u0EF9\u0EFA\x07N\x02\x02\u0EFA\u0EFB\x07C\x02\x02\u0EFB\u0EFC\x07V\x02" + - "\x02\u0EFC\u0EFD\x07K\x02\x02\u0EFD\u0EFE\x07N\x02\x02\u0EFE\u0EFF\x07" + - "G\x02\x02\u0EFF\u02EE\x03\x02\x02\x02\u0F00\u0F01\x07Y\x02\x02\u0F01\u0F02" + - "\x07J\x02\x02\u0F02\u0F03\x07K\x02\x02\u0F03\u0F04\x07V\x02\x02\u0F04" + - "\u0F05\x07G\x02\x02\u0F05\u0F06\x07U\x02\x02\u0F06\u0F07\x07R\x02\x02" + - "\u0F07\u0F08\x07C\x02\x02\u0F08\u0F09\x07E\x02\x02\u0F09\u0F0A\x07G\x02" + - "\x02\u0F0A\u02F0\x03\x02\x02\x02\u0F0B\u0F0C\x07Y\x02\x02\u0F0C\u0F0D" + - "\x07K\x02\x02\u0F0D\u0F0E\x07V\x02\x02\u0F0E\u0F0F\x07J\x02\x02\u0F0F" + - "\u0F10\x07Q\x02\x02\u0F10\u0F11\x07W\x02\x02\u0F11\u0F12\x07V\x02\x02" + - "\u0F12\u02F2\x03\x02\x02\x02\u0F13\u0F14\x07Y\x02\x02\u0F14\u0F15\x07" + - "Q\x02\x02\u0F15\u0F16\x07T\x02\x02\u0F16\u0F17\x07M\x02\x02\u0F17\u02F4" + - "\x03\x02\x02\x02\u0F18\u0F19\x07Y\x02\x02\u0F19\u0F1A\x07T\x02\x02\u0F1A" + - "\u0F1B\x07C\x02\x02\u0F1B\u0F1C\x07R\x02\x02\u0F1C\u0F1D\x07R\x02\x02" + - "\u0F1D\u0F1E\x07G\x02\x02\u0F1E\u0F1F\x07T\x02\x02\u0F1F\u02F6\x03\x02" + - "\x02\x02\u0F20\u0F21\x07Y\x02\x02\u0F21\u0F22\x07T\x02\x02\u0F22\u0F23" + - "\x07K\x02\x02\u0F23\u0F24\x07V\x02\x02\u0F24\u0F25\x07G\x02\x02\u0F25" + - "\u02F8\x03\x02\x02\x02\u0F26\u0F27\x07Z\x02\x02\u0F27\u0F28\x07O\x02\x02" + - "\u0F28\u0F29\x07N\x02\x02\u0F29\u02FA\x03\x02\x02\x02\u0F2A\u0F2B\x07" + - "[\x02\x02\u0F2B\u0F2C\x07G\x02\x02\u0F2C\u0F2D\x07C\x02\x02\u0F2D\u0F2E" + - "\x07T\x02\x02\u0F2E\u02FC\x03\x02\x02\x02\u0F2F\u0F30\x07[\x02\x02\u0F30" + - "\u0F31\x07G\x02\x02\u0F31\u0F32\x07U\x02\x02\u0F32\u02FE\x03\x02\x02\x02" + - "\u0F33\u0F34\x07\\\x02\x02\u0F34\u0F35\x07Q\x02\x02\u0F35\u0F36\x07P\x02" + - "\x02\u0F36\u0F37\x07G\x02\x02\u0F37\u0300\x03\x02\x02\x02\u0F38\u0F39" + - "\x07D\x02\x02\u0F39\u0F3A\x07G\x02\x02\u0F3A\u0F3B\x07V\x02\x02\u0F3B" + - "\u0F3C\x07Y\x02\x02\u0F3C\u0F3D\x07G\x02\x02\u0F3D\u0F3E\x07G\x02\x02" + - "\u0F3E\u0F3F\x07P\x02\x02\u0F3F\u0302\x03\x02\x02\x02\u0F40\u0F41\x07" + - "D\x02\x02\u0F41\u0F42\x07K\x02\x02\u0F42\u0F43\x07I\x02\x02\u0F43\u0F44" + - "\x07K\x02\x02\u0F44\u0F45\x07P\x02\x02\u0F45\u0F46\x07V\x02\x02\u0F46" + - "\u0304\x03\x02\x02\x02\u0F47\u0F48\x07D\x02\x02\u0F48\u0F49\x07K\x02\x02" + - "\u0F49\u0F4A\x07V\x02\x02\u0F4A\u0306\x03\x02\x02\x02\u0F4B\u0F4C\x07" + - "D\x02\x02\u0F4C\u0F4D\x07Q\x02\x02\u0F4D\u0F4E\x07Q\x02\x02\u0F4E\u0F4F" + - "\x07N\x02\x02\u0F4F\u0F50\x07G\x02\x02\u0F50\u0F51\x07C\x02\x02\u0F51" + - "\u0F52\x07P\x02\x02\u0F52\u0308\x03\x02\x02\x02\u0F53\u0F54\x07E\x02\x02" + - "\u0F54\u0F55\x07J\x02\x02\u0F55\u0F56\x07C\x02\x02\u0F56\u0F57\x07T\x02" + - "\x02\u0F57\u030A\x03\x02\x02\x02\u0F58\u0F59\x07E\x02\x02\u0F59\u0F5A" + - "\x07J\x02\x02\u0F5A\u0F5B\x07C\x02\x02\u0F5B\u0F5C\x07T\x02\x02\u0F5C" + - "\u0F5D\x07C\x02\x02\u0F5D\u0F5E\x07E\x02\x02\u0F5E\u0F5F\x07V\x02\x02" + - "\u0F5F\u0F60\x07G\x02\x02\u0F60\u0F61\x07T\x02\x02\u0F61\u030C\x03\x02" + - "\x02\x02\u0F62\u0F63\x07E\x02\x02\u0F63\u0F64\x07Q\x02\x02\u0F64\u0F65" + - "\x07C\x02\x02\u0F65\u0F66\x07N\x02\x02\u0F66\u0F67\x07G\x02\x02\u0F67" + - "\u0F68\x07U\x02\x02\u0F68\u0F69\x07E\x02\x02\u0F69\u0F6A\x07G\x02\x02" + - "\u0F6A\u030E\x03\x02\x02\x02\u0F6B\u0F6C\x07F\x02\x02\u0F6C\u0F6D\x07" + - "G\x02\x02\u0F6D\u0F6E\x07E\x02\x02\u0F6E\u0310\x03\x02\x02\x02\u0F6F\u0F70" + - "\x07F\x02\x02\u0F70\u0F71\x07G\x02\x02\u0F71\u0F72\x07E\x02\x02\u0F72" + - "\u0F73\x07K\x02\x02\u0F73\u0F74\x07O\x02\x02\u0F74\u0F75\x07C\x02\x02" + - "\u0F75\u0F76\x07N\x02\x02\u0F76\u0312\x03\x02\x02\x02\u0F77\u0F78\x07" + - "G\x02\x02\u0F78\u0F79\x07Z\x02\x02\u0F79\u0F7A\x07K\x02\x02\u0F7A\u0F7B" + - "\x07U\x02\x02\u0F7B\u0F7C\x07V\x02\x02\u0F7C\u0F7D\x07U\x02\x02\u0F7D" + - "\u0314\x03\x02\x02\x02\u0F7E\u0F7F\x07G\x02\x02\u0F7F\u0F80\x07Z\x02\x02" + - "\u0F80\u0F81\x07V\x02\x02\u0F81\u0F82\x07T\x02\x02\u0F82\u0F83\x07C\x02" + - "\x02\u0F83\u0F84\x07E\x02\x02\u0F84\u0F85\x07V\x02\x02\u0F85\u0316\x03" + - "\x02\x02\x02\u0F86\u0F87\x07H\x02\x02\u0F87\u0F88\x07N\x02\x02\u0F88\u0F89" + - "\x07Q\x02\x02\u0F89\u0F8A\x07C\x02\x02\u0F8A\u0F8B\x07V\x02\x02\u0F8B" + - "\u0318\x03\x02\x02\x02\u0F8C\u0F8D\x07I\x02\x02\u0F8D\u0F8E\x07T\x02\x02" + - "\u0F8E\u0F8F\x07G\x02\x02\u0F8F\u0F90\x07C\x02\x02\u0F90\u0F91\x07V\x02" + - "\x02\u0F91\u0F92\x07G\x02\x02\u0F92\u0F93\x07U\x02\x02\u0F93\u0F94\x07" + - "V\x02\x02\u0F94\u031A\x03\x02\x02\x02\u0F95\u0F96\x07K\x02\x02\u0F96\u0F97" + - "\x07P\x02\x02\u0F97\u0F98\x07Q\x02\x02\u0F98\u0F99\x07W\x02\x02\u0F99" + - "\u0F9A\x07V\x02\x02\u0F9A\u031C\x03\x02\x02\x02\u0F9B\u0F9C\x07K\x02\x02" + - "\u0F9C\u0F9D\x07P\x02\x02\u0F9D\u0F9E\x07V\x02\x02\u0F9E\u031E\x03\x02" + - "\x02\x02\u0F9F\u0FA0\x07K\x02\x02\u0FA0\u0FA1\x07P\x02\x02\u0FA1\u0FA2" + - "\x07V\x02\x02\u0FA2\u0FA3\x07G\x02\x02\u0FA3\u0FA4\x07I\x02\x02\u0FA4" + - "\u0FA5\x07G\x02\x02\u0FA5\u0FA6\x07T\x02\x02\u0FA6\u0320\x03\x02\x02\x02" + - "\u0FA7\u0FA8\x07K\x02\x02\u0FA8\u0FA9\x07P\x02\x02\u0FA9\u0FAA\x07V\x02" + - "\x02\u0FAA\u0FAB\x07G\x02\x02\u0FAB\u0FAC\x07T\x02\x02\u0FAC\u0FAD\x07" + - "X\x02\x02\u0FAD\u0FAE\x07C\x02\x02\u0FAE\u0FAF\x07N\x02\x02\u0FAF\u0322" + - "\x03\x02\x02\x02\u0FB0\u0FB1\x07N\x02\x02\u0FB1\u0FB2\x07G\x02\x02\u0FB2" + - "\u0FB3\x07C\x02\x02\u0FB3\u0FB4\x07U\x02\x02\u0FB4\u0FB5\x07V\x02\x02" + - "\u0FB5\u0324\x03\x02\x02\x02\u0FB6\u0FB7\x07P\x02\x02\u0FB7\u0FB8\x07" + - "C\x02\x02\u0FB8\u0FB9\x07V\x02\x02\u0FB9\u0FBA\x07K\x02\x02\u0FBA\u0FBB" + - "\x07Q\x02\x02\u0FBB\u0FBC\x07P\x02\x02\u0FBC\u0FBD\x07C\x02\x02\u0FBD" + - "\u0FBE\x07N\x02\x02\u0FBE\u0326\x03\x02\x02\x02\u0FBF\u0FC0\x07P\x02\x02" + - "\u0FC0\u0FC1\x07E\x02\x02\u0FC1\u0FC2\x07J\x02\x02\u0FC2\u0FC3\x07C\x02" + - "\x02\u0FC3\u0FC4\x07T\x02\x02\u0FC4\u0328\x03\x02\x02\x02\u0FC5\u0FC6" + - "\x07P\x02\x02\u0FC6\u0FC7\x07Q\x02\x02\u0FC7\u0FC8\x07P\x02\x02\u0FC8" + - "\u0FC9\x07G\x02\x02\u0FC9\u032A\x03\x02\x02\x02\u0FCA\u0FCB\x07P\x02\x02" + - "\u0FCB\u0FCC\x07W\x02\x02\u0FCC\u0FCD\x07N\x02\x02\u0FCD\u0FCE\x07N\x02" + - "\x02\u0FCE\u0FCF\x07K\x02\x02\u0FCF\u0FD0\x07H\x02\x02\u0FD0\u032C\x03" + - "\x02\x02\x02\u0FD1\u0FD2\x07P\x02\x02\u0FD2\u0FD3\x07W\x02\x02\u0FD3\u0FD4" + - "\x07O\x02\x02\u0FD4\u0FD5\x07G\x02\x02\u0FD5\u0FD6\x07T\x02\x02\u0FD6" + - "\u0FD7\x07K\x02\x02\u0FD7\u0FD8\x07E\x02\x02\u0FD8\u032E\x03\x02\x02\x02" + - "\u0FD9\u0FDA\x07Q\x02\x02\u0FDA\u0FDB\x07X\x02\x02\u0FDB\u0FDC\x07G\x02" + - "\x02\u0FDC\u0FDD\x07T\x02\x02\u0FDD\u0FDE\x07N\x02\x02\u0FDE\u0FDF\x07" + - "C\x02\x02\u0FDF\u0FE0\x07[\x02\x02\u0FE0\u0330\x03\x02\x02\x02\u0FE1\u0FE2" + - "\x07R\x02\x02\u0FE2\u0FE3\x07Q\x02\x02\u0FE3\u0FE4\x07U\x02\x02\u0FE4" + - "\u0FE5\x07K\x02\x02\u0FE5\u0FE6\x07V\x02\x02\u0FE6\u0FE7\x07K\x02\x02" + - "\u0FE7\u0FE8\x07Q\x02\x02\u0FE8\u0FE9\x07P\x02\x02\u0FE9\u0332\x03\x02" + - "\x02\x02\u0FEA\u0FEB\x07R\x02\x02\u0FEB\u0FEC\x07T\x02\x02\u0FEC\u0FED" + - "\x07G\x02\x02\u0FED\u0FEE\x07E\x02\x02\u0FEE\u0FEF\x07K\x02\x02\u0FEF" + - "\u0FF0\x07U\x02\x02\u0FF0\u0FF1\x07K\x02\x02\u0FF1\u0FF2\x07Q\x02\x02" + - "\u0FF2\u0FF3\x07P\x02\x02\u0FF3\u0334\x03\x02\x02\x02\u0FF4\u0FF5\x07" + - "T\x02\x02\u0FF5\u0FF6\x07G\x02\x02\u0FF6\u0FF7\x07C\x02\x02\u0FF7\u0FF8" + - "\x07N\x02\x02\u0FF8\u0336\x03\x02\x02\x02\u0FF9\u0FFA\x07T\x02\x02\u0FFA" + - "\u0FFB\x07Q\x02\x02\u0FFB\u0FFC\x07Y\x02\x02\u0FFC\u0338\x03\x02\x02\x02" + - "\u0FFD\u0FFE\x07U\x02\x02\u0FFE\u0FFF\x07G\x02\x02\u0FFF\u1000\x07V\x02" + - "\x02\u1000\u1001\x07Q\x02\x02\u1001\u1002\x07H\x02\x02\u1002\u033A\x03" + - "\x02\x02\x02\u1003\u1004\x07U\x02\x02\u1004\u1005\x07O\x02\x02\u1005\u1006" + - "\x07C\x02\x02\u1006\u1007\x07N\x02\x02\u1007\u1008\x07N\x02\x02\u1008" + - "\u1009\x07K\x02\x02\u1009\u100A\x07P\x02\x02\u100A\u100B\x07V\x02\x02" + - "\u100B\u033C\x03\x02\x02\x02\u100C\u100D\x07U\x02\x02\u100D\u100E\x07" + - "W\x02\x02\u100E\u100F\x07D\x02\x02\u100F\u1010\x07U\x02\x02\u1010\u1011" + - "\x07V\x02\x02\u1011\u1012\x07T\x02\x02\u1012\u1013\x07K\x02\x02\u1013" + - "\u1014\x07P\x02\x02\u1014\u1015\x07I\x02\x02\u1015\u033E\x03\x02\x02\x02" + - "\u1016\u1017\x07V\x02\x02\u1017\u1018\x07K\x02\x02\u1018\u1019\x07O\x02" + - "\x02\u1019\u101A\x07G\x02\x02\u101A\u0340\x03\x02\x02\x02\u101B\u101C" + - "\x07V\x02\x02\u101C\u101D\x07K\x02\x02\u101D\u101E\x07O\x02\x02\u101E" + - "\u101F\x07G\x02\x02\u101F\u1020\x07U\x02\x02\u1020\u1021\x07V\x02\x02" + - "\u1021\u1022\x07C\x02\x02\u1022\u1023\x07O\x02\x02\u1023\u1024\x07R\x02" + - "\x02\u1024\u0342\x03\x02\x02\x02\u1025\u1026\x07V\x02\x02\u1026\u1027" + - "\x07T\x02\x02\u1027\u1028\x07G\x02\x02\u1028\u1029\x07C\x02\x02\u1029" + - "\u102A\x07V\x02\x02\u102A\u0344\x03\x02\x02\x02\u102B\u102C\x07V\x02\x02" + - "\u102C\u102D\x07T\x02\x02\u102D\u102E\x07K\x02\x02\u102E\u102F\x07O\x02" + - "\x02\u102F\u0346\x03\x02\x02\x02\u1030\u1031\x07X\x02\x02\u1031\u1032" + - "\x07C\x02\x02\u1032\u1033\x07N\x02\x02\u1033\u1034\x07W\x02\x02\u1034" + - "\u1035\x07G\x02\x02\u1035\u1036\x07U\x02\x02\u1036\u0348\x03\x02\x02\x02" + - "\u1037\u1038\x07X\x02\x02\u1038\u1039\x07C\x02\x02\u1039\u103A\x07T\x02" + - "\x02\u103A\u103B\x07E\x02\x02\u103B\u103C\x07J\x02\x02\u103C\u103D\x07" + - "C\x02\x02\u103D\u103E\x07T\x02\x02\u103E\u034A\x03\x02\x02\x02\u103F\u1040" + - "\x07Z\x02\x02\u1040\u1041\x07O\x02\x02\u1041\u1042\x07N\x02\x02\u1042" + - "\u1043\x07C\x02\x02\u1043\u1044\x07V\x02\x02\u1044\u1045\x07V\x02\x02" + - "\u1045\u1046\x07T\x02\x02\u1046\u1047\x07K\x02\x02\u1047\u1048\x07D\x02" + - "\x02\u1048\u1049\x07W\x02\x02\u1049\u104A\x07V\x02\x02\u104A\u104B\x07" + - "G\x02\x02\u104B\u104C\x07U\x02\x02\u104C\u034C\x03\x02\x02\x02\u104D\u104E" + - "\x07Z\x02\x02\u104E\u104F\x07O\x02\x02\u104F\u1050\x07N\x02\x02\u1050" + - "\u1051\x07E\x02\x02\u1051\u1052\x07Q\x02\x02\u1052\u1053\x07P\x02\x02" + - "\u1053\u1054\x07E\x02\x02\u1054\u1055\x07C\x02\x02\u1055\u1056\x07V\x02" + - "\x02\u1056\u034E\x03\x02\x02\x02\u1057\u1058\x07Z\x02\x02\u1058\u1059" + - "\x07O\x02\x02\u1059\u105A\x07N\x02\x02\u105A\u105B\x07G\x02\x02\u105B" + - "\u105C\x07N\x02\x02\u105C\u105D\x07G\x02\x02\u105D\u105E\x07O\x02\x02" + - "\u105E\u105F\x07G\x02\x02\u105F\u1060\x07P\x02\x02\u1060\u1061\x07V\x02" + - "\x02\u1061\u0350\x03\x02\x02\x02\u1062\u1063\x07Z\x02\x02\u1063\u1064" + - "\x07O\x02\x02\u1064\u1065\x07N\x02\x02\u1065\u1066\x07G\x02\x02\u1066" + - "\u1067\x07Z\x02\x02\u1067\u1068\x07K\x02\x02\u1068\u1069\x07U\x02\x02" + - "\u1069\u106A\x07V\x02\x02\u106A\u106B\x07U\x02\x02\u106B\u0352\x03\x02" + - "\x02\x02\u106C\u106D\x07Z\x02\x02\u106D\u106E\x07O\x02\x02\u106E\u106F" + - "\x07N\x02\x02\u106F\u1070\x07H\x02\x02\u1070\u1071\x07Q\x02\x02\u1071" + - "\u1072\x07T\x02\x02\u1072\u1073\x07G\x02\x02\u1073\u1074\x07U\x02\x02" + - "\u1074\u1075\x07V\x02\x02\u1075\u0354\x03\x02\x02\x02\u1076\u1077\x07" + - "Z\x02\x02\u1077\u1078\x07O\x02\x02\u1078\u1079\x07N\x02\x02\u1079\u107A" + - "\x07R\x02\x02\u107A\u107B\x07C\x02\x02\u107B\u107C\x07T\x02\x02\u107C" + - "\u107D\x07U\x02\x02\u107D\u107E\x07G\x02\x02\u107E\u0356\x03\x02\x02\x02" + - "\u107F\u1080\x07Z\x02\x02\u1080\u1081\x07O\x02\x02\u1081\u1082\x07N\x02" + - "\x02\u1082\u1083\x07R\x02\x02\u1083\u1084\x07K\x02\x02\u1084\u0358\x03" + - "\x02\x02\x02\u1085\u1086\x07Z\x02\x02\u1086\u1087\x07O\x02\x02\u1087\u1088" + - "\x07N\x02\x02\u1088\u1089\x07T\x02\x02\u1089\u108A\x07Q\x02\x02\u108A" + - "\u108B\x07Q\x02\x02\u108B\u108C\x07V\x02\x02\u108C\u035A\x03\x02\x02\x02" + - "\u108D\u108E\x07Z\x02\x02\u108E\u108F\x07O\x02\x02\u108F\u1090\x07N\x02" + - "\x02\u1090\u1091\x07U\x02\x02\u1091\u1092\x07G\x02\x02\u1092\u1093\x07" + - "T\x02\x02\u1093\u1094\x07K\x02\x02\u1094\u1095\x07C\x02\x02\u1095\u1096" + - "\x07N\x02\x02\u1096\u1097\x07K\x02\x02\u1097\u1098\x07\\\x02\x02\u1098" + - "\u1099\x07G\x02\x02\u1099\u035C\x03\x02\x02\x02\u109A\u109B\x07E\x02\x02" + - "\u109B\u109C\x07C\x02\x02\u109C\u109D\x07N\x02\x02\u109D\u109E\x07N\x02" + - "\x02\u109E\u035E\x03\x02\x02\x02\u109F\u10A0\x07E\x02\x02\u10A0\u10A1" + - "\x07W\x02\x02\u10A1\u10A2\x07T\x02\x02\u10A2\u10A3\x07T\x02\x02\u10A3" + - "\u10A4\x07G\x02\x02\u10A4\u10A5\x07P\x02\x02\u10A5\u10A6\x07V\x02\x02" + - "\u10A6\u0360\x03\x02\x02\x02\u10A7\u10A8\x07C\x02\x02\u10A8\u10A9\x07" + - "V\x02\x02\u10A9\u10AA\x07V\x02\x02\u10AA\u10AB\x07C\x02\x02\u10AB\u10AC" + - "\x07E\x02\x02\u10AC\u10AD\x07J\x02\x02\u10AD\u0362\x03\x02\x02\x02\u10AE" + - "\u10AF\x07F\x02\x02\u10AF\u10B0\x07G\x02\x02\u10B0\u10B1\x07V\x02\x02" + - "\u10B1\u10B2\x07C\x02\x02\u10B2\u10B3\x07E\x02\x02\u10B3\u10B4\x07J\x02" + - "\x02\u10B4\u0364\x03\x02\x02\x02\u10B5\u10B6\x07G\x02\x02\u10B6\u10B7" + - "\x07Z\x02\x02\u10B7\u10B8\x07R\x02\x02\u10B8\u10B9\x07T\x02\x02\u10B9" + - "\u10BA\x07G\x02\x02\u10BA\u10BB\x07U\x02\x02\u10BB\u10BC\x07U\x02\x02" + - "\u10BC\u10BD\x07K\x02\x02\u10BD\u10BE\x07Q\x02\x02\u10BE\u10BF\x07P\x02" + - "\x02\u10BF\u0366\x03\x02\x02\x02\u10C0\u10C1\x07I\x02\x02\u10C1\u10C2" + - "\x07G\x02\x02\u10C2\u10C3\x07P\x02\x02\u10C3\u10C4\x07G\x02\x02\u10C4" + - "\u10C5\x07T\x02\x02\u10C5\u10C6\x07C\x02\x02\u10C6\u10C7\x07V\x02\x02" + - "\u10C7\u10C8\x07G\x02\x02\u10C8\u10C9\x07F\x02\x02\u10C9\u0368\x03\x02" + - "\x02\x02\u10CA\u10CB\x07N\x02\x02\u10CB\u10CC\x07Q\x02\x02\u10CC\u10CD" + - "\x07I\x02\x02\u10CD\u10CE\x07I\x02\x02\u10CE\u10CF\x07G\x02\x02\u10CF" + - "\u10D0\x07F\x02\x02\u10D0\u036A\x03\x02\x02\x02\u10D1\u10D2\x07U\x02\x02" + - "\u10D2\u10D3\x07V\x02\x02\u10D3\u10D4\x07Q\x02\x02\u10D4\u10D5\x07T\x02" + - "\x02\u10D5\u10D6\x07G\x02\x02\u10D6\u10D7\x07F\x02\x02\u10D7\u036C\x03" + - "\x02\x02\x02\u10D8\u10D9\x07K\x02\x02\u10D9\u10DA\x07P\x02\x02\u10DA\u10DB" + - "\x07E\x02\x02\u10DB\u10DC\x07N\x02\x02\u10DC\u10DD\x07W\x02\x02\u10DD" + - "\u10DE\x07F\x02\x02\u10DE\u10DF\x07G\x02\x02\u10DF\u036E\x03\x02\x02\x02" + - "\u10E0\u10E1\x07T\x02\x02\u10E1\u10E2\x07Q\x02\x02\u10E2\u10E3\x07W\x02" + - "\x02\u10E3\u10E4\x07V\x02\x02\u10E4\u10E5\x07K\x02\x02\u10E5\u10E6\x07" + - "P\x02\x02\u10E6\u10E7\x07G\x02\x02\u10E7\u0370\x03\x02\x02\x02\u10E8\u10E9" + - "\x07V\x02\x02\u10E9\u10EA\x07T\x02\x02\u10EA\u10EB\x07C\x02\x02\u10EB" + - "\u10EC\x07P\x02\x02\u10EC\u10ED\x07U\x02\x02\u10ED\u10EE\x07H\x02\x02" + - "\u10EE\u10EF\x07Q\x02\x02\u10EF\u10F0\x07T\x02\x02\u10F0\u10F1\x07O\x02" + - "\x02\u10F1\u0372\x03\x02\x02\x02\u10F2\u10F3\x07K\x02\x02\u10F3\u10F4" + - "\x07O\x02\x02\u10F4\u10F5\x07R\x02\x02\u10F5\u10F6\x07Q\x02\x02\u10F6" + - "\u10F7\x07T\x02\x02\u10F7\u10F8\x07V\x02\x02\u10F8\u0374\x03\x02\x02\x02" + - "\u10F9\u10FA\x07R\x02\x02\u10FA\u10FB\x07Q\x02\x02\u10FB\u10FC\x07N\x02" + - "\x02\u10FC\u10FD\x07K\x02\x02\u10FD\u10FE\x07E\x02\x02\u10FE\u10FF\x07" + - "[\x02\x02\u10FF\u0376\x03\x02\x02\x02\u1100\u1101\x07O\x02\x02\u1101\u1102" + - "\x07G\x02\x02\u1102\u1103\x07V\x02\x02\u1103\u1104\x07J\x02\x02\u1104" + - "\u1105\x07Q\x02\x02\u1105\u1106\x07F\x02\x02\u1106\u0378\x03\x02\x02\x02" + - "\u1107\u1108\x07T\x02\x02\u1108\u1109\x07G\x02\x02\u1109\u110A\x07H\x02" + - "\x02\u110A\u110B\x07G\x02\x02\u110B\u110C\x07T\x02\x02\u110C\u110D\x07" + - "G\x02\x02\u110D\u110E\x07P\x02\x02\u110E\u110F\x07E\x02\x02\u110F\u1110" + - "\x07K\x02\x02\u1110\u1111\x07P\x02\x02\u1111\u1112\x07I\x02\x02\u1112" + - "\u037A\x03\x02\x02\x02\u1113\u1114\x07P\x02\x02\u1114\u1115\x07G\x02\x02" + - "\u1115\u1116\x07Y\x02\x02\u1116\u037C\x03\x02\x02\x02\u1117\u1118\x07" + - "Q\x02\x02\u1118\u1119\x07N\x02\x02\u1119\u111A\x07F\x02\x02\u111A\u037E" + - "\x03\x02\x02\x02\u111B\u111C\x07X\x02\x02\u111C\u111D\x07C\x02\x02\u111D" + - "\u111E\x07N\x02\x02\u111E\u111F\x07W\x02\x02\u111F\u1120\x07G\x02\x02" + - "\u1120\u0380\x03\x02\x02\x02\u1121\u1122\x07U\x02\x02\u1122\u1123\x07" + - "W\x02\x02\u1123\u1124\x07D\x02\x02\u1124\u1125\x07U\x02\x02\u1125\u1126" + - "\x07E\x02\x02\u1126\u1127\x07T\x02\x02\u1127\u1128\x07K\x02\x02\u1128" + - "\u1129\x07R\x02\x02\u1129\u112A\x07V\x02\x02\u112A\u112B\x07K\x02\x02" + - "\u112B\u112C\x07Q\x02\x02\u112C\u112D\x07P\x02\x02\u112D\u0382\x03\x02" + - "\x02\x02\u112E\u112F\x07R\x02\x02\u112F\u1130\x07W\x02\x02\u1130\u1131" + - "\x07D\x02\x02\u1131\u1132\x07N\x02\x02\u1132\u1133\x07K\x02\x02\u1133" + - "\u1134\x07E\x02\x02\u1134\u1135\x07C\x02\x02\u1135\u1136\x07V\x02\x02" + - "\u1136\u1137\x07K\x02\x02\u1137\u1138\x07Q\x02\x02\u1138\u1139\x07P\x02" + - "\x02\u1139\u0384\x03\x02\x02\x02\u113A\u113B\x07Q\x02\x02\u113B\u113C" + - "\x07W\x02\x02\u113C\u113D\x07V\x02\x02\u113D\u0386\x03\x02\x02\x02\u113E" + - "\u113F\x07G\x02\x02\u113F\u1140\x07P\x02\x02\u1140\u1141\x07F\x02\x02" + - "\u1141\u0388\x03\x02\x02\x02\u1142\u1143\x07T\x02\x02\u1143\u1144\x07" + - "Q\x02\x02\u1144\u1145\x07W\x02\x02\u1145\u1146\x07V\x02\x02\u1146\u1147" + - "\x07K\x02\x02\u1147\u1148\x07P\x02\x02\u1148\u1149\x07G\x02\x02\u1149" + - "\u114A\x07U\x02\x02\u114A\u038A\x03\x02\x02\x02\u114B\u114C\x07U\x02\x02" + - "\u114C\u114D\x07E\x02\x02\u114D\u114E\x07J\x02\x02\u114E\u114F\x07G\x02" + - "\x02\u114F\u1150\x07O\x02\x02\u1150\u1151\x07C\x02\x02\u1151\u1152\x07" + - "U\x02\x02\u1152\u038C\x03\x02\x02\x02\u1153\u1154\x07R\x02\x02\u1154\u1155" + - "\x07T\x02\x02\u1155\u1156\x07Q\x02\x02\u1156\u1157\x07E\x02\x02\u1157" + - "\u1158\x07G\x02\x02\u1158\u1159\x07F\x02\x02\u1159\u115A\x07W\x02\x02" + - "\u115A\u115B\x07T\x02\x02\u115B\u115C\x07G\x02\x02\u115C\u115D\x07U\x02" + - "\x02\u115D\u038E\x03\x02\x02\x02\u115E\u115F\x07K\x02\x02\u115F\u1160" + - "\x07P\x02\x02\u1160\u1161\x07R\x02\x02\u1161\u1162\x07W\x02\x02\u1162" + - "\u1163\x07V\x02\x02\u1163\u0390\x03\x02\x02\x02\u1164\u1165\x07U\x02\x02" + - "\u1165\u1166\x07W\x02\x02\u1166\u1167\x07R\x02\x02\u1167\u1168\x07R\x02" + - "\x02\u1168\u1169\x07Q\x02\x02\u1169\u116A\x07T\x02\x02\u116A\u116B\x07" + - "V\x02\x02\u116B\u0392\x03\x02\x02\x02\u116C\u116D\x07R\x02\x02\u116D\u116E" + - "\x07C\x02\x02\u116E\u116F\x07T\x02\x02\u116F\u1170\x07C\x02\x02\u1170" + - "\u1171\x07N\x02\x02\u1171\u1172\x07N\x02\x02\u1172\u1173\x07G\x02\x02" + - "\u1173\u1174\x07N\x02\x02\u1174\u0394\x03\x02\x02\x02\u1175\u1176\x07" + - "U\x02\x02\u1176\u1177\x07S\x02\x02\u1177\u1178\x07N\x02\x02\u1178\u0396" + - "\x03\x02\x02\x02\u1179\u117A\x07F\x02\x02\u117A\u117B\x07G\x02\x02\u117B" + - "\u117C\x07R\x02\x02\u117C\u117D\x07G\x02\x02\u117D\u117E\x07P\x02\x02" + - "\u117E\u117F\x07F\x02\x02\u117F\u1180\x07U\x02\x02\u1180\u0398\x03\x02" + - "\x02\x02\u1181\u1182\x07Q\x02\x02\u1182\u1183\x07X\x02\x02\u1183\u1184" + - "\x07G\x02\x02\u1184\u1185\x07T\x02\x02\u1185\u1186\x07T\x02\x02\u1186" + - "\u1187\x07K\x02\x02\u1187\u1188\x07F\x02\x02\u1188\u1189\x07K\x02\x02" + - "\u1189\u118A\x07P\x02\x02\u118A\u118B\x07I\x02\x02\u118B\u039A\x03\x02" + - "\x02\x02\u118C\u118D\x07E\x02\x02\u118D\u118E\x07Q\x02\x02\u118E\u118F" + - "\x07P\x02\x02\u118F\u1190\x07H\x02\x02\u1190\u1191\x07N\x02\x02\u1191" + - "\u1192\x07K\x02\x02\u1192\u1193\x07E\x02\x02\u1193\u1194\x07V\x02\x02" + - "\u1194\u039C\x03\x02\x02\x02\u1195\u1196\x07U\x02\x02\u1196\u1197\x07" + - "M\x02\x02\u1197\u1198\x07K\x02\x02\u1198\u1199\x07R\x02\x02\u1199\u039E" + - "\x03\x02\x02\x02\u119A\u119B\x07N\x02\x02\u119B\u119C\x07Q\x02\x02\u119C" + - "\u119D\x07E\x02\x02\u119D\u119E\x07M\x02\x02\u119E\u119F\x07G\x02\x02" + - "\u119F\u11A0\x07F\x02\x02\u11A0\u03A0\x03\x02\x02\x02\u11A1\u11A2\x07" + - "V\x02\x02\u11A2\u11A3\x07K\x02\x02\u11A3\u11A4\x07G\x02\x02\u11A4\u11A5" + - "\x07U\x02\x02\u11A5\u03A2\x03\x02\x02\x02\u11A6\u11A7\x07T\x02\x02\u11A7" + - "\u11A8\x07Q\x02\x02\u11A8\u11A9\x07N\x02\x02\u11A9\u11AA\x07N\x02\x02" + - "\u11AA\u11AB\x07W\x02\x02\u11AB\u11AC\x07R\x02\x02\u11AC\u03A4\x03\x02" + - "\x02\x02\u11AD\u11AE\x07E\x02\x02\u11AE\u11AF\x07W\x02\x02\u11AF\u11B0" + - "\x07D\x02\x02\u11B0\u11B1\x07G\x02\x02\u11B1\u03A6\x03\x02\x02\x02\u11B2" + - "\u11B3\x07I\x02\x02\u11B3\u11B4\x07T\x02\x02\u11B4\u11B5\x07Q\x02\x02" + - "\u11B5\u11B6\x07W\x02\x02\u11B6\u11B7\x07R\x02\x02\u11B7\u11B8\x07K\x02" + - "\x02"; + "\x02\x02\u0E44\u02B4\x03\x02\x02\x02\u0E45\u0E46\x07U\x02\x02\u0E46\u0E47" + + "\x07V\x02\x02\u0E47\u0E48\x07C\x02\x02\u0E48\u0E49\x07T\x02\x02\u0E49" + + "\u0E4A\x07V\x02\x02\u0E4A\u02B6\x03\x02\x02\x02\u0E4B\u0E4C\x07U\x02\x02" + + "\u0E4C\u0E4D\x07V\x02\x02\u0E4D\u0E4E\x07C\x02\x02\u0E4E\u0E4F\x07V\x02" + + "\x02\u0E4F\u0E50\x07G\x02\x02\u0E50\u0E51\x07O\x02\x02\u0E51\u0E52\x07" + + "G\x02\x02\u0E52\u0E53\x07P\x02\x02\u0E53\u0E54\x07V\x02\x02\u0E54\u02B8" + + "\x03\x02\x02\x02\u0E55\u0E56\x07U\x02\x02\u0E56\u0E57\x07V\x02\x02\u0E57" + + "\u0E58\x07C\x02\x02\u0E58\u0E59\x07V\x02\x02\u0E59\u0E5A\x07K\x02\x02" + + "\u0E5A\u0E5B\x07U\x02\x02\u0E5B\u0E5C\x07V\x02\x02\u0E5C\u0E5D\x07K\x02" + + "\x02\u0E5D\u0E5E\x07E\x02\x02\u0E5E\u0E5F\x07U\x02\x02\u0E5F\u02BA\x03" + + "\x02\x02\x02\u0E60\u0E61\x07U\x02\x02\u0E61\u0E62\x07V\x02\x02\u0E62\u0E63" + + "\x07F\x02\x02\u0E63\u0E64\x07K\x02\x02\u0E64\u0E65\x07P\x02\x02\u0E65" + + "\u02BC\x03\x02\x02\x02\u0E66\u0E67\x07U\x02\x02\u0E67\u0E68\x07V\x02\x02" + + "\u0E68\u0E69\x07F\x02\x02\u0E69\u0E6A\x07Q\x02\x02\u0E6A\u0E6B\x07W\x02" + + "\x02\u0E6B\u0E6C\x07V\x02\x02\u0E6C\u02BE\x03\x02\x02\x02\u0E6D\u0E6E" + + "\x07U\x02\x02\u0E6E\u0E6F\x07V\x02\x02\u0E6F\u0E70\x07Q\x02\x02\u0E70" + + "\u0E71\x07T\x02\x02\u0E71\u0E72\x07C\x02\x02\u0E72\u0E73\x07I\x02\x02" + + "\u0E73\u0E74\x07G\x02\x02\u0E74\u02C0\x03\x02\x02\x02\u0E75\u0E76\x07" + + "U\x02\x02\u0E76\u0E77\x07V\x02\x02\u0E77\u0E78\x07T\x02\x02\u0E78\u0E79" + + "\x07K\x02\x02\u0E79\u0E7A\x07E\x02\x02\u0E7A\u0E7B\x07V\x02\x02\u0E7B" + + "\u02C2\x03\x02\x02\x02\u0E7C\u0E7D\x07U\x02\x02\u0E7D\u0E7E\x07V\x02\x02" + + "\u0E7E\u0E7F\x07T\x02\x02\u0E7F\u0E80\x07K\x02\x02\u0E80\u0E81\x07R\x02" + + "\x02\u0E81\u02C4\x03\x02\x02\x02\u0E82\u0E83\x07U\x02\x02\u0E83\u0E84" + + "\x07[\x02\x02\u0E84\u0E85\x07U\x02\x02\u0E85\u0E86\x07K\x02\x02\u0E86" + + "\u0E87\x07F\x02\x02\u0E87\u02C6\x03\x02\x02\x02\u0E88\u0E89\x07U\x02\x02" + + "\u0E89\u0E8A\x07[\x02\x02\u0E8A\u0E8B\x07U\x02\x02\u0E8B\u0E8C\x07V\x02" + + "\x02\u0E8C\u0E8D\x07G\x02\x02\u0E8D\u0E8E\x07O\x02\x02\u0E8E\u02C8\x03" + + "\x02\x02\x02\u0E8F\u0E90\x07V\x02\x02\u0E90\u0E91\x07C\x02\x02\u0E91\u0E92" + + "\x07D\x02\x02\u0E92\u0E93\x07N\x02\x02\u0E93\u0E94\x07G\x02\x02\u0E94" + + "\u0E95\x07U\x02\x02\u0E95\u02CA\x03\x02\x02\x02\u0E96\u0E97\x07V\x02\x02" + + "\u0E97\u0E98\x07C\x02\x02\u0E98\u0E99\x07D\x02\x02\u0E99\u0E9A\x07N\x02" + + "\x02\u0E9A\u0E9B\x07G\x02\x02\u0E9B\u0E9C\x07U\x02\x02\u0E9C\u0E9D\x07" + + "R\x02\x02\u0E9D\u0E9E\x07C\x02\x02\u0E9E\u0E9F\x07E\x02\x02\u0E9F\u0EA0" + + "\x07G\x02\x02\u0EA0\u02CC\x03\x02\x02\x02\u0EA1\u0EA2\x07V\x02\x02\u0EA2" + + "\u0EA3\x07G\x02\x02\u0EA3\u0EA4\x07O\x02\x02\u0EA4\u0EA5\x07R\x02\x02" + + "\u0EA5\u02CE\x03\x02\x02\x02\u0EA6\u0EA7\x07V\x02\x02\u0EA7\u0EA8\x07" + + "G\x02\x02\u0EA8\u0EA9\x07O\x02\x02\u0EA9\u0EAA\x07R\x02\x02\u0EAA\u0EAB" + + "\x07N\x02\x02\u0EAB\u0EAC\x07C\x02\x02\u0EAC\u0EAD\x07V\x02\x02\u0EAD" + + "\u0EAE\x07G\x02\x02\u0EAE\u02D0\x03\x02\x02\x02\u0EAF\u0EB0\x07V\x02\x02" + + "\u0EB0\u0EB1\x07G\x02\x02\u0EB1\u0EB2\x07O\x02\x02\u0EB2\u0EB3\x07R\x02" + + "\x02\u0EB3\u0EB4\x07Q\x02\x02\u0EB4\u0EB5\x07T\x02\x02\u0EB5\u0EB6\x07" + + "C\x02\x02\u0EB6\u0EB7\x07T\x02\x02\u0EB7\u0EB8\x07[\x02\x02\u0EB8\u02D2" + + "\x03\x02\x02\x02\u0EB9\u0EBA\x07V\x02\x02\u0EBA\u0EBB\x07G\x02\x02\u0EBB" + + "\u0EBC\x07Z\x02\x02\u0EBC\u0EBD\x07V\x02\x02\u0EBD\u02D4\x03\x02\x02\x02" + + "\u0EBE\u0EBF\x07V\x02\x02\u0EBF\u0EC0\x07T\x02\x02\u0EC0\u0EC1\x07C\x02" + + "\x02\u0EC1\u0EC2\x07P\x02\x02\u0EC2\u0EC3\x07U\x02\x02\u0EC3\u0EC4\x07" + + "C\x02\x02\u0EC4\u0EC5\x07E\x02\x02\u0EC5\u0EC6\x07V\x02\x02\u0EC6\u0EC7" + + "\x07K\x02\x02\u0EC7\u0EC8\x07Q\x02\x02\u0EC8\u0EC9\x07P\x02\x02\u0EC9" + + "\u02D6\x03\x02\x02\x02\u0ECA\u0ECB\x07V\x02\x02\u0ECB\u0ECC\x07T\x02\x02" + + "\u0ECC\u0ECD\x07K\x02\x02\u0ECD\u0ECE\x07I\x02\x02\u0ECE\u0ECF\x07I\x02" + + "\x02\u0ECF\u0ED0\x07G\x02\x02\u0ED0\u0ED1\x07T\x02\x02\u0ED1\u02D8\x03" + + "\x02\x02\x02\u0ED2\u0ED3\x07V\x02\x02\u0ED3\u0ED4\x07T\x02\x02\u0ED4\u0ED5" + + "\x07W\x02\x02\u0ED5\u0ED6\x07P\x02\x02\u0ED6\u0ED7\x07E\x02\x02\u0ED7" + + "\u0ED8\x07C\x02\x02\u0ED8\u0ED9\x07V\x02\x02\u0ED9\u0EDA\x07G\x02\x02" + + "\u0EDA\u02DA\x03\x02\x02\x02\u0EDB\u0EDC\x07V\x02\x02\u0EDC\u0EDD\x07" + + "T\x02\x02\u0EDD\u0EDE\x07W\x02\x02\u0EDE\u0EDF\x07U\x02\x02\u0EDF\u0EE0" + + "\x07V\x02\x02\u0EE0\u0EE1\x07G\x02\x02\u0EE1\u0EE2\x07F\x02\x02\u0EE2" + + "\u02DC\x03\x02\x02\x02\u0EE3\u0EE4\x07V\x02\x02\u0EE4\u0EE5\x07[\x02\x02" + + "\u0EE5\u0EE6\x07R\x02\x02\u0EE6\u0EE7\x07G\x02\x02\u0EE7\u02DE\x03\x02" + + "\x02\x02\u0EE8\u0EE9\x07V\x02\x02\u0EE9\u0EEA\x07[\x02\x02\u0EEA\u0EEB" + + "\x07R\x02\x02\u0EEB\u0EEC\x07G\x02\x02\u0EEC\u0EED\x07U\x02\x02\u0EED" + + "\u02E0\x03\x02\x02\x02\u0EEE\u0EEF\x07W\x02\x02\u0EEF\u0EF0\x07P\x02\x02" + + "\u0EF0\u0EF1\x07D\x02\x02\u0EF1\u0EF2\x07Q\x02\x02\u0EF2\u0EF3\x07W\x02" + + "\x02\u0EF3\u0EF4\x07P\x02\x02\u0EF4\u0EF5\x07F\x02\x02\u0EF5\u0EF6\x07" + + "G\x02\x02\u0EF6\u0EF7\x07F\x02\x02\u0EF7\u02E2\x03\x02\x02\x02\u0EF8\u0EF9" + + "\x07W\x02\x02\u0EF9\u0EFA\x07P\x02\x02\u0EFA\u0EFB\x07E\x02\x02\u0EFB" + + "\u0EFC\x07Q\x02\x02\u0EFC\u0EFD\x07O\x02\x02\u0EFD\u0EFE\x07O\x02\x02" + + "\u0EFE\u0EFF\x07K\x02\x02\u0EFF\u0F00\x07V\x02\x02\u0F00\u0F01\x07V\x02" + + "\x02\u0F01\u0F02\x07G\x02\x02\u0F02\u0F03\x07F\x02\x02\u0F03\u02E4\x03" + + "\x02\x02\x02\u0F04\u0F05\x07W\x02\x02\u0F05\u0F06\x07P\x02\x02\u0F06\u0F07" + + "\x07G\x02\x02\u0F07\u0F08\x07P\x02\x02\u0F08\u0F09\x07E\x02\x02\u0F09" + + "\u0F0A\x07T\x02\x02\u0F0A\u0F0B\x07[\x02\x02\u0F0B\u0F0C\x07R\x02\x02" + + "\u0F0C\u0F0D\x07V\x02\x02\u0F0D\u0F0E\x07G\x02\x02\u0F0E\u0F0F\x07F\x02" + + "\x02\u0F0F\u02E6\x03\x02\x02\x02\u0F10\u0F11\x07W\x02\x02\u0F11\u0F12" + + "\x07P\x02\x02\u0F12\u0F13\x07M\x02\x02\u0F13\u0F14\x07P\x02\x02\u0F14" + + "\u0F15\x07Q\x02\x02\u0F15\u0F16\x07Y\x02\x02\u0F16\u0F17\x07P\x02\x02" + + "\u0F17\u02E8\x03\x02\x02\x02\u0F18\u0F19\x07W\x02\x02\u0F19\u0F1A\x07" + + "P\x02\x02\u0F1A\u0F1B\x07N\x02\x02\u0F1B\u0F1C\x07K\x02\x02\u0F1C\u0F1D" + + "\x07U\x02\x02\u0F1D\u0F1E\x07V\x02\x02\u0F1E\u0F1F\x07G\x02\x02\u0F1F" + + "\u0F20\x07P\x02\x02\u0F20\u02EA\x03\x02\x02\x02\u0F21\u0F22\x07W\x02\x02" + + "\u0F22\u0F23\x07P\x02\x02\u0F23\u0F24\x07N\x02\x02\u0F24\u0F25\x07Q\x02" + + "\x02\u0F25\u0F26\x07I\x02\x02\u0F26\u0F27\x07I\x02\x02\u0F27\u0F28\x07" + + "G\x02\x02\u0F28\u0F29\x07F\x02\x02\u0F29\u02EC\x03\x02\x02\x02\u0F2A\u0F2B" + + "\x07W\x02\x02\u0F2B\u0F2C\x07P\x02\x02\u0F2C\u0F2D\x07V\x02\x02\u0F2D" + + "\u0F2E\x07K\x02\x02\u0F2E\u0F2F\x07N\x02\x02\u0F2F\u02EE\x03\x02\x02\x02" + + "\u0F30\u0F31\x07W\x02\x02\u0F31\u0F32\x07R\x02\x02\u0F32\u0F33\x07F\x02" + + "\x02\u0F33\u0F34\x07C\x02\x02\u0F34\u0F35\x07V\x02\x02\u0F35\u0F36\x07" + + "G\x02\x02\u0F36\u02F0\x03\x02\x02\x02\u0F37\u0F38\x07X\x02\x02\u0F38\u0F39" + + "\x07C\x02\x02\u0F39\u0F3A\x07E\x02\x02\u0F3A\u0F3B\x07W\x02\x02\u0F3B" + + "\u0F3C\x07W\x02\x02\u0F3C\u0F3D\x07O\x02\x02\u0F3D\u02F2\x03\x02\x02\x02" + + "\u0F3E\u0F3F\x07X\x02\x02\u0F3F\u0F40\x07C\x02\x02\u0F40\u0F41\x07N\x02" + + "\x02\u0F41\u0F42\x07K\x02\x02\u0F42\u0F43\x07F\x02\x02\u0F43\u02F4\x03" + + "\x02\x02\x02\u0F44\u0F45\x07X\x02\x02\u0F45\u0F46\x07C\x02\x02\u0F46\u0F47" + + "\x07N\x02\x02\u0F47\u0F48\x07K\x02\x02\u0F48\u0F49\x07F\x02\x02\u0F49" + + "\u0F4A\x07C\x02\x02\u0F4A\u0F4B\x07V\x02\x02\u0F4B\u0F4C\x07G\x02\x02" + + "\u0F4C\u02F6\x03\x02\x02\x02\u0F4D\u0F4E\x07X\x02\x02\u0F4E\u0F4F\x07" + + "C\x02\x02\u0F4F\u0F50\x07N\x02\x02\u0F50\u0F51\x07K\x02\x02\u0F51\u0F52" + + "\x07F\x02\x02\u0F52\u0F53\x07C\x02\x02\u0F53\u0F54\x07V\x02\x02\u0F54" + + "\u0F55\x07Q\x02\x02\u0F55\u0F56\x07T\x02\x02\u0F56\u02F8\x03\x02\x02\x02" + + "\u0F57\u0F58\x07X\x02\x02\u0F58\u0F59\x07C\x02\x02\u0F59\u0F5A\x07T\x02" + + "\x02\u0F5A\u0F5B\x07[\x02\x02\u0F5B\u0F5C\x07K\x02\x02\u0F5C\u0F5D\x07" + + "P\x02\x02\u0F5D\u0F5E\x07I\x02\x02\u0F5E\u02FA\x03\x02\x02\x02\u0F5F\u0F60" + + "\x07X\x02\x02\u0F60\u0F61\x07G\x02\x02\u0F61\u0F62\x07T\x02\x02\u0F62" + + "\u0F63\x07U\x02\x02\u0F63\u0F64\x07K\x02\x02\u0F64\u0F65\x07Q\x02\x02" + + "\u0F65\u0F66\x07P\x02\x02\u0F66\u02FC\x03\x02\x02\x02\u0F67\u0F68\x07" + + "X\x02\x02\u0F68\u0F69\x07K\x02\x02\u0F69\u0F6A\x07G\x02\x02\u0F6A\u0F6B" + + "\x07Y\x02\x02\u0F6B\u02FE\x03\x02\x02\x02\u0F6C\u0F6D\x07X\x02\x02\u0F6D" + + "\u0F6E\x07Q\x02\x02\u0F6E\u0F6F\x07N\x02\x02\u0F6F\u0F70\x07C\x02\x02" + + "\u0F70\u0F71\x07V\x02\x02\u0F71\u0F72\x07K\x02\x02\u0F72\u0F73\x07N\x02" + + "\x02\u0F73\u0F74\x07G\x02\x02\u0F74\u0300\x03\x02\x02\x02\u0F75\u0F76" + + "\x07Y\x02\x02\u0F76\u0F77\x07J\x02\x02\u0F77\u0F78\x07K\x02\x02\u0F78" + + "\u0F79\x07V\x02\x02\u0F79\u0F7A\x07G\x02\x02\u0F7A\u0F7B\x07U\x02\x02" + + "\u0F7B\u0F7C\x07R\x02\x02\u0F7C\u0F7D\x07C\x02\x02\u0F7D\u0F7E\x07E\x02" + + "\x02\u0F7E\u0F7F\x07G\x02\x02\u0F7F\u0302\x03\x02\x02\x02\u0F80\u0F81" + + "\x07Y\x02\x02\u0F81\u0F82\x07K\x02\x02\u0F82\u0F83\x07V\x02\x02\u0F83" + + "\u0F84\x07J\x02\x02\u0F84\u0F85\x07Q\x02\x02\u0F85\u0F86\x07W\x02\x02" + + "\u0F86\u0F87\x07V\x02\x02\u0F87\u0304\x03\x02\x02\x02\u0F88\u0F89\x07" + + "Y\x02\x02\u0F89\u0F8A\x07Q\x02\x02\u0F8A\u0F8B\x07T\x02\x02\u0F8B\u0F8C" + + "\x07M\x02\x02\u0F8C\u0306\x03\x02\x02\x02\u0F8D\u0F8E\x07Y\x02\x02\u0F8E" + + "\u0F8F\x07T\x02\x02\u0F8F\u0F90\x07C\x02\x02\u0F90\u0F91\x07R\x02\x02" + + "\u0F91\u0F92\x07R\x02\x02\u0F92\u0F93\x07G\x02\x02\u0F93\u0F94\x07T\x02" + + "\x02\u0F94\u0308\x03\x02\x02\x02\u0F95\u0F96\x07Y\x02\x02\u0F96\u0F97" + + "\x07T\x02\x02\u0F97\u0F98\x07K\x02\x02\u0F98\u0F99\x07V\x02\x02\u0F99" + + "\u0F9A\x07G\x02\x02\u0F9A\u030A\x03\x02\x02\x02\u0F9B\u0F9C\x07Z\x02\x02" + + "\u0F9C\u0F9D\x07O\x02\x02\u0F9D\u0F9E\x07N\x02\x02\u0F9E\u030C\x03\x02" + + "\x02\x02\u0F9F\u0FA0\x07[\x02\x02\u0FA0\u0FA1\x07G\x02\x02\u0FA1\u0FA2" + + "\x07C\x02\x02\u0FA2\u0FA3\x07T\x02\x02\u0FA3\u030E\x03\x02\x02\x02\u0FA4" + + "\u0FA5\x07[\x02\x02\u0FA5\u0FA6\x07G\x02\x02\u0FA6\u0FA7\x07U\x02\x02" + + "\u0FA7\u0310\x03\x02\x02\x02\u0FA8\u0FA9\x07\\\x02\x02\u0FA9\u0FAA\x07" + + "Q\x02\x02\u0FAA\u0FAB\x07P\x02\x02\u0FAB\u0FAC\x07G\x02\x02\u0FAC\u0312" + + "\x03\x02\x02\x02\u0FAD\u0FAE\x07D\x02\x02\u0FAE\u0FAF\x07G\x02\x02\u0FAF" + + "\u0FB0\x07V\x02\x02\u0FB0\u0FB1\x07Y\x02\x02\u0FB1\u0FB2\x07G\x02\x02" + + "\u0FB2\u0FB3\x07G\x02\x02\u0FB3\u0FB4\x07P\x02\x02\u0FB4\u0314\x03\x02" + + "\x02\x02\u0FB5\u0FB6\x07D\x02\x02\u0FB6\u0FB7\x07K\x02\x02\u0FB7\u0FB8" + + "\x07I\x02\x02\u0FB8\u0FB9\x07K\x02\x02\u0FB9\u0FBA\x07P\x02\x02\u0FBA" + + "\u0FBB\x07V\x02\x02\u0FBB\u0316\x03\x02\x02\x02\u0FBC\u0FBD\x07D\x02\x02" + + "\u0FBD\u0FBE\x07K\x02\x02\u0FBE\u0FBF\x07V\x02\x02\u0FBF\u0318\x03\x02" + + "\x02\x02\u0FC0\u0FC1\x07D\x02\x02\u0FC1\u0FC2\x07Q\x02\x02\u0FC2\u0FC3" + + "\x07Q\x02\x02\u0FC3\u0FC4\x07N\x02\x02\u0FC4\u0FC5\x07G\x02\x02\u0FC5" + + "\u0FC6\x07C\x02\x02\u0FC6\u0FC7\x07P\x02\x02\u0FC7\u031A\x03\x02\x02\x02" + + "\u0FC8\u0FC9\x07E\x02\x02\u0FC9\u0FCA\x07J\x02\x02\u0FCA\u0FCB\x07C\x02" + + "\x02\u0FCB\u0FCC\x07T\x02\x02\u0FCC\u031C\x03\x02\x02\x02\u0FCD\u0FCE" + + "\x07E\x02\x02\u0FCE\u0FCF\x07J\x02\x02\u0FCF\u0FD0\x07C\x02\x02\u0FD0" + + "\u0FD1\x07T\x02\x02\u0FD1\u0FD2\x07C\x02\x02\u0FD2\u0FD3\x07E\x02\x02" + + "\u0FD3\u0FD4\x07V\x02\x02\u0FD4\u0FD5\x07G\x02\x02\u0FD5\u0FD6\x07T\x02" + + "\x02\u0FD6\u031E\x03\x02\x02\x02\u0FD7\u0FD8\x07E\x02\x02\u0FD8\u0FD9" + + "\x07Q\x02\x02\u0FD9\u0FDA\x07C\x02\x02\u0FDA\u0FDB\x07N\x02\x02\u0FDB" + + "\u0FDC\x07G\x02\x02\u0FDC\u0FDD\x07U\x02\x02\u0FDD\u0FDE\x07E\x02\x02" + + "\u0FDE\u0FDF\x07G\x02\x02\u0FDF\u0320\x03\x02\x02\x02\u0FE0\u0FE1\x07" + + "F\x02\x02\u0FE1\u0FE2\x07G\x02\x02\u0FE2\u0FE3\x07E\x02\x02\u0FE3\u0322" + + "\x03\x02\x02\x02\u0FE4\u0FE5\x07F\x02\x02\u0FE5\u0FE6\x07G\x02\x02\u0FE6" + + "\u0FE7\x07E\x02\x02\u0FE7\u0FE8\x07K\x02\x02\u0FE8\u0FE9\x07O\x02\x02" + + "\u0FE9\u0FEA\x07C\x02\x02\u0FEA\u0FEB\x07N\x02\x02\u0FEB\u0324\x03\x02" + + "\x02\x02\u0FEC\u0FED\x07G\x02\x02\u0FED\u0FEE\x07Z\x02\x02\u0FEE\u0FEF" + + "\x07K\x02\x02\u0FEF\u0FF0\x07U\x02\x02\u0FF0\u0FF1\x07V\x02\x02\u0FF1" + + "\u0FF2\x07U\x02\x02\u0FF2\u0326\x03\x02\x02\x02\u0FF3\u0FF4\x07G\x02\x02" + + "\u0FF4\u0FF5\x07Z\x02\x02\u0FF5\u0FF6\x07V\x02\x02\u0FF6\u0FF7\x07T\x02" + + "\x02\u0FF7\u0FF8\x07C\x02\x02\u0FF8\u0FF9\x07E\x02\x02\u0FF9\u0FFA\x07" + + "V\x02\x02\u0FFA\u0328\x03\x02\x02\x02\u0FFB\u0FFC\x07H\x02\x02\u0FFC\u0FFD" + + "\x07N\x02\x02\u0FFD\u0FFE\x07Q\x02\x02\u0FFE\u0FFF\x07C\x02\x02\u0FFF" + + "\u1000\x07V\x02\x02\u1000\u032A\x03\x02\x02\x02\u1001\u1002\x07I\x02\x02" + + "\u1002\u1003\x07T\x02\x02\u1003\u1004\x07G\x02\x02\u1004\u1005\x07C\x02" + + "\x02\u1005\u1006\x07V\x02\x02\u1006\u1007\x07G\x02\x02\u1007\u1008\x07" + + "U\x02\x02\u1008\u1009\x07V\x02\x02\u1009\u032C\x03\x02\x02\x02\u100A\u100B" + + "\x07K\x02\x02\u100B\u100C\x07P\x02\x02\u100C\u100D\x07Q\x02\x02\u100D" + + "\u100E\x07W\x02\x02\u100E\u100F\x07V\x02\x02\u100F\u032E\x03\x02\x02\x02" + + "\u1010\u1011\x07K\x02\x02\u1011\u1012\x07P\x02\x02\u1012\u1013\x07V\x02" + + "\x02\u1013\u0330\x03\x02\x02\x02\u1014\u1015\x07K\x02\x02\u1015\u1016" + + "\x07P\x02\x02\u1016\u1017\x07V\x02\x02\u1017\u1018\x07G\x02\x02\u1018" + + "\u1019\x07I\x02\x02\u1019\u101A\x07G\x02\x02\u101A\u101B\x07T\x02\x02" + + "\u101B\u0332\x03\x02\x02\x02\u101C\u101D\x07K\x02\x02\u101D\u101E\x07" + + "P\x02\x02\u101E\u101F\x07V\x02\x02\u101F\u1020\x07G\x02\x02\u1020\u1021" + + "\x07T\x02\x02\u1021\u1022\x07X\x02\x02\u1022\u1023\x07C\x02\x02\u1023" + + "\u1024\x07N\x02\x02\u1024\u0334\x03\x02\x02\x02\u1025\u1026\x07N\x02\x02" + + "\u1026\u1027\x07G\x02\x02\u1027\u1028\x07C\x02\x02\u1028\u1029\x07U\x02" + + "\x02\u1029\u102A\x07V\x02\x02\u102A\u0336\x03\x02\x02\x02\u102B\u102C" + + "\x07P\x02\x02\u102C\u102D\x07C\x02\x02\u102D\u102E\x07V\x02\x02\u102E" + + "\u102F\x07K\x02\x02\u102F\u1030\x07Q\x02\x02\u1030\u1031\x07P\x02\x02" + + "\u1031\u1032\x07C\x02\x02\u1032\u1033\x07N\x02\x02\u1033\u0338\x03\x02" + + "\x02\x02\u1034\u1035\x07P\x02\x02\u1035\u1036\x07E\x02\x02\u1036\u1037" + + "\x07J\x02\x02\u1037\u1038\x07C\x02\x02\u1038\u1039\x07T\x02\x02\u1039" + + "\u033A\x03\x02\x02\x02\u103A\u103B\x07P\x02\x02\u103B\u103C\x07Q\x02\x02" + + "\u103C\u103D\x07P\x02\x02\u103D\u103E\x07G\x02\x02\u103E\u033C\x03\x02" + + "\x02\x02\u103F\u1040\x07P\x02\x02\u1040\u1041\x07W\x02\x02\u1041\u1042" + + "\x07N\x02\x02\u1042\u1043\x07N\x02\x02\u1043\u1044\x07K\x02\x02\u1044" + + "\u1045\x07H\x02\x02\u1045\u033E\x03\x02\x02\x02\u1046\u1047\x07P\x02\x02" + + "\u1047\u1048\x07W\x02\x02\u1048\u1049\x07O\x02\x02\u1049\u104A\x07G\x02" + + "\x02\u104A\u104B\x07T\x02\x02\u104B\u104C\x07K\x02\x02\u104C\u104D\x07" + + "E\x02\x02\u104D\u0340\x03\x02\x02\x02\u104E\u104F\x07Q\x02\x02\u104F\u1050" + + "\x07X\x02\x02\u1050\u1051\x07G\x02\x02\u1051\u1052\x07T\x02\x02\u1052" + + "\u1053\x07N\x02\x02\u1053\u1054\x07C\x02\x02\u1054\u1055\x07[\x02\x02" + + "\u1055\u0342\x03\x02\x02\x02\u1056\u1057\x07R\x02\x02\u1057\u1058\x07" + + "Q\x02\x02\u1058\u1059\x07U\x02\x02\u1059\u105A\x07K\x02\x02\u105A\u105B" + + "\x07V\x02\x02\u105B\u105C\x07K\x02\x02\u105C\u105D\x07Q\x02\x02\u105D" + + "\u105E\x07P\x02\x02\u105E\u0344\x03\x02\x02\x02\u105F\u1060\x07R\x02\x02" + + "\u1060\u1061\x07T\x02\x02\u1061\u1062\x07G\x02\x02\u1062\u1063\x07E\x02" + + "\x02\u1063\u1064\x07K\x02\x02\u1064\u1065\x07U\x02\x02\u1065\u1066\x07" + + "K\x02\x02\u1066\u1067\x07Q\x02\x02\u1067\u1068\x07P\x02\x02\u1068\u0346" + + "\x03\x02\x02\x02\u1069\u106A\x07T\x02\x02\u106A\u106B\x07G\x02\x02\u106B" + + "\u106C\x07C\x02\x02\u106C\u106D\x07N\x02\x02\u106D\u0348\x03\x02\x02\x02" + + "\u106E\u106F\x07T\x02\x02\u106F\u1070\x07Q\x02\x02\u1070\u1071\x07Y\x02" + + "\x02\u1071\u034A\x03\x02\x02\x02\u1072\u1073\x07U\x02\x02\u1073\u1074" + + "\x07G\x02\x02\u1074\u1075\x07V\x02\x02\u1075\u1076\x07Q\x02\x02\u1076" + + "\u1077\x07H\x02\x02\u1077\u034C\x03\x02\x02\x02\u1078\u1079\x07U\x02\x02" + + "\u1079\u107A\x07O\x02\x02\u107A\u107B\x07C\x02\x02\u107B\u107C\x07N\x02" + + "\x02\u107C\u107D\x07N\x02\x02\u107D\u107E\x07K\x02\x02\u107E\u107F\x07" + + "P\x02\x02\u107F\u1080\x07V\x02\x02\u1080\u034E\x03\x02\x02\x02\u1081\u1082" + + "\x07U\x02\x02\u1082\u1083\x07W\x02\x02\u1083\u1084\x07D\x02\x02\u1084" + + "\u1085\x07U\x02\x02\u1085\u1086\x07V\x02\x02\u1086\u1087\x07T\x02\x02" + + "\u1087\u1088\x07K\x02\x02\u1088\u1089\x07P\x02\x02\u1089\u108A\x07I\x02" + + "\x02\u108A\u0350\x03\x02\x02\x02\u108B\u108C\x07V\x02\x02\u108C\u108D" + + "\x07K\x02\x02\u108D\u108E\x07O\x02\x02\u108E\u108F\x07G\x02\x02\u108F" + + "\u0352\x03\x02\x02\x02\u1090\u1091\x07V\x02\x02\u1091\u1092\x07K\x02\x02" + + "\u1092\u1093\x07O\x02\x02\u1093\u1094\x07G\x02\x02\u1094\u1095\x07U\x02" + + "\x02\u1095\u1096\x07V\x02\x02\u1096\u1097\x07C\x02\x02\u1097\u1098\x07" + + "O\x02\x02\u1098\u1099\x07R\x02\x02\u1099\u0354\x03\x02\x02\x02\u109A\u109B" + + "\x07V\x02\x02\u109B\u109C\x07T\x02\x02\u109C\u109D\x07G\x02\x02\u109D" + + "\u109E\x07C\x02\x02\u109E\u109F\x07V\x02\x02\u109F\u0356\x03\x02\x02\x02" + + "\u10A0\u10A1\x07V\x02\x02\u10A1\u10A2\x07T\x02\x02\u10A2\u10A3\x07K\x02" + + "\x02\u10A3\u10A4\x07O\x02\x02\u10A4\u0358\x03\x02\x02\x02\u10A5\u10A6" + + "\x07X\x02\x02\u10A6\u10A7\x07C\x02\x02\u10A7\u10A8\x07N\x02\x02\u10A8" + + "\u10A9\x07W\x02\x02\u10A9\u10AA\x07G\x02\x02\u10AA\u10AB\x07U\x02\x02" + + "\u10AB\u035A\x03\x02\x02\x02\u10AC\u10AD\x07X\x02\x02\u10AD\u10AE\x07" + + "C\x02\x02\u10AE\u10AF\x07T\x02\x02\u10AF\u10B0\x07E\x02\x02\u10B0\u10B1" + + "\x07J\x02\x02\u10B1\u10B2\x07C\x02\x02\u10B2\u10B3\x07T\x02\x02\u10B3" + + "\u035C\x03\x02\x02\x02\u10B4\u10B5\x07Z\x02\x02\u10B5\u10B6\x07O\x02\x02" + + "\u10B6\u10B7\x07N\x02\x02\u10B7\u10B8\x07C\x02\x02\u10B8\u10B9\x07V\x02" + + "\x02\u10B9\u10BA\x07V\x02\x02\u10BA\u10BB\x07T\x02\x02\u10BB\u10BC\x07" + + "K\x02\x02\u10BC\u10BD\x07D\x02\x02\u10BD\u10BE\x07W\x02\x02\u10BE\u10BF" + + "\x07V\x02\x02\u10BF\u10C0\x07G\x02\x02\u10C0\u10C1\x07U\x02\x02\u10C1" + + "\u035E\x03\x02\x02\x02\u10C2\u10C3\x07Z\x02\x02\u10C3\u10C4\x07O\x02\x02" + + "\u10C4\u10C5\x07N\x02\x02\u10C5\u10C6\x07E\x02\x02\u10C6\u10C7\x07Q\x02" + + "\x02\u10C7\u10C8\x07P\x02\x02\u10C8\u10C9\x07E\x02\x02\u10C9\u10CA\x07" + + "C\x02\x02\u10CA\u10CB\x07V\x02\x02\u10CB\u0360\x03\x02\x02\x02\u10CC\u10CD" + + "\x07Z\x02\x02\u10CD\u10CE\x07O\x02\x02\u10CE\u10CF\x07N\x02\x02\u10CF" + + "\u10D0\x07G\x02\x02\u10D0\u10D1\x07N\x02\x02\u10D1\u10D2\x07G\x02\x02" + + "\u10D2\u10D3\x07O\x02\x02\u10D3\u10D4\x07G\x02\x02\u10D4\u10D5\x07P\x02" + + "\x02\u10D5\u10D6\x07V\x02\x02\u10D6\u0362\x03\x02\x02\x02\u10D7\u10D8" + + "\x07Z\x02\x02\u10D8\u10D9\x07O\x02\x02\u10D9\u10DA\x07N\x02\x02\u10DA" + + "\u10DB\x07G\x02\x02\u10DB\u10DC\x07Z\x02\x02\u10DC\u10DD\x07K\x02\x02" + + "\u10DD\u10DE\x07U\x02\x02\u10DE\u10DF\x07V\x02\x02\u10DF\u10E0\x07U\x02" + + "\x02\u10E0\u0364\x03\x02\x02\x02\u10E1\u10E2\x07Z\x02\x02\u10E2\u10E3" + + "\x07O\x02\x02\u10E3\u10E4\x07N\x02\x02\u10E4\u10E5\x07H\x02\x02\u10E5" + + "\u10E6\x07Q\x02\x02\u10E6\u10E7\x07T\x02\x02\u10E7\u10E8\x07G\x02\x02" + + "\u10E8\u10E9\x07U\x02\x02\u10E9\u10EA\x07V\x02\x02\u10EA\u0366\x03\x02" + + "\x02\x02\u10EB\u10EC\x07Z\x02\x02\u10EC\u10ED\x07O\x02\x02\u10ED\u10EE" + + "\x07N\x02\x02\u10EE\u10EF\x07R\x02\x02\u10EF\u10F0\x07C\x02\x02\u10F0" + + "\u10F1\x07T\x02\x02\u10F1\u10F2\x07U\x02\x02\u10F2\u10F3\x07G\x02\x02" + + "\u10F3\u0368\x03\x02\x02\x02\u10F4\u10F5\x07Z\x02\x02\u10F5\u10F6\x07" + + "O\x02\x02\u10F6\u10F7\x07N\x02\x02\u10F7\u10F8\x07R\x02\x02\u10F8\u10F9" + + "\x07K\x02\x02\u10F9\u036A\x03\x02\x02\x02\u10FA\u10FB\x07Z\x02\x02\u10FB" + + "\u10FC\x07O\x02\x02\u10FC\u10FD\x07N\x02\x02\u10FD\u10FE\x07T\x02\x02" + + "\u10FE\u10FF\x07Q\x02\x02\u10FF\u1100\x07Q\x02\x02\u1100\u1101\x07V\x02" + + "\x02\u1101\u036C\x03\x02\x02\x02\u1102\u1103\x07Z\x02\x02\u1103\u1104" + + "\x07O\x02\x02\u1104\u1105\x07N\x02\x02\u1105\u1106\x07U\x02\x02\u1106" + + "\u1107\x07G\x02\x02\u1107\u1108\x07T\x02\x02\u1108\u1109\x07K\x02\x02" + + "\u1109\u110A\x07C\x02\x02\u110A\u110B\x07N\x02\x02\u110B\u110C\x07K\x02" + + "\x02\u110C\u110D\x07\\\x02\x02\u110D\u110E\x07G\x02\x02\u110E\u036E\x03" + + "\x02\x02\x02\u110F\u1110\x07E\x02\x02\u1110\u1111\x07C\x02\x02\u1111\u1112" + + "\x07N\x02\x02\u1112\u1113\x07N\x02\x02\u1113\u0370\x03\x02\x02\x02\u1114" + + "\u1115\x07E\x02\x02\u1115\u1116\x07W\x02\x02\u1116\u1117\x07T\x02\x02" + + "\u1117\u1118\x07T\x02\x02\u1118\u1119\x07G\x02\x02\u1119\u111A\x07P\x02" + + "\x02\u111A\u111B\x07V\x02\x02\u111B\u0372\x03\x02\x02\x02\u111C\u111D" + + "\x07C\x02\x02\u111D\u111E\x07V\x02\x02\u111E\u111F\x07V\x02\x02\u111F" + + "\u1120\x07C\x02\x02\u1120\u1121\x07E\x02\x02\u1121\u1122\x07J\x02\x02" + + "\u1122\u0374\x03\x02\x02\x02\u1123\u1124\x07F\x02\x02\u1124\u1125\x07" + + "G\x02\x02\u1125\u1126\x07V\x02\x02\u1126\u1127\x07C\x02\x02\u1127\u1128" + + "\x07E\x02\x02\u1128\u1129\x07J\x02\x02\u1129\u0376\x03\x02\x02\x02\u112A" + + "\u112B\x07G\x02\x02\u112B\u112C\x07Z\x02\x02\u112C\u112D\x07R\x02\x02" + + "\u112D\u112E\x07T\x02\x02\u112E\u112F\x07G\x02\x02\u112F\u1130\x07U\x02" + + "\x02\u1130\u1131\x07U\x02\x02\u1131\u1132\x07K\x02\x02\u1132\u1133\x07" + + "Q\x02\x02\u1133\u1134\x07P\x02\x02\u1134\u0378\x03\x02\x02\x02\u1135\u1136" + + "\x07I\x02\x02\u1136\u1137\x07G\x02\x02\u1137\u1138\x07P\x02\x02\u1138" + + "\u1139\x07G\x02\x02\u1139\u113A\x07T\x02\x02\u113A\u113B\x07C\x02\x02" + + "\u113B\u113C\x07V\x02\x02\u113C\u113D\x07G\x02\x02\u113D\u113E\x07F\x02" + + "\x02\u113E\u037A\x03\x02\x02\x02\u113F\u1140\x07N\x02\x02\u1140\u1141" + + "\x07Q\x02\x02\u1141\u1142\x07I\x02\x02\u1142\u1143\x07I\x02\x02\u1143" + + "\u1144\x07G\x02\x02\u1144\u1145\x07F\x02\x02\u1145\u037C\x03\x02\x02\x02" + + "\u1146\u1147\x07U\x02\x02\u1147\u1148\x07V\x02\x02\u1148\u1149\x07Q\x02" + + "\x02\u1149\u114A\x07T\x02\x02\u114A\u114B\x07G\x02\x02\u114B\u114C\x07" + + "F\x02\x02\u114C\u037E\x03\x02\x02\x02\u114D\u114E\x07K\x02\x02\u114E\u114F" + + "\x07P\x02\x02\u114F\u1150\x07E\x02\x02\u1150\u1151\x07N\x02\x02\u1151" + + "\u1152\x07W\x02\x02\u1152\u1153\x07F\x02\x02\u1153\u1154\x07G\x02\x02" + + "\u1154\u0380\x03\x02\x02\x02\u1155\u1156\x07T\x02\x02\u1156\u1157\x07" + + "Q\x02\x02\u1157\u1158\x07W\x02\x02\u1158\u1159\x07V\x02\x02\u1159\u115A" + + "\x07K\x02\x02\u115A\u115B\x07P\x02\x02\u115B\u115C\x07G\x02\x02\u115C" + + "\u0382\x03\x02\x02\x02\u115D\u115E\x07V\x02\x02\u115E\u115F\x07T\x02\x02" + + "\u115F\u1160\x07C\x02\x02\u1160\u1161\x07P\x02\x02\u1161\u1162\x07U\x02" + + "\x02\u1162\u1163\x07H\x02\x02\u1163\u1164\x07Q\x02\x02\u1164\u1165\x07" + + "T\x02\x02\u1165\u1166\x07O\x02\x02\u1166\u0384\x03\x02\x02\x02\u1167\u1168" + + "\x07K\x02\x02\u1168\u1169\x07O\x02\x02\u1169\u116A\x07R\x02\x02\u116A" + + "\u116B\x07Q\x02\x02\u116B\u116C\x07T\x02\x02\u116C\u116D\x07V\x02\x02" + + "\u116D\u0386\x03\x02\x02\x02\u116E\u116F\x07R\x02\x02\u116F\u1170\x07" + + "Q\x02\x02\u1170\u1171\x07N\x02\x02\u1171\u1172\x07K\x02\x02\u1172\u1173" + + "\x07E\x02\x02\u1173\u1174\x07[\x02\x02\u1174\u0388\x03\x02\x02\x02\u1175" + + "\u1176\x07O\x02\x02\u1176\u1177\x07G\x02\x02\u1177\u1178\x07V\x02\x02" + + "\u1178\u1179\x07J\x02\x02\u1179\u117A\x07Q\x02\x02\u117A\u117B\x07F\x02" + + "\x02\u117B\u038A\x03\x02\x02\x02\u117C\u117D\x07T\x02\x02\u117D\u117E" + + "\x07G\x02\x02\u117E\u117F\x07H\x02\x02\u117F\u1180\x07G\x02\x02\u1180" + + "\u1181\x07T\x02\x02\u1181\u1182\x07G\x02\x02\u1182\u1183\x07P\x02\x02" + + "\u1183\u1184\x07E\x02\x02\u1184\u1185\x07K\x02\x02"; private static readonly _serializedATNSegment8: string = - "\u11B8\u11B9\x07P\x02\x02\u11B9\u11BA\x07I\x02\x02\u11BA\u03A8\x03\x02" + - "\x02\x02\u11BB\u11BC\x07U\x02\x02\u11BC\u11BD\x07G\x02\x02\u11BD\u11BE" + - "\x07V\x02\x02\u11BE\u11BF\x07U\x02\x02\u11BF\u03AA\x03\x02\x02\x02\u11C0" + - "\u11C1\x07V\x02\x02\u11C1\u11C2\x07C\x02\x02\u11C2\u11C3\x07D\x02\x02" + - "\u11C3\u11C4\x07N\x02\x02\u11C4\u11C5\x07G\x02\x02\u11C5\u11C6\x07U\x02" + - "\x02\u11C6\u11C7\x07C\x02\x02\u11C7\u11C8\x07O\x02\x02\u11C8\u11C9\x07" + - "R\x02\x02\u11C9\u11CA\x07N\x02\x02\u11CA\u11CB\x07G\x02\x02\u11CB\u03AC" + - "\x03\x02\x02\x02\u11CC\u11CD\x07Q\x02\x02\u11CD\u11CE\x07T\x02\x02\u11CE" + - "\u11CF\x07F\x02\x02\u11CF\u11D0\x07K\x02\x02\u11D0\u11D1\x07P\x02\x02" + - "\u11D1\u11D2\x07C\x02\x02\u11D2\u11D3\x07N\x02\x02\u11D3\u11D4\x07K\x02" + - "\x02\u11D4\u11D5\x07V\x02\x02\u11D5\u11D6\x07[\x02\x02\u11D6\u03AE\x03" + - "\x02\x02\x02\u11D7\u11D8\x07Z\x02\x02\u11D8\u11D9\x07O\x02\x02\u11D9\u11DA" + - "\x07N\x02\x02\u11DA\u11DB\x07V\x02\x02\u11DB\u11DC\x07C\x02\x02\u11DC" + - "\u11DD\x07D\x02\x02\u11DD\u11DE\x07N\x02\x02\u11DE\u11DF\x07G\x02\x02" + - "\u11DF\u03B0\x03\x02\x02\x02\u11E0\u11E1\x07E\x02\x02\u11E1\u11E2\x07" + - "Q\x02\x02\u11E2\u11E3\x07N\x02\x02\u11E3\u11E4\x07W\x02\x02\u11E4\u11E5" + - "\x07O\x02\x02\u11E5\u11E6\x07P\x02\x02\u11E6\u11E7\x07U\x02\x02\u11E7" + - "\u03B2\x03\x02\x02\x02\u11E8\u11E9\x07Z\x02\x02\u11E9\u11EA\x07O\x02\x02" + - "\u11EA\u11EB\x07N\x02\x02\u11EB\u11EC\x07P\x02\x02\u11EC\u11ED\x07C\x02" + - "\x02\u11ED\u11EE\x07O\x02\x02\u11EE\u11EF\x07G\x02\x02\u11EF\u11F0\x07" + - "U\x02\x02\u11F0\u11F1\x07R\x02\x02\u11F1\u11F2\x07C\x02\x02\u11F2\u11F3" + - "\x07E\x02\x02\u11F3\u11F4\x07G\x02\x02\u11F4\u11F5\x07U\x02\x02\u11F5" + - "\u03B4\x03\x02\x02\x02\u11F6\u11F7\x07T\x02\x02\u11F7\u11F8\x07Q\x02\x02" + - "\u11F8\u11F9\x07Y\x02\x02\u11F9\u11FA\x07V\x02\x02\u11FA\u11FB\x07[\x02" + - "\x02\u11FB\u11FC\x07R\x02\x02\u11FC\u11FD\x07G\x02\x02\u11FD\u03B6\x03" + - "\x02\x02\x02\u11FE\u11FF\x07P\x02\x02\u11FF\u1200\x07Q\x02\x02\u1200\u1201" + - "\x07T\x02\x02\u1201\u1202\x07O\x02\x02\u1202\u1203\x07C\x02\x02\u1203" + - "\u1204\x07N\x02\x02\u1204\u1205\x07K\x02\x02\u1205\u1206\x07\\\x02\x02" + - "\u1206\u1207\x07G\x02\x02\u1207\u1208\x07F\x02\x02\u1208\u03B8\x03\x02" + - "\x02\x02\u1209\u120A\x07Y\x02\x02\u120A\u120B\x07K\x02\x02\u120B\u120C" + - "\x07V\x02\x02\u120C\u120D\x07J\x02\x02\u120D\u120E\x07K\x02\x02\u120E" + - "\u120F\x07P\x02\x02\u120F\u03BA\x03\x02\x02\x02\u1210\u1211\x07H\x02\x02" + - "\u1211\u1212\x07K\x02\x02\u1212\u1213\x07N\x02\x02\u1213\u1214\x07V\x02" + - "\x02\u1214\u1215\x07G\x02\x02\u1215\u1216\x07T\x02\x02\u1216\u03BC\x03" + - "\x02\x02\x02\u1217\u1218\x07I\x02\x02\u1218\u1219\x07T\x02\x02\u1219\u121A" + - "\x07Q\x02\x02\u121A\u121B\x07W\x02\x02\u121B\u121C\x07R\x02\x02\u121C" + - "\u121D\x07U\x02\x02\u121D\u03BE\x03\x02\x02\x02\u121E\u121F\x07Q\x02\x02" + - "\u121F\u1220\x07V\x02\x02\u1220\u1221\x07J\x02\x02\u1221\u1222\x07G\x02" + - "\x02\u1222\u1223\x07T\x02\x02\u1223\u1224\x07U\x02\x02\u1224\u03C0\x03" + - "\x02\x02\x02\u1225\u1226\x07P\x02\x02\u1226\u1227\x07H\x02\x02\u1227\u1228" + - "\x07E\x02\x02\u1228\u03C2\x03\x02\x02\x02\u1229\u122A\x07P\x02\x02\u122A" + - "\u122B\x07H\x02\x02\u122B\u122C\x07F\x02\x02\u122C\u03C4\x03\x02\x02\x02" + - "\u122D\u122E\x07P\x02\x02\u122E\u122F\x07H\x02\x02\u122F\u1230\x07M\x02" + - "\x02\u1230\u1231\x07E\x02\x02\u1231\u03C6\x03\x02\x02\x02\u1232\u1233" + - "\x07P\x02\x02\u1233\u1234\x07H\x02\x02\u1234\u1235\x07M\x02\x02\u1235" + - "\u1236\x07F\x02\x02\u1236\u03C8\x03\x02\x02\x02\u1237\u1238\x07W\x02\x02" + - "\u1238\u1239\x07G\x02\x02\u1239\u123A\x07U\x02\x02\u123A\u123B\x07E\x02" + - "\x02\u123B\u123C\x07C\x02\x02\u123C\u123D\x07R\x02\x02\u123D\u123E\x07" + - "G\x02\x02\u123E\u03CA\x03\x02\x02\x02\u123F\u1240\x07X\x02\x02\u1240\u1241" + - "\x07K\x02\x02\u1241\u1242\x07G\x02\x02\u1242\u1243\x07Y\x02\x02\u1243" + - "\u1244\x07U\x02\x02\u1244\u03CC\x03\x02\x02\x02\u1245\u1246\x07P\x02\x02" + - "\u1246\u1247\x07Q\x02\x02\u1247\u1248\x07T\x02\x02\u1248\u1249\x07O\x02" + - "\x02\u1249\u124A\x07C\x02\x02\u124A\u124B\x07N\x02\x02\u124B\u124C\x07" + - "K\x02\x02\u124C\u124D\x07\\\x02\x02\u124D\u124E\x07G\x02\x02\u124E\u03CE" + - "\x03\x02\x02\x02\u124F\u1250\x07F\x02\x02\u1250\u1251\x07W\x02\x02\u1251" + - "\u1252\x07O\x02\x02\u1252\u1253\x07R\x02\x02\u1253\u03D0\x03\x02\x02\x02" + - "\u1254\u1255\x07R\x02\x02\u1255\u1256\x07T\x02\x02\u1256\u1257\x07K\x02" + - "\x02\u1257\u1258\x07P\x02\x02\u1258\u1259\x07V\x02\x02\u1259\u125A\x07" + - "a\x02\x02\u125A\u125B\x07U\x02\x02\u125B\u125C\x07V\x02\x02\u125C\u125D" + - "\x07T\x02\x02\u125D\u125E\x07K\x02\x02\u125E\u125F\x07E\x02\x02\u125F" + - "\u1260\x07V\x02\x02\u1260\u1261\x07a\x02\x02\u1261\u1262\x07R\x02\x02" + - "\u1262\u1263\x07C\x02\x02\u1263\u1264\x07T\x02\x02\u1264\u1265\x07C\x02" + - "\x02\u1265\u1266\x07O\x02\x02\u1266\u1267\x07U\x02\x02\u1267\u03D2\x03" + - "\x02\x02\x02\u1268\u1269\x07X\x02\x02\u1269\u126A\x07C\x02\x02\u126A\u126B" + - "\x07T\x02\x02\u126B\u126C\x07K\x02\x02\u126C\u126D\x07C\x02\x02\u126D" + - "\u126E\x07D\x02\x02\u126E\u126F\x07N\x02\x02\u126F\u1270\x07G\x02\x02" + - "\u1270\u1271\x07a\x02\x02\u1271\u1272\x07E\x02\x02\u1272\u1273\x07Q\x02" + - "\x02\u1273\u1274\x07P\x02\x02\u1274\u1275\x07H\x02\x02\u1275\u1276\x07" + - "N\x02\x02\u1276\u1277\x07K\x02\x02\u1277\u1278\x07E\x02\x02\u1278\u1279" + - "\x07V\x02\x02\u1279\u03D4\x03\x02\x02\x02\u127A\u127B\x07G\x02\x02\u127B" + - "\u127C\x07T\x02\x02\u127C\u127D\x07T\x02\x02\u127D\u127E\x07Q\x02\x02" + - "\u127E\u127F\x07T\x02\x02\u127F\u03D6\x03\x02\x02\x02\u1280\u1281\x07" + - "W\x02\x02\u1281\u1282\x07U\x02\x02\u1282\u1283\x07G\x02\x02\u1283\u1284" + - "\x07a\x02\x02\u1284\u1285\x07X\x02\x02\u1285\u1286\x07C\x02\x02\u1286" + - "\u1287\x07T\x02\x02\u1287\u1288\x07K\x02\x02\u1288\u1289\x07C\x02\x02" + - "\u1289\u128A\x07D\x02\x02\u128A\u128B\x07N\x02\x02\u128B\u128C\x07G\x02" + - "\x02\u128C\u03D8\x03\x02\x02\x02\u128D\u128E\x07W\x02\x02\u128E\u128F" + - "\x07U\x02\x02\u128F\u1290\x07G\x02\x02\u1290\u1291\x07a\x02\x02\u1291" + - "\u1292\x07E\x02\x02\u1292\u1293\x07Q\x02\x02\u1293\u1294\x07N\x02\x02" + - "\u1294\u1295\x07W\x02\x02\u1295\u1296\x07O\x02\x02\u1296\u1297\x07P\x02" + - "\x02\u1297\u03DA\x03\x02\x02\x02\u1298\u1299\x07C\x02\x02\u1299\u129A" + - "\x07N\x02\x02\u129A\u129B\x07K\x02\x02\u129B\u129C\x07C\x02\x02\u129C" + - "\u129D\x07U\x02\x02\u129D\u03DC\x03\x02\x02\x02\u129E\u129F\x07E\x02\x02" + - "\u129F\u12A0\x07Q\x02\x02\u12A0\u12A1\x07P\x02\x02\u12A1\u12A2\x07U\x02" + - "\x02\u12A2\u12A3\x07V\x02\x02\u12A3\u12A4\x07C\x02\x02\u12A4\u12A5\x07" + - "P\x02\x02\u12A5\u12A6\x07V\x02\x02\u12A6\u03DE\x03\x02\x02\x02\u12A7\u12A8" + - "\x07R\x02\x02\u12A8\u12A9\x07G\x02\x02\u12A9\u12AA\x07T\x02\x02\u12AA" + - "\u12AB\x07H\x02\x02\u12AB\u12AC\x07Q\x02\x02\u12AC\u12AD\x07T\x02\x02" + - "\u12AD\u12AE\x07O\x02\x02\u12AE\u03E0\x03\x02\x02\x02\u12AF\u12B0\x07" + - "I\x02\x02\u12B0\u12B1\x07G\x02\x02\u12B1\u12B2\x07V\x02\x02\u12B2\u03E2" + - "\x03\x02\x02\x02\u12B3\u12B4\x07F\x02\x02\u12B4\u12B5\x07K\x02\x02\u12B5" + - "\u12B6\x07C\x02\x02\u12B6\u12B7\x07I\x02\x02\u12B7\u12B8\x07P\x02\x02" + - "\u12B8\u12B9\x07Q\x02\x02\u12B9\u12BA\x07U\x02\x02\u12BA\u12BB\x07V\x02" + - "\x02\u12BB\u12BC\x07K\x02\x02\u12BC\u12BD\x07E\x02\x02\u12BD\u12BE\x07" + - "U\x02\x02\u12BE\u03E4\x03\x02\x02\x02\u12BF\u12C0\x07U\x02\x02\u12C0\u12C1" + - "\x07V\x02\x02\u12C1\u12C2\x07C\x02\x02\u12C2\u12C3\x07E\x02\x02\u12C3" + - "\u12C4\x07M\x02\x02\u12C4\u12C5\x07G\x02\x02\u12C5\u12C6\x07F\x02\x02" + - "\u12C6\u03E6\x03\x02\x02\x02\u12C7\u12C8\x07G\x02\x02\u12C8\u12C9\x07" + - "N\x02\x02\u12C9\u12CA\x07U\x02\x02\u12CA\u12CB\x07K\x02\x02\u12CB\u12CC" + - "\x07H\x02\x02\u12CC\u03E8\x03\x02\x02\x02\u12CD\u12CE\x07Y\x02\x02\u12CE" + - "\u12CF\x07J\x02\x02\u12CF\u12D0\x07K\x02\x02\u12D0\u12D1\x07N\x02\x02" + - "\u12D1\u12D2\x07G\x02\x02\u12D2\u03EA\x03\x02\x02\x02\u12D3\u12D4\x07" + - "T\x02\x02\u12D4\u12D5\x07G\x02\x02\u12D5\u12D6\x07X\x02\x02\u12D6\u12D7" + - "\x07G\x02\x02\u12D7\u12D8\x07T\x02\x02\u12D8\u12D9\x07U\x02\x02\u12D9" + - "\u12DA\x07G\x02\x02\u12DA\u03EC\x03\x02\x02\x02\u12DB\u12DC\x07H\x02\x02" + - "\u12DC\u12DD\x07Q\x02\x02\u12DD\u12DE\x07T\x02\x02\u12DE\u12DF\x07G\x02" + - "\x02\u12DF\u12E0\x07C\x02\x02\u12E0\u12E1\x07E\x02\x02\u12E1\u12E2\x07" + - "J\x02\x02\u12E2\u03EE\x03\x02\x02\x02\u12E3\u12E4\x07U\x02\x02\u12E4\u12E5" + - "\x07N\x02\x02\u12E5\u12E6\x07K\x02\x02\u12E6\u12E7\x07E\x02\x02\u12E7" + - "\u12E8\x07G\x02\x02\u12E8\u03F0\x03\x02\x02\x02\u12E9\u12EA\x07G\x02\x02" + - "\u12EA\u12EB\x07Z\x02\x02\u12EB\u12EC\x07K\x02\x02\u12EC\u12ED\x07V\x02" + - "\x02\u12ED\u03F2\x03\x02\x02\x02\u12EE\u12EF\x07T\x02\x02\u12EF\u12F0" + - "\x07G\x02\x02\u12F0\u12F1\x07V\x02\x02\u12F1\u12F2\x07W\x02\x02\u12F2" + - "\u12F3\x07T\x02\x02\u12F3\u12F4\x07P\x02\x02\u12F4\u03F4\x03\x02\x02\x02" + - "\u12F5\u12F6\x07S\x02\x02\u12F6\u12F7\x07W\x02\x02\u12F7\u12F8\x07G\x02" + - "\x02\u12F8\u12F9\x07T\x02\x02\u12F9\u12FA\x07[\x02\x02\u12FA\u03F6\x03" + - "\x02\x02\x02\u12FB\u12FC\x07T\x02\x02\u12FC\u12FD\x07C\x02\x02\u12FD\u12FE" + - "\x07K\x02\x02\u12FE\u12FF\x07U\x02\x02\u12FF\u1300\x07G\x02\x02\u1300" + - "\u03F8\x03\x02\x02\x02\u1301\u1302\x07U\x02\x02\u1302\u1303\x07S\x02\x02" + - "\u1303\u1304\x07N\x02\x02\u1304\u1305\x07U\x02\x02\u1305\u1306\x07V\x02" + - "\x02\u1306\u1307\x07C\x02\x02\u1307\u1308\x07V\x02\x02\u1308\u1309\x07" + - "G\x02\x02\u1309\u03FA\x03\x02\x02\x02\u130A\u130B\x07F\x02\x02\u130B\u130C" + - "\x07G\x02\x02\u130C\u130D\x07D\x02\x02\u130D\u130E\x07W\x02\x02\u130E" + - "\u130F\x07I\x02\x02\u130F\u03FC\x03\x02\x02\x02\u1310\u1311\x07N\x02\x02" + - "\u1311\u1312\x07Q\x02\x02\u1312\u1313\x07I\x02\x02\u1313\u03FE\x03\x02" + - "\x02\x02\u1314\u1315\x07K\x02\x02\u1315\u1316\x07P\x02\x02\u1316\u1317" + - "\x07H\x02\x02\u1317\u1318\x07Q\x02\x02\u1318\u0400\x03\x02\x02\x02\u1319" + - "\u131A\x07P\x02\x02\u131A\u131B\x07Q\x02\x02\u131B\u131C\x07V\x02\x02" + - "\u131C\u131D\x07K\x02\x02\u131D\u131E\x07E\x02\x02\u131E\u131F\x07G\x02" + - "\x02\u131F\u0402\x03\x02\x02\x02\u1320\u1321\x07Y\x02\x02\u1321\u1322" + - "\x07C\x02\x02\u1322\u1323\x07T\x02\x02\u1323\u1324\x07P\x02\x02\u1324" + - "\u1325\x07K\x02\x02\u1325\u1326\x07P\x02\x02\u1326\u1327\x07I\x02\x02" + - "\u1327\u0404\x03\x02\x02\x02\u1328\u1329\x07G\x02\x02\u1329\u132A\x07" + - "Z\x02\x02\u132A\u132B\x07E\x02\x02\u132B\u132C\x07G\x02\x02\u132C\u132D" + - "\x07R\x02\x02\u132D\u132E\x07V\x02\x02\u132E\u132F\x07K\x02\x02\u132F" + - "\u1330\x07Q\x02\x02\u1330\u1331\x07P\x02\x02\u1331\u0406\x03\x02\x02\x02" + - "\u1332\u1333\x07C\x02\x02\u1333\u1334\x07U\x02\x02\u1334\u1335\x07U\x02" + - "\x02\u1335\u1336\x07G\x02\x02\u1336\u1337\x07T\x02\x02\u1337\u1338\x07" + - "V\x02\x02\u1338\u0408\x03\x02\x02\x02\u1339\u133A\x07N\x02\x02\u133A\u133B" + - "\x07Q\x02\x02\u133B\u133C\x07Q\x02\x02\u133C\u133D\x07R\x02\x02\u133D" + - "\u040A\x03\x02\x02\x02\u133E\u133F\x07Q\x02\x02\u133F\u1340\x07R\x02\x02" + - "\u1340\u1341\x07G\x02\x02\u1341\u1342\x07P\x02\x02\u1342\u040C\x03\x02" + - "\x02\x02\u1343\u1347\x05\u040F\u0206\x02\u1344\u1346\x05\u0411\u0207\x02" + - "\u1345\u1344\x03\x02\x02\x02\u1346\u1349\x03\x02\x02\x02\u1347\u1345\x03" + - "\x02\x02\x02\u1347\u1348\x03\x02\x02\x02\u1348\u040E\x03\x02\x02\x02\u1349" + - "\u1347\x03\x02\x02\x02\u134A\u1351\t\x07\x02\x02\u134B\u134C\t\b\x02\x02" + - "\u134C\u1351\x06\u0206\b\x02\u134D\u134E\t\t\x02\x02\u134E\u134F\t\n\x02" + - "\x02\u134F\u1351\x06\u0206\t\x02\u1350\u134A\x03\x02\x02\x02\u1350\u134B" + - "\x03\x02\x02\x02\u1350\u134D\x03\x02\x02\x02\u1351\u0410\x03\x02\x02\x02" + - "\u1352\u1355\x05\u0413\u0208\x02\u1353\u1355\x07&\x02\x02\u1354\u1352" + - "\x03\x02\x02\x02\u1354\u1353\x03\x02\x02\x02\u1355\u0412\x03\x02\x02\x02" + - "\u1356\u1359\x05\u040F\u0206\x02\u1357\u1359\t\x02\x02\x02\u1358\u1356" + - "\x03\x02\x02\x02\u1358\u1357\x03\x02\x02\x02\u1359\u0414\x03\x02\x02\x02" + - "\u135A\u135B\x05\u0417\u020A\x02\u135B\u135C\x07$\x02\x02\u135C\u0416" + - "\x03\x02\x02\x02\u135D\u1363\x07$\x02\x02\u135E\u135F\x07$\x02\x02\u135F" + - "\u1362\x07$\x02\x02\u1360\u1362\n\v\x02\x02\u1361\u135E\x03\x02\x02\x02" + - "\u1361\u1360\x03\x02\x02\x02\u1362\u1365\x03\x02\x02\x02\u1363\u1361\x03" + - "\x02\x02\x02\u1363\u1364\x03\x02\x02\x02\u1364\u0418\x03\x02\x02\x02\u1365" + - "\u1363\x03\x02\x02\x02\u1366\u1367\x05\u041B\u020C\x02\u1367\u1368\x07" + - "$\x02\x02\u1368\u041A\x03\x02\x02\x02\u1369\u136F\x07$\x02\x02\u136A\u136B" + - "\x07$\x02\x02\u136B\u136E\x07$\x02\x02\u136C\u136E\n\f\x02\x02\u136D\u136A" + - "\x03\x02\x02\x02\u136D\u136C\x03\x02\x02\x02\u136E\u1371\x03\x02\x02\x02" + - "\u136F\u136D\x03\x02\x02\x02\u136F\u1370\x03\x02\x02\x02\u1370\u041C\x03" + - "\x02\x02\x02\u1371\u136F\x03\x02\x02\x02\u1372\u1373\x07W\x02\x02\u1373" + - "\u1374\x07(\x02\x02\u1374\u1375\x05\u0415\u0209\x02\u1375\u041E\x03\x02" + - "\x02\x02\u1376\u1377\x07W\x02\x02\u1377\u1378\x07(\x02\x02\u1378\u1379" + - "\x05\u0417\u020A\x02\u1379\u0420\x03\x02\x02\x02\u137A\u137B\x07W\x02" + - "\x02\u137B\u137C\x07(\x02\x02\u137C\u137D\x05\u0419\u020B\x02\u137D\u0422" + - "\x03\x02\x02\x02\u137E\u137F\x07W\x02\x02\u137F\u1380\x07(\x02\x02\u1380" + - "\u1381\x05\u041B\u020C\x02\u1381\u0424\x03\x02\x02\x02\u1382\u1383\x05" + - "\u0427\u0212\x02\u1383\u1384\x07)\x02\x02\u1384\u0426\x03\x02\x02\x02" + - "\u1385\u138B\x07)\x02\x02\u1386\u1387\x07)\x02\x02\u1387\u138A\x07)\x02" + - "\x02\u1388\u138A\n\r\x02\x02\u1389\u1386\x03\x02\x02\x02\u1389\u1388\x03" + - "\x02\x02\x02\u138A\u138D\x03\x02\x02\x02\u138B\u1389\x03\x02\x02\x02\u138B" + - "\u138C\x03\x02\x02\x02\u138C\u0428\x03\x02\x02\x02\u138D\u138B\x03\x02" + - "\x02\x02\u138E\u138F\x07G\x02\x02\u138F\u1390\x07)\x02\x02\u1390\u1391" + - "\x03\x02\x02\x02\u1391\u1392\b\u0213\x04\x02\u1392\u1393\b\u0213\x05\x02" + - "\u1393\u042A\x03\x02\x02\x02\u1394\u1395\x05\u042D\u0215\x02\u1395\u1396" + - "\x07)\x02\x02\u1396\u042C\x03\x02\x02\x02\u1397\u1398\x07W\x02\x02\u1398" + - "\u1399\x07(\x02\x02\u1399\u139A\x05\u0427\u0212\x02\u139A\u042E\x03\x02" + - "\x02\x02\u139B\u139D\x07&\x02\x02\u139C\u139E\x05\u0431\u0217\x02\u139D" + - "\u139C\x03\x02\x02\x02\u139D\u139E\x03\x02\x02\x02\u139E\u139F\x03\x02" + - "\x02\x02\u139F\u13A0\x07&\x02\x02\u13A0\u13A1\b\u0216\x06\x02\u13A1\u13A2" + - "\x03\x02\x02\x02\u13A2\u13A3\b\u0216\x07\x02\u13A3\u0430\x03\x02\x02\x02" + - "\u13A4\u13A8\x05\u040F\u0206\x02\u13A5\u13A7\x05\u0413\u0208\x02\u13A6" + - "\u13A5\x03\x02\x02\x02\u13A7\u13AA\x03\x02\x02\x02\u13A8\u13A6\x03\x02" + - "\x02\x02\u13A8\u13A9\x03\x02\x02\x02\u13A9\u0432\x03\x02\x02\x02\u13AA" + - "\u13A8\x03\x02\x02\x02\u13AB\u13AC\x05\u0435\u0219\x02\u13AC\u13AD\x07" + - ")\x02\x02\u13AD\u0434\x03\x02\x02\x02\u13AE\u13AF\x07D\x02\x02\u13AF\u13B3" + - "\x07)\x02\x02\u13B0\u13B2\t\x0E\x02\x02\u13B1\u13B0\x03\x02\x02\x02\u13B2" + - "\u13B5\x03\x02\x02\x02\u13B3\u13B1\x03\x02\x02\x02\u13B3\u13B4\x03\x02" + - "\x02\x02\u13B4\u0436\x03\x02\x02\x02\u13B5\u13B3\x03\x02\x02\x02\u13B6" + - "\u13B7\x05\u0439\u021B\x02\u13B7\u13B8\x07)\x02\x02\u13B8\u0438\x03\x02" + - "\x02\x02\u13B9\u13BA\x07D\x02\x02\u13BA\u13BB\x05\u0427\u0212\x02\u13BB" + - "\u043A\x03\x02\x02\x02\u13BC\u13BD\x05\u043D\u021D\x02\u13BD\u13BE\x07" + - ")\x02\x02\u13BE\u043C\x03\x02\x02\x02\u13BF\u13C0\x07Z\x02\x02\u13C0\u13C4" + - "\x07)\x02\x02\u13C1\u13C3\t\x0F\x02\x02\u13C2\u13C1\x03\x02\x02\x02\u13C3" + - "\u13C6\x03\x02\x02\x02\u13C4\u13C2\x03\x02\x02\x02\u13C4\u13C5\x03\x02" + - "\x02\x02\u13C5\u043E\x03\x02\x02\x02\u13C6\u13C4\x03\x02\x02\x02\u13C7" + - "\u13C8\x05\u0441\u021F\x02\u13C8\u13C9\x07)\x02\x02\u13C9\u0440\x03\x02" + - "\x02\x02\u13CA\u13CB\x07Z\x02\x02\u13CB\u13CC\x05\u0427\u0212\x02\u13CC" + - "\u0442\x03\x02\x02\x02\u13CD\u13CE\x05\u0449\u0223\x02\u13CE\u0444\x03" + - "\x02\x02\x02\u13CF\u13D0\x05\u0449\u0223\x02\u13D0\u13D1\x070\x02\x02" + - "\u13D1\u13D2\x070\x02\x02\u13D2\u13D3\x03\x02\x02\x02\u13D3\u13D4\b\u0221" + - "\b\x02\u13D4\u0446\x03\x02\x02\x02\u13D5\u13D6\x05\u0449\u0223\x02\u13D6" + - "\u13D8\x070\x02\x02\u13D7\u13D9\x05\u0449\u0223\x02\u13D8\u13D7\x03\x02" + - "\x02\x02\u13D8\u13D9\x03\x02\x02\x02\u13D9\u13DF\x03\x02\x02\x02\u13DA" + - "\u13DC\x07G\x02\x02\u13DB\u13DD\t\x03\x02\x02\u13DC\u13DB\x03\x02\x02" + - "\x02\u13DC\u13DD\x03\x02\x02\x02\u13DD\u13DE\x03\x02\x02\x02\u13DE\u13E0" + - "\x05\u0449\u0223\x02\u13DF\u13DA\x03\x02\x02\x02\u13DF\u13E0\x03\x02\x02" + - "\x02\u13E0\u13F2\x03\x02\x02\x02\u13E1\u13E2\x070\x02\x02\u13E2\u13E8" + - "\x05\u0449\u0223\x02\u13E3\u13E5\x07G\x02\x02\u13E4\u13E6\t\x03\x02\x02" + - "\u13E5\u13E4\x03\x02\x02\x02\u13E5\u13E6\x03\x02\x02\x02\u13E6\u13E7\x03" + - "\x02\x02\x02\u13E7\u13E9\x05\u0449\u0223\x02\u13E8\u13E3\x03\x02\x02\x02" + - "\u13E8\u13E9\x03\x02\x02\x02\u13E9\u13F2\x03\x02\x02\x02\u13EA\u13EB\x05" + - "\u0449\u0223\x02\u13EB\u13ED\x07G\x02\x02\u13EC\u13EE\t\x03\x02\x02\u13ED" + - "\u13EC\x03\x02\x02\x02\u13ED\u13EE\x03\x02\x02\x02\u13EE\u13EF\x03\x02" + - "\x02\x02\u13EF\u13F0\x05\u0449\u0223\x02\u13F0\u13F2\x03\x02\x02\x02\u13F1" + - "\u13D5\x03\x02\x02\x02\u13F1\u13E1\x03\x02\x02\x02\u13F1\u13EA\x03\x02" + - "\x02\x02\u13F2\u0448\x03\x02\x02\x02\u13F3\u13F5\t\x02\x02\x02\u13F4\u13F3" + - "\x03\x02\x02\x02\u13F5\u13F6\x03\x02\x02\x02\u13F6\u13F4\x03\x02\x02\x02" + - "\u13F6\u13F7\x03\x02\x02\x02\u13F7\u044A\x03\x02\x02\x02\u13F8\u13F9\x07" + - "<\x02\x02\u13F9\u13FD\t\x10\x02\x02\u13FA\u13FC\t\x11\x02\x02\u13FB\u13FA" + - "\x03\x02\x02\x02\u13FC\u13FF\x03\x02\x02\x02\u13FD\u13FB\x03\x02\x02\x02" + - "\u13FD\u13FE\x03\x02\x02\x02\u13FE\u044C\x03\x02\x02\x02\u13FF\u13FD\x03" + - "\x02\x02\x02\u1400\u1401\x07<\x02\x02\u1401\u1402\x07$\x02\x02\u1402\u140A" + - "\x03\x02\x02\x02\u1403\u1404\x07^\x02\x02\u1404\u1409\v\x02\x02\x02\u1405" + - "\u1406\x07$\x02\x02\u1406\u1409\x07$\x02\x02\u1407\u1409\n\x12\x02\x02" + - "\u1408\u1403\x03\x02\x02\x02\u1408\u1405\x03\x02\x02\x02\u1408\u1407\x03" + - "\x02\x02\x02\u1409\u140C\x03\x02\x02\x02\u140A\u1408\x03\x02\x02\x02\u140A" + - "\u140B\x03\x02\x02\x02\u140B\u140D\x03\x02\x02\x02\u140C\u140A\x03\x02" + - "\x02\x02\u140D\u140E\x07$\x02\x02\u140E\u044E\x03\x02\x02\x02\u140F\u1411" + - "\t\x13\x02\x02\u1410\u140F\x03\x02\x02\x02\u1411\u1412\x03\x02\x02\x02" + - "\u1412\u1410\x03\x02\x02\x02\u1412\u1413\x03\x02\x02\x02\u1413\u1414\x03" + - "\x02\x02\x02\u1414\u1415\b\u0226\t\x02\u1415\u0450\x03\x02\x02\x02\u1416" + - "\u1418\x07\x0F\x02\x02\u1417\u1419\x07\f\x02\x02\u1418\u1417\x03\x02\x02" + - "\x02\u1418\u1419\x03\x02\x02\x02\u1419\u141C\x03\x02\x02\x02\u141A\u141C" + - "\x07\f\x02\x02\u141B\u1416\x03\x02\x02\x02\u141B\u141A\x03\x02\x02\x02" + - "\u141C\u141D\x03\x02\x02\x02\u141D\u141E\b\u0227\t\x02\u141E\u0452\x03" + - "\x02\x02\x02\u141F\u1420\x07/\x02\x02\u1420\u1421\x07/\x02\x02\u1421\u1425" + - "\x03\x02\x02\x02\u1422\u1424\n\x14\x02\x02\u1423\u1422\x03\x02\x02\x02" + - "\u1424\u1427\x03\x02\x02\x02\u1425\u1423\x03\x02\x02\x02\u1425\u1426\x03" + - "\x02\x02\x02\u1426\u1428\x03\x02\x02\x02\u1427\u1425\x03\x02\x02\x02\u1428" + - "\u1429\b\u0228\t\x02\u1429\u0454\x03\x02\x02\x02\u142A\u142B\x071\x02" + - "\x02\u142B\u142C\x07,\x02\x02\u142C\u1443\x03\x02\x02\x02\u142D\u142F" + - "\x071\x02\x02\u142E\u142D\x03\x02\x02\x02\u142F\u1432\x03\x02\x02\x02" + - "\u1430\u142E\x03\x02\x02\x02\u1430\u1431\x03\x02\x02\x02\u1431\u1433\x03" + - "\x02\x02\x02\u1432\u1430\x03\x02\x02\x02\u1433\u1442\x05\u0455\u0229\x02" + - "\u1434\u1442\n\x15\x02\x02\u1435\u1437\x071\x02\x02\u1436\u1435\x03\x02" + - "\x02\x02\u1437\u1438\x03\x02\x02\x02\u1438\u1436\x03\x02\x02\x02\u1438" + - "\u1439\x03\x02\x02\x02\u1439\u143A\x03\x02\x02\x02\u143A\u1442\n\x15\x02" + - "\x02\u143B\u143D\x07,\x02\x02\u143C\u143B\x03\x02\x02\x02\u143D\u143E" + - "\x03\x02\x02\x02\u143E\u143C\x03\x02\x02\x02\u143E\u143F\x03\x02\x02\x02" + - "\u143F\u1440\x03\x02\x02\x02\u1440\u1442\n\x15\x02\x02\u1441\u1430\x03" + - "\x02\x02\x02\u1441\u1434\x03\x02\x02\x02\u1441\u1436\x03\x02\x02\x02\u1441" + - "\u143C\x03\x02\x02\x02\u1442\u1445\x03\x02\x02\x02\u1443\u1441\x03\x02" + - "\x02\x02\u1443\u1444\x03\x02\x02\x02\u1444\u1449\x03\x02\x02\x02\u1445" + - "\u1443\x03\x02\x02\x02\u1446\u1448\x07,\x02\x02\u1447\u1446\x03\x02\x02" + - "\x02\u1448\u144B\x03\x02\x02\x02\u1449\u1447\x03\x02\x02\x02\u1449\u144A" + - "\x03\x02\x02\x02\u144A\u144C\x03\x02\x02\x02\u144B\u1449\x03\x02\x02\x02" + - "\u144C\u144D\x07,\x02\x02\u144D\u144E\x071\x02\x02\u144E\u144F\x03\x02" + - "\x02\x02\u144F\u1450\b\u0229\t\x02\u1450\u0456\x03\x02\x02\x02\u1451\u1452" + - "\x071\x02\x02\u1452\u1453\x07,\x02\x02\u1453\u146C\x03\x02\x02\x02\u1454" + - "\u1456\x071\x02\x02\u1455\u1454\x03\x02\x02\x02\u1456\u1459\x03\x02\x02" + - "\x02\u1457\u1455\x03\x02\x02\x02\u1457\u1458\x03\x02\x02\x02\u1458\u145A" + - "\x03\x02\x02\x02\u1459\u1457\x03\x02\x02\x02\u145A\u146B\x05\u0455\u0229" + - "\x02\u145B\u146B\n\x15\x02\x02\u145C\u145E\x071\x02\x02\u145D\u145C\x03" + - "\x02\x02\x02\u145E\u145F\x03\x02\x02\x02\u145F\u145D\x03\x02\x02\x02\u145F" + - "\u1460\x03\x02\x02\x02\u1460\u1461\x03\x02\x02\x02\u1461\u1469\n\x15\x02" + - "\x02\u1462\u1464\x07,\x02\x02\u1463\u1462\x03\x02\x02\x02\u1464\u1465" + - "\x03\x02\x02\x02\u1465\u1463\x03\x02\x02\x02\u1465\u1466\x03\x02\x02\x02" + - "\u1466\u1467\x03\x02\x02\x02\u1467\u1469\n\x15\x02\x02\u1468\u145D\x03" + - "\x02\x02\x02\u1468\u1463\x03\x02\x02\x02\u1469\u146B\x03\x02\x02\x02\u146A" + - "\u1457\x03\x02\x02\x02\u146A\u145B\x03\x02\x02\x02\u146A\u1468\x03\x02" + - "\x02\x02\u146B\u146E\x03\x02\x02\x02\u146C\u146A\x03\x02\x02\x02\u146C" + - "\u146D\x03\x02\x02\x02\u146D\u1480\x03\x02\x02\x02\u146E\u146C\x03\x02" + - "\x02\x02\u146F\u1471\x071\x02\x02\u1470\u146F\x03\x02\x02\x02\u1471\u1472" + - "\x03\x02\x02\x02\u1472\u1470\x03\x02\x02\x02\u1472\u1473\x03\x02\x02\x02" + - "\u1473\u1481\x03\x02\x02\x02\u1474\u1476\x07,\x02\x02\u1475\u1474\x03" + - "\x02\x02\x02\u1476\u1477\x03\x02\x02\x02\u1477\u1475\x03\x02\x02\x02\u1477" + - "\u1478\x03\x02\x02\x02\u1478\u1481\x03\x02\x02\x02\u1479\u147B\x071\x02" + - "\x02\u147A\u1479\x03\x02\x02\x02\u147B\u147E\x03\x02\x02\x02\u147C\u147A" + - "\x03\x02\x02\x02\u147C\u147D\x03\x02\x02\x02\u147D\u147F\x03\x02\x02\x02" + - "\u147E\u147C\x03\x02\x02\x02\u147F\u1481\x05\u0457\u022A\x02\u1480\u1470" + - "\x03\x02\x02\x02\u1480\u1475\x03\x02\x02\x02\u1480\u147C\x03\x02\x02\x02" + - "\u1480\u1481\x03\x02\x02\x02\u1481\u1482\x03\x02\x02\x02\u1482\u1483\b" + - "\u022A\n\x02\u1483\u0458\x03\x02\x02\x02\u1484\u1490\x07^\x02\x02\u1485" + - "\u148F\n\x16\x02\x02\u1486\u148A\x07$\x02\x02\u1487\u1489\n\x17\x02\x02" + - "\u1488\u1487\x03\x02\x02\x02\u1489\u148C\x03\x02\x02\x02\u148A\u1488\x03" + - "\x02\x02\x02\u148A\u148B\x03\x02\x02\x02\u148B\u148D\x03\x02\x02\x02\u148C" + - "\u148A\x03\x02\x02\x02\u148D\u148F\x07$\x02\x02\u148E\u1485\x03\x02\x02" + - "\x02\u148E\u1486\x03\x02\x02\x02\u148F\u1492\x03\x02\x02\x02\u1490\u148E" + - "\x03\x02\x02\x02\u1490\u1491\x03\x02\x02\x02\u1491\u149A\x03\x02\x02\x02" + - "\u1492\u1490\x03\x02\x02\x02\u1493\u1497\x07$\x02\x02\u1494\u1496\n\x17" + - "\x02\x02\u1495\u1494\x03\x02\x02\x02\u1496\u1499\x03\x02\x02\x02\u1497" + - "\u1495\x03\x02\x02\x02\u1497\u1498\x03\x02\x02\x02\u1498\u149B\x03\x02" + - "\x02\x02\u1499\u1497\x03\x02\x02\x02\u149A\u1493\x03\x02\x02\x02\u149A" + - "\u149B\x03\x02\x02\x02\u149B\u045A\x03\x02\x02\x02\u149C\u149D\x07^\x02" + - "\x02\u149D\u149E\x07^\x02\x02\u149E\u045C\x03\x02\x02\x02\u149F\u14A0" + - "\v\x02\x02\x02\u14A0\u045E\x03\x02\x02\x02\u14A1\u14A2\x05\u0463\u0230" + - "\x02\u14A2\u14A3\x07)\x02\x02\u14A3\u14A4\x03\x02\x02\x02\u14A4\u14A5" + - "\b\u022E\v\x02\u14A5\u0460\x03\x02\x02\x02\u14A6\u14A8\x05\u0463\u0230" + - "\x02\u14A7\u14A9\x07^\x02\x02\u14A8\u14A7\x03\x02\x02\x02\u14A8\u14A9" + - "\x03\x02\x02\x02\u14A9\u14AA\x03\x02\x02\x02\u14AA\u14AB\x07\x02\x02\x03" + - "\u14AB\u0462\x03\x02\x02\x02\u14AC\u14AD\x07)\x02\x02\u14AD\u14C4\x07" + - ")\x02\x02\u14AE\u14C0\x07^\x02\x02\u14AF\u14B0\x07z\x02\x02\u14B0\u14C1" + - "\t\x0F\x02\x02\u14B1\u14B2\x07w\x02\x02\u14B2\u14B3\t\x0F\x02\x02\u14B3" + - "\u14B4\t\x0F\x02\x02\u14B4\u14B5\t\x0F\x02\x02\u14B5\u14C1\t\x0F\x02\x02" + - "\u14B6\u14B7\x07W\x02\x02\u14B7\u14B8\t\x0F\x02\x02\u14B8\u14B9\t\x0F" + - "\x02\x02\u14B9\u14BA\t\x0F\x02\x02\u14BA\u14BB\t\x0F\x02\x02\u14BB\u14BC" + - "\t\x0F\x02\x02\u14BC\u14BD\t\x0F\x02\x02\u14BD\u14BE\t\x0F\x02\x02\u14BE" + - "\u14C1"; + "\u1185\u1186\x07P\x02\x02\u1186\u1187\x07I\x02\x02\u1187\u038C\x03\x02" + + "\x02\x02\u1188\u1189\x07P\x02\x02\u1189\u118A\x07G\x02\x02\u118A\u118B" + + "\x07Y\x02\x02\u118B\u038E\x03\x02\x02\x02\u118C\u118D\x07Q\x02\x02\u118D" + + "\u118E\x07N\x02\x02\u118E\u118F\x07F\x02\x02\u118F\u0390\x03\x02\x02\x02" + + "\u1190\u1191\x07X\x02\x02\u1191\u1192\x07C\x02\x02\u1192\u1193\x07N\x02" + + "\x02\u1193\u1194\x07W\x02\x02\u1194\u1195\x07G\x02\x02\u1195\u0392\x03" + + "\x02\x02\x02\u1196\u1197\x07U\x02\x02\u1197\u1198\x07W\x02\x02\u1198\u1199" + + "\x07D\x02\x02\u1199\u119A\x07U\x02\x02\u119A\u119B\x07E\x02\x02\u119B" + + "\u119C\x07T\x02\x02\u119C\u119D\x07K\x02\x02\u119D\u119E\x07R\x02\x02" + + "\u119E\u119F\x07V\x02\x02\u119F\u11A0\x07K\x02\x02\u11A0\u11A1\x07Q\x02" + + "\x02\u11A1\u11A2\x07P\x02\x02\u11A2\u0394\x03\x02\x02\x02\u11A3\u11A4" + + "\x07R\x02\x02\u11A4\u11A5\x07W\x02\x02\u11A5\u11A6\x07D\x02\x02\u11A6" + + "\u11A7\x07N\x02\x02\u11A7\u11A8\x07K\x02\x02\u11A8\u11A9\x07E\x02\x02" + + "\u11A9\u11AA\x07C\x02\x02\u11AA\u11AB\x07V\x02\x02\u11AB\u11AC\x07K\x02" + + "\x02\u11AC\u11AD\x07Q\x02\x02\u11AD\u11AE\x07P\x02\x02\u11AE\u0396\x03" + + "\x02\x02\x02\u11AF\u11B0\x07Q\x02\x02\u11B0\u11B1\x07W\x02\x02\u11B1\u11B2" + + "\x07V\x02\x02\u11B2\u0398\x03\x02\x02\x02\u11B3\u11B4\x07G\x02\x02\u11B4" + + "\u11B5\x07P\x02\x02\u11B5\u11B6\x07F\x02\x02\u11B6\u039A\x03\x02\x02\x02" + + "\u11B7\u11B8\x07T\x02\x02\u11B8\u11B9\x07Q\x02\x02\u11B9\u11BA\x07W\x02" + + "\x02\u11BA\u11BB\x07V\x02\x02\u11BB\u11BC\x07K\x02\x02\u11BC\u11BD\x07" + + "P\x02\x02\u11BD\u11BE\x07G\x02\x02\u11BE\u11BF\x07U\x02\x02\u11BF\u039C" + + "\x03\x02\x02\x02\u11C0\u11C1\x07U\x02\x02\u11C1\u11C2\x07E\x02\x02\u11C2" + + "\u11C3\x07J\x02\x02\u11C3\u11C4\x07G\x02\x02\u11C4\u11C5\x07O\x02\x02" + + "\u11C5\u11C6\x07C\x02\x02\u11C6\u11C7\x07U\x02\x02\u11C7\u039E\x03\x02" + + "\x02\x02\u11C8\u11C9\x07R\x02\x02\u11C9\u11CA\x07T\x02\x02\u11CA\u11CB" + + "\x07Q\x02\x02\u11CB\u11CC\x07E\x02\x02\u11CC\u11CD\x07G\x02\x02\u11CD" + + "\u11CE\x07F\x02\x02\u11CE\u11CF\x07W\x02\x02\u11CF\u11D0\x07T\x02\x02" + + "\u11D0\u11D1\x07G\x02\x02\u11D1\u11D2\x07U\x02\x02\u11D2\u03A0\x03\x02" + + "\x02\x02\u11D3\u11D4\x07K\x02\x02\u11D4\u11D5\x07P\x02\x02\u11D5\u11D6" + + "\x07R\x02\x02\u11D6\u11D7\x07W\x02\x02\u11D7\u11D8\x07V\x02\x02\u11D8" + + "\u03A2\x03\x02\x02\x02\u11D9\u11DA\x07U\x02\x02\u11DA\u11DB\x07W\x02\x02" + + "\u11DB\u11DC\x07R\x02\x02\u11DC\u11DD\x07R\x02\x02\u11DD\u11DE\x07Q\x02" + + "\x02\u11DE\u11DF\x07T\x02\x02\u11DF\u11E0\x07V\x02\x02\u11E0\u03A4\x03" + + "\x02\x02\x02\u11E1\u11E2\x07R\x02\x02\u11E2\u11E3\x07C\x02\x02\u11E3\u11E4" + + "\x07T\x02\x02\u11E4\u11E5\x07C\x02\x02\u11E5\u11E6\x07N\x02\x02\u11E6" + + "\u11E7\x07N\x02\x02\u11E7\u11E8\x07G\x02\x02\u11E8\u11E9\x07N\x02\x02" + + "\u11E9\u03A6\x03\x02\x02\x02\u11EA\u11EB\x07U\x02\x02\u11EB\u11EC\x07" + + "S\x02\x02\u11EC\u11ED\x07N\x02\x02\u11ED\u03A8\x03\x02\x02\x02\u11EE\u11EF" + + "\x07F\x02\x02\u11EF\u11F0\x07G\x02\x02\u11F0\u11F1\x07R\x02\x02\u11F1" + + "\u11F2\x07G\x02\x02\u11F2\u11F3\x07P\x02\x02\u11F3\u11F4\x07F\x02\x02" + + "\u11F4\u11F5\x07U\x02\x02\u11F5\u03AA\x03\x02\x02\x02\u11F6\u11F7\x07" + + "Q\x02\x02\u11F7\u11F8\x07X\x02\x02\u11F8\u11F9\x07G\x02\x02\u11F9\u11FA" + + "\x07T\x02\x02\u11FA\u11FB\x07T\x02\x02\u11FB\u11FC\x07K\x02\x02\u11FC" + + "\u11FD\x07F\x02\x02\u11FD\u11FE\x07K\x02\x02\u11FE\u11FF\x07P\x02\x02" + + "\u11FF\u1200\x07I\x02\x02\u1200\u03AC\x03\x02\x02\x02\u1201\u1202\x07" + + "E\x02\x02\u1202\u1203\x07Q\x02\x02\u1203\u1204\x07P\x02\x02\u1204\u1205" + + "\x07H\x02\x02\u1205\u1206\x07N\x02\x02\u1206\u1207\x07K\x02\x02\u1207" + + "\u1208\x07E\x02\x02\u1208\u1209\x07V\x02\x02\u1209\u03AE\x03\x02\x02\x02" + + "\u120A\u120B\x07U\x02\x02\u120B\u120C\x07M\x02\x02\u120C\u120D\x07K\x02" + + "\x02\u120D\u120E\x07R\x02\x02\u120E\u03B0\x03\x02\x02\x02\u120F\u1210" + + "\x07N\x02\x02\u1210\u1211\x07Q\x02\x02\u1211\u1212\x07E\x02\x02\u1212" + + "\u1213\x07M\x02\x02\u1213\u1214\x07G\x02\x02\u1214\u1215\x07F\x02\x02" + + "\u1215\u03B2\x03\x02\x02\x02\u1216\u1217\x07V\x02\x02\u1217\u1218\x07" + + "K\x02\x02\u1218\u1219\x07G\x02\x02\u1219\u121A\x07U\x02\x02\u121A\u03B4" + + "\x03\x02\x02\x02\u121B\u121C\x07T\x02\x02\u121C\u121D\x07Q\x02\x02\u121D" + + "\u121E\x07N\x02\x02\u121E\u121F\x07N\x02\x02\u121F\u1220\x07W\x02\x02" + + "\u1220\u1221\x07R\x02\x02\u1221\u03B6\x03\x02\x02\x02\u1222\u1223\x07" + + "E\x02\x02\u1223\u1224\x07W\x02\x02\u1224\u1225\x07D\x02\x02\u1225\u1226" + + "\x07G\x02\x02\u1226\u03B8\x03\x02\x02\x02\u1227\u1228\x07I\x02\x02\u1228" + + "\u1229\x07T\x02\x02\u1229\u122A\x07Q\x02\x02\u122A\u122B\x07W\x02\x02" + + "\u122B\u122C\x07R\x02\x02\u122C\u122D\x07K\x02\x02\u122D\u122E\x07P\x02" + + "\x02\u122E\u122F\x07I\x02\x02\u122F\u03BA\x03\x02\x02\x02\u1230\u1231" + + "\x07U\x02\x02\u1231\u1232\x07G\x02\x02\u1232\u1233\x07V\x02\x02\u1233" + + "\u1234\x07U\x02\x02\u1234\u03BC\x03\x02\x02\x02\u1235\u1236\x07V\x02\x02" + + "\u1236\u1237\x07C\x02\x02\u1237\u1238\x07D\x02\x02\u1238\u1239\x07N\x02" + + "\x02\u1239\u123A\x07G\x02\x02\u123A\u123B\x07U\x02\x02\u123B\u123C\x07" + + "C\x02\x02\u123C\u123D\x07O\x02\x02\u123D\u123E\x07R\x02\x02\u123E\u123F" + + "\x07N\x02\x02\u123F\u1240\x07G\x02\x02\u1240\u03BE\x03\x02\x02\x02\u1241" + + "\u1242\x07Q\x02\x02\u1242\u1243\x07T\x02\x02\u1243\u1244\x07F\x02\x02" + + "\u1244\u1245\x07K\x02\x02\u1245\u1246\x07P\x02\x02\u1246\u1247\x07C\x02" + + "\x02\u1247\u1248\x07N\x02\x02\u1248\u1249\x07K\x02\x02\u1249\u124A\x07" + + "V\x02\x02\u124A\u124B\x07[\x02\x02\u124B\u03C0\x03\x02\x02\x02\u124C\u124D" + + "\x07Z\x02\x02\u124D\u124E\x07O\x02\x02\u124E\u124F\x07N\x02\x02\u124F" + + "\u1250\x07V\x02\x02\u1250\u1251\x07C\x02\x02\u1251\u1252\x07D\x02\x02" + + "\u1252\u1253\x07N\x02\x02\u1253\u1254\x07G\x02\x02\u1254\u03C2\x03\x02" + + "\x02\x02\u1255\u1256\x07E\x02\x02\u1256\u1257\x07Q\x02\x02\u1257\u1258" + + "\x07N\x02\x02\u1258\u1259\x07W\x02\x02\u1259\u125A\x07O\x02\x02\u125A" + + "\u125B\x07P\x02\x02\u125B\u125C\x07U\x02\x02\u125C\u03C4\x03\x02\x02\x02" + + "\u125D\u125E\x07Z\x02\x02\u125E\u125F\x07O\x02\x02\u125F\u1260\x07N\x02" + + "\x02\u1260\u1261\x07P\x02\x02\u1261\u1262\x07C\x02\x02\u1262\u1263\x07" + + "O\x02\x02\u1263\u1264\x07G\x02\x02\u1264\u1265\x07U\x02\x02\u1265\u1266" + + "\x07R\x02\x02\u1266\u1267\x07C\x02\x02\u1267\u1268\x07E\x02\x02\u1268" + + "\u1269\x07G\x02\x02\u1269\u126A\x07U\x02\x02\u126A\u03C6\x03\x02\x02\x02" + + "\u126B\u126C\x07T\x02\x02\u126C\u126D\x07Q\x02\x02\u126D\u126E\x07Y\x02" + + "\x02\u126E\u126F\x07V\x02\x02\u126F\u1270\x07[\x02\x02\u1270\u1271\x07" + + "R\x02\x02\u1271\u1272\x07G\x02\x02\u1272\u03C8\x03\x02\x02\x02\u1273\u1274" + + "\x07P\x02\x02\u1274\u1275\x07Q\x02\x02\u1275\u1276\x07T\x02\x02\u1276" + + "\u1277\x07O\x02\x02\u1277\u1278\x07C\x02\x02\u1278\u1279\x07N\x02\x02" + + "\u1279\u127A\x07K\x02\x02\u127A\u127B\x07\\\x02\x02\u127B\u127C\x07G\x02" + + "\x02\u127C\u127D\x07F\x02\x02\u127D\u03CA\x03\x02\x02\x02\u127E\u127F" + + "\x07Y\x02\x02\u127F\u1280\x07K\x02\x02\u1280\u1281\x07V\x02\x02\u1281" + + "\u1282\x07J\x02\x02\u1282\u1283\x07K\x02\x02\u1283\u1284\x07P\x02\x02" + + "\u1284\u03CC\x03\x02\x02\x02\u1285\u1286\x07H\x02\x02\u1286\u1287\x07" + + "K\x02\x02\u1287\u1288\x07N\x02\x02\u1288\u1289\x07V\x02\x02\u1289\u128A" + + "\x07G\x02\x02\u128A\u128B\x07T\x02\x02\u128B\u03CE\x03\x02\x02\x02\u128C" + + "\u128D\x07I\x02\x02\u128D\u128E\x07T\x02\x02\u128E\u128F\x07Q\x02\x02" + + "\u128F\u1290\x07W\x02\x02\u1290\u1291\x07R\x02\x02\u1291\u1292\x07U\x02" + + "\x02\u1292\u03D0\x03\x02\x02\x02\u1293\u1294\x07Q\x02\x02\u1294\u1295" + + "\x07V\x02\x02\u1295\u1296\x07J\x02\x02\u1296\u1297\x07G\x02\x02\u1297" + + "\u1298\x07T\x02\x02\u1298\u1299\x07U\x02\x02\u1299\u03D2\x03\x02\x02\x02" + + "\u129A\u129B\x07P\x02\x02\u129B\u129C\x07H\x02\x02\u129C\u129D\x07E\x02" + + "\x02\u129D\u03D4\x03\x02\x02\x02\u129E\u129F\x07P\x02\x02\u129F\u12A0" + + "\x07H\x02\x02\u12A0\u12A1\x07F\x02\x02\u12A1\u03D6\x03\x02\x02\x02\u12A2" + + "\u12A3\x07P\x02\x02\u12A3\u12A4\x07H\x02\x02\u12A4\u12A5\x07M\x02\x02" + + "\u12A5\u12A6\x07E\x02\x02\u12A6\u03D8\x03\x02\x02\x02\u12A7\u12A8\x07" + + "P\x02\x02\u12A8\u12A9\x07H\x02\x02\u12A9\u12AA\x07M\x02\x02\u12AA\u12AB" + + "\x07F\x02\x02\u12AB\u03DA\x03\x02\x02\x02\u12AC\u12AD\x07W\x02\x02\u12AD" + + "\u12AE\x07G\x02\x02\u12AE\u12AF\x07U\x02\x02\u12AF\u12B0\x07E\x02\x02" + + "\u12B0\u12B1\x07C\x02\x02\u12B1\u12B2\x07R\x02\x02\u12B2\u12B3\x07G\x02" + + "\x02\u12B3\u03DC\x03\x02\x02\x02\u12B4\u12B5\x07X\x02\x02\u12B5\u12B6" + + "\x07K\x02\x02\u12B6\u12B7\x07G\x02\x02\u12B7\u12B8\x07Y\x02\x02\u12B8" + + "\u12B9\x07U\x02\x02\u12B9\u03DE\x03\x02\x02\x02\u12BA\u12BB\x07P\x02\x02" + + "\u12BB\u12BC\x07Q\x02\x02\u12BC\u12BD\x07T\x02\x02\u12BD\u12BE\x07O\x02" + + "\x02\u12BE\u12BF\x07C\x02\x02\u12BF\u12C0\x07N\x02\x02\u12C0\u12C1\x07" + + "K\x02\x02\u12C1\u12C2\x07\\\x02\x02\u12C2\u12C3\x07G\x02\x02\u12C3\u03E0" + + "\x03\x02\x02\x02\u12C4\u12C5\x07F\x02\x02\u12C5\u12C6\x07W\x02\x02\u12C6" + + "\u12C7\x07O\x02\x02\u12C7\u12C8\x07R\x02\x02\u12C8\u03E2\x03\x02\x02\x02" + + "\u12C9\u12CA\x07R\x02\x02\u12CA\u12CB\x07T\x02\x02\u12CB\u12CC\x07K\x02" + + "\x02\u12CC\u12CD\x07P\x02\x02\u12CD\u12CE\x07V\x02\x02\u12CE\u12CF\x07" + + "a\x02\x02\u12CF\u12D0\x07U\x02\x02\u12D0\u12D1\x07V\x02\x02\u12D1\u12D2" + + "\x07T\x02\x02\u12D2\u12D3\x07K\x02\x02\u12D3\u12D4\x07E\x02\x02\u12D4" + + "\u12D5\x07V\x02\x02\u12D5\u12D6\x07a\x02\x02\u12D6\u12D7\x07R\x02\x02" + + "\u12D7\u12D8\x07C\x02\x02\u12D8\u12D9\x07T\x02\x02\u12D9\u12DA\x07C\x02" + + "\x02\u12DA\u12DB\x07O\x02\x02\u12DB\u12DC\x07U\x02\x02\u12DC\u03E4\x03" + + "\x02\x02\x02\u12DD\u12DE\x07X\x02\x02\u12DE\u12DF\x07C\x02\x02\u12DF\u12E0" + + "\x07T\x02\x02\u12E0\u12E1\x07K\x02\x02\u12E1\u12E2\x07C\x02\x02\u12E2" + + "\u12E3\x07D\x02\x02\u12E3\u12E4\x07N\x02\x02\u12E4\u12E5\x07G\x02\x02" + + "\u12E5\u12E6\x07a\x02\x02\u12E6\u12E7\x07E\x02\x02\u12E7\u12E8\x07Q\x02" + + "\x02\u12E8\u12E9\x07P\x02\x02\u12E9\u12EA\x07H\x02\x02\u12EA\u12EB\x07" + + "N\x02\x02\u12EB\u12EC\x07K\x02\x02\u12EC\u12ED\x07E\x02\x02\u12ED\u12EE" + + "\x07V\x02\x02\u12EE\u03E6\x03\x02\x02\x02\u12EF\u12F0\x07G\x02\x02\u12F0" + + "\u12F1\x07T\x02\x02\u12F1\u12F2\x07T\x02\x02\u12F2\u12F3\x07Q\x02\x02" + + "\u12F3\u12F4\x07T\x02\x02\u12F4\u03E8\x03\x02\x02\x02\u12F5\u12F6\x07" + + "W\x02\x02\u12F6\u12F7\x07U\x02\x02\u12F7\u12F8\x07G\x02\x02\u12F8\u12F9" + + "\x07a\x02\x02\u12F9\u12FA\x07X\x02\x02\u12FA\u12FB\x07C\x02\x02\u12FB" + + "\u12FC\x07T\x02\x02\u12FC\u12FD\x07K\x02\x02\u12FD\u12FE\x07C\x02\x02" + + "\u12FE\u12FF\x07D\x02\x02\u12FF\u1300\x07N\x02\x02\u1300\u1301\x07G\x02" + + "\x02\u1301\u03EA\x03\x02\x02\x02\u1302\u1303\x07W\x02\x02\u1303\u1304" + + "\x07U\x02\x02\u1304\u1305\x07G\x02\x02\u1305\u1306\x07a\x02\x02\u1306" + + "\u1307\x07E\x02\x02\u1307\u1308\x07Q\x02\x02\u1308\u1309\x07N\x02\x02" + + "\u1309\u130A\x07W\x02\x02\u130A\u130B\x07O\x02\x02\u130B\u130C\x07P\x02" + + "\x02\u130C\u03EC\x03\x02\x02\x02\u130D\u130E\x07C\x02\x02\u130E\u130F" + + "\x07N\x02\x02\u130F\u1310\x07K\x02\x02\u1310\u1311\x07C\x02\x02\u1311" + + "\u1312\x07U\x02\x02\u1312\u03EE\x03\x02\x02\x02\u1313\u1314\x07E\x02\x02" + + "\u1314\u1315\x07Q\x02\x02\u1315\u1316\x07P\x02\x02\u1316\u1317\x07U\x02" + + "\x02\u1317\u1318\x07V\x02\x02\u1318\u1319\x07C\x02\x02\u1319\u131A\x07" + + "P\x02\x02\u131A\u131B\x07V\x02\x02\u131B\u03F0\x03\x02\x02\x02\u131C\u131D" + + "\x07R\x02\x02\u131D\u131E\x07G\x02\x02\u131E\u131F\x07T\x02\x02\u131F" + + "\u1320\x07H\x02\x02\u1320\u1321\x07Q\x02\x02\u1321\u1322\x07T\x02\x02" + + "\u1322\u1323\x07O\x02\x02\u1323\u03F2\x03\x02\x02\x02\u1324\u1325\x07" + + "I\x02\x02\u1325\u1326\x07G\x02\x02\u1326\u1327\x07V\x02\x02\u1327\u03F4" + + "\x03\x02\x02\x02\u1328\u1329\x07F\x02\x02\u1329\u132A\x07K\x02\x02\u132A" + + "\u132B\x07C\x02\x02\u132B\u132C\x07I\x02\x02\u132C\u132D\x07P\x02\x02" + + "\u132D\u132E\x07Q\x02\x02\u132E\u132F\x07U\x02\x02\u132F\u1330\x07V\x02" + + "\x02\u1330\u1331\x07K\x02\x02\u1331\u1332\x07E\x02\x02\u1332\u1333\x07" + + "U\x02\x02\u1333\u03F6\x03\x02\x02\x02\u1334\u1335\x07U\x02\x02\u1335\u1336" + + "\x07V\x02\x02\u1336\u1337\x07C\x02\x02\u1337\u1338\x07E\x02\x02\u1338" + + "\u1339\x07M\x02\x02\u1339\u133A\x07G\x02\x02\u133A\u133B\x07F\x02\x02" + + "\u133B\u03F8\x03\x02\x02\x02\u133C\u133D\x07G\x02\x02\u133D\u133E\x07" + + "N\x02\x02\u133E\u133F\x07U\x02\x02\u133F\u1340\x07K\x02\x02\u1340\u1341" + + "\x07H\x02\x02\u1341\u03FA\x03\x02\x02\x02\u1342\u1343\x07Y\x02\x02\u1343" + + "\u1344\x07J\x02\x02\u1344\u1345\x07K\x02\x02\u1345\u1346\x07N\x02\x02" + + "\u1346\u1347\x07G\x02\x02\u1347\u03FC\x03\x02\x02\x02\u1348\u1349\x07" + + "T\x02\x02\u1349\u134A\x07G\x02\x02\u134A\u134B\x07X\x02\x02\u134B\u134C" + + "\x07G\x02\x02\u134C\u134D\x07T\x02\x02\u134D\u134E\x07U\x02\x02\u134E" + + "\u134F\x07G\x02\x02\u134F\u03FE\x03\x02\x02\x02\u1350\u1351\x07H\x02\x02" + + "\u1351\u1352\x07Q\x02\x02\u1352\u1353\x07T\x02\x02\u1353\u1354\x07G\x02" + + "\x02\u1354\u1355\x07C\x02\x02\u1355\u1356\x07E\x02\x02\u1356\u1357\x07" + + "J\x02\x02\u1357\u0400\x03\x02\x02\x02\u1358\u1359\x07U\x02\x02\u1359\u135A" + + "\x07N\x02\x02\u135A\u135B\x07K\x02\x02\u135B\u135C\x07E\x02\x02\u135C" + + "\u135D\x07G\x02\x02\u135D\u0402\x03\x02\x02\x02\u135E\u135F\x07G\x02\x02" + + "\u135F\u1360\x07Z\x02\x02\u1360\u1361\x07K\x02\x02\u1361\u1362\x07V\x02" + + "\x02\u1362\u0404\x03\x02\x02\x02\u1363\u1364\x07T\x02\x02\u1364\u1365" + + "\x07G\x02\x02\u1365\u1366\x07V\x02\x02\u1366\u1367\x07W\x02\x02\u1367" + + "\u1368\x07T\x02\x02\u1368\u1369\x07P\x02\x02\u1369\u0406\x03\x02\x02\x02" + + "\u136A\u136B\x07S\x02\x02\u136B\u136C\x07W\x02\x02\u136C\u136D\x07G\x02" + + "\x02\u136D\u136E\x07T\x02\x02\u136E\u136F\x07[\x02\x02\u136F\u0408\x03" + + "\x02\x02\x02\u1370\u1371\x07T\x02\x02\u1371\u1372\x07C\x02\x02\u1372\u1373" + + "\x07K\x02\x02\u1373\u1374\x07U\x02\x02\u1374\u1375\x07G\x02\x02\u1375" + + "\u040A\x03\x02\x02\x02\u1376\u1377\x07U\x02\x02\u1377\u1378\x07S\x02\x02" + + "\u1378\u1379\x07N\x02\x02\u1379\u137A\x07U\x02\x02\u137A\u137B\x07V\x02" + + "\x02\u137B\u137C\x07C\x02\x02\u137C\u137D\x07V\x02\x02\u137D\u137E\x07" + + "G\x02\x02\u137E\u040C\x03\x02\x02\x02\u137F\u1380\x07F\x02\x02\u1380\u1381" + + "\x07G\x02\x02\u1381\u1382\x07D\x02\x02\u1382\u1383\x07W\x02\x02\u1383" + + "\u1384\x07I\x02\x02\u1384\u040E\x03\x02\x02\x02\u1385\u1386\x07N\x02\x02" + + "\u1386\u1387\x07Q\x02\x02\u1387\u1388\x07I\x02\x02\u1388\u0410\x03\x02" + + "\x02\x02\u1389\u138A\x07K\x02\x02\u138A\u138B\x07P\x02\x02\u138B\u138C" + + "\x07H\x02\x02\u138C\u138D\x07Q\x02\x02\u138D\u0412\x03\x02\x02\x02\u138E" + + "\u138F\x07P\x02\x02\u138F\u1390\x07Q\x02\x02\u1390\u1391\x07V\x02\x02" + + "\u1391\u1392\x07K\x02\x02\u1392\u1393\x07E\x02\x02\u1393\u1394\x07G\x02" + + "\x02\u1394\u0414\x03\x02\x02\x02\u1395\u1396\x07Y\x02\x02\u1396\u1397" + + "\x07C\x02\x02\u1397\u1398\x07T\x02\x02\u1398\u1399\x07P\x02\x02\u1399" + + "\u139A\x07K\x02\x02\u139A\u139B\x07P\x02\x02\u139B\u139C\x07I\x02\x02" + + "\u139C\u0416\x03\x02\x02\x02\u139D\u139E\x07G\x02\x02\u139E\u139F\x07" + + "Z\x02\x02\u139F\u13A0\x07E\x02\x02\u13A0\u13A1\x07G\x02\x02\u13A1\u13A2" + + "\x07R\x02\x02\u13A2\u13A3\x07V\x02\x02\u13A3\u13A4\x07K\x02\x02\u13A4" + + "\u13A5\x07Q\x02\x02\u13A5\u13A6\x07P\x02\x02\u13A6\u0418\x03\x02\x02\x02" + + "\u13A7\u13A8\x07C\x02\x02\u13A8\u13A9\x07U\x02\x02\u13A9\u13AA\x07U\x02" + + "\x02\u13AA\u13AB\x07G\x02\x02\u13AB\u13AC\x07T\x02\x02\u13AC\u13AD\x07" + + "V\x02\x02\u13AD\u041A\x03\x02\x02\x02\u13AE\u13AF\x07N\x02\x02\u13AF\u13B0" + + "\x07Q\x02\x02\u13B0\u13B1\x07Q\x02\x02\u13B1\u13B2\x07R\x02\x02\u13B2" + + "\u041C\x03\x02\x02\x02\u13B3\u13B4\x07Q\x02\x02\u13B4\u13B5\x07R\x02\x02" + + "\u13B5\u13B6\x07G\x02\x02\u13B6\u13B7\x07P\x02\x02\u13B7\u041E\x03\x02" + + "\x02\x02\u13B8\u13B9\x07R\x02\x02\u13B9\u13BA\x07G\x02\x02\u13BA\u13BB" + + "\x07H\x02\x02\u13BB\u13BC\x07G\x02\x02\u13BC\u13BD\x07T\x02\x02\u13BD" + + "\u13BE\x07G\x02\x02\u13BE\u13BF\x07P\x02\x02\u13BF\u13C0\x07E\x02\x02" + + "\u13C0\u13C1\x07G\x02\x02\u13C1\u13C2\x07U\x02\x02\u13C2\u0420\x03\x02" + + "\x02\x02\u13C3\u13C4\x07W\x02\x02\u13C4\u13C5\x07U\x02\x02\u13C5\u13C6" + + "\x07C\x02\x02\u13C6\u13C7\x07I\x02\x02\u13C7\u13C8\x07G\x02\x02\u13C8" + + "\u0422\x03\x02\x02\x02\u13C9\u13CA\x07E\x02\x02\u13CA\u13CB\x07Q\x02\x02" + + "\u13CB\u13CC\x07P\x02\x02\u13CC\u13CD\x07P\x02\x02\u13CD\u13CE\x07G\x02" + + "\x02\u13CE\u13CF\x07E\x02\x02\u13CF\u13D0\x07V\x02\x02\u13D0\u0424\x03" + + "\x02\x02\x02\u13D1\u13D2\x07R\x02\x02\u13D2\u13D3\x07W\x02\x02\u13D3\u13D4" + + "\x07D\x02\x02\u13D4\u13D5\x07N\x02\x02\u13D5\u13D6\x07K\x02\x02\u13D6" + + "\u13D7\x07E\x02\x02\u13D7\u0426\x03\x02\x02\x02\u13D8\u13DC\x05\u0429" + + "\u0213\x02\u13D9\u13DB\x05\u042B\u0214\x02\u13DA\u13D9\x03\x02\x02\x02" + + "\u13DB\u13DE\x03\x02\x02\x02\u13DC\u13DA\x03\x02\x02\x02\u13DC\u13DD\x03" + + "\x02\x02\x02\u13DD\u0428\x03\x02\x02\x02\u13DE\u13DC\x03\x02\x02\x02\u13DF" + + "\u13E3\t\b\x02\x02\u13E0\u13E1\t\t\x02\x02\u13E1\u13E3\t\n\x02\x02\u13E2" + + "\u13DF\x03\x02\x02\x02\u13E2\u13E0\x03\x02\x02\x02\u13E3\u042A\x03\x02" + + "\x02\x02\u13E4\u13E7\x05\u042D\u0215\x02\u13E5\u13E7\x07&\x02\x02\u13E6" + + "\u13E4\x03\x02\x02\x02\u13E6\u13E5\x03\x02\x02\x02\u13E7\u042C\x03\x02" + + "\x02\x02\u13E8\u13EB\x05\u0429\u0213\x02\u13E9\u13EB\t\x02\x02\x02\u13EA" + + "\u13E8\x03\x02\x02\x02\u13EA\u13E9\x03\x02\x02\x02\u13EB\u042E\x03\x02" + + "\x02\x02\u13EC\u13ED\x05\u0431\u0217\x02\u13ED\u13EE\x07$\x02\x02\u13EE" + + "\u0430\x03\x02\x02\x02\u13EF\u13F5\x07$\x02\x02\u13F0\u13F1\x07$\x02\x02" + + "\u13F1\u13F4\x07$\x02\x02\u13F2\u13F4\n\v\x02\x02\u13F3\u13F0\x03\x02" + + "\x02\x02\u13F3\u13F2\x03\x02\x02\x02\u13F4\u13F7\x03\x02\x02\x02\u13F5" + + "\u13F3\x03\x02\x02\x02\u13F5\u13F6\x03\x02\x02\x02\u13F6\u0432\x03\x02" + + "\x02\x02\u13F7\u13F5\x03\x02\x02\x02\u13F8\u13F9\x05\u0435\u0219\x02\u13F9" + + "\u13FA\x07$\x02\x02\u13FA\u0434\x03\x02\x02\x02\u13FB\u1401\x07$\x02\x02" + + "\u13FC\u13FD\x07$\x02\x02\u13FD\u1400\x07$\x02\x02\u13FE\u1400\n\f\x02" + + "\x02\u13FF\u13FC\x03\x02\x02\x02\u13FF\u13FE\x03\x02\x02\x02\u1400\u1403" + + "\x03\x02\x02\x02\u1401\u13FF\x03\x02\x02\x02\u1401\u1402\x03\x02\x02\x02" + + "\u1402\u0436\x03\x02\x02\x02\u1403\u1401\x03\x02\x02\x02\u1404\u1405\x07" + + "W\x02\x02\u1405\u1406\x07(\x02\x02\u1406\u1407\x05\u042F\u0216\x02\u1407" + + "\u0438\x03\x02\x02\x02\u1408\u1409\x07W\x02\x02\u1409\u140A\x07(\x02\x02" + + "\u140A\u140B\x05\u0431\u0217\x02\u140B\u043A\x03\x02\x02\x02\u140C\u140D" + + "\x07W\x02\x02\u140D\u140E\x07(\x02\x02\u140E\u140F\x05\u0433\u0218\x02" + + "\u140F\u043C\x03\x02\x02\x02\u1410\u1411\x07W\x02\x02\u1411\u1412\x07" + + "(\x02\x02\u1412\u1413\x05\u0435\u0219\x02\u1413\u043E\x03\x02\x02\x02" + + "\u1414\u1415\x05\u0441\u021F\x02\u1415\u1416\x07)\x02\x02\u1416\u0440" + + "\x03\x02\x02\x02\u1417\u141D\x07)\x02\x02\u1418\u1419\x07)\x02\x02\u1419" + + "\u141C\x07)\x02\x02\u141A\u141C\n\r\x02\x02\u141B\u1418\x03\x02\x02\x02" + + "\u141B\u141A\x03\x02\x02\x02\u141C\u141F\x03\x02\x02\x02\u141D\u141B\x03" + + "\x02\x02\x02\u141D\u141E\x03\x02\x02\x02\u141E\u0442\x03\x02\x02\x02\u141F" + + "\u141D\x03\x02\x02\x02\u1420\u1421\x07G\x02\x02\u1421\u1422\x07)\x02\x02" + + "\u1422\u1423\x03\x02\x02\x02\u1423\u1424\b\u0220\x03\x02\u1424\u1425\b" + + "\u0220\x04\x02\u1425\u0444\x03\x02\x02\x02\u1426\u1427\x05\u0447\u0222" + + "\x02\u1427\u1428\x07)\x02\x02\u1428\u0446\x03\x02\x02\x02\u1429\u142A" + + "\x07W\x02\x02\u142A\u142B\x07(\x02\x02\u142B\u142C\x05\u0441\u021F\x02" + + "\u142C\u0448\x03\x02\x02\x02\u142D\u142F\x07&\x02\x02\u142E\u1430\x05" + + "\u044B\u0224\x02\u142F\u142E\x03\x02\x02\x02\u142F\u1430\x03\x02\x02\x02" + + "\u1430\u1431\x03\x02\x02\x02\u1431\u1432\x07&\x02\x02\u1432\u1433\x03" + + "\x02\x02\x02\u1433\u1434\b\u0223\x05\x02\u1434\u044A\x03\x02\x02\x02\u1435" + + "\u1439\x05\u0429\u0213\x02\u1436\u1438\x05\u042D\u0215\x02\u1437\u1436" + + "\x03\x02\x02\x02\u1438\u143B\x03\x02\x02\x02\u1439\u1437\x03\x02\x02\x02" + + "\u1439\u143A\x03\x02\x02\x02\u143A\u044C\x03\x02\x02\x02\u143B\u1439\x03" + + "\x02\x02\x02\u143C\u143D\x05\u044F\u0226\x02\u143D\u143E\x07)\x02\x02" + + "\u143E\u044E\x03\x02\x02\x02\u143F\u1440\x07D\x02\x02\u1440\u1444\x07" + + ")\x02\x02\u1441\u1443\t\x0E\x02\x02\u1442\u1441\x03\x02\x02\x02\u1443" + + "\u1446\x03\x02\x02\x02\u1444\u1442\x03\x02\x02\x02\u1444\u1445\x03\x02" + + "\x02\x02\u1445\u0450\x03\x02\x02\x02\u1446\u1444\x03\x02\x02\x02\u1447" + + "\u1448\x05\u0453\u0228\x02\u1448\u1449\x07)\x02\x02\u1449\u0452\x03\x02" + + "\x02\x02\u144A\u144B\x07D\x02\x02\u144B\u144C\x05\u0441\u021F\x02\u144C" + + "\u0454\x03\x02\x02\x02\u144D\u144E\x05\u0457\u022A\x02\u144E\u144F\x07" + + ")\x02\x02\u144F\u0456\x03\x02\x02\x02\u1450\u1451\x07Z\x02\x02\u1451\u1455" + + "\x07)\x02\x02\u1452\u1454\t\x0F\x02\x02\u1453\u1452\x03\x02\x02\x02\u1454" + + "\u1457\x03\x02\x02\x02\u1455\u1453\x03\x02\x02\x02\u1455\u1456\x03\x02" + + "\x02\x02\u1456\u0458\x03\x02\x02\x02\u1457\u1455\x03\x02\x02\x02\u1458" + + "\u1459\x05\u045B\u022C\x02\u1459\u145A\x07)\x02\x02\u145A\u045A\x03\x02" + + "\x02\x02\u145B\u145C\x07Z\x02\x02\u145C\u145D\x05\u0441\u021F\x02\u145D" + + "\u045C\x03\x02\x02\x02\u145E\u145F\x05\u0463\u0230\x02\u145F\u045E\x03" + + "\x02\x02\x02\u1460\u1461\x05\u0463\u0230\x02\u1461\u1462\x070\x02\x02" + + "\u1462\u1463\x070\x02\x02\u1463\u0460\x03\x02\x02\x02\u1464\u1465\x05" + + "\u0463\u0230\x02\u1465\u1467\x070\x02\x02\u1466\u1468\x05\u0463\u0230" + + "\x02\u1467\u1466\x03\x02\x02\x02\u1467\u1468\x03\x02\x02\x02\u1468\u146E" + + "\x03\x02\x02\x02\u1469\u146B\x07G\x02\x02\u146A\u146C\t\x03\x02\x02\u146B" + + "\u146A\x03\x02\x02\x02\u146B\u146C\x03\x02\x02\x02\u146C\u146D\x03\x02" + + "\x02\x02\u146D\u146F\x05\u0463\u0230\x02\u146E\u1469\x03\x02\x02\x02\u146E" + + "\u146F\x03\x02\x02\x02\u146F\u1481\x03\x02\x02\x02\u1470\u1471\x070\x02" + + "\x02\u1471\u1477\x05\u0463\u0230\x02\u1472\u1474\x07G\x02\x02\u1473\u1475" + + "\t\x03\x02\x02\u1474\u1473\x03\x02\x02\x02\u1474\u1475\x03\x02\x02\x02" + + "\u1475\u1476\x03\x02\x02\x02\u1476\u1478\x05\u0463\u0230\x02\u1477\u1472" + + "\x03\x02\x02\x02\u1477\u1478\x03\x02\x02\x02\u1478\u1481\x03\x02\x02\x02" + + "\u1479\u147A\x05\u0463\u0230\x02\u147A\u147C\x07G\x02\x02\u147B\u147D" + + "\t\x03\x02\x02\u147C\u147B\x03\x02\x02\x02\u147C\u147D\x03\x02\x02\x02" + + "\u147D\u147E\x03\x02\x02\x02\u147E\u147F\x05\u0463\u0230\x02\u147F\u1481" + + "\x03\x02\x02\x02\u1480\u1464\x03\x02\x02\x02\u1480\u1470\x03\x02\x02\x02" + + "\u1480\u1479\x03\x02\x02\x02\u1481\u0462\x03\x02\x02\x02\u1482\u1484\t" + + "\x02\x02\x02\u1483\u1482\x03\x02\x02\x02\u1484\u1485\x03\x02\x02\x02\u1485" + + "\u1483\x03\x02\x02\x02\u1485\u1486\x03\x02\x02\x02\u1486\u0464\x03\x02" + + "\x02\x02\u1487\u1488\x07<\x02\x02\u1488\u148C\t\x10\x02\x02\u1489\u148B" + + "\t\x11\x02\x02\u148A\u1489\x03\x02\x02\x02\u148B\u148E\x03\x02\x02\x02" + + "\u148C\u148A\x03\x02\x02\x02\u148C\u148D\x03\x02\x02\x02\u148D\u0466\x03" + + "\x02\x02\x02\u148E\u148C\x03\x02\x02\x02\u148F\u1490\x07<\x02\x02\u1490" + + "\u1491\x07$\x02\x02\u1491\u1499\x03\x02\x02\x02\u1492\u1493\x07^\x02\x02" + + "\u1493\u1498\v\x02\x02\x02\u1494\u1495\x07$\x02\x02\u1495\u1498\x07$\x02" + + "\x02\u1496\u1498\n\x12\x02\x02\u1497\u1492\x03\x02\x02\x02\u1497\u1494" + + "\x03\x02\x02\x02\u1497\u1496\x03\x02\x02\x02\u1498\u149B\x03\x02\x02\x02" + + "\u1499\u1497\x03\x02\x02\x02\u1499\u149A\x03\x02\x02\x02\u149A\u149C\x03" + + "\x02\x02\x02\u149B\u1499\x03\x02\x02\x02\u149C\u149D\x07$\x02\x02\u149D" + + "\u0468\x03\x02\x02\x02\u149E\u14A0\t\x13\x02\x02\u149F\u149E\x03\x02\x02" + + "\x02\u14A0\u14A1\x03\x02\x02\x02\u14A1\u149F\x03\x02\x02\x02\u14A1\u14A2" + + "\x03\x02\x02\x02\u14A2\u14A3\x03\x02\x02\x02\u14A3\u14A4\b\u0233\x06\x02" + + "\u14A4\u046A\x03\x02\x02\x02\u14A5\u14A7\x07\x0F\x02\x02\u14A6\u14A8\x07" + + "\f\x02\x02\u14A7\u14A6\x03\x02\x02\x02\u14A7\u14A8\x03\x02\x02\x02\u14A8" + + "\u14AB\x03\x02\x02\x02\u14A9\u14AB"; private static readonly _serializedATNSegment9: string = - "\t\x0F\x02\x02\u14BF\u14C1\n\x18\x02\x02\u14C0\u14AF\x03\x02\x02\x02\u14C0" + - "\u14B1\x03\x02\x02\x02\u14C0\u14B6\x03\x02\x02\x02\u14C0\u14BF\x03\x02" + - "\x02\x02\u14C1\u14C4\x03\x02\x02\x02\u14C2\u14C4\n\x19\x02\x02\u14C3\u14AC" + - "\x03\x02\x02\x02\u14C3\u14AE\x03\x02\x02\x02\u14C3\u14C2\x03\x02\x02\x02" + - "\u14C4\u14C7\x03\x02\x02\x02\u14C5\u14C3\x03\x02\x02\x02\u14C5\u14C6\x03" + - "\x02\x02\x02\u14C6\u0464\x03\x02\x02\x02\u14C7\u14C5\x03\x02\x02\x02\u14C8" + - "\u14C9\x05\u0469\u0233\x02\u14C9\u14CA\x07)\x02\x02\u14CA\u14CB\x03\x02" + - "\x02\x02\u14CB\u14CC\b\u0231\v\x02\u14CC\u0466\x03\x02\x02\x02\u14CD\u14CF" + - "\x05\u0469\u0233\x02\u14CE\u14D0\x07^\x02\x02\u14CF\u14CE\x03\x02\x02" + - "\x02\u14CF\u14D0\x03\x02\x02\x02\u14D0\u14D1\x03\x02\x02\x02\u14D1\u14D2" + - "\x07\x02\x02\x03\u14D2\u0468\x03\x02\x02\x02\u14D3\u14D4\x07)\x02\x02" + - "\u14D4\u14D9\x07)\x02\x02\u14D5\u14D6\x07^\x02\x02\u14D6\u14D9\v\x02\x02" + - "\x02\u14D7\u14D9\n\x19\x02\x02\u14D8\u14D3\x03\x02\x02\x02\u14D8\u14D5" + - "\x03\x02\x02\x02\u14D8\u14D7\x03\x02\x02\x02\u14D9\u14DC\x03\x02\x02\x02" + - "\u14DA\u14D8\x03\x02\x02\x02\u14DA\u14DB\x03\x02\x02\x02\u14DB\u046A\x03" + - "\x02\x02\x02\u14DC\u14DA\x03\x02\x02\x02\u14DD\u14DE\x05\u044F\u0226\x02" + - "\u14DE\u14DF\x03\x02\x02\x02\u14DF\u14E0\b\u0234\f\x02\u14E0\u14E1\b\u0234" + - "\t\x02\u14E1\u046C\x03\x02\x02\x02\u14E2\u14E3\x05\u0451\u0227\x02\u14E3" + - "\u14E4\x03\x02\x02\x02\u14E4\u14E5\b\u0235\r\x02\u14E5\u14E6\b\u0235\t" + - "\x02\u14E6\u14E7\b\u0235\x0E\x02\u14E7\u046E\x03\x02\x02\x02\u14E8\u14E9" + - "\x05\u044F\u0226\x02\u14E9\u14EA\x03\x02\x02\x02\u14EA\u14EB\b\u0236\f" + - "\x02\u14EB\u14EC\b\u0236\t\x02\u14EC\u0470\x03\x02\x02\x02\u14ED\u14EE" + - "\x05\u0451\u0227\x02\u14EE\u14EF\x03\x02\x02\x02\u14EF\u14F0\b\u0237\r" + - "\x02\u14F0\u14F1\b\u0237\t\x02\u14F1\u0472\x03\x02\x02\x02\u14F2\u14F3" + - "\x07)\x02\x02\u14F3\u14F4\x03\x02\x02\x02\u14F4\u14F5\b\u0238\x04\x02" + - "\u14F5\u14F6\b\u0238\x0F\x02\u14F6\u0474\x03\x02\x02\x02\u14F7\u14F9\n" + - "\x1A\x02\x02\u14F8\u14F7\x03\x02\x02\x02\u14F9\u14FA\x03\x02\x02\x02\u14FA" + - "\u14F8\x03\x02\x02\x02\u14FA\u14FB\x03\x02\x02\x02\u14FB\u1504\x03\x02" + - "\x02\x02\u14FC\u1500\x07&\x02\x02\u14FD\u14FF\n\x1A\x02\x02\u14FE\u14FD" + - "\x03\x02\x02\x02\u14FF\u1502\x03\x02\x02\x02\u1500\u14FE\x03\x02\x02\x02" + - "\u1500\u1501\x03\x02\x02\x02\u1501\u1504\x03\x02\x02\x02\u1502\u1500\x03" + - "\x02\x02\x02\u1503\u14F8\x03\x02\x02\x02\u1503\u14FC\x03\x02\x02\x02\u1504" + - "\u0476\x03\x02\x02\x02\u1505\u1507\x07&\x02\x02\u1506\u1508\x05\u0431" + - "\u0217\x02\u1507\u1506\x03\x02\x02\x02\u1507\u1508\x03\x02\x02\x02\u1508" + - "\u1509\x03\x02\x02\x02\u1509\u150A\x07&\x02\x02\u150A\u150B\x03\x02\x02" + - "\x02\u150B\u150C\x06\u023A\n\x02\u150C\u150D\b\u023A\x10\x02\u150D\u150E" + - "\x03\x02\x02\x02\u150E\u150F\b\u023A\x11\x02\u150F\u0478\x03\x02\x02\x02" + - "P\x02\x03\x04\x05\x06\u04BC\u04C2\u04C4\u04C9\u04CD\u04CF\u04D2\u04DB" + - "\u04DD\u04E2\u04E7\u04E9\u1347\u1350\u1354\u1358\u1361\u1363\u136D\u136F" + - "\u1389\u138B\u139D\u13A8\u13B3\u13C4\u13D8\u13DC\u13DF\u13E5\u13E8\u13ED" + - "\u13F1\u13F6\u13FD\u1408\u140A\u1412\u1418\u141B\u1425\u1430\u1438\u143E" + - "\u1441\u1443\u1449\u1457\u145F\u1465\u1468\u146A\u146C\u1472\u1477\u147C" + - "\u1480\u148A\u148E\u1490\u1497\u149A\u14A8\u14C0\u14C3\u14C5\u14CF\u14D8" + - "\u14DA\u14FA\u1500\u1503\u1507\x12\x03\x1E\x02\t\x1F\x02\x05\x02\x02\x07" + - "\x03\x02\x03\u0216\x03\x07\x06\x02\x03\u0221\x04\x02\x03\x02\x03\u022A" + - "\x05\x04\x04\x02\t\u021D\x02\t\u021E\x02\x04\x05\x02\x04\x03\x02\x03\u023A" + - "\x06\x06\x02\x02"; + "\x07\f\x02\x02\u14AA\u14A5\x03\x02\x02\x02\u14AA\u14A9\x03\x02\x02\x02" + + "\u14AB\u14AC\x03\x02\x02\x02\u14AC\u14AD\b\u0234\x06\x02\u14AD\u046C\x03" + + "\x02\x02\x02\u14AE\u14AF\x07/\x02\x02\u14AF\u14B0\x07/\x02\x02\u14B0\u14B4" + + "\x03\x02\x02\x02\u14B1\u14B3\n\x14\x02\x02\u14B2\u14B1\x03\x02\x02\x02" + + "\u14B3\u14B6\x03\x02\x02\x02\u14B4\u14B2\x03\x02\x02\x02\u14B4\u14B5\x03" + + "\x02\x02\x02\u14B5\u14B7\x03\x02\x02\x02\u14B6\u14B4\x03\x02\x02\x02\u14B7" + + "\u14B8\b\u0235\x06\x02\u14B8\u046E\x03\x02\x02\x02\u14B9\u14BA\x071\x02" + + "\x02\u14BA\u14BB\x07,\x02\x02\u14BB\u14D2\x03\x02\x02\x02\u14BC\u14BE" + + "\x071\x02\x02\u14BD\u14BC\x03\x02\x02\x02\u14BE\u14C1\x03\x02\x02\x02" + + "\u14BF\u14BD\x03\x02\x02\x02\u14BF\u14C0\x03\x02\x02\x02\u14C0\u14C2\x03" + + "\x02\x02\x02\u14C1\u14BF\x03\x02\x02\x02\u14C2\u14D1\x05\u046F\u0236\x02" + + "\u14C3\u14D1\n\x15\x02\x02\u14C4\u14C6\x071\x02\x02\u14C5\u14C4\x03\x02" + + "\x02\x02\u14C6\u14C7\x03\x02\x02\x02\u14C7\u14C5\x03\x02\x02\x02\u14C7" + + "\u14C8\x03\x02\x02\x02\u14C8\u14C9\x03\x02\x02\x02\u14C9\u14D1\n\x15\x02" + + "\x02\u14CA\u14CC\x07,\x02\x02\u14CB\u14CA\x03\x02\x02\x02\u14CC\u14CD" + + "\x03\x02\x02\x02\u14CD\u14CB\x03\x02\x02\x02\u14CD\u14CE\x03\x02\x02\x02" + + "\u14CE\u14CF\x03\x02\x02\x02\u14CF\u14D1\n\x15\x02\x02\u14D0\u14BF\x03" + + "\x02\x02\x02\u14D0\u14C3\x03\x02\x02\x02\u14D0\u14C5\x03\x02\x02\x02\u14D0" + + "\u14CB\x03\x02\x02\x02\u14D1\u14D4\x03\x02\x02\x02\u14D2\u14D0\x03\x02" + + "\x02\x02\u14D2\u14D3\x03\x02\x02\x02\u14D3\u14D8\x03\x02\x02\x02\u14D4" + + "\u14D2\x03\x02\x02\x02\u14D5\u14D7\x07,\x02\x02\u14D6\u14D5\x03\x02\x02" + + "\x02\u14D7\u14DA\x03\x02\x02\x02\u14D8\u14D6\x03\x02\x02\x02\u14D8\u14D9" + + "\x03\x02\x02\x02\u14D9\u14DB\x03\x02\x02\x02\u14DA\u14D8\x03\x02\x02\x02" + + "\u14DB\u14DC\x07,\x02\x02\u14DC\u14DD\x071\x02\x02\u14DD\u14DE\x03\x02" + + "\x02\x02\u14DE\u14DF\b\u0236\x06\x02\u14DF\u0470\x03\x02\x02\x02\u14E0" + + "\u14E1\x071\x02\x02\u14E1\u14E2\x07,\x02\x02\u14E2\u14FB\x03\x02\x02\x02" + + "\u14E3\u14E5\x071\x02\x02\u14E4\u14E3\x03\x02\x02\x02\u14E5\u14E8\x03" + + "\x02\x02\x02\u14E6\u14E4\x03\x02\x02\x02\u14E6\u14E7\x03\x02\x02\x02\u14E7" + + "\u14E9\x03\x02\x02\x02\u14E8\u14E6\x03\x02\x02\x02\u14E9\u14FA\x05\u046F" + + "\u0236\x02\u14EA\u14FA\n\x15\x02\x02\u14EB\u14ED\x071\x02\x02\u14EC\u14EB" + + "\x03\x02\x02\x02\u14ED\u14EE\x03\x02\x02\x02\u14EE\u14EC\x03\x02\x02\x02" + + "\u14EE\u14EF\x03\x02\x02\x02\u14EF\u14F0\x03\x02\x02\x02\u14F0\u14F8\n" + + "\x15\x02\x02\u14F1\u14F3\x07,\x02\x02\u14F2\u14F1\x03\x02\x02\x02\u14F3" + + "\u14F4\x03\x02\x02\x02\u14F4\u14F2\x03\x02\x02\x02\u14F4\u14F5\x03\x02" + + "\x02\x02\u14F5\u14F6\x03\x02\x02\x02\u14F6\u14F8\n\x15\x02\x02\u14F7\u14EC" + + "\x03\x02\x02\x02\u14F7\u14F2\x03\x02\x02\x02\u14F8\u14FA\x03\x02\x02\x02" + + "\u14F9\u14E6\x03\x02\x02\x02\u14F9\u14EA\x03\x02\x02\x02\u14F9\u14F7\x03" + + "\x02\x02\x02\u14FA\u14FD\x03\x02\x02\x02\u14FB\u14F9\x03\x02\x02\x02\u14FB" + + "\u14FC\x03\x02\x02\x02\u14FC\u150F\x03\x02\x02\x02\u14FD\u14FB\x03\x02" + + "\x02\x02\u14FE\u1500\x071\x02\x02\u14FF\u14FE\x03\x02\x02\x02\u1500\u1501" + + "\x03\x02\x02\x02\u1501\u14FF\x03\x02\x02\x02\u1501\u1502\x03\x02\x02\x02" + + "\u1502\u1510\x03\x02\x02\x02\u1503\u1505\x07,\x02\x02\u1504\u1503\x03" + + "\x02\x02\x02\u1505\u1506\x03\x02\x02\x02\u1506\u1504\x03\x02\x02\x02\u1506" + + "\u1507\x03\x02\x02\x02\u1507\u1510\x03\x02\x02\x02\u1508\u150A\x071\x02" + + "\x02\u1509\u1508\x03\x02\x02\x02\u150A\u150D\x03\x02\x02\x02\u150B\u1509" + + "\x03\x02\x02\x02\u150B\u150C\x03\x02\x02\x02\u150C\u150E\x03\x02\x02\x02" + + "\u150D\u150B\x03\x02\x02\x02\u150E\u1510\x05\u0471\u0237\x02\u150F\u14FF" + + "\x03\x02\x02\x02\u150F\u1504\x03\x02\x02\x02\u150F\u150B\x03\x02\x02\x02" + + "\u150F\u1510\x03\x02\x02\x02\u1510\u0472\x03\x02\x02\x02\u1511\u151D\x07" + + "^\x02\x02\u1512\u151C\n\x16\x02\x02\u1513\u1517\x07$\x02\x02\u1514\u1516" + + "\n\x17\x02\x02\u1515\u1514\x03\x02\x02\x02\u1516\u1519\x03\x02\x02\x02" + + "\u1517\u1515\x03\x02\x02\x02\u1517\u1518\x03\x02\x02\x02\u1518\u151A\x03" + + "\x02\x02\x02\u1519\u1517\x03\x02\x02\x02\u151A\u151C\x07$\x02\x02\u151B" + + "\u1512\x03\x02\x02\x02\u151B\u1513\x03\x02\x02\x02\u151C\u151F\x03\x02" + + "\x02\x02\u151D\u151B\x03\x02\x02\x02\u151D\u151E\x03\x02\x02\x02\u151E" + + "\u1527\x03\x02\x02\x02\u151F\u151D\x03\x02\x02\x02\u1520\u1524\x07$\x02" + + "\x02\u1521\u1523\n\x17\x02\x02\u1522\u1521\x03\x02\x02\x02\u1523\u1526" + + "\x03\x02\x02\x02\u1524\u1522\x03\x02\x02\x02\u1524\u1525\x03\x02\x02\x02" + + "\u1525\u1528\x03\x02\x02\x02\u1526\u1524\x03\x02\x02\x02\u1527\u1520\x03" + + "\x02\x02\x02\u1527\u1528\x03\x02\x02\x02\u1528\u0474\x03\x02\x02\x02\u1529" + + "\u152A\x07^\x02\x02\u152A\u152B\x07^\x02\x02\u152B\u0476\x03\x02\x02\x02" + + "\u152C\u152D\v\x02\x02\x02\u152D\u0478\x03\x02\x02\x02\u152E\u152F\x05" + + "\u047D\u023D\x02\u152F\u1530\x07)\x02\x02\u1530\u1531\x03\x02\x02\x02" + + "\u1531\u1532\b\u023B\x07\x02\u1532\u047A\x03\x02\x02\x02\u1533\u1535\x05" + + "\u047D\u023D\x02\u1534\u1536\x07^\x02\x02\u1535\u1534\x03\x02\x02\x02" + + "\u1535\u1536\x03\x02\x02\x02\u1536\u1537\x03\x02\x02\x02\u1537\u1538\x07" + + "\x02\x02\x03\u1538\u047C\x03\x02\x02\x02\u1539\u153A\x07)\x02\x02\u153A" + + "\u1551\x07)\x02\x02\u153B\u154D\x07^\x02\x02\u153C\u153D\x07z\x02\x02" + + "\u153D\u154E\t\x0F\x02\x02\u153E\u153F\x07w\x02\x02\u153F\u1540\t\x0F" + + "\x02\x02\u1540\u1541\t\x0F\x02\x02\u1541\u1542\t\x0F\x02\x02\u1542\u154E" + + "\t\x0F\x02\x02\u1543\u1544\x07W\x02\x02\u1544\u1545\t\x0F\x02\x02\u1545" + + "\u1546\t\x0F\x02\x02\u1546\u1547\t\x0F\x02\x02\u1547\u1548\t\x0F\x02\x02" + + "\u1548\u1549\t\x0F\x02\x02\u1549\u154A\t\x0F\x02\x02\u154A\u154B\t\x0F" + + "\x02\x02\u154B\u154E\t\x0F\x02\x02\u154C\u154E\n\x18\x02\x02\u154D\u153C" + + "\x03\x02\x02\x02\u154D\u153E\x03\x02\x02\x02\u154D\u1543\x03\x02\x02\x02" + + "\u154D\u154C\x03\x02\x02\x02\u154E\u1551\x03\x02\x02\x02\u154F\u1551\n" + + "\x19\x02\x02\u1550\u1539\x03\x02\x02\x02\u1550\u153B\x03\x02\x02\x02\u1550" + + "\u154F\x03\x02\x02\x02\u1551\u1554\x03\x02\x02\x02\u1552\u1550\x03\x02" + + "\x02\x02\u1552\u1553\x03\x02\x02\x02\u1553\u047E\x03\x02\x02\x02\u1554" + + "\u1552\x03\x02\x02\x02\u1555\u1556\x05\u0483\u0240\x02\u1556\u1557\x07" + + ")\x02\x02\u1557\u1558\x03\x02\x02\x02\u1558\u1559\b\u023E\x07\x02\u1559" + + "\u0480\x03\x02\x02\x02\u155A\u155C\x05\u0483\u0240\x02\u155B\u155D\x07" + + "^\x02\x02\u155C\u155B\x03\x02\x02\x02\u155C\u155D\x03\x02\x02\x02\u155D" + + "\u155E\x03\x02\x02\x02\u155E\u155F\x07\x02\x02\x03\u155F\u0482\x03\x02" + + "\x02\x02\u1560\u1561\x07)\x02\x02\u1561\u1566\x07)\x02\x02\u1562\u1563" + + "\x07^\x02\x02\u1563\u1566\v\x02\x02\x02\u1564\u1566\n\x19\x02\x02\u1565" + + "\u1560\x03\x02\x02\x02\u1565\u1562\x03\x02\x02\x02\u1565\u1564\x03\x02" + + "\x02\x02\u1566\u1569\x03\x02\x02\x02\u1567\u1565\x03\x02\x02\x02\u1567" + + "\u1568\x03\x02\x02\x02\u1568\u0484\x03\x02\x02\x02\u1569\u1567\x03\x02" + + "\x02\x02\u156A\u156B\x05\u0469\u0233\x02\u156B\u156C\x03\x02\x02\x02\u156C" + + "\u156D\b\u0241\b\x02\u156D\u156E\b\u0241\x06\x02\u156E\u0486\x03\x02\x02" + + "\x02\u156F\u1570\x05\u046B\u0234\x02\u1570\u1571\x03\x02\x02\x02\u1571" + + "\u1572\b\u0242\t\x02\u1572\u1573\b\u0242\x06\x02\u1573\u1574\b\u0242\n" + + "\x02\u1574\u0488\x03\x02\x02\x02\u1575\u1576\x05\u0469\u0233\x02\u1576" + + "\u1577\x03\x02\x02\x02\u1577\u1578\b\u0243\b\x02\u1578\u1579\b\u0243\x06" + + "\x02\u1579\u048A\x03\x02\x02\x02\u157A\u157B\x05\u046B\u0234\x02\u157B" + + "\u157C\x03\x02\x02\x02\u157C\u157D\b\u0244\t\x02\u157D\u157E\b\u0244\x06" + + "\x02\u157E\u048C\x03\x02\x02\x02\u157F\u1580\x07)\x02\x02\u1580\u1581" + + "\x03\x02\x02\x02\u1581\u1582\b\u0245\x03\x02\u1582\u1583\b\u0245\v\x02" + + "\u1583\u048E\x03\x02\x02\x02\u1584\u1586\n\x1A\x02\x02\u1585\u1584\x03" + + "\x02\x02\x02\u1586\u1587\x03\x02\x02\x02\u1587\u1585\x03\x02\x02\x02\u1587" + + "\u1588\x03\x02\x02\x02\u1588\u1591\x03\x02\x02\x02\u1589\u158D\x07&\x02" + + "\x02\u158A\u158C\n\x1A\x02\x02\u158B\u158A\x03\x02\x02\x02\u158C\u158F" + + "\x03\x02\x02\x02\u158D\u158B\x03\x02\x02\x02\u158D\u158E\x03\x02\x02\x02" + + "\u158E\u1591\x03\x02\x02\x02\u158F\u158D\x03\x02\x02\x02\u1590\u1585\x03" + + "\x02\x02\x02\u1590\u1589\x03\x02\x02\x02\u1591\u0490\x03\x02\x02\x02\u1592" + + "\u1594\x07&\x02\x02\u1593\u1595\x05\u044B\u0224\x02\u1594\u1593\x03\x02" + + "\x02\x02\u1594\u1595\x03\x02\x02\x02\u1595\u1596\x03\x02\x02\x02\u1596" + + "\u1597\x07&\x02\x02\u1597\u1598\x03\x02\x02\x02\u1598\u1599\b\u0247\f" + + "\x02\u1599\u0492\x03\x02\x02\x02O\x02\x03\x04\x05\x06\u04D6\u04DC\u04E0" + + "\u04E2\u04E5\u04E7\u04EA\u04EE\u04F0\u04F5\u04FA\u13DC\u13E2\u13E6\u13EA" + + "\u13F3\u13F5\u13FF\u1401\u141B\u141D\u142F\u1439\u1444\u1455\u1467\u146B" + + "\u146E\u1474\u1477\u147C\u1480\u1485\u148C\u1497\u1499\u14A1\u14A7\u14AA" + + "\u14B4\u14BF\u14C7\u14CD\u14D0\u14D2\u14D8\u14E6\u14EE\u14F4\u14F7\u14F9" + + "\u14FB\u1501\u1506\u150B\u150F\u1517\u151B\u151D\u1524\u1527\u1535\u154D" + + "\u1550\u1552\u155C\u1565\u1567\u1587\u158D\u1590\u1594\r\t\x1F\x02\x05" + + "\x02\x02\x07\x03\x02\x07\x06\x02\x02\x03\x02\x04\x04\x02\t\u022A\x02\t" + + "\u022B\x02\x04\x05\x02\x04\x03\x02\x06\x02\x02"; public static readonly _serializedATN: string = Utils.join( [ PostgreSQLLexer._serializedATNSegment0, diff --git a/src/lib/pgsql/PostgreSQLLexerBase.ts b/src/lib/pgsql/PostgreSQLLexerBase.ts deleted file mode 100644 index 702d399..0000000 --- a/src/lib/pgsql/PostgreSQLLexerBase.ts +++ /dev/null @@ -1,67 +0,0 @@ -import { Lexer } from "antlr4ts/Lexer"; - - -function isLetter(str) { - return str.length === 1 && str.match(/[a-z]/i); -} - -export default abstract class PostgreSQLLexerBase extends Lexer { - - tags: string[] = []; - _interp: any; - - constructor(input) { - super(input); - } - - pushTag() { - this.tags.push(this.text); - } - - isTag() { - return this.text === this.tags[this.tags.length - 1]; - } - - popTag() { - this.tags.pop(); - } - - getInputStream() { - return this._input; - } - checkLA( c) { - return this.getInputStream().LA(1) !== c; - } - - charIsLetter() { - return isLetter(this.getInputStream().LA(-1)); - } - - HandleNumericFail() { - this.getInputStream().seek(this.getInputStream().index - 2); - const Integral = 535; - this.type = Integral; - } - - HandleLessLessGreaterGreater() { - const LESS_LESS = 18; - const GREATER_GREATER = 19; - if (this.text === '<<') this.type = LESS_LESS; - if (this.text === '>>') this.type = GREATER_GREATER; - } - - UnterminatedBlockCommentDebugAssert() { - } - - CheckIfUtf32Letter() { - 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]); - } -} \ No newline at end of file diff --git a/src/lib/pgsql/PostgreSQLParser.interp b/src/lib/pgsql/PostgreSQLParser.interp index 8a5cb8e..2c58f52 100644 --- a/src/lib/pgsql/PostgreSQLParser.interp +++ b/src/lib/pgsql/PostgreSQLParser.interp @@ -228,6 +228,15 @@ null 'INDEX' 'INDEXES' 'INHERIT' +'NOINHERIT' +'SUPERUSER' +'NOSUPERUSER' +'CREATEDB' +'NOCREATEDB' +'CREATEROLE' +'NOCREATEROLE' +'CREATEUSER' +'NOCREATEUSER' 'INHERITS' 'INLINE' 'INSENSITIVE' @@ -511,6 +520,10 @@ null 'ASSERT' 'LOOP' 'OPEN' +'PEFERENCES' +'USAGE' +'CONNECT' +'PUBLIC' null null null @@ -585,488 +598,501 @@ 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 +KW_ALL +KW_ANALYSE +KW_ANALYZE +KW_AND +KW_ANY +KW_ARRAY +KW_AS +KW_ASC +KW_ASYMMETRIC +KW_BOTH +KW_CASE +KW_CAST +KW_CHECK +KW_COLLATE +KW_COLUMN +KW_CONSTRAINT +KW_CREATE +KW_CURRENT_CATALOG +KW_CURRENT_DATE +KW_CURRENT_ROLE +KW_CURRENT_TIME +KW_CURRENT_TIMESTAMP +KW_CURRENT_USER +KW_DEFAULT +KW_DEFERRABLE +KW_DESC +KW_DISTINCT +KW_DO +KW_ELSE +KW_EXCEPT +KW_FALSE +KW_FETCH +KW_FOR +KW_FOREIGN +KW_FROM +KW_GRANT +KW_GROUP +KW_HAVING +KW_IN +KW_INITIALLY +KW_INTERSECT +KW_INTO +KW_LATERAL +KW_LEADING +KW_LIMIT +KW_LOCALTIME +KW_LOCALTIMESTAMP +KW_NOT +KW_NULL +KW_OFFSET +KW_ON +KW_ONLY +KW_OR +KW_ORDER +KW_PLACING +KW_PRIMARY +KW_REFERENCES +KW_RETURNING +KW_SELECT +KW_SESSION_USER +KW_SOME +KW_SYMMETRIC +KW_TABLE +KW_THEN +KW_TO +KW_TRAILING +KW_TRUE +KW_UNION +KW_UNIQUE +KW_USER +KW_USING +KW_VARIADIC +KW_WHEN +KW_WHERE +KW_WINDOW +KW_WITH +KW_AUTHORIZATION +KW_BINARY +KW_COLLATION +KW_CONCURRENTLY +KW_CROSS +KW_CURRENT_SCHEMA +KW_FREEZE +KW_FULL +KW_ILIKE +KW_INNER +KW_IS +KW_ISNULL +KW_JOIN +KW_LEFT +KW_LIKE +KW_NATURAL +KW_NOTNULL +KW_OUTER +KW_OVER +KW_OVERLAPS +KW_RIGHT +KW_SIMILAR +KW_VERBOSE +KW_ABORT +KW_ABSOLUTE +KW_ACCESS +KW_ACTION +KW_ADD +KW_ADMIN +KW_AFTER +KW_AGGREGATE +KW_ALSO +KW_ALTER +KW_ALWAYS +KW_ASSERTION +KW_ASSIGNMENT +KW_AT +KW_ATTRIBUTE +KW_BACKWARD +KW_BEFORE +KW_BEGIN +KW_BY +KW_CACHE +KW_CALLED +KW_CASCADE +KW_CASCADED +KW_CATALOG +KW_CHAIN +KW_CHARACTERISTICS +KW_CHECKPOINT +KW_CLASS +KW_CLOSE +KW_CLUSTER +KW_COMMENT +KW_COMMENTS +KW_COMMIT +KW_COMMITTED +KW_CONFIGURATION +KW_CONNECTION +KW_CONSTRAINTS +KW_CONTENT +KW_CONTINUE +KW_CONVERSION +KW_COPY +KW_COST +KW_CSV +KW_CURSOR +KW_CYCLE +KW_DATA +KW_DATABASE +KW_DAY +KW_DEALLOCATE +KW_DECLARE +KW_DEFAULTS +KW_DEFERRED +KW_DEFINER +KW_DELETE +KW_DELIMITER +KW_DELIMITERS +KW_DICTIONARY +KW_DISABLE +KW_DISCARD +KW_DOCUMENT +KW_DOMAIN +KW_DOUBLE +KW_DROP +KW_EACH +KW_ENABLE +KW_ENCODING +KW_ENCRYPTED +KW_ENUM +KW_ESCAPE +KW_EVENT +KW_EXCLUDE +KW_EXCLUDING +KW_EXCLUSIVE +KW_EXECUTE +KW_EXPLAIN +KW_EXTENSION +KW_EXTERNAL +KW_FAMILY +KW_FIRST +KW_FOLLOWING +KW_FORCE +KW_FORWARD +KW_FUNCTION +KW_FUNCTIONS +KW_GLOBAL +KW_GRANTED +KW_HANDLER +KW_HEADER +KW_HOLD +KW_HOUR +KW_IDENTITY +KW_IF +KW_IMMEDIATE +KW_IMMUTABLE +KW_IMPLICIT +KW_INCLUDING +KW_INCREMENT +KW_INDEX +KW_INDEXES +KW_INHERIT +KW_NOINHERIT +KW_SUPERUSER +KW_NOSUPERUSER +KW_CREATEDB +KW_NOCREATEDB +KW_CREATEROLE +KW_NOCREATEROLE +KW_CREATEUSER +KW_NOCREATEUSER +KW_INHERITS +KW_INLINE +KW_INSENSITIVE +KW_INSERT +KW_INSTEAD +KW_INVOKER +KW_ISOLATION +KW_KEY +KW_LABEL +KW_LANGUAGE +KW_LARGE +KW_LAST +KW_LEAKPROOF +KW_LEVEL +KW_LISTEN +KW_LOAD +KW_LOCAL +KW_LOCATION +KW_LOCK +KW_MAPPING +KW_MATCH +KW_MATERIALIZED +KW_MAXVALUE +KW_MINUTE +KW_MINVALUE +KW_MODE +KW_MONTH +KW_MOVE +KW_NAME +KW_NAMES +KW_NEXT +KW_NO +KW_NOTHING +KW_NOTIFY +KW_NOWAIT +KW_NULLS +KW_OBJECT +KW_OF +KW_OFF +KW_OIDS +KW_OPERATOR +KW_OPTION +KW_OPTIONS +KW_OWNED +KW_OWNER +KW_PARSER +KW_PARTIAL +KW_PARTITION +KW_PASSING +KW_PASSWORD +KW_PLANS +KW_PRECEDING +KW_PREPARE +KW_PREPARED +KW_PRESERVE +KW_PRIOR +KW_PRIVILEGES +KW_PROCEDURAL +KW_PROCEDURE +KW_PROGRAM +KW_QUOTE +KW_RANGE +KW_READ +KW_REASSIGN +KW_RECHECK +KW_RECURSIVE +KW_REF +KW_REFRESH +KW_REINDEX +KW_RELATIVE +KW_RELEASE +KW_RENAME +KW_REPEATABLE +KW_REPLACE +KW_REPLICA +KW_RESET +KW_RESTART +KW_RESTRICT +KW_RETURNS +KW_REVOKE +KW_ROLE +KW_ROLLBACK +KW_ROWS +KW_RULE +KW_SAVEPOINT +KW_SCHEMA +KW_SCROLL +KW_SEARCH +KW_SECOND +KW_SECURITY +KW_SEQUENCE +KW_SEQUENCES +KW_SERIALIZABLE +KW_SERVER +KW_SESSION +KW_SET +KW_SHARE +KW_SHOW +KW_SIMPLE +KW_SNAPSHOT +KW_STABLE +KW_STANDALONE +KW_START +KW_STATEMENT +KW_STATISTICS +KW_STDIN +KW_STDOUT +KW_STORAGE +KW_STRICT +KW_STRIP +KW_SYSID +KW_SYSTEM +KW_TABLES +KW_TABLESPACE +KW_TEMP +KW_TEMPLATE +KW_TEMPORARY +KW_TEXT +KW_TRANSACTION +KW_TRIGGER +KW_TRUNCATE +KW_TRUSTED +KW_TYPE +KW_TYPES +KW_UNBOUNDED +KW_UNCOMMITTED +KW_UNENCRYPTED +KW_UNKNOWN +KW_UNLISTEN +KW_UNLOGGED +KW_UNTIL +KW_UPDATE +KW_VACUUM +KW_VALID +KW_VALIDATE +KW_VALIDATOR +KW_VARYING +KW_VERSION +KW_VIEW +KW_VOLATILE +KW_WHITESPACE +KW_WITHOUT +KW_WORK +KW_WRAPPER +KW_WRITE +KW_XML +KW_YEAR +KW_YES +KW_ZONE +KW_BETWEEN +KW_BIGINT +KW_BIT +KW_BOOLEAN +KW_CHAR +KW_CHARACTER +KW_COALESCE +KW_DEC +KW_DECIMAL +KW_EXISTS +KW_EXTRACT +KW_FLOAT +KW_GREATEST +KW_INOUT +KW_INT +KW_INTEGER +KW_INTERVAL +KW_LEAST +KW_NATIONAL +KW_NCHAR +KW_NONE +KW_NULLIF +KW_NUMERIC +KW_OVERLAY +KW_POSITION +KW_PRECISION +KW_REAL +KW_ROW +KW_SETOF +KW_SMALLINT +KW_SUBSTRING +KW_TIME +KW_TIMESTAMP +KW_TREAT +KW_TRIM +KW_VALUES +KW_VARCHAR +KW_XMLATTRIBUTES +KW_XMLCONCAT +KW_XMLELEMENT +KW_XMLEXISTS +KW_XMLFOREST +KW_XMLPARSE +KW_XMLPI +KW_XMLROOT +KW_XMLSERIALIZE +KW_CALL +KW_CURRENT +KW_ATTACH +KW_DETACH +KW_EXPRESSION +KW_GENERATED +KW_LOGGED +KW_STORED +KW_INCLUDE +KW_ROUTINE +KW_TRANSFORM +KW_IMPORT +KW_POLICY +KW_METHOD +KW_REFERENCING +KW_NEW +KW_OLD +KW_VALUE +KW_SUBSCRIPTION +KW_PUBLICATION +KW_OUT +KW_END +KW_ROUTINES +KW_SCHEMAS +KW_PROCEDURES +KW_INPUT +KW_SUPPORT +KW_PARALLEL +KW_SQL +KW_DEPENDS +KW_OVERRIDING +KW_CONFLICT +KW_SKIP +KW_LOCKED +KW_TIES +KW_ROLLUP +KW_CUBE +KW_GROUPING +KW_SETS +KW_TABLESAMPLE +KW_ORDINALITY +KW_XMLTABLE +KW_COLUMNS +KW_XMLNAMESPACES +KW_ROWTYPE +KW_NORMALIZED +KW_WITHIN +KW_FILTER +KW_GROUPS +KW_OTHERS +KW_NFC +KW_NFD +KW_NFKC +KW_NFKD +KW_UESCAPE +KW_VIEWS +KW_NORMALIZE +KW_DUMP +KW_PRINT_STRICT_PARAMS +KW_VARIABLE_CONFLICT +KW_ERROR +KW_USE_VARIABLE +KW_USE_COLUMN +KW_ALIAS +KW_CONSTANT +KW_PERFORM +KW_GET +KW_DIAGNOSTICS +KW_STACKED +KW_ELSIF +KW_WHILE +KW_REVERSE +KW_FOREACH +KW_SLICE +KW_EXIT +KW_RETURN +KW_QUERY +KW_RAISE +KW_SQLSTATE +KW_DEBUG +KW_LOG +KW_INFO +KW_NOTICE +KW_WARNING +KW_EXCEPTION +KW_ASSERT +KW_LOOP +KW_OPEN +KW_PEFERENCES +KW_USAGE +KW_CONNECT +KW_PUBLIC Identifier QuotedIdentifier UnterminatedQuotedIdentifier @@ -1198,6 +1224,7 @@ copy_generic_opt_arg_list copy_generic_opt_arg_list_item createstmt opttemp +table_column_list opttableelementlist opttypedtableelementlist tableelementlist @@ -1210,7 +1237,8 @@ colquallist colconstraint colconstraintelem generated_when -constraintattr +deferrable_trigger +initially_trigger tablelikeclause tablelikeoptionlist tablelikeoption @@ -1314,6 +1342,8 @@ createamstmt am_type createtrigstmt triggeractiontime +foreachrow +roworstatment triggerevents triggeroneevent triggerreferencing @@ -1389,6 +1419,8 @@ opt_from_in grantstmt revokestmt privileges +beforeprivilegeselectlist +beforeprivilegeselect privilege_list privilege privilege_target @@ -1419,6 +1451,7 @@ opt_class opt_asc_desc opt_nulls_order createfunctionstmt +attrilist opt_or_replace func_args func_args_list @@ -1772,6 +1805,7 @@ opt_target_list target_list target_el qualified_name_list +table_qualified_name qualified_name name_list name @@ -1787,10 +1821,15 @@ sconst anysconst opt_uescape signediconst +groupname roleid rolespec role_list colid +index_method_choices +exclude_element +index_paramenters +wherePredicate type_function_name nonreservedword collabel @@ -1917,4 +1956,4 @@ opt_returning_clause_into atn: -[3, 51485, 51898, 1421, 44986, 20307, 1543, 60043, 49729, 3, 555, 10985, 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, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 5, 4, 1615, 10, 4, 7, 4, 1617, 10, 4, 12, 4, 14, 4, 1620, 11, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 1746, 10, 5, 3, 6, 3, 6, 5, 6, 1750, 10, 6, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 1759, 10, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 7, 10, 1766, 10, 10, 12, 10, 14, 10, 1769, 11, 10, 3, 11, 7, 11, 1772, 10, 11, 12, 11, 14, 11, 1775, 11, 11, 3, 12, 3, 12, 3, 12, 5, 12, 1780, 10, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 1795, 10, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 1807, 10, 13, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 1813, 10, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 5, 15, 1821, 10, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1829, 10, 16, 3, 17, 3, 17, 3, 17, 5, 17, 1834, 10, 17, 3, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 5, 18, 1844, 10, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 1852, 10, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 5, 22, 1870, 10, 22, 3, 22, 5, 22, 1873, 10, 22, 3, 22, 3, 22, 3, 22, 5, 22, 1878, 10, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 24, 7, 24, 1885, 10, 24, 12, 24, 14, 24, 1888, 11, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 1896, 10, 25, 3, 26, 3, 26, 5, 26, 1900, 10, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 1912, 10, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 1932, 10, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 1945, 10, 29, 3, 30, 3, 30, 3, 30, 7, 30, 1950, 10, 30, 12, 30, 14, 30, 1953, 11, 30, 3, 31, 3, 31, 3, 31, 7, 31, 1958, 10, 31, 12, 31, 14, 31, 1961, 11, 31, 3, 32, 3, 32, 5, 32, 1965, 10, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 5, 33, 1972, 10, 33, 3, 34, 3, 34, 3, 34, 3, 34, 5, 34, 1978, 10, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 1985, 10, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 1996, 10, 35, 3, 36, 3, 36, 5, 36, 2000, 10, 36, 3, 37, 3, 37, 5, 37, 2004, 10, 37, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 5, 39, 2017, 10, 39, 3, 40, 3, 40, 5, 40, 2021, 10, 40, 3, 41, 3, 41, 3, 41, 5, 41, 2026, 10, 41, 3, 42, 3, 42, 3, 42, 5, 42, 2031, 10, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 5, 43, 2043, 10, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 5, 45, 2052, 10, 45, 3, 46, 3, 46, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2065, 10, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2070, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2081, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2087, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2093, 10, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2098, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2109, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2115, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2121, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2130, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2140, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2155, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2161, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2168, 10, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2173, 10, 49, 3, 50, 3, 50, 3, 50, 7, 50, 2178, 10, 50, 12, 50, 14, 50, 2181, 11, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 5, 51, 2191, 10, 51, 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, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2215, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2222, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2231, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2240, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2248, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2258, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2267, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2276, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2284, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2292, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2301, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2310, 10, 53, 3, 53, 3, 53, 5, 53, 2314, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2321, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2329, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2339, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2345, 10, 53, 3, 53, 3, 53, 5, 53, 2349, 10, 53, 3, 53, 3, 53, 5, 53, 2353, 10, 53, 3, 53, 3, 53, 5, 53, 2357, 10, 53, 3, 53, 3, 53, 5, 53, 2361, 10, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2366, 10, 53, 3, 53, 5, 53, 2369, 10, 53, 3, 53, 3, 53, 5, 53, 2373, 10, 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, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2394, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2400, 10, 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, 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, 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, 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, 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, 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, 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, 53, 3, 53, 3, 53, 5, 53, 2495, 10, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 2502, 10, 54, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 5, 58, 2518, 10, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 7, 61, 2530, 10, 61, 12, 61, 14, 61, 2533, 11, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 5, 62, 2542, 10, 62, 5, 62, 2544, 10, 62, 3, 63, 6, 63, 2547, 10, 63, 13, 63, 14, 63, 2548, 3, 64, 3, 64, 5, 64, 2553, 10, 64, 3, 64, 5, 64, 2556, 10, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 2562, 10, 64, 5, 64, 2564, 10, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 5, 65, 2592, 10, 65, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 7, 67, 2600, 10, 67, 12, 67, 14, 67, 2603, 11, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 7, 69, 2613, 10, 69, 12, 69, 14, 69, 2616, 11, 69, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2622, 10, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2628, 10, 70, 3, 70, 3, 70, 5, 70, 2632, 10, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2638, 10, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2643, 10, 70, 3, 70, 5, 70, 2646, 10, 70, 5, 70, 2648, 10, 70, 3, 71, 3, 71, 3, 71, 5, 71, 2653, 10, 71, 3, 72, 3, 72, 5, 72, 2657, 10, 72, 3, 72, 3, 72, 5, 72, 2661, 10, 72, 3, 72, 3, 72, 5, 72, 2665, 10, 72, 3, 72, 3, 72, 5, 72, 2669, 10, 72, 3, 72, 5, 72, 2672, 10, 72, 3, 72, 3, 72, 5, 72, 2676, 10, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 2684, 10, 72, 3, 72, 3, 72, 5, 72, 2688, 10, 72, 3, 72, 3, 72, 5, 72, 2692, 10, 72, 3, 73, 3, 73, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 5, 75, 2701, 10, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 5, 76, 2708, 10, 76, 3, 77, 7, 77, 2711, 10, 77, 12, 77, 14, 77, 2714, 11, 77, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2720, 10, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2725, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2732, 10, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2737, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2755, 10, 78, 3, 79, 3, 79, 3, 80, 5, 80, 2760, 10, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 7, 82, 2770, 10, 82, 12, 82, 14, 82, 2773, 11, 82, 3, 83, 3, 83, 5, 83, 2777, 10, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 2786, 10, 84, 3, 85, 3, 85, 3, 85, 7, 85, 2791, 10, 85, 12, 85, 14, 85, 2794, 11, 85, 3, 86, 3, 86, 3, 87, 3, 87, 5, 87, 2800, 10, 87, 3, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2806, 10, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2811, 10, 87, 3, 87, 3, 87, 5, 87, 2815, 10, 87, 3, 87, 5, 87, 2818, 10, 87, 3, 87, 5, 87, 2821, 10, 87, 3, 87, 5, 87, 2824, 10, 87, 3, 87, 5, 87, 2827, 10, 87, 3, 87, 5, 87, 2830, 10, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2835, 10, 87, 3, 87, 5, 87, 2838, 10, 87, 3, 87, 5, 87, 2841, 10, 87, 3, 87, 5, 87, 2844, 10, 87, 3, 87, 5, 87, 2847, 10, 87, 3, 87, 5, 87, 2850, 10, 87, 3, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2856, 10, 87, 3, 87, 3, 87, 5, 87, 2860, 10, 87, 3, 87, 5, 87, 2863, 10, 87, 3, 87, 5, 87, 2866, 10, 87, 3, 87, 5, 87, 2869, 10, 87, 3, 87, 5, 87, 2872, 10, 87, 5, 87, 2874, 10, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 5, 88, 2883, 10, 88, 3, 89, 3, 89, 3, 90, 3, 90, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 7, 91, 2894, 10, 91, 12, 91, 14, 91, 2897, 11, 91, 3, 92, 3, 92, 3, 92, 7, 92, 2902, 10, 92, 12, 92, 14, 92, 2905, 11, 92, 3, 93, 3, 93, 3, 93, 5, 93, 2910, 10, 93, 3, 94, 3, 94, 5, 94, 2914, 10, 94, 3, 95, 3, 95, 3, 95, 5, 95, 2919, 10, 95, 3, 95, 3, 95, 3, 96, 3, 96, 3, 96, 5, 96, 2926, 10, 96, 3, 96, 3, 96, 3, 97, 7, 97, 2931, 10, 97, 12, 97, 14, 97, 2934, 11, 97, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 3, 98, 5, 98, 2944, 10, 98, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 2951, 10, 99, 3, 99, 5, 99, 2954, 10, 99, 3, 99, 3, 99, 3, 99, 5, 99, 2959, 10, 99, 3, 99, 5, 99, 2962, 10, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 2969, 10, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 2978, 10, 99, 3, 99, 3, 99, 3, 99, 3, 99, 3, 99, 5, 99, 2985, 10, 99, 3, 99, 3, 99, 3, 99, 5, 99, 2990, 10, 99, 3, 99, 5, 99, 2993, 10, 99, 3, 99, 5, 99, 2996, 10, 99, 5, 99, 2998, 10, 99, 3, 100, 3, 100, 3, 100, 5, 100, 3003, 10, 100, 3, 101, 3, 101, 3, 101, 3, 101, 3, 101, 5, 101, 3010, 10, 101, 3, 102, 3, 102, 3, 102, 3, 102, 3, 103, 3, 103, 7, 103, 3018, 10, 103, 12, 103, 14, 103, 3021, 11, 103, 3, 104, 3, 104, 3, 105, 3, 105, 3, 105, 3, 105, 3, 105, 5, 105, 3030, 10, 105, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 3043, 10, 106, 3, 106, 5, 106, 3046, 10, 106, 3, 106, 5, 106, 3049, 10, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 3056, 10, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 3064, 10, 106, 3, 106, 5, 106, 3067, 10, 106, 3, 106, 5, 106, 3070, 10, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 3077, 10, 106, 3, 106, 3, 106, 5, 106, 3081, 10, 106, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 3087, 10, 106, 3, 106, 5, 106, 3090, 10, 106, 3, 106, 5, 106, 3093, 10, 106, 3, 106, 5, 106, 3096, 10, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 3, 106, 5, 106, 3108, 10, 106, 3, 106, 5, 106, 3111, 10, 106, 3, 106, 5, 106, 3114, 10, 106, 3, 106, 3, 106, 5, 106, 3118, 10, 106, 3, 107, 3, 107, 3, 107, 3, 108, 3, 108, 3, 108, 3, 108, 3, 109, 3, 109, 3, 109, 7, 109, 3130, 10, 109, 12, 109, 14, 109, 3133, 11, 109, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 3, 111, 3, 111, 3, 112, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 7, 113, 3148, 10, 113, 12, 113, 14, 113, 3151, 11, 113, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 3, 114, 5, 114, 3161, 10, 114, 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, 5, 116, 3176, 10, 116, 3, 117, 3, 117, 3, 117, 3, 117, 3, 118, 3, 118, 3, 118, 3, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 3, 119, 5, 119, 3192, 10, 119, 3, 120, 3, 120, 3, 120, 3, 120, 3, 120, 3, 121, 3, 121, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 123, 7, 123, 3211, 10, 123, 12, 123, 14, 123, 3214, 11, 123, 3, 124, 3, 124, 5, 124, 3218, 10, 124, 3, 124, 5, 124, 3221, 10, 124, 3, 124, 3, 124, 5, 124, 3225, 10, 124, 3, 124, 5, 124, 3228, 10, 124, 3, 124, 3, 124, 3, 124, 3, 124, 5, 124, 3234, 10, 124, 3, 124, 5, 124, 3237, 10, 124, 5, 124, 3239, 10, 124, 3, 125, 3, 125, 3, 125, 3, 126, 3, 126, 3, 126, 3, 126, 5, 126, 3248, 10, 126, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 3, 127, 5, 127, 3257, 10, 127, 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, 131, 3, 131, 3, 131, 3, 131, 3, 131, 5, 131, 3276, 10, 131, 3, 131, 3, 131, 5, 131, 3280, 10, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 132, 3, 132, 3, 132, 3, 132, 5, 132, 3291, 10, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 132, 3, 133, 3, 133, 5, 133, 3300, 10, 133, 3, 133, 3, 133, 3, 133, 3, 133, 5, 133, 3306, 10, 133, 3, 133, 3, 133, 3, 133, 3, 133, 5, 133, 3312, 10, 133, 3, 134, 3, 134, 5, 134, 3316, 10, 134, 3, 134, 5, 134, 3319, 10, 134, 3, 134, 5, 134, 3322, 10, 134, 3, 134, 5, 134, 3325, 10, 134, 3, 134, 5, 134, 3328, 10, 134, 3, 135, 3, 135, 3, 135, 3, 135, 5, 135, 3334, 10, 135, 3, 136, 3, 136, 5, 136, 3338, 10, 136, 3, 136, 3, 136, 3, 136, 3, 136, 3, 136, 5, 136, 3345, 10, 136, 3, 136, 3, 136, 3, 136, 3, 136, 5, 136, 3351, 10, 136, 3, 137, 3, 137, 5, 137, 3355, 10, 137, 3, 137, 5, 137, 3358, 10, 137, 3, 137, 5, 137, 3361, 10, 137, 3, 137, 5, 137, 3364, 10, 137, 3, 138, 3, 138, 3, 139, 3, 139, 3, 139, 3, 139, 5, 139, 3372, 10, 139, 3, 139, 3, 139, 5, 139, 3376, 10, 139, 3, 140, 3, 140, 5, 140, 3380, 10, 140, 3, 140, 3, 140, 3, 140, 3, 140, 5, 140, 3386, 10, 140, 3, 140, 3, 140, 5, 140, 3390, 10, 140, 3, 141, 3, 141, 3, 141, 3, 141, 5, 141, 3396, 10, 141, 3, 141, 3, 141, 3, 141, 3, 142, 3, 142, 3, 143, 3, 143, 3, 143, 3, 143, 3, 144, 6, 144, 3408, 10, 144, 13, 144, 14, 144, 3409, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 5, 145, 3419, 10, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 3, 145, 5, 145, 3436, 10, 145, 3, 145, 3, 145, 3, 145, 5, 145, 3441, 10, 145, 3, 145, 5, 145, 3444, 10, 145, 5, 145, 3446, 10, 145, 3, 146, 3, 146, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 5, 147, 3456, 10, 147, 3, 148, 3, 148, 3, 148, 7, 148, 3461, 10, 148, 12, 148, 14, 148, 3464, 11, 148, 3, 149, 3, 149, 5, 149, 3468, 10, 149, 3, 149, 5, 149, 3471, 10, 149, 3, 149, 5, 149, 3474, 10, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 5, 149, 3481, 10, 149, 3, 149, 5, 149, 3484, 10, 149, 5, 149, 3486, 10, 149, 3, 150, 3, 150, 3, 151, 3, 151, 5, 151, 3492, 10, 151, 3, 152, 3, 152, 3, 152, 3, 153, 3, 153, 3, 153, 3, 153, 5, 153, 3501, 10, 153, 3, 154, 3, 154, 3, 155, 3, 155, 3, 156, 3, 156, 3, 156, 3, 156, 5, 156, 3511, 10, 156, 3, 156, 3, 156, 3, 156, 5, 156, 3516, 10, 156, 3, 157, 3, 157, 3, 157, 3, 158, 3, 158, 3, 158, 3, 158, 5, 158, 3525, 10, 158, 3, 158, 3, 158, 3, 159, 3, 159, 3, 159, 3, 159, 3, 159, 5, 159, 3534, 10, 159, 3, 159, 3, 159, 5, 159, 3538, 10, 159, 3, 159, 3, 159, 3, 160, 7, 160, 3543, 10, 160, 12, 160, 14, 160, 3546, 11, 160, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 5, 161, 3555, 10, 161, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 162, 3, 163, 7, 163, 3564, 10, 163, 12, 163, 14, 163, 3567, 11, 163, 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, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 3, 165, 5, 165, 3676, 10, 165, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 3, 166, 5, 166, 3684, 10, 166, 3, 166, 5, 166, 3687, 10, 166, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 5, 167, 3697, 10, 167, 3, 168, 6, 168, 3700, 10, 168, 13, 168, 14, 168, 3701, 3, 169, 3, 169, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 5, 170, 3712, 10, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 3, 170, 5, 170, 3723, 10, 170, 3, 171, 3, 171, 3, 171, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 7, 172, 3733, 10, 172, 12, 172, 14, 172, 3736, 11, 172, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 174, 3, 174, 3, 174, 7, 174, 3746, 10, 174, 12, 174, 14, 174, 3749, 11, 174, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 5, 175, 3758, 10, 175, 3, 176, 3, 176, 3, 176, 3, 177, 3, 177, 3, 178, 3, 178, 3, 179, 3, 179, 3, 179, 3, 179, 5, 179, 3771, 10, 179, 3, 179, 5, 179, 3774, 10, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 5, 179, 3781, 10, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 5, 179, 3790, 10, 179, 3, 179, 5, 179, 3793, 10, 179, 3, 179, 3, 179, 3, 179, 3, 179, 3, 179, 5, 179, 3800, 10, 179, 5, 179, 3802, 10, 179, 3, 180, 3, 180, 3, 180, 3, 181, 3, 181, 3, 181, 5, 181, 3810, 10, 181, 3, 182, 3, 182, 3, 183, 3, 183, 3, 183, 3, 183, 3, 183, 3, 183, 5, 183, 3820, 10, 183, 5, 183, 3822, 10, 183, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 3830, 10, 184, 3, 184, 3, 184, 5, 184, 3834, 10, 184, 3, 184, 3, 184, 3, 184, 5, 184, 3839, 10, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 3850, 10, 184, 3, 184, 3, 184, 5, 184, 3854, 10, 184, 3, 184, 3, 184, 3, 184, 5, 184, 3859, 10, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 3869, 10, 184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 3875, 10, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 3888, 10, 184, 3, 184, 3, 184, 3, 184, 3, 184, 5, 184, 3894, 10, 184, 5, 184, 3896, 10, 184, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 5, 185, 3903, 10, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 5, 185, 3911, 10, 185, 3, 186, 3, 186, 3, 186, 5, 186, 3916, 10, 186, 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, 5, 188, 3931, 10, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 3, 188, 5, 188, 3944, 10, 188, 5, 188, 3946, 10, 188, 3, 189, 3, 189, 5, 189, 3950, 10, 189, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 5, 190, 3970, 10, 190, 3, 191, 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, 5, 192, 3987, 10, 192, 3, 192, 5, 192, 3990, 10, 192, 3, 192, 5, 192, 3993, 10, 192, 3, 192, 5, 192, 3996, 10, 192, 3, 192, 5, 192, 3999, 10, 192, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 3, 193, 5, 193, 4007, 10, 193, 3, 193, 5, 193, 4010, 10, 193, 3, 193, 5, 193, 4013, 10, 193, 3, 194, 3, 194, 3, 194, 3, 194, 3, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 196, 3, 196, 3, 196, 3, 197, 3, 197, 3, 197, 3, 198, 3, 198, 3, 198, 3, 199, 3, 199, 3, 199, 3, 200, 3, 200, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 201, 3, 202, 3, 202, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 4059, 10, 203, 3, 203, 5, 203, 4062, 10, 203, 3, 203, 5, 203, 4065, 10, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 4083, 10, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 4090, 10, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 5, 203, 4099, 10, 203, 3, 204, 3, 204, 3, 204, 3, 204, 5, 204, 4105, 10, 204, 3, 205, 3, 205, 3, 205, 7, 205, 4110, 10, 205, 12, 205, 14, 205, 4113, 11, 205, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 3, 206, 5, 206, 4122, 10, 206, 3, 207, 3, 207, 3, 207, 3, 208, 6, 208, 4128, 10, 208, 13, 208, 14, 208, 4129, 3, 209, 3, 209, 3, 209, 5, 209, 4135, 10, 209, 3, 209, 3, 209, 3, 210, 3, 210, 3, 211, 3, 211, 3, 212, 3, 212, 3, 213, 3, 213, 5, 213, 4147, 10, 213, 3, 213, 3, 213, 3, 214, 3, 214, 3, 215, 3, 215, 3, 216, 3, 216, 3, 216, 3, 216, 3, 216, 3, 217, 3, 217, 3, 218, 3, 218, 5, 218, 4164, 10, 218, 3, 218, 3, 218, 7, 218, 4168, 10, 218, 12, 218, 14, 218, 4171, 11, 218, 3, 219, 3, 219, 3, 219, 3, 219, 5, 219, 4177, 10, 219, 3, 220, 3, 220, 3, 220, 3, 221, 7, 221, 4183, 10, 221, 12, 221, 14, 221, 4186, 11, 221, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 3, 222, 5, 222, 4199, 10, 222, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 3, 223, 5, 223, 4227, 10, 223, 3, 224, 3, 224, 3, 224, 7, 224, 4232, 10, 224, 12, 224, 14, 224, 4235, 11, 224, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 225, 3, 226, 3, 226, 3, 226, 7, 226, 4246, 10, 226, 12, 226, 14, 226, 4249, 11, 226, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 3, 228, 5, 228, 4263, 10, 228, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 230, 3, 230, 5, 230, 4276, 10, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 5, 230, 4285, 10, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 5, 230, 4310, 10, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 5, 230, 4321, 10, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 3, 230, 5, 230, 4388, 10, 230, 3, 231, 3, 231, 3, 231, 3, 231, 3, 232, 3, 232, 3, 232, 7, 232, 4397, 10, 232, 12, 232, 14, 232, 4400, 11, 232, 3, 233, 3, 233, 3, 233, 5, 233, 4405, 10, 233, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 5, 234, 4413, 10, 234, 3, 235, 3, 235, 3, 235, 3, 235, 3, 236, 3, 236, 3, 236, 7, 236, 4422, 10, 236, 12, 236, 14, 236, 4425, 11, 236, 3, 237, 3, 237, 3, 237, 3, 237, 3, 238, 3, 238, 3, 239, 3, 239, 3, 239, 7, 239, 4436, 10, 239, 12, 239, 14, 239, 4439, 11, 239, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 5, 240, 4447, 10, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 5, 240, 4457, 10, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 5, 240, 4469, 10, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 3, 240, 5, 240, 4484, 10, 240, 3, 241, 3, 241, 3, 241, 3, 241, 3, 242, 3, 242, 3, 242, 3, 242, 3, 242, 5, 242, 4495, 10, 242, 3, 242, 3, 242, 3, 242, 3, 242, 3, 242, 3, 242, 5, 242, 4503, 10, 242, 3, 242, 3, 242, 3, 242, 3, 243, 3, 243, 3, 243, 7, 243, 4511, 10, 243, 12, 243, 14, 243, 4514, 11, 243, 3, 244, 3, 244, 3, 244, 3, 244, 5, 244, 4520, 10, 244, 3, 244, 5, 244, 4523, 10, 244, 3, 244, 3, 244, 3, 244, 3, 244, 5, 244, 4529, 10, 244, 3, 244, 5, 244, 4532, 10, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 5, 244, 4547, 10, 244, 3, 245, 3, 245, 3, 246, 3, 246, 3, 246, 3, 247, 3, 247, 3, 247, 3, 247, 3, 247, 3, 247, 5, 247, 4560, 10, 247, 3, 248, 3, 248, 3, 249, 3, 249, 3, 249, 3, 249, 3, 249, 3, 249, 3, 249, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 3, 250, 5, 250, 4589, 10, 250, 3, 251, 3, 251, 3, 251, 7, 251, 4594, 10, 251, 12, 251, 14, 251, 4597, 11, 251, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 3, 252, 5, 252, 4611, 10, 252, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 5, 253, 4620, 10, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 3, 253, 5, 253, 4631, 10, 253, 5, 253, 4633, 10, 253, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 5, 254, 4642, 10, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 3, 254, 5, 254, 4653, 10, 254, 5, 254, 4655, 10, 254, 3, 255, 3, 255, 3, 255, 3, 255, 3, 255, 5, 255, 4662, 10, 255, 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, 5, 257, 4677, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4683, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4691, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4697, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4705, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4715, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4721, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4729, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4735, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4743, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4750, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4759, 10, 257, 5, 257, 4761, 10, 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, 5, 258, 4786, 10, 258, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 5, 259, 4793, 10, 259, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 5, 260, 4804, 10, 260, 3, 260, 3, 260, 3, 260, 3, 260, 5, 260, 4810, 10, 260, 3, 261, 3, 261, 3, 262, 3, 262, 3, 262, 7, 262, 4817, 10, 262, 12, 262, 14, 262, 4820, 11, 262, 3, 263, 3, 263, 5, 263, 4824, 10, 263, 3, 264, 3, 264, 6, 264, 4828, 10, 264, 13, 264, 14, 264, 4829, 3, 265, 3, 265, 3, 265, 7, 265, 4835, 10, 265, 12, 265, 14, 265, 4838, 11, 265, 3, 266, 3, 266, 5, 266, 4842, 10, 266, 3, 266, 3, 266, 5, 266, 4846, 10, 266, 3, 266, 5, 266, 4849, 10, 266, 3, 267, 3, 267, 3, 267, 3, 267, 5, 267, 4855, 10, 267, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 3, 268, 5, 268, 5004, 10, 268, 3, 269, 3, 269, 5, 269, 5008, 10, 269, 3, 270, 3, 270, 3, 270, 5, 270, 5013, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5024, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5035, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5046, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5057, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5068, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5079, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5090, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5102, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5113, 10, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 3, 270, 5, 270, 5121, 10, 270, 3, 271, 3, 271, 3, 271, 3, 272, 3, 272, 5, 272, 5128, 10, 272, 3, 273, 3, 273, 3, 273, 3, 273, 5, 273, 5134, 10, 273, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5142, 10, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5147, 10, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5152, 10, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5157, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5163, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5170, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5176, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5182, 10, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5187, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5193, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5200, 10, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5205, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5211, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5218, 10, 274, 3, 274, 5, 274, 5221, 10, 274, 3, 275, 3, 275, 3, 276, 3, 276, 3, 277, 3, 277, 3, 277, 3, 277, 3, 277, 3, 277, 3, 277, 5, 277, 5234, 10, 277, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5243, 10, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5255, 10, 278, 5, 278, 5257, 10, 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, 5, 279, 5274, 10, 279, 3, 280, 3, 280, 3, 280, 7, 280, 5279, 10, 280, 12, 280, 14, 280, 5282, 11, 280, 3, 281, 3, 281, 5, 281, 5286, 10, 281, 3, 281, 3, 281, 5, 281, 5290, 10, 281, 3, 281, 3, 281, 5, 281, 5294, 10, 281, 3, 281, 3, 281, 5, 281, 5298, 10, 281, 5, 281, 5300, 10, 281, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 5, 282, 5360, 10, 282, 3, 283, 3, 283, 3, 283, 7, 283, 5365, 10, 283, 12, 283, 14, 283, 5368, 11, 283, 3, 284, 3, 284, 3, 284, 5, 284, 5373, 10, 284, 3, 285, 3, 285, 3, 285, 3, 285, 3, 286, 3, 286, 3, 286, 3, 286, 3, 286, 5, 286, 5384, 10, 286, 3, 286, 5, 286, 5387, 10, 286, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 5, 287, 5394, 10, 287, 3, 287, 5, 287, 5397, 10, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 3, 287, 5, 287, 5407, 10, 287, 3, 287, 5, 287, 5410, 10, 287, 5, 287, 5412, 10, 287, 3, 288, 3, 288, 3, 288, 3, 288, 3, 289, 3, 289, 3, 289, 3, 289, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 290, 3, 291, 7, 291, 5429, 10, 291, 12, 291, 14, 291, 5432, 11, 291, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 5, 292, 5443, 10, 292, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 5, 293, 5452, 10, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 5, 293, 5461, 10, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 5, 293, 5473, 10, 293, 5, 293, 5475, 10, 293, 3, 294, 3, 294, 3, 295, 3, 295, 5, 295, 5481, 10, 295, 3, 295, 3, 295, 5, 295, 5485, 10, 295, 3, 295, 5, 295, 5488, 10, 295, 3, 295, 3, 295, 3, 295, 5, 295, 5493, 10, 295, 3, 295, 3, 295, 3, 295, 3, 295, 5, 295, 5499, 10, 295, 3, 295, 5, 295, 5502, 10, 295, 3, 295, 5, 295, 5505, 10, 295, 3, 295, 5, 295, 5508, 10, 295, 3, 295, 3, 295, 5, 295, 5512, 10, 295, 3, 295, 3, 295, 5, 295, 5516, 10, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 3, 295, 5, 295, 5525, 10, 295, 3, 295, 3, 295, 3, 295, 3, 295, 5, 295, 5531, 10, 295, 3, 295, 5, 295, 5534, 10, 295, 3, 295, 5, 295, 5537, 10, 295, 3, 295, 5, 295, 5540, 10, 295, 5, 295, 5542, 10, 295, 3, 296, 3, 296, 3, 297, 3, 297, 3, 298, 3, 298, 3, 299, 3, 299, 3, 299, 3, 300, 3, 300, 3, 300, 7, 300, 5556, 10, 300, 12, 300, 14, 300, 5559, 11, 300, 3, 301, 5, 301, 5562, 10, 301, 3, 301, 5, 301, 5565, 10, 301, 3, 301, 5, 301, 5568, 10, 301, 3, 301, 5, 301, 5571, 10, 301, 3, 301, 5, 301, 5574, 10, 301, 3, 301, 3, 301, 3, 301, 5, 301, 5579, 10, 301, 3, 301, 5, 301, 5582, 10, 301, 5, 301, 5584, 10, 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, 5597, 10, 302, 3, 303, 3, 303, 3, 303, 3, 303, 3, 303, 3, 304, 3, 304, 3, 304, 7, 304, 5607, 10, 304, 12, 304, 14, 304, 5610, 11, 304, 3, 305, 3, 305, 3, 305, 3, 306, 3, 306, 3, 307, 3, 307, 3, 308, 3, 308, 3, 308, 3, 308, 5, 308, 5623, 10, 308, 3, 309, 3, 309, 5, 309, 5627, 10, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 5, 309, 5639, 10, 309, 5, 309, 5641, 10, 309, 3, 309, 3, 309, 3, 310, 3, 310, 3, 310, 3, 311, 3, 311, 5, 311, 5650, 10, 311, 3, 311, 3, 311, 3, 312, 3, 312, 3, 312, 7, 312, 5657, 10, 312, 12, 312, 14, 312, 5660, 11, 312, 3, 313, 3, 313, 3, 313, 7, 313, 5665, 10, 313, 12, 313, 14, 313, 5668, 11, 313, 3, 314, 3, 314, 3, 314, 3, 314, 3, 314, 3, 314, 5, 314, 5676, 10, 314, 5, 314, 5678, 10, 314, 3, 315, 3, 315, 5, 315, 5682, 10, 315, 3, 315, 3, 315, 3, 316, 3, 316, 3, 316, 7, 316, 5689, 10, 316, 12, 316, 14, 316, 5692, 11, 316, 3, 317, 3, 317, 5, 317, 5696, 10, 317, 3, 317, 3, 317, 3, 317, 3, 317, 5, 317, 5702, 10, 317, 3, 317, 3, 317, 3, 317, 5, 317, 5707, 10, 317, 3, 318, 3, 318, 5, 318, 5711, 10, 318, 3, 318, 3, 318, 3, 318, 5, 318, 5716, 10, 318, 3, 319, 3, 319, 3, 320, 3, 320, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 5, 321, 5734, 10, 321, 3, 322, 3, 322, 3, 322, 5, 322, 5739, 10, 322, 3, 323, 3, 323, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 3, 324, 5, 324, 5754, 10, 324, 3, 324, 3, 324, 3, 325, 3, 325, 3, 325, 7, 325, 5761, 10, 325, 12, 325, 14, 325, 5764, 11, 325, 3, 326, 3, 326, 3, 326, 3, 327, 3, 327, 3, 327, 7, 327, 5772, 10, 327, 12, 327, 14, 327, 5775, 11, 327, 3, 328, 6, 328, 5778, 10, 328, 13, 328, 14, 328, 5779, 3, 328, 3, 328, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 3, 329, 5, 329, 5819, 10, 329, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 3, 330, 5, 330, 5829, 10, 330, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 5, 331, 5836, 10, 331, 3, 332, 3, 332, 3, 332, 3, 332, 3, 332, 3, 332, 3, 332, 7, 332, 5845, 10, 332, 12, 332, 14, 332, 5848, 11, 332, 3, 333, 3, 333, 3, 333, 3, 334, 3, 334, 3, 334, 3, 335, 3, 335, 3, 335, 7, 335, 5859, 10, 335, 12, 335, 14, 335, 5862, 11, 335, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 5, 336, 5869, 10, 336, 3, 337, 6, 337, 5872, 10, 337, 13, 337, 14, 337, 5873, 3, 338, 3, 338, 3, 339, 3, 339, 3, 339, 3, 339, 5, 339, 5882, 10, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 5, 339, 5890, 10, 339, 3, 339, 3, 339, 3, 339, 3, 339, 5, 339, 5896, 10, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 5, 339, 5904, 10, 339, 3, 339, 3, 339, 3, 339, 3, 339, 5, 339, 5910, 10, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 5, 339, 5918, 10, 339, 5, 339, 5920, 10, 339, 3, 340, 3, 340, 3, 340, 3, 340, 5, 340, 5926, 10, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 3, 340, 5, 340, 5934, 10, 340, 5, 340, 5936, 10, 340, 3, 341, 3, 341, 3, 341, 3, 341, 5, 341, 5942, 10, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 3, 341, 5, 341, 5950, 10, 341, 5, 341, 5952, 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, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 3, 342, 5, 342, 5976, 10, 342, 3, 343, 3, 343, 3, 343, 7, 343, 5981, 10, 343, 12, 343, 14, 343, 5984, 11, 343, 3, 343, 3, 343, 3, 344, 3, 344, 3, 344, 7, 344, 5991, 10, 344, 12, 344, 14, 344, 5994, 11, 344, 3, 345, 3, 345, 3, 345, 3, 346, 3, 346, 3, 346, 3, 347, 6, 347, 6003, 10, 347, 13, 347, 14, 347, 6004, 3, 348, 3, 348, 3, 348, 5, 348, 6010, 10, 348, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 5, 349, 6023, 10, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 5, 349, 6035, 10, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 5, 349, 6047, 10, 349, 5, 349, 6049, 10, 349, 3, 350, 3, 350, 3, 350, 3, 350, 5, 350, 6055, 10, 350, 3, 351, 3, 351, 3, 351, 5, 351, 6060, 10, 351, 3, 351, 3, 351, 3, 351, 3, 351, 3, 351, 3, 351, 5, 351, 6068, 10, 351, 3, 352, 3, 352, 3, 352, 3, 353, 3, 353, 5, 353, 6075, 10, 353, 3, 353, 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, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 3, 354, 5, 354, 6120, 10, 354, 3, 355, 3, 355, 3, 355, 5, 355, 6125, 10, 355, 3, 355, 3, 355, 3, 355, 3, 355, 3, 355, 5, 355, 6132, 10, 355, 3, 356, 3, 356, 3, 356, 5, 356, 6137, 10, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 5, 356, 6144, 10, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 5, 356, 6154, 10, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 5, 356, 6164, 10, 356, 3, 356, 3, 356, 5, 356, 6168, 10, 356, 3, 357, 3, 357, 3, 358, 3, 358, 3, 359, 3, 359, 3, 359, 7, 359, 6177, 10, 359, 12, 359, 14, 359, 6180, 11, 359, 3, 360, 3, 360, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 5, 361, 6196, 10, 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, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 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, 6267, 10, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 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, 6462, 10, 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, 6475, 10, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 5, 362, 6486, 10, 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, 6499, 10, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 5, 362, 6511, 10, 362, 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, 6525, 10, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 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, 6557, 10, 362, 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, 6571, 10, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 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, 6683, 10, 362, 5, 362, 6685, 10, 362, 3, 363, 3, 363, 3, 364, 3, 364, 3, 364, 3, 365, 3, 365, 3, 365, 3, 365, 5, 365, 6696, 10, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 5, 365, 6707, 10, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 5, 365, 6718, 10, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 5, 365, 6731, 10, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 5, 365, 6743, 10, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 5, 365, 6754, 10, 365, 3, 365, 3, 365, 3, 365, 3, 365, 3, 365, 5, 365, 6761, 10, 365, 3, 366, 3, 366, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 3, 367, 5, 367, 6982, 10, 367, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 368, 3, 369, 3, 369, 3, 369, 7, 369, 6995, 10, 369, 12, 369, 14, 369, 6998, 11, 369, 3, 370, 3, 370, 3, 370, 3, 370, 3, 370, 3, 370, 3, 370, 3, 370, 5, 370, 7008, 10, 370, 3, 371, 3, 371, 3, 371, 3, 371, 3, 371, 5, 371, 7015, 10, 371, 3, 372, 3, 372, 3, 372, 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, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 5, 373, 7069, 10, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 3, 373, 5, 373, 7210, 10, 373, 3, 374, 3, 374, 3, 374, 3, 374, 5, 374, 7216, 10, 374, 3, 374, 5, 374, 7219, 10, 374, 3, 375, 3, 375, 3, 376, 3, 376, 3, 376, 3, 376, 3, 376, 3, 376, 5, 376, 7229, 10, 376, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 5, 377, 7258, 10, 377, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 5, 378, 7268, 10, 378, 3, 379, 3, 379, 3, 379, 7, 379, 7273, 10, 379, 12, 379, 14, 379, 7276, 11, 379, 3, 380, 3, 380, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 5, 381, 7298, 10, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 5, 381, 7307, 10, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 3, 381, 5, 381, 7319, 10, 381, 3, 382, 3, 382, 3, 382, 3, 382, 5, 382, 7325, 10, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 3, 382, 5, 382, 7333, 10, 382, 5, 382, 7335, 10, 382, 3, 383, 3, 383, 5, 383, 7339, 10, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 5, 383, 7349, 10, 383, 3, 383, 3, 383, 5, 383, 7353, 10, 383, 3, 383, 3, 383, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 3, 384, 5, 384, 7363, 10, 384, 3, 385, 5, 385, 7366, 10, 385, 3, 385, 3, 385, 5, 385, 7370, 10, 385, 7, 385, 7372, 10, 385, 12, 385, 14, 385, 7375, 11, 385, 3, 386, 3, 386, 3, 386, 3, 386, 3, 386, 5, 386, 7382, 10, 386, 3, 387, 3, 387, 3, 388, 3, 388, 3, 389, 3, 389, 3, 390, 3, 390, 3, 390, 5, 390, 7393, 10, 390, 3, 391, 3, 391, 3, 391, 3, 392, 3, 392, 3, 392, 3, 393, 3, 393, 3, 393, 3, 393, 5, 393, 7405, 10, 393, 3, 394, 3, 394, 5, 394, 7409, 10, 394, 3, 394, 5, 394, 7412, 10, 394, 3, 394, 3, 394, 5, 394, 7416, 10, 394, 3, 394, 5, 394, 7419, 10, 394, 3, 394, 3, 394, 3, 394, 5, 394, 7424, 10, 394, 3, 394, 3, 394, 5, 394, 7428, 10, 394, 3, 394, 5, 394, 7431, 10, 394, 3, 394, 3, 394, 5, 394, 7435, 10, 394, 3, 394, 5, 394, 7438, 10, 394, 3, 394, 3, 394, 5, 394, 7442, 10, 394, 3, 394, 5, 394, 7445, 10, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 5, 394, 7456, 10, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 5, 394, 7463, 10, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 3, 394, 5, 394, 7476, 10, 394, 3, 395, 3, 395, 3, 396, 3, 396, 3, 396, 3, 396, 3, 396, 3, 396, 3, 396, 3, 396, 3, 396, 3, 396, 5, 396, 7490, 10, 396, 3, 397, 3, 397, 5, 397, 7494, 10, 397, 3, 397, 7, 397, 7497, 10, 397, 12, 397, 14, 397, 7500, 11, 397, 3, 398, 3, 398, 3, 399, 3, 399, 5, 399, 7506, 10, 399, 3, 399, 3, 399, 3, 400, 3, 400, 3, 400, 5, 400, 7513, 10, 400, 3, 400, 5, 400, 7516, 10, 400, 3, 400, 3, 400, 3, 400, 5, 400, 7521, 10, 400, 3, 400, 5, 400, 7524, 10, 400, 3, 400, 3, 400, 3, 400, 3, 400, 3, 400, 3, 400, 3, 400, 5, 400, 7533, 10, 400, 5, 400, 7535, 10, 400, 3, 400, 3, 400, 3, 400, 5, 400, 7540, 10, 400, 3, 401, 3, 401, 5, 401, 7544, 10, 401, 3, 401, 3, 401, 3, 401, 3, 402, 3, 402, 3, 402, 3, 403, 3, 403, 3, 403, 3, 403, 5, 403, 7556, 10, 403, 3, 403, 5, 403, 7559, 10, 403, 3, 404, 3, 404, 3, 405, 6, 405, 7564, 10, 405, 13, 405, 14, 405, 7565, 3, 406, 3, 406, 5, 406, 7570, 10, 406, 3, 406, 3, 406, 3, 406, 5, 406, 7575, 10, 406, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 5, 407, 7585, 10, 407, 3, 408, 3, 408, 3, 409, 3, 409, 3, 409, 3, 409, 3, 409, 5, 409, 7594, 10, 409, 3, 409, 5, 409, 7597, 10, 409, 3, 409, 3, 409, 3, 409, 5, 409, 7602, 10, 409, 3, 410, 3, 410, 3, 410, 3, 410, 3, 410, 3, 411, 3, 411, 3, 411, 3, 411, 5, 411, 7613, 10, 411, 3, 411, 3, 411, 5, 411, 7617, 10, 411, 3, 411, 3, 411, 3, 411, 3, 411, 5, 411, 7623, 10, 411, 3, 412, 3, 412, 3, 412, 7, 412, 7628, 10, 412, 12, 412, 14, 412, 7631, 11, 412, 3, 413, 3, 413, 3, 414, 3, 414, 3, 414, 3, 414, 3, 414, 3, 414, 3, 415, 3, 415, 3, 415, 3, 415, 3, 415, 3, 416, 3, 416, 3, 416, 3, 416, 5, 416, 7650, 10, 416, 3, 416, 3, 416, 3, 416, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 5, 417, 7671, 10, 417, 3, 417, 3, 417, 5, 417, 7675, 10, 417, 3, 417, 3, 417, 3, 417, 5, 417, 7680, 10, 417, 3, 418, 3, 418, 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, 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, 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, 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, 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, 420, 3, 420, 5, 420, 7763, 10, 420, 3, 421, 3, 421, 3, 422, 3, 422, 5, 422, 7769, 10, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 423, 3, 423, 5, 423, 7782, 10, 423, 3, 423, 3, 423, 5, 423, 7786, 10, 423, 3, 423, 3, 423, 5, 423, 7790, 10, 423, 3, 423, 3, 423, 5, 423, 7794, 10, 423, 3, 423, 3, 423, 3, 423, 3, 423, 5, 423, 7800, 10, 423, 3, 424, 3, 424, 3, 424, 3, 425, 3, 425, 5, 425, 7807, 10, 425, 3, 425, 5, 425, 7810, 10, 425, 3, 425, 5, 425, 7813, 10, 425, 3, 425, 5, 425, 7816, 10, 425, 3, 425, 5, 425, 7819, 10, 425, 3, 425, 3, 425, 3, 425, 3, 425, 3, 425, 5, 425, 7826, 10, 425, 5, 425, 7828, 10, 425, 3, 426, 3, 426, 5, 426, 7832, 10, 426, 3, 426, 5, 426, 7835, 10, 426, 3, 426, 3, 426, 3, 426, 3, 426, 3, 426, 5, 426, 7842, 10, 426, 5, 426, 7844, 10, 426, 3, 427, 3, 427, 3, 427, 7, 427, 7849, 10, 427, 12, 427, 14, 427, 7852, 11, 427, 3, 428, 3, 428, 3, 429, 3, 429, 5, 429, 7858, 10, 429, 3, 430, 3, 430, 5, 430, 7862, 10, 430, 3, 431, 3, 431, 5, 431, 7866, 10, 431, 3, 432, 3, 432, 3, 433, 3, 433, 3, 434, 3, 434, 3, 435, 3, 435, 3, 436, 3, 436, 3, 436, 3, 436, 3, 437, 3, 437, 5, 437, 7882, 10, 437, 3, 438, 3, 438, 3, 438, 7, 438, 7887, 10, 438, 12, 438, 14, 438, 7890, 11, 438, 3, 439, 3, 439, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 5, 440, 7899, 10, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 3, 440, 5, 440, 7912, 10, 440, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 3, 441, 5, 441, 7923, 10, 441, 3, 442, 3, 442, 3, 442, 7, 442, 7928, 10, 442, 12, 442, 14, 442, 7931, 11, 442, 3, 443, 3, 443, 5, 443, 7935, 10, 443, 3, 444, 3, 444, 5, 444, 7939, 10, 444, 3, 445, 3, 445, 5, 445, 7943, 10, 445, 3, 446, 3, 446, 3, 446, 5, 446, 7948, 10, 446, 3, 446, 3, 446, 3, 446, 3, 447, 3, 447, 3, 447, 3, 447, 3, 448, 3, 448, 3, 448, 3, 448, 5, 448, 7961, 10, 448, 3, 449, 3, 449, 3, 449, 5, 449, 7966, 10, 449, 3, 449, 3, 449, 5, 449, 7970, 10, 449, 3, 449, 3, 449, 3, 449, 3, 449, 3, 449, 3, 449, 5, 449, 7978, 10, 449, 3, 449, 5, 449, 7981, 10, 449, 3, 449, 3, 449, 5, 449, 7985, 10, 449, 3, 449, 3, 449, 3, 449, 3, 449, 3, 449, 3, 449, 3, 449, 3, 449, 3, 449, 5, 449, 7996, 10, 449, 3, 449, 5, 449, 7999, 10, 449, 5, 449, 8001, 10, 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, 451, 5, 451, 8017, 10, 451, 3, 452, 5, 452, 8020, 10, 452, 3, 452, 3, 452, 3, 452, 3, 452, 3, 452, 5, 452, 8027, 10, 452, 3, 452, 5, 452, 8030, 10, 452, 3, 453, 3, 453, 3, 453, 5, 453, 8035, 10, 453, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 3, 454, 5, 454, 8050, 10, 454, 3, 454, 3, 454, 3, 454, 3, 454, 5, 454, 8056, 10, 454, 3, 455, 3, 455, 3, 456, 3, 456, 3, 456, 7, 456, 8063, 10, 456, 12, 456, 14, 456, 8066, 11, 456, 3, 457, 3, 457, 3, 457, 3, 458, 3, 458, 3, 458, 5, 458, 8074, 10, 458, 3, 458, 3, 458, 3, 458, 3, 458, 3, 458, 5, 458, 8081, 10, 458, 3, 458, 5, 458, 8084, 10, 458, 3, 459, 3, 459, 3, 459, 3, 459, 5, 459, 8090, 10, 459, 3, 459, 3, 459, 3, 459, 5, 459, 8095, 10, 459, 3, 460, 3, 460, 3, 460, 3, 461, 5, 461, 8101, 10, 461, 3, 461, 3, 461, 3, 461, 3, 461, 5, 461, 8107, 10, 461, 3, 461, 5, 461, 8110, 10, 461, 3, 461, 5, 461, 8113, 10, 461, 3, 462, 3, 462, 3, 462, 3, 463, 3, 463, 5, 463, 8120, 10, 463, 3, 463, 3, 463, 5, 463, 8124, 10, 463, 3, 463, 5, 463, 8127, 10, 463, 3, 464, 3, 464, 3, 464, 3, 464, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 5, 465, 8142, 10, 465, 3, 465, 5, 465, 8145, 10, 465, 3, 466, 3, 466, 3, 467, 3, 467, 3, 467, 5, 467, 8152, 10, 467, 3, 468, 5, 468, 8155, 10, 468, 3, 468, 3, 468, 3, 468, 3, 468, 3, 468, 5, 468, 8162, 10, 468, 3, 468, 5, 468, 8165, 10, 468, 3, 468, 5, 468, 8168, 10, 468, 3, 469, 3, 469, 3, 469, 7, 469, 8173, 10, 469, 12, 469, 14, 469, 8176, 11, 469, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 3, 470, 5, 470, 8188, 10, 470, 3, 471, 3, 471, 3, 471, 3, 472, 3, 472, 3, 472, 7, 472, 8196, 10, 472, 12, 472, 14, 472, 8199, 11, 472, 3, 473, 3, 473, 3, 473, 3, 473, 3, 473, 3, 473, 3, 473, 3, 473, 3, 474, 3, 474, 3, 475, 3, 475, 3, 475, 3, 475, 3, 475, 7, 475, 8216, 10, 475, 12, 475, 14, 475, 8219, 11, 475, 3, 476, 3, 476, 3, 476, 3, 476, 3, 476, 5, 476, 8226, 10, 476, 3, 477, 3, 477, 5, 477, 8230, 10, 477, 3, 478, 3, 478, 3, 478, 3, 478, 3, 478, 3, 478, 3, 478, 3, 478, 5, 478, 8240, 10, 478, 3, 479, 3, 479, 5, 479, 8244, 10, 479, 3, 479, 3, 479, 5, 479, 8248, 10, 479, 3, 479, 3, 479, 5, 479, 8252, 10, 479, 5, 479, 8254, 10, 479, 3, 479, 3, 479, 3, 479, 5, 479, 8259, 10, 479, 3, 479, 3, 479, 5, 479, 8263, 10, 479, 3, 479, 3, 479, 5, 479, 8267, 10, 479, 5, 479, 8269, 10, 479, 5, 479, 8271, 10, 479, 3, 480, 3, 480, 5, 480, 8275, 10, 480, 3, 481, 3, 481, 5, 481, 8279, 10, 481, 3, 481, 5, 481, 8282, 10, 481, 3, 481, 5, 481, 8285, 10, 481, 3, 481, 3, 481, 3, 481, 5, 481, 8290, 10, 481, 3, 481, 5, 481, 8293, 10, 481, 3, 481, 5, 481, 8296, 10, 481, 3, 481, 5, 481, 8299, 10, 481, 3, 481, 5, 481, 8302, 10, 481, 3, 481, 5, 481, 8305, 10, 481, 3, 481, 5, 481, 8308, 10, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 3, 481, 5, 481, 8317, 10, 481, 5, 481, 8319, 10, 481, 3, 481, 3, 481, 3, 481, 5, 481, 8324, 10, 481, 7, 481, 8326, 10, 481, 12, 481, 14, 481, 8329, 11, 481, 3, 482, 3, 482, 3, 482, 5, 482, 8334, 10, 482, 3, 483, 3, 483, 5, 483, 8338, 10, 483, 3, 484, 3, 484, 5, 484, 8342, 10, 484, 3, 484, 3, 484, 3, 485, 3, 485, 3, 485, 7, 485, 8349, 10, 485, 12, 485, 14, 485, 8352, 11, 485, 3, 486, 3, 486, 5, 486, 8356, 10, 486, 3, 486, 3, 486, 5, 486, 8360, 10, 486, 3, 486, 3, 486, 3, 486, 3, 486, 3, 487, 3, 487, 3, 487, 5, 487, 8369, 10, 487, 3, 488, 3, 488, 3, 489, 3, 489, 3, 489, 3, 489, 3, 489, 5, 489, 8378, 10, 489, 3, 490, 3, 490, 5, 490, 8382, 10, 490, 3, 491, 5, 491, 8385, 10, 491, 3, 491, 3, 491, 5, 491, 8389, 10, 491, 3, 491, 3, 491, 3, 491, 5, 491, 8394, 10, 491, 3, 491, 3, 491, 3, 491, 3, 491, 5, 491, 8400, 10, 491, 3, 492, 3, 492, 3, 493, 3, 493, 3, 494, 3, 494, 3, 494, 3, 494, 3, 494, 3, 494, 5, 494, 8412, 10, 494, 3, 495, 3, 495, 3, 496, 3, 496, 3, 497, 3, 497, 3, 497, 3, 497, 3, 498, 3, 498, 3, 498, 7, 498, 8425, 10, 498, 12, 498, 14, 498, 8428, 11, 498, 3, 499, 3, 499, 3, 499, 3, 499, 5, 499, 8434, 10, 499, 5, 499, 8436, 10, 499, 3, 499, 5, 499, 8439, 10, 499, 3, 500, 3, 500, 5, 500, 8443, 10, 500, 3, 500, 3, 500, 5, 500, 8447, 10, 500, 5, 500, 8449, 10, 500, 3, 501, 3, 501, 3, 502, 3, 502, 3, 502, 3, 502, 5, 502, 8457, 10, 502, 3, 502, 3, 502, 3, 502, 3, 502, 3, 502, 3, 502, 3, 502, 5, 502, 8466, 10, 502, 3, 502, 3, 502, 3, 502, 3, 502, 5, 502, 8472, 10, 502, 5, 502, 8474, 10, 502, 5, 502, 8476, 10, 502, 3, 503, 3, 503, 3, 503, 3, 503, 3, 503, 5, 503, 8483, 10, 503, 3, 504, 3, 504, 5, 504, 8487, 10, 504, 3, 505, 3, 505, 3, 506, 3, 506, 3, 506, 3, 506, 3, 506, 5, 506, 8496, 10, 506, 3, 507, 3, 507, 5, 507, 8500, 10, 507, 3, 508, 3, 508, 3, 509, 3, 509, 3, 510, 3, 510, 3, 510, 3, 510, 3, 511, 3, 511, 3, 511, 7, 511, 8513, 10, 511, 12, 511, 14, 511, 8516, 11, 511, 3, 512, 3, 512, 3, 512, 3, 512, 3, 512, 5, 512, 8523, 10, 512, 3, 513, 3, 513, 3, 513, 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, 516, 3, 517, 3, 517, 3, 517, 3, 518, 3, 518, 3, 518, 3, 518, 5, 518, 8551, 10, 518, 3, 519, 3, 519, 3, 520, 6, 520, 8556, 10, 520, 13, 520, 14, 520, 8557, 3, 521, 3, 521, 5, 521, 8562, 10, 521, 3, 521, 5, 521, 8565, 10, 521, 3, 522, 3, 522, 3, 522, 5, 522, 8570, 10, 522, 3, 522, 3, 522, 5, 522, 8574, 10, 522, 3, 522, 5, 522, 8577, 10, 522, 3, 523, 3, 523, 3, 523, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 3, 524, 7, 524, 8591, 10, 524, 12, 524, 14, 524, 8594, 11, 524, 3, 525, 3, 525, 3, 525, 3, 526, 3, 526, 3, 526, 7, 526, 8602, 10, 526, 12, 526, 14, 526, 8605, 11, 526, 3, 527, 3, 527, 5, 527, 8609, 10, 527, 3, 527, 5, 527, 8612, 10, 527, 3, 527, 3, 527, 5, 527, 8616, 10, 527, 3, 527, 3, 527, 5, 527, 8620, 10, 527, 3, 527, 3, 527, 5, 527, 8624, 10, 527, 3, 527, 3, 527, 3, 527, 5, 527, 8629, 10, 527, 3, 527, 3, 527, 5, 527, 8633, 10, 527, 3, 527, 3, 527, 5, 527, 8637, 10, 527, 5, 527, 8639, 10, 527, 3, 527, 3, 527, 3, 527, 3, 527, 3, 527, 3, 527, 3, 527, 5, 527, 8648, 10, 527, 3, 527, 3, 527, 3, 527, 5, 527, 8653, 10, 527, 3, 527, 3, 527, 3, 527, 3, 527, 5, 527, 8659, 10, 527, 3, 527, 3, 527, 5, 527, 8663, 10, 527, 5, 527, 8665, 10, 527, 3, 527, 3, 527, 3, 527, 3, 527, 3, 527, 5, 527, 8672, 10, 527, 3, 527, 3, 527, 3, 527, 5, 527, 8677, 10, 527, 3, 527, 3, 527, 3, 527, 3, 527, 7, 527, 8683, 10, 527, 12, 527, 14, 527, 8686, 11, 527, 3, 528, 5, 528, 8689, 10, 528, 3, 528, 3, 528, 3, 528, 3, 528, 3, 528, 5, 528, 8696, 10, 528, 3, 529, 3, 529, 3, 530, 3, 530, 3, 530, 5, 530, 8703, 10, 530, 3, 530, 5, 530, 8706, 10, 530, 3, 530, 3, 530, 3, 530, 3, 530, 5, 530, 8712, 10, 530, 3, 531, 3, 531, 5, 531, 8716, 10, 531, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 3, 532, 5, 532, 8725, 10, 532, 3, 533, 3, 533, 5, 533, 8729, 10, 533, 3, 533, 3, 533, 3, 533, 3, 533, 3, 533, 3, 533, 5, 533, 8737, 10, 533, 5, 533, 8739, 10, 533, 3, 534, 3, 534, 3, 534, 7, 534, 8744, 10, 534, 12, 534, 14, 534, 8747, 11, 534, 3, 535, 3, 535, 5, 535, 8751, 10, 535, 3, 535, 5, 535, 8754, 10, 535, 3, 536, 3, 536, 3, 536, 3, 536, 3, 536, 3, 536, 5, 536, 8762, 10, 536, 3, 537, 3, 537, 3, 537, 3, 537, 3, 537, 3, 538, 3, 538, 5, 538, 8771, 10, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 3, 538, 5, 538, 8779, 10, 538, 5, 538, 8781, 10, 538, 3, 539, 3, 539, 5, 539, 8785, 10, 539, 3, 540, 3, 540, 3, 540, 7, 540, 8790, 10, 540, 12, 540, 14, 540, 8793, 11, 540, 3, 541, 3, 541, 3, 541, 3, 541, 3, 541, 3, 542, 3, 542, 3, 542, 3, 543, 3, 543, 3, 543, 3, 544, 3, 544, 3, 544, 3, 544, 3, 544, 5, 544, 8811, 10, 544, 3, 545, 3, 545, 3, 546, 3, 546, 3, 546, 7, 546, 8818, 10, 546, 12, 546, 14, 546, 8821, 11, 546, 3, 547, 3, 547, 3, 547, 5, 547, 8826, 10, 547, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 5, 548, 8845, 10, 548, 3, 548, 3, 548, 3, 549, 3, 549, 3, 549, 7, 549, 8852, 10, 549, 12, 549, 14, 549, 8855, 11, 549, 3, 550, 3, 550, 3, 550, 5, 550, 8860, 10, 550, 3, 550, 3, 550, 5, 550, 8864, 10, 550, 3, 551, 6, 551, 8867, 10, 551, 13, 551, 14, 551, 8868, 3, 552, 3, 552, 3, 552, 3, 552, 3, 552, 3, 552, 3, 552, 3, 552, 5, 552, 8879, 10, 552, 3, 553, 3, 553, 3, 553, 7, 553, 8884, 10, 553, 12, 553, 14, 553, 8887, 11, 553, 3, 554, 3, 554, 3, 554, 3, 554, 3, 554, 3, 554, 5, 554, 8895, 10, 554, 3, 555, 5, 555, 8898, 10, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 5, 555, 8907, 10, 555, 5, 555, 8909, 10, 555, 3, 555, 3, 555, 3, 555, 3, 555, 5, 555, 8915, 10, 555, 3, 556, 3, 556, 5, 556, 8919, 10, 556, 3, 556, 7, 556, 8922, 10, 556, 12, 556, 14, 556, 8925, 11, 556, 3, 557, 3, 557, 3, 557, 3, 557, 3, 557, 3, 557, 3, 557, 5, 557, 8934, 10, 557, 3, 557, 3, 557, 3, 557, 3, 557, 5, 557, 8940, 10, 557, 5, 557, 8942, 10, 557, 3, 558, 3, 558, 3, 558, 3, 558, 5, 558, 8948, 10, 558, 3, 559, 3, 559, 5, 559, 8952, 10, 559, 3, 559, 5, 559, 8955, 10, 559, 3, 560, 3, 560, 3, 560, 3, 560, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 5, 561, 8968, 10, 561, 3, 561, 3, 561, 3, 561, 3, 561, 5, 561, 8974, 10, 561, 3, 561, 3, 561, 5, 561, 8978, 10, 561, 3, 561, 3, 561, 5, 561, 8982, 10, 561, 3, 561, 5, 561, 8985, 10, 561, 3, 562, 3, 562, 3, 562, 3, 562, 3, 563, 3, 563, 5, 563, 8993, 10, 563, 3, 564, 3, 564, 5, 564, 8997, 10, 564, 3, 565, 3, 565, 5, 565, 9001, 10, 565, 3, 565, 3, 565, 3, 565, 3, 565, 3, 566, 3, 566, 5, 566, 9009, 10, 566, 3, 567, 3, 567, 3, 567, 3, 567, 3, 567, 5, 567, 9016, 10, 567, 3, 568, 3, 568, 3, 568, 3, 568, 3, 568, 5, 568, 9023, 10, 568, 3, 569, 3, 569, 5, 569, 9027, 10, 569, 3, 569, 3, 569, 3, 569, 3, 569, 5, 569, 9033, 10, 569, 5, 569, 9035, 10, 569, 3, 570, 3, 570, 3, 571, 3, 571, 3, 571, 3, 571, 3, 571, 5, 571, 9044, 10, 571, 3, 571, 5, 571, 9047, 10, 571, 3, 572, 3, 572, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 3, 573, 5, 573, 9057, 10, 573, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 5, 574, 9073, 10, 574, 3, 574, 3, 574, 3, 574, 3, 574, 5, 574, 9079, 10, 574, 3, 574, 3, 574, 3, 574, 5, 574, 9084, 10, 574, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 5, 575, 9091, 10, 575, 3, 576, 3, 576, 3, 576, 3, 577, 3, 577, 3, 578, 3, 578, 5, 578, 9100, 10, 578, 3, 579, 3, 579, 3, 579, 7, 579, 9105, 10, 579, 12, 579, 14, 579, 9108, 11, 579, 3, 580, 3, 580, 3, 580, 7, 580, 9113, 10, 580, 12, 580, 14, 580, 9116, 11, 580, 3, 581, 3, 581, 3, 581, 7, 581, 9121, 10, 581, 12, 581, 14, 581, 9124, 11, 581, 3, 582, 3, 582, 5, 582, 9128, 10, 582, 3, 582, 3, 582, 5, 582, 9132, 10, 582, 3, 583, 5, 583, 9135, 10, 583, 3, 583, 3, 583, 3, 584, 3, 584, 5, 584, 9141, 10, 584, 3, 585, 3, 585, 3, 585, 5, 585, 9146, 10, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 3, 585, 5, 585, 9162, 10, 585, 3, 585, 5, 585, 9165, 10, 585, 5, 585, 9167, 10, 585, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 3, 586, 5, 586, 9179, 10, 586, 5, 586, 9181, 10, 586, 3, 587, 3, 587, 5, 587, 9185, 10, 587, 3, 587, 3, 587, 3, 587, 3, 587, 3, 587, 3, 587, 5, 587, 9193, 10, 587, 5, 587, 9195, 10, 587, 3, 587, 3, 587, 5, 587, 9199, 10, 587, 5, 587, 9201, 10, 587, 3, 588, 3, 588, 3, 588, 3, 588, 7, 588, 9207, 10, 588, 12, 588, 14, 588, 9210, 11, 588, 3, 589, 5, 589, 9213, 10, 589, 3, 589, 3, 589, 3, 590, 3, 590, 3, 590, 7, 590, 9220, 10, 590, 12, 590, 14, 590, 9223, 11, 590, 3, 591, 3, 591, 3, 591, 7, 591, 9228, 10, 591, 12, 591, 14, 591, 9231, 11, 591, 3, 592, 3, 592, 3, 592, 5, 592, 9236, 10, 592, 3, 593, 5, 593, 9239, 10, 593, 3, 593, 3, 593, 3, 594, 3, 594, 3, 594, 3, 594, 3, 594, 5, 594, 9248, 10, 594, 3, 595, 3, 595, 3, 595, 5, 595, 9253, 10, 595, 3, 596, 3, 596, 3, 596, 7, 596, 9258, 10, 596, 12, 596, 14, 596, 9261, 11, 596, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 5, 597, 9270, 10, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 5, 597, 9296, 10, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 3, 597, 5, 597, 9307, 10, 597, 7, 597, 9309, 10, 597, 12, 597, 14, 597, 9312, 11, 597, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 5, 598, 9319, 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, 5, 598, 9342, 10, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 3, 598, 5, 598, 9350, 10, 598, 3, 599, 3, 599, 3, 600, 3, 600, 3, 600, 3, 600, 3, 600, 3, 600, 5, 600, 9360, 10, 600, 3, 600, 5, 600, 9363, 10, 600, 3, 600, 3, 600, 3, 600, 5, 600, 9368, 10, 600, 3, 600, 3, 600, 3, 600, 5, 600, 9373, 10, 600, 3, 600, 3, 600, 5, 600, 9377, 10, 600, 3, 600, 3, 600, 3, 601, 3, 601, 5, 601, 9383, 10, 601, 3, 601, 5, 601, 9386, 10, 601, 3, 601, 5, 601, 9389, 10, 601, 3, 601, 5, 601, 9392, 10, 601, 3, 602, 3, 602, 5, 602, 9396, 10, 602, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9410, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9417, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9424, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9431, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9449, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9457, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9469, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9475, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9488, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9527, 10, 603, 5, 603, 9529, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9549, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9559, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9570, 10, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 3, 603, 5, 603, 9582, 10, 603, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9589, 10, 604, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 5, 605, 9601, 10, 605, 3, 606, 3, 606, 3, 606, 3, 606, 3, 606, 3, 607, 3, 607, 3, 607, 7, 607, 9611, 10, 607, 12, 607, 14, 607, 9614, 11, 607, 3, 608, 3, 608, 3, 608, 5, 608, 9619, 10, 608, 3, 609, 3, 609, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9627, 10, 610, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 5, 611, 9644, 10, 611, 3, 612, 3, 612, 3, 612, 3, 613, 3, 613, 3, 613, 3, 613, 3, 613, 3, 613, 3, 614, 3, 614, 3, 614, 3, 614, 3, 614, 3, 614, 3, 615, 3, 615, 3, 615, 3, 616, 3, 616, 3, 616, 7, 616, 9667, 10, 616, 12, 616, 14, 616, 9670, 11, 616, 3, 617, 3, 617, 3, 617, 3, 617, 3, 618, 3, 618, 3, 618, 5, 618, 9679, 10, 618, 3, 619, 3, 619, 5, 619, 9683, 10, 619, 3, 619, 5, 619, 9686, 10, 619, 3, 619, 5, 619, 9689, 10, 619, 3, 619, 5, 619, 9692, 10, 619, 3, 619, 3, 619, 3, 620, 3, 620, 3, 621, 3, 621, 3, 621, 3, 621, 3, 622, 3, 622, 3, 622, 5, 622, 9705, 10, 622, 3, 622, 3, 622, 3, 622, 5, 622, 9710, 10, 622, 3, 622, 3, 622, 3, 622, 5, 622, 9715, 10, 622, 5, 622, 9717, 10, 622, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 3, 623, 5, 623, 9725, 10, 623, 3, 624, 3, 624, 3, 624, 3, 624, 3, 624, 3, 624, 3, 624, 5, 624, 9734, 10, 624, 3, 625, 3, 625, 3, 625, 3, 625, 3, 625, 3, 625, 3, 625, 5, 625, 9743, 10, 625, 3, 626, 3, 626, 3, 626, 5, 626, 9748, 10, 626, 3, 626, 3, 626, 3, 626, 3, 626, 3, 626, 3, 626, 3, 626, 5, 626, 9757, 10, 626, 3, 627, 3, 627, 3, 627, 5, 627, 9762, 10, 627, 3, 627, 3, 627, 3, 628, 3, 628, 3, 628, 3, 628, 3, 628, 3, 628, 3, 629, 3, 629, 3, 630, 3, 630, 5, 630, 9776, 10, 630, 3, 631, 3, 631, 3, 632, 3, 632, 3, 632, 3, 632, 3, 632, 3, 632, 5, 632, 9786, 10, 632, 3, 633, 3, 633, 3, 633, 3, 633, 3, 633, 3, 633, 5, 633, 9794, 10, 633, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 3, 634, 5, 634, 9808, 10, 634, 3, 635, 3, 635, 3, 635, 7, 635, 9813, 10, 635, 12, 635, 14, 635, 9816, 11, 635, 3, 636, 3, 636, 3, 636, 7, 636, 9821, 10, 636, 12, 636, 14, 636, 9824, 11, 636, 3, 637, 3, 637, 3, 637, 3, 637, 3, 637, 5, 637, 9831, 10, 637, 3, 638, 3, 638, 3, 638, 7, 638, 9836, 10, 638, 12, 638, 14, 638, 9839, 11, 638, 3, 639, 3, 639, 3, 639, 5, 639, 9844, 10, 639, 3, 639, 3, 639, 3, 640, 3, 640, 3, 640, 7, 640, 9851, 10, 640, 12, 640, 14, 640, 9854, 11, 640, 3, 641, 3, 641, 3, 641, 3, 641, 3, 642, 3, 642, 3, 642, 3, 642, 3, 642, 3, 642, 3, 642, 3, 642, 5, 642, 9868, 10, 642, 3, 643, 3, 643, 3, 644, 3, 644, 3, 644, 3, 644, 3, 644, 3, 644, 3, 644, 5, 644, 9879, 10, 644, 3, 645, 3, 645, 3, 645, 3, 645, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 3, 646, 5, 646, 9912, 10, 646, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 3, 647, 5, 647, 9921, 10, 647, 3, 648, 3, 648, 3, 648, 3, 648, 3, 648, 5, 648, 9928, 10, 648, 3, 649, 3, 649, 5, 649, 9932, 10, 649, 3, 649, 3, 649, 5, 649, 9936, 10, 649, 3, 649, 3, 649, 3, 650, 6, 650, 9941, 10, 650, 13, 650, 14, 650, 9942, 3, 651, 3, 651, 3, 651, 3, 651, 3, 651, 3, 652, 3, 652, 3, 652, 3, 653, 3, 653, 3, 654, 3, 654, 5, 654, 9957, 10, 654, 3, 655, 3, 655, 3, 655, 5, 655, 9962, 10, 655, 3, 655, 3, 655, 3, 655, 5, 655, 9967, 10, 655, 3, 655, 3, 655, 5, 655, 9971, 10, 655, 5, 655, 9973, 10, 655, 3, 655, 5, 655, 9976, 10, 655, 3, 656, 3, 656, 3, 657, 6, 657, 9981, 10, 657, 13, 657, 14, 657, 9982, 3, 658, 7, 658, 9986, 10, 658, 12, 658, 14, 658, 9989, 11, 658, 3, 659, 3, 659, 3, 660, 3, 660, 3, 660, 7, 660, 9996, 10, 660, 12, 660, 14, 660, 9999, 11, 660, 3, 661, 3, 661, 3, 661, 3, 661, 3, 661, 5, 661, 10006, 10, 661, 3, 661, 5, 661, 10009, 10, 661, 3, 662, 3, 662, 3, 662, 7, 662, 10014, 10, 662, 12, 662, 14, 662, 10017, 11, 662, 3, 663, 3, 663, 5, 663, 10021, 10, 663, 3, 664, 3, 664, 3, 664, 7, 664, 10026, 10, 664, 12, 664, 14, 664, 10029, 11, 664, 3, 665, 3, 665, 3, 666, 3, 666, 3, 667, 3, 667, 3, 668, 3, 668, 3, 668, 3, 668, 5, 668, 10041, 10, 668, 3, 669, 3, 669, 3, 669, 3, 669, 3, 669, 3, 669, 3, 669, 3, 669, 3, 669, 3, 669, 5, 669, 10053, 10, 669, 3, 669, 3, 669, 3, 669, 5, 669, 10058, 10, 669, 3, 669, 3, 669, 3, 669, 3, 669, 3, 669, 3, 669, 5, 669, 10066, 10, 669, 3, 669, 3, 669, 3, 669, 3, 669, 3, 669, 5, 669, 10073, 10, 669, 3, 669, 3, 669, 3, 669, 5, 669, 10078, 10, 669, 3, 670, 3, 670, 3, 671, 3, 671, 3, 672, 3, 672, 3, 673, 3, 673, 3, 674, 3, 674, 5, 674, 10090, 10, 674, 3, 675, 3, 675, 3, 675, 3, 675, 7, 675, 10096, 10, 675, 12, 675, 14, 675, 10099, 11, 675, 3, 675, 3, 675, 5, 675, 10103, 10, 675, 3, 676, 3, 676, 3, 676, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 5, 677, 10113, 10, 677, 3, 678, 3, 678, 3, 679, 3, 679, 3, 679, 5, 679, 10120, 10, 679, 3, 680, 3, 680, 3, 680, 7, 680, 10125, 10, 680, 12, 680, 14, 680, 10128, 11, 680, 3, 681, 3, 681, 3, 681, 3, 681, 5, 681, 10134, 10, 681, 3, 682, 3, 682, 3, 682, 3, 682, 5, 682, 10140, 10, 682, 3, 683, 3, 683, 3, 683, 3, 683, 5, 683, 10146, 10, 683, 3, 684, 3, 684, 3, 684, 3, 684, 3, 684, 3, 684, 5, 684, 10154, 10, 684, 3, 685, 3, 685, 5, 685, 10158, 10, 685, 3, 685, 3, 685, 3, 685, 3, 685, 3, 685, 5, 685, 10165, 10, 685, 3, 686, 3, 686, 3, 687, 3, 687, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 3, 688, 5, 688, 10222, 10, 688, 3, 689, 3, 689, 3, 690, 3, 690, 3, 691, 3, 691, 3, 691, 3, 691, 3, 692, 7, 692, 10233, 10, 692, 12, 692, 14, 692, 10236, 11, 692, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 3, 693, 5, 693, 10258, 10, 693, 3, 694, 3, 694, 3, 695, 3, 695, 3, 695, 3, 695, 5, 695, 10266, 10, 695, 3, 696, 3, 696, 5, 696, 10270, 10, 696, 3, 697, 3, 697, 3, 697, 3, 697, 3, 697, 3, 697, 3, 697, 3, 698, 3, 698, 3, 698, 5, 698, 10282, 10, 698, 5, 698, 10284, 10, 698, 3, 699, 3, 699, 3, 700, 6, 700, 10289, 10, 700, 13, 700, 14, 700, 10290, 3, 701, 3, 701, 3, 701, 3, 701, 3, 702, 3, 702, 3, 702, 5, 702, 10300, 10, 702, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 3, 703, 5, 703, 10318, 10, 703, 3, 703, 3, 703, 3, 704, 3, 704, 3, 704, 3, 704, 5, 704, 10326, 10, 704, 3, 705, 3, 705, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 5, 706, 10335, 10, 706, 3, 707, 3, 707, 3, 707, 7, 707, 10340, 10, 707, 12, 707, 14, 707, 10343, 11, 707, 3, 708, 3, 708, 3, 708, 3, 709, 3, 709, 3, 710, 3, 710, 5, 710, 10352, 10, 710, 3, 711, 3, 711, 3, 712, 3, 712, 5, 712, 10358, 10, 712, 3, 713, 3, 713, 3, 714, 3, 714, 3, 714, 5, 714, 10365, 10, 714, 3, 715, 3, 715, 3, 715, 5, 715, 10370, 10, 715, 3, 716, 3, 716, 3, 716, 3, 716, 5, 716, 10376, 10, 716, 3, 717, 3, 717, 5, 717, 10380, 10, 717, 3, 718, 3, 718, 3, 719, 7, 719, 10385, 10, 719, 12, 719, 14, 719, 10388, 11, 719, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 3, 720, 5, 720, 10417, 10, 720, 3, 721, 3, 721, 3, 721, 3, 721, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 3, 722, 5, 722, 10437, 10, 722, 3, 723, 3, 723, 5, 723, 10441, 10, 723, 3, 724, 3, 724, 3, 724, 3, 724, 3, 724, 3, 725, 3, 725, 3, 725, 3, 725, 3, 725, 3, 725, 3, 726, 3, 726, 3, 726, 5, 726, 10457, 10, 726, 3, 727, 3, 727, 3, 727, 7, 727, 10462, 10, 727, 12, 727, 14, 727, 10465, 11, 727, 3, 728, 3, 728, 3, 728, 3, 728, 3, 729, 3, 729, 3, 730, 3, 730, 3, 731, 3, 731, 5, 731, 10477, 10, 731, 3, 731, 3, 731, 3, 731, 3, 731, 7, 731, 10483, 10, 731, 12, 731, 14, 731, 10486, 11, 731, 3, 732, 3, 732, 3, 732, 3, 732, 3, 732, 3, 732, 3, 732, 3, 732, 3, 732, 3, 732, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 7, 733, 10503, 10, 733, 12, 733, 14, 733, 10506, 11, 733, 3, 734, 3, 734, 3, 734, 5, 734, 10511, 10, 734, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 736, 3, 736, 5, 736, 10523, 10, 736, 3, 737, 6, 737, 10526, 10, 737, 13, 737, 14, 737, 10527, 3, 738, 3, 738, 3, 738, 3, 738, 3, 738, 3, 739, 3, 739, 3, 739, 5, 739, 10538, 10, 739, 3, 740, 3, 740, 3, 740, 3, 741, 3, 741, 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, 743, 3, 743, 3, 743, 3, 743, 3, 743, 3, 743, 3, 743, 3, 743, 3, 743, 3, 743, 3, 743, 3, 743, 5, 743, 10570, 10, 743, 3, 744, 3, 744, 3, 744, 5, 744, 10575, 10, 744, 3, 745, 3, 745, 3, 745, 3, 745, 3, 745, 7, 745, 10582, 10, 745, 12, 745, 14, 745, 10585, 11, 745, 3, 745, 3, 745, 5, 745, 10589, 10, 745, 3, 746, 3, 746, 5, 746, 10593, 10, 746, 3, 747, 3, 747, 3, 747, 5, 747, 10598, 10, 747, 3, 748, 3, 748, 3, 749, 3, 749, 3, 749, 3, 749, 3, 749, 3, 749, 3, 749, 3, 749, 3, 749, 3, 750, 3, 750, 3, 750, 5, 750, 10614, 10, 750, 3, 751, 3, 751, 3, 751, 5, 751, 10619, 10, 751, 3, 751, 3, 751, 3, 752, 3, 752, 3, 753, 3, 753, 3, 753, 3, 753, 3, 753, 3, 753, 3, 753, 3, 753, 3, 753, 5, 753, 10634, 10, 753, 3, 753, 5, 753, 10637, 10, 753, 3, 753, 3, 753, 3, 754, 3, 754, 5, 754, 10643, 10, 754, 3, 755, 3, 755, 5, 755, 10647, 10, 755, 3, 755, 3, 755, 3, 755, 3, 755, 3, 755, 3, 755, 3, 755, 5, 755, 10656, 10, 755, 3, 755, 3, 755, 3, 755, 3, 755, 3, 755, 3, 755, 5, 755, 10664, 10, 755, 3, 755, 3, 755, 3, 755, 3, 755, 3, 755, 3, 755, 3, 755, 5, 755, 10673, 10, 755, 3, 755, 3, 755, 3, 755, 3, 755, 5, 755, 10679, 10, 755, 3, 756, 3, 756, 3, 757, 3, 757, 3, 757, 6, 757, 10686, 10, 757, 13, 757, 14, 757, 10687, 5, 757, 10690, 10, 757, 3, 758, 3, 758, 3, 758, 5, 758, 10695, 10, 758, 3, 759, 3, 759, 3, 759, 3, 759, 3, 760, 3, 760, 3, 760, 7, 760, 10704, 10, 760, 12, 760, 14, 760, 10707, 11, 760, 3, 761, 3, 761, 3, 761, 3, 761, 3, 761, 3, 762, 3, 762, 3, 762, 5, 762, 10717, 10, 762, 3, 763, 3, 763, 3, 763, 3, 763, 3, 763, 3, 763, 3, 763, 3, 764, 3, 764, 3, 764, 3, 765, 3, 765, 3, 765, 3, 765, 3, 765, 3, 765, 3, 765, 3, 765, 3, 765, 5, 765, 10738, 10, 765, 3, 765, 3, 765, 3, 766, 3, 766, 3, 766, 5, 766, 10745, 10, 766, 3, 767, 3, 767, 3, 767, 7, 767, 10750, 10, 767, 12, 767, 14, 767, 10753, 11, 767, 3, 768, 3, 768, 3, 768, 5, 768, 10758, 10, 768, 3, 768, 5, 768, 10761, 10, 768, 3, 769, 3, 769, 3, 769, 3, 769, 3, 769, 3, 769, 3, 769, 3, 769, 3, 769, 5, 769, 10772, 10, 769, 3, 769, 3, 769, 3, 769, 3, 769, 3, 769, 5, 769, 10779, 10, 769, 5, 769, 10781, 10, 769, 3, 769, 3, 769, 3, 770, 3, 770, 3, 770, 3, 770, 3, 770, 5, 770, 10790, 10, 770, 3, 771, 3, 771, 3, 771, 7, 771, 10795, 10, 771, 12, 771, 14, 771, 10798, 11, 771, 3, 772, 3, 772, 3, 772, 5, 772, 10803, 10, 772, 3, 773, 3, 773, 3, 773, 3, 773, 5, 773, 10809, 10, 773, 3, 774, 3, 774, 5, 774, 10813, 10, 774, 3, 775, 3, 775, 5, 775, 10817, 10, 775, 3, 775, 3, 775, 3, 775, 3, 775, 3, 775, 3, 775, 3, 776, 3, 776, 3, 777, 3, 777, 3, 777, 5, 777, 10830, 10, 777, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 5, 778, 10845, 10, 778, 5, 778, 10847, 10, 778, 3, 779, 3, 779, 5, 779, 10851, 10, 779, 3, 779, 3, 779, 3, 779, 3, 780, 3, 780, 3, 780, 3, 780, 3, 781, 3, 781, 3, 781, 3, 782, 3, 782, 5, 782, 10865, 10, 782, 3, 782, 3, 782, 3, 783, 3, 783, 5, 783, 10871, 10, 783, 3, 783, 3, 783, 3, 784, 3, 784, 5, 784, 10877, 10, 784, 3, 784, 3, 784, 3, 785, 3, 785, 3, 785, 3, 785, 3, 785, 3, 785, 3, 785, 3, 785, 3, 785, 5, 785, 10890, 10, 785, 3, 785, 5, 785, 10893, 10, 785, 3, 786, 3, 786, 5, 786, 10897, 10, 786, 3, 787, 3, 787, 3, 787, 5, 787, 10902, 10, 787, 3, 788, 6, 788, 10905, 10, 788, 13, 788, 14, 788, 10906, 3, 789, 3, 789, 3, 789, 3, 789, 3, 789, 3, 790, 3, 790, 3, 790, 7, 790, 10917, 10, 790, 12, 790, 14, 790, 10920, 11, 790, 3, 791, 3, 791, 3, 791, 5, 791, 10925, 10, 791, 3, 792, 3, 792, 5, 792, 10929, 10, 792, 3, 793, 3, 793, 5, 793, 10933, 10, 793, 3, 794, 3, 794, 5, 794, 10937, 10, 794, 3, 795, 3, 795, 3, 795, 3, 796, 3, 796, 5, 796, 10944, 10, 796, 3, 797, 3, 797, 3, 798, 5, 798, 10949, 10, 798, 3, 798, 5, 798, 10952, 10, 798, 3, 798, 5, 798, 10955, 10, 798, 3, 798, 5, 798, 10958, 10, 798, 3, 798, 5, 798, 10961, 10, 798, 3, 798, 5, 798, 10964, 10, 798, 3, 798, 5, 798, 10967, 10, 798, 3, 799, 3, 799, 3, 800, 3, 800, 3, 801, 3, 801, 3, 802, 3, 802, 3, 803, 3, 803, 5, 803, 10979, 10, 803, 3, 804, 3, 804, 3, 804, 3, 804, 3, 804, 2, 2, 3, 1192, 805, 2, 2, 4, 2, 6, 2, 8, 2, 10, 2, 12, 2, 14, 2, 16, 2, 18, 2, 20, 2, 22, 2, 24, 2, 26, 2, 28, 2, 30, 2, 32, 2, 34, 2, 36, 2, 38, 2, 40, 2, 42, 2, 44, 2, 46, 2, 48, 2, 50, 2, 52, 2, 54, 2, 56, 2, 58, 2, 60, 2, 62, 2, 64, 2, 66, 2, 68, 2, 70, 2, 72, 2, 74, 2, 76, 2, 78, 2, 80, 2, 82, 2, 84, 2, 86, 2, 88, 2, 90, 2, 92, 2, 94, 2, 96, 2, 98, 2, 100, 2, 102, 2, 104, 2, 106, 2, 108, 2, 110, 2, 112, 2, 114, 2, 116, 2, 118, 2, 120, 2, 122, 2, 124, 2, 126, 2, 128, 2, 130, 2, 132, 2, 134, 2, 136, 2, 138, 2, 140, 2, 142, 2, 144, 2, 146, 2, 148, 2, 150, 2, 152, 2, 154, 2, 156, 2, 158, 2, 160, 2, 162, 2, 164, 2, 166, 2, 168, 2, 170, 2, 172, 2, 174, 2, 176, 2, 178, 2, 180, 2, 182, 2, 184, 2, 186, 2, 188, 2, 190, 2, 192, 2, 194, 2, 196, 2, 198, 2, 200, 2, 202, 2, 204, 2, 206, 2, 208, 2, 210, 2, 212, 2, 214, 2, 216, 2, 218, 2, 220, 2, 222, 2, 224, 2, 226, 2, 228, 2, 230, 2, 232, 2, 234, 2, 236, 2, 238, 2, 240, 2, 242, 2, 244, 2, 246, 2, 248, 2, 250, 2, 252, 2, 254, 2, 256, 2, 258, 2, 260, 2, 262, 2, 264, 2, 266, 2, 268, 2, 270, 2, 272, 2, 274, 2, 276, 2, 278, 2, 280, 2, 282, 2, 284, 2, 286, 2, 288, 2, 290, 2, 292, 2, 294, 2, 296, 2, 298, 2, 300, 2, 302, 2, 304, 2, 306, 2, 308, 2, 310, 2, 312, 2, 314, 2, 316, 2, 318, 2, 320, 2, 322, 2, 324, 2, 326, 2, 328, 2, 330, 2, 332, 2, 334, 2, 336, 2, 338, 2, 340, 2, 342, 2, 344, 2, 346, 2, 348, 2, 350, 2, 352, 2, 354, 2, 356, 2, 358, 2, 360, 2, 362, 2, 364, 2, 366, 2, 368, 2, 370, 2, 372, 2, 374, 2, 376, 2, 378, 2, 380, 2, 382, 2, 384, 2, 386, 2, 388, 2, 390, 2, 392, 2, 394, 2, 396, 2, 398, 2, 400, 2, 402, 2, 404, 2, 406, 2, 408, 2, 410, 2, 412, 2, 414, 2, 416, 2, 418, 2, 420, 2, 422, 2, 424, 2, 426, 2, 428, 2, 430, 2, 432, 2, 434, 2, 436, 2, 438, 2, 440, 2, 442, 2, 444, 2, 446, 2, 448, 2, 450, 2, 452, 2, 454, 2, 456, 2, 458, 2, 460, 2, 462, 2, 464, 2, 466, 2, 468, 2, 470, 2, 472, 2, 474, 2, 476, 2, 478, 2, 480, 2, 482, 2, 484, 2, 486, 2, 488, 2, 490, 2, 492, 2, 494, 2, 496, 2, 498, 2, 500, 2, 502, 2, 504, 2, 506, 2, 508, 2, 510, 2, 512, 2, 514, 2, 516, 2, 518, 2, 520, 2, 522, 2, 524, 2, 526, 2, 528, 2, 530, 2, 532, 2, 534, 2, 536, 2, 538, 2, 540, 2, 542, 2, 544, 2, 546, 2, 548, 2, 550, 2, 552, 2, 554, 2, 556, 2, 558, 2, 560, 2, 562, 2, 564, 2, 566, 2, 568, 2, 570, 2, 572, 2, 574, 2, 576, 2, 578, 2, 580, 2, 582, 2, 584, 2, 586, 2, 588, 2, 590, 2, 592, 2, 594, 2, 596, 2, 598, 2, 600, 2, 602, 2, 604, 2, 606, 2, 608, 2, 610, 2, 612, 2, 614, 2, 616, 2, 618, 2, 620, 2, 622, 2, 624, 2, 626, 2, 628, 2, 630, 2, 632, 2, 634, 2, 636, 2, 638, 2, 640, 2, 642, 2, 644, 2, 646, 2, 648, 2, 650, 2, 652, 2, 654, 2, 656, 2, 658, 2, 660, 2, 662, 2, 664, 2, 666, 2, 668, 2, 670, 2, 672, 2, 674, 2, 676, 2, 678, 2, 680, 2, 682, 2, 684, 2, 686, 2, 688, 2, 690, 2, 692, 2, 694, 2, 696, 2, 698, 2, 700, 2, 702, 2, 704, 2, 706, 2, 708, 2, 710, 2, 712, 2, 714, 2, 716, 2, 718, 2, 720, 2, 722, 2, 724, 2, 726, 2, 728, 2, 730, 2, 732, 2, 734, 2, 736, 2, 738, 2, 740, 2, 742, 2, 744, 2, 746, 2, 748, 2, 750, 2, 752, 2, 754, 2, 756, 2, 758, 2, 760, 2, 762, 2, 764, 2, 766, 2, 768, 2, 770, 2, 772, 2, 774, 2, 776, 2, 778, 2, 780, 2, 782, 2, 784, 2, 786, 2, 788, 2, 790, 2, 792, 2, 794, 2, 796, 2, 798, 2, 800, 2, 802, 2, 804, 2, 806, 2, 808, 2, 810, 2, 812, 2, 814, 2, 816, 2, 818, 2, 820, 2, 822, 2, 824, 2, 826, 2, 828, 2, 830, 2, 832, 2, 834, 2, 836, 2, 838, 2, 840, 2, 842, 2, 844, 2, 846, 2, 848, 2, 850, 2, 852, 2, 854, 2, 856, 2, 858, 2, 860, 2, 862, 2, 864, 2, 866, 2, 868, 2, 870, 2, 872, 2, 874, 2, 876, 2, 878, 2, 880, 2, 882, 2, 884, 2, 886, 2, 888, 2, 890, 2, 892, 2, 894, 2, 896, 2, 898, 2, 900, 2, 902, 2, 904, 2, 906, 2, 908, 2, 910, 2, 912, 2, 914, 2, 916, 2, 918, 2, 920, 2, 922, 2, 924, 2, 926, 2, 928, 2, 930, 2, 932, 2, 934, 2, 936, 2, 938, 2, 940, 2, 942, 2, 944, 2, 946, 2, 948, 2, 950, 2, 952, 2, 954, 2, 956, 2, 958, 2, 960, 2, 962, 2, 964, 2, 966, 2, 968, 2, 970, 2, 972, 2, 974, 2, 976, 2, 978, 2, 980, 2, 982, 2, 984, 2, 986, 2, 988, 2, 990, 2, 992, 2, 994, 2, 996, 2, 998, 2, 1000, 2, 1002, 2, 1004, 2, 1006, 2, 1008, 2, 1010, 2, 1012, 2, 1014, 2, 1016, 2, 1018, 2, 1020, 2, 1022, 2, 1024, 2, 1026, 2, 1028, 2, 1030, 2, 1032, 2, 1034, 2, 1036, 2, 1038, 2, 1040, 2, 1042, 2, 1044, 2, 1046, 2, 1048, 2, 1050, 2, 1052, 2, 1054, 2, 1056, 2, 1058, 2, 1060, 2, 1062, 2, 1064, 2, 1066, 2, 1068, 2, 1070, 2, 1072, 2, 1074, 2, 1076, 2, 1078, 2, 1080, 2, 1082, 2, 1084, 2, 1086, 2, 1088, 2, 1090, 2, 1092, 2, 1094, 2, 1096, 2, 1098, 2, 1100, 2, 1102, 2, 1104, 2, 1106, 2, 1108, 2, 1110, 2, 1112, 2, 1114, 2, 1116, 2, 1118, 2, 1120, 2, 1122, 2, 1124, 2, 1126, 2, 1128, 2, 1130, 2, 1132, 2, 1134, 2, 1136, 2, 1138, 2, 1140, 2, 1142, 2, 1144, 2, 1146, 2, 1148, 2, 1150, 2, 1152, 2, 1154, 2, 1156, 2, 1158, 2, 1160, 2, 1162, 2, 1164, 2, 1166, 2, 1168, 2, 1170, 2, 1172, 2, 1174, 2, 1176, 2, 1178, 2, 1180, 2, 1182, 2, 1184, 2, 1186, 2, 1188, 2, 1190, 2, 1192, 2, 1194, 2, 1196, 2, 1198, 2, 1200, 2, 1202, 2, 1204, 2, 1206, 2, 1208, 2, 1210, 2, 1212, 2, 1214, 2, 1216, 2, 1218, 2, 1220, 2, 1222, 2, 1224, 2, 1226, 2, 1228, 2, 1230, 2, 1232, 2, 1234, 2, 1236, 2, 1238, 2, 1240, 2, 1242, 2, 1244, 2, 1246, 2, 1248, 2, 1250, 2, 1252, 2, 1254, 2, 1256, 2, 1258, 2, 1260, 2, 1262, 2, 1264, 2, 1266, 2, 1268, 2, 1270, 2, 1272, 2, 1274, 2, 1276, 2, 1278, 2, 1280, 2, 1282, 2, 1284, 2, 1286, 2, 1288, 2, 1290, 2, 1292, 2, 1294, 2, 1296, 2, 1298, 2, 1300, 2, 1302, 2, 1304, 2, 1306, 2, 1308, 2, 1310, 2, 1312, 2, 1314, 2, 1316, 2, 1318, 2, 1320, 2, 1322, 2, 1324, 2, 1326, 2, 1328, 2, 1330, 2, 1332, 2, 1334, 2, 1336, 2, 1338, 2, 1340, 2, 1342, 2, 1344, 2, 1346, 2, 1348, 2, 1350, 2, 1352, 2, 1354, 2, 1356, 2, 1358, 2, 1360, 2, 1362, 2, 1364, 2, 1366, 2, 1368, 2, 1370, 2, 1372, 2, 1374, 2, 1376, 2, 1378, 2, 1380, 2, 1382, 2, 1384, 2, 1386, 2, 1388, 2, 1390, 2, 1392, 2, 1394, 2, 1396, 2, 1398, 2, 1400, 2, 1402, 2, 1404, 2, 1406, 2, 1408, 2, 1410, 2, 1412, 2, 1414, 2, 1416, 2, 1418, 2, 1420, 2, 1422, 2, 1424, 2, 1426, 2, 1428, 2, 1430, 2, 1432, 2, 1434, 2, 1436, 2, 1438, 2, 1440, 2, 1442, 2, 1444, 2, 1446, 2, 1448, 2, 1450, 2, 1452, 2, 1454, 2, 1456, 2, 1458, 2, 1460, 2, 1462, 2, 1464, 2, 1466, 2, 1468, 2, 1470, 2, 1472, 2, 1474, 2, 1476, 2, 1478, 2, 1480, 2, 1482, 2, 1484, 2, 1486, 2, 1488, 2, 1490, 2, 1492, 2, 1494, 2, 1496, 2, 1498, 2, 1500, 2, 1502, 2, 1504, 2, 1506, 2, 1508, 2, 1510, 2, 1512, 2, 1514, 2, 1516, 2, 1518, 2, 1520, 2, 1522, 2, 1524, 2, 1526, 2, 1528, 2, 1530, 2, 1532, 2, 1534, 2, 1536, 2, 1538, 2, 1540, 2, 1542, 2, 1544, 2, 1546, 2, 1548, 2, 1550, 2, 1552, 2, 1554, 2, 1556, 2, 1558, 2, 1560, 2, 1562, 2, 1564, 2, 1566, 2, 1568, 2, 1570, 2, 1572, 2, 1574, 2, 1576, 2, 1578, 2, 1580, 2, 1582, 2, 1584, 2, 1586, 2, 1588, 2, 1590, 2, 1592, 2, 1594, 2, 1596, 2, 1598, 2, 1600, 2, 1602, 2, 1604, 2, 1606, 2, 2, 72, 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, 152, 152, 308, 308, 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, 39, 39, 57, 57, 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, 139, 139, 235, 235, 4, 2, 349, 349, 373, 373, 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, 32, 32, 58, 58, 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, 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, 3, 2, 505, 510, 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, 12132, 2, 1608, 3, 2, 2, 2, 4, 1610, 3, 2, 2, 2, 6, 1618, 3, 2, 2, 2, 8, 1745, 3, 2, 2, 2, 10, 1747, 3, 2, 2, 2, 12, 1751, 3, 2, 2, 2, 14, 1754, 3, 2, 2, 2, 16, 1762, 3, 2, 2, 2, 18, 1767, 3, 2, 2, 2, 20, 1773, 3, 2, 2, 2, 22, 1794, 3, 2, 2, 2, 24, 1806, 3, 2, 2, 2, 26, 1808, 3, 2, 2, 2, 28, 1816, 3, 2, 2, 2, 30, 1828, 3, 2, 2, 2, 32, 1830, 3, 2, 2, 2, 34, 1839, 3, 2, 2, 2, 36, 1847, 3, 2, 2, 2, 38, 1855, 3, 2, 2, 2, 40, 1862, 3, 2, 2, 2, 42, 1864, 3, 2, 2, 2, 44, 1881, 3, 2, 2, 2, 46, 1886, 3, 2, 2, 2, 48, 1895, 3, 2, 2, 2, 50, 1897, 3, 2, 2, 2, 52, 1911, 3, 2, 2, 2, 54, 1913, 3, 2, 2, 2, 56, 1944, 3, 2, 2, 2, 58, 1946, 3, 2, 2, 2, 60, 1954, 3, 2, 2, 2, 62, 1964, 3, 2, 2, 2, 64, 1971, 3, 2, 2, 2, 66, 1977, 3, 2, 2, 2, 68, 1995, 3, 2, 2, 2, 70, 1999, 3, 2, 2, 2, 72, 2003, 3, 2, 2, 2, 74, 2005, 3, 2, 2, 2, 76, 2016, 3, 2, 2, 2, 78, 2020, 3, 2, 2, 2, 80, 2025, 3, 2, 2, 2, 82, 2030, 3, 2, 2, 2, 84, 2032, 3, 2, 2, 2, 86, 2044, 3, 2, 2, 2, 88, 2051, 3, 2, 2, 2, 90, 2053, 3, 2, 2, 2, 92, 2055, 3, 2, 2, 2, 94, 2057, 3, 2, 2, 2, 96, 2172, 3, 2, 2, 2, 98, 2174, 3, 2, 2, 2, 100, 2190, 3, 2, 2, 2, 102, 2192, 3, 2, 2, 2, 104, 2494, 3, 2, 2, 2, 106, 2501, 3, 2, 2, 2, 108, 2503, 3, 2, 2, 2, 110, 2505, 3, 2, 2, 2, 112, 2508, 3, 2, 2, 2, 114, 2517, 3, 2, 2, 2, 116, 2519, 3, 2, 2, 2, 118, 2523, 3, 2, 2, 2, 120, 2526, 3, 2, 2, 2, 122, 2534, 3, 2, 2, 2, 124, 2546, 3, 2, 2, 2, 126, 2563, 3, 2, 2, 2, 128, 2591, 3, 2, 2, 2, 130, 2593, 3, 2, 2, 2, 132, 2596, 3, 2, 2, 2, 134, 2604, 3, 2, 2, 2, 136, 2609, 3, 2, 2, 2, 138, 2647, 3, 2, 2, 2, 140, 2649, 3, 2, 2, 2, 142, 2691, 3, 2, 2, 2, 144, 2693, 3, 2, 2, 2, 146, 2695, 3, 2, 2, 2, 148, 2700, 3, 2, 2, 2, 150, 2707, 3, 2, 2, 2, 152, 2712, 3, 2, 2, 2, 154, 2754, 3, 2, 2, 2, 156, 2756, 3, 2, 2, 2, 158, 2759, 3, 2, 2, 2, 160, 2764, 3, 2, 2, 2, 162, 2766, 3, 2, 2, 2, 164, 2774, 3, 2, 2, 2, 166, 2785, 3, 2, 2, 2, 168, 2787, 3, 2, 2, 2, 170, 2795, 3, 2, 2, 2, 172, 2797, 3, 2, 2, 2, 174, 2882, 3, 2, 2, 2, 176, 2884, 3, 2, 2, 2, 178, 2886, 3, 2, 2, 2, 180, 2890, 3, 2, 2, 2, 182, 2898, 3, 2, 2, 2, 184, 2909, 3, 2, 2, 2, 186, 2913, 3, 2, 2, 2, 188, 2915, 3, 2, 2, 2, 190, 2922, 3, 2, 2, 2, 192, 2932, 3, 2, 2, 2, 194, 2943, 3, 2, 2, 2, 196, 2997, 3, 2, 2, 2, 198, 3002, 3, 2, 2, 2, 200, 3009, 3, 2, 2, 2, 202, 3011, 3, 2, 2, 2, 204, 3019, 3, 2, 2, 2, 206, 3022, 3, 2, 2, 2, 208, 3029, 3, 2, 2, 2, 210, 3117, 3, 2, 2, 2, 212, 3119, 3, 2, 2, 2, 214, 3122, 3, 2, 2, 2, 216, 3126, 3, 2, 2, 2, 218, 3134, 3, 2, 2, 2, 220, 3136, 3, 2, 2, 2, 222, 3141, 3, 2, 2, 2, 224, 3144, 3, 2, 2, 2, 226, 3152, 3, 2, 2, 2, 228, 3162, 3, 2, 2, 2, 230, 3175, 3, 2, 2, 2, 232, 3177, 3, 2, 2, 2, 234, 3181, 3, 2, 2, 2, 236, 3191, 3, 2, 2, 2, 238, 3193, 3, 2, 2, 2, 240, 3198, 3, 2, 2, 2, 242, 3200, 3, 2, 2, 2, 244, 3207, 3, 2, 2, 2, 246, 3238, 3, 2, 2, 2, 248, 3240, 3, 2, 2, 2, 250, 3247, 3, 2, 2, 2, 252, 3249, 3, 2, 2, 2, 254, 3258, 3, 2, 2, 2, 256, 3261, 3, 2, 2, 2, 258, 3266, 3, 2, 2, 2, 260, 3270, 3, 2, 2, 2, 262, 3286, 3, 2, 2, 2, 264, 3297, 3, 2, 2, 2, 266, 3313, 3, 2, 2, 2, 268, 3329, 3, 2, 2, 2, 270, 3335, 3, 2, 2, 2, 272, 3352, 3, 2, 2, 2, 274, 3365, 3, 2, 2, 2, 276, 3367, 3, 2, 2, 2, 278, 3377, 3, 2, 2, 2, 280, 3391, 3, 2, 2, 2, 282, 3400, 3, 2, 2, 2, 284, 3402, 3, 2, 2, 2, 286, 3407, 3, 2, 2, 2, 288, 3445, 3, 2, 2, 2, 290, 3447, 3, 2, 2, 2, 292, 3455, 3, 2, 2, 2, 294, 3457, 3, 2, 2, 2, 296, 3465, 3, 2, 2, 2, 298, 3487, 3, 2, 2, 2, 300, 3489, 3, 2, 2, 2, 302, 3493, 3, 2, 2, 2, 304, 3500, 3, 2, 2, 2, 306, 3502, 3, 2, 2, 2, 308, 3504, 3, 2, 2, 2, 310, 3506, 3, 2, 2, 2, 312, 3517, 3, 2, 2, 2, 314, 3520, 3, 2, 2, 2, 316, 3528, 3, 2, 2, 2, 318, 3544, 3, 2, 2, 2, 320, 3554, 3, 2, 2, 2, 322, 3556, 3, 2, 2, 2, 324, 3565, 3, 2, 2, 2, 326, 3568, 3, 2, 2, 2, 328, 3675, 3, 2, 2, 2, 330, 3677, 3, 2, 2, 2, 332, 3696, 3, 2, 2, 2, 334, 3699, 3, 2, 2, 2, 336, 3703, 3, 2, 2, 2, 338, 3722, 3, 2, 2, 2, 340, 3724, 3, 2, 2, 2, 342, 3729, 3, 2, 2, 2, 344, 3737, 3, 2, 2, 2, 346, 3742, 3, 2, 2, 2, 348, 3757, 3, 2, 2, 2, 350, 3759, 3, 2, 2, 2, 352, 3762, 3, 2, 2, 2, 354, 3764, 3, 2, 2, 2, 356, 3801, 3, 2, 2, 2, 358, 3803, 3, 2, 2, 2, 360, 3806, 3, 2, 2, 2, 362, 3811, 3, 2, 2, 2, 364, 3813, 3, 2, 2, 2, 366, 3895, 3, 2, 2, 2, 368, 3897, 3, 2, 2, 2, 370, 3915, 3, 2, 2, 2, 372, 3917, 3, 2, 2, 2, 374, 3945, 3, 2, 2, 2, 376, 3949, 3, 2, 2, 2, 378, 3969, 3, 2, 2, 2, 380, 3971, 3, 2, 2, 2, 382, 3980, 3, 2, 2, 2, 384, 4000, 3, 2, 2, 2, 386, 4014, 3, 2, 2, 2, 388, 4019, 3, 2, 2, 2, 390, 4025, 3, 2, 2, 2, 392, 4028, 3, 2, 2, 2, 394, 4031, 3, 2, 2, 2, 396, 4034, 3, 2, 2, 2, 398, 4037, 3, 2, 2, 2, 400, 4039, 3, 2, 2, 2, 402, 4048, 3, 2, 2, 2, 404, 4098, 3, 2, 2, 2, 406, 4104, 3, 2, 2, 2, 408, 4106, 3, 2, 2, 2, 410, 4121, 3, 2, 2, 2, 412, 4123, 3, 2, 2, 2, 414, 4127, 3, 2, 2, 2, 416, 4131, 3, 2, 2, 2, 418, 4138, 3, 2, 2, 2, 420, 4140, 3, 2, 2, 2, 422, 4142, 3, 2, 2, 2, 424, 4144, 3, 2, 2, 2, 426, 4150, 3, 2, 2, 2, 428, 4152, 3, 2, 2, 2, 430, 4154, 3, 2, 2, 2, 432, 4159, 3, 2, 2, 2, 434, 4163, 3, 2, 2, 2, 436, 4176, 3, 2, 2, 2, 438, 4178, 3, 2, 2, 2, 440, 4184, 3, 2, 2, 2, 442, 4198, 3, 2, 2, 2, 444, 4226, 3, 2, 2, 2, 446, 4228, 3, 2, 2, 2, 448, 4236, 3, 2, 2, 2, 450, 4242, 3, 2, 2, 2, 452, 4250, 3, 2, 2, 2, 454, 4262, 3, 2, 2, 2, 456, 4264, 3, 2, 2, 2, 458, 4387, 3, 2, 2, 2, 460, 4389, 3, 2, 2, 2, 462, 4393, 3, 2, 2, 2, 464, 4401, 3, 2, 2, 2, 466, 4412, 3, 2, 2, 2, 468, 4414, 3, 2, 2, 2, 470, 4418, 3, 2, 2, 2, 472, 4426, 3, 2, 2, 2, 474, 4430, 3, 2, 2, 2, 476, 4432, 3, 2, 2, 2, 478, 4483, 3, 2, 2, 2, 480, 4485, 3, 2, 2, 2, 482, 4489, 3, 2, 2, 2, 484, 4507, 3, 2, 2, 2, 486, 4546, 3, 2, 2, 2, 488, 4548, 3, 2, 2, 2, 490, 4550, 3, 2, 2, 2, 492, 4559, 3, 2, 2, 2, 494, 4561, 3, 2, 2, 2, 496, 4563, 3, 2, 2, 2, 498, 4588, 3, 2, 2, 2, 500, 4590, 3, 2, 2, 2, 502, 4610, 3, 2, 2, 2, 504, 4632, 3, 2, 2, 2, 506, 4654, 3, 2, 2, 2, 508, 4656, 3, 2, 2, 2, 510, 4663, 3, 2, 2, 2, 512, 4760, 3, 2, 2, 2, 514, 4785, 3, 2, 2, 2, 516, 4792, 3, 2, 2, 2, 518, 4809, 3, 2, 2, 2, 520, 4811, 3, 2, 2, 2, 522, 4813, 3, 2, 2, 2, 524, 4821, 3, 2, 2, 2, 526, 4827, 3, 2, 2, 2, 528, 4831, 3, 2, 2, 2, 530, 4839, 3, 2, 2, 2, 532, 4854, 3, 2, 2, 2, 534, 5003, 3, 2, 2, 2, 536, 5007, 3, 2, 2, 2, 538, 5120, 3, 2, 2, 2, 540, 5122, 3, 2, 2, 2, 542, 5127, 3, 2, 2, 2, 544, 5133, 3, 2, 2, 2, 546, 5220, 3, 2, 2, 2, 548, 5222, 3, 2, 2, 2, 550, 5224, 3, 2, 2, 2, 552, 5226, 3, 2, 2, 2, 554, 5256, 3, 2, 2, 2, 556, 5273, 3, 2, 2, 2, 558, 5275, 3, 2, 2, 2, 560, 5299, 3, 2, 2, 2, 562, 5359, 3, 2, 2, 2, 564, 5361, 3, 2, 2, 2, 566, 5372, 3, 2, 2, 2, 568, 5374, 3, 2, 2, 2, 570, 5378, 3, 2, 2, 2, 572, 5411, 3, 2, 2, 2, 574, 5413, 3, 2, 2, 2, 576, 5417, 3, 2, 2, 2, 578, 5421, 3, 2, 2, 2, 580, 5430, 3, 2, 2, 2, 582, 5442, 3, 2, 2, 2, 584, 5474, 3, 2, 2, 2, 586, 5476, 3, 2, 2, 2, 588, 5541, 3, 2, 2, 2, 590, 5543, 3, 2, 2, 2, 592, 5545, 3, 2, 2, 2, 594, 5547, 3, 2, 2, 2, 596, 5549, 3, 2, 2, 2, 598, 5552, 3, 2, 2, 2, 600, 5583, 3, 2, 2, 2, 602, 5596, 3, 2, 2, 2, 604, 5598, 3, 2, 2, 2, 606, 5603, 3, 2, 2, 2, 608, 5611, 3, 2, 2, 2, 610, 5614, 3, 2, 2, 2, 612, 5616, 3, 2, 2, 2, 614, 5622, 3, 2, 2, 2, 616, 5624, 3, 2, 2, 2, 618, 5644, 3, 2, 2, 2, 620, 5647, 3, 2, 2, 2, 622, 5653, 3, 2, 2, 2, 624, 5661, 3, 2, 2, 2, 626, 5677, 3, 2, 2, 2, 628, 5679, 3, 2, 2, 2, 630, 5685, 3, 2, 2, 2, 632, 5706, 3, 2, 2, 2, 634, 5715, 3, 2, 2, 2, 636, 5717, 3, 2, 2, 2, 638, 5719, 3, 2, 2, 2, 640, 5733, 3, 2, 2, 2, 642, 5735, 3, 2, 2, 2, 644, 5740, 3, 2, 2, 2, 646, 5742, 3, 2, 2, 2, 648, 5757, 3, 2, 2, 2, 650, 5765, 3, 2, 2, 2, 652, 5768, 3, 2, 2, 2, 654, 5777, 3, 2, 2, 2, 656, 5818, 3, 2, 2, 2, 658, 5828, 3, 2, 2, 2, 660, 5835, 3, 2, 2, 2, 662, 5837, 3, 2, 2, 2, 664, 5849, 3, 2, 2, 2, 666, 5852, 3, 2, 2, 2, 668, 5855, 3, 2, 2, 2, 670, 5863, 3, 2, 2, 2, 672, 5871, 3, 2, 2, 2, 674, 5875, 3, 2, 2, 2, 676, 5919, 3, 2, 2, 2, 678, 5935, 3, 2, 2, 2, 680, 5951, 3, 2, 2, 2, 682, 5975, 3, 2, 2, 2, 684, 5982, 3, 2, 2, 2, 686, 5987, 3, 2, 2, 2, 688, 5995, 3, 2, 2, 2, 690, 5998, 3, 2, 2, 2, 692, 6002, 3, 2, 2, 2, 694, 6009, 3, 2, 2, 2, 696, 6048, 3, 2, 2, 2, 698, 6054, 3, 2, 2, 2, 700, 6056, 3, 2, 2, 2, 702, 6069, 3, 2, 2, 2, 704, 6072, 3, 2, 2, 2, 706, 6119, 3, 2, 2, 2, 708, 6121, 3, 2, 2, 2, 710, 6167, 3, 2, 2, 2, 712, 6169, 3, 2, 2, 2, 714, 6171, 3, 2, 2, 2, 716, 6173, 3, 2, 2, 2, 718, 6181, 3, 2, 2, 2, 720, 6195, 3, 2, 2, 2, 722, 6684, 3, 2, 2, 2, 724, 6686, 3, 2, 2, 2, 726, 6688, 3, 2, 2, 2, 728, 6760, 3, 2, 2, 2, 730, 6762, 3, 2, 2, 2, 732, 6981, 3, 2, 2, 2, 734, 6983, 3, 2, 2, 2, 736, 6991, 3, 2, 2, 2, 738, 7007, 3, 2, 2, 2, 740, 7014, 3, 2, 2, 2, 742, 7016, 3, 2, 2, 2, 744, 7209, 3, 2, 2, 2, 746, 7211, 3, 2, 2, 2, 748, 7220, 3, 2, 2, 2, 750, 7228, 3, 2, 2, 2, 752, 7257, 3, 2, 2, 2, 754, 7259, 3, 2, 2, 2, 756, 7269, 3, 2, 2, 2, 758, 7277, 3, 2, 2, 2, 760, 7318, 3, 2, 2, 2, 762, 7334, 3, 2, 2, 2, 764, 7336, 3, 2, 2, 2, 766, 7362, 3, 2, 2, 2, 768, 7365, 3, 2, 2, 2, 770, 7381, 3, 2, 2, 2, 772, 7383, 3, 2, 2, 2, 774, 7385, 3, 2, 2, 2, 776, 7387, 3, 2, 2, 2, 778, 7389, 3, 2, 2, 2, 780, 7394, 3, 2, 2, 2, 782, 7397, 3, 2, 2, 2, 784, 7404, 3, 2, 2, 2, 786, 7475, 3, 2, 2, 2, 788, 7477, 3, 2, 2, 2, 790, 7489, 3, 2, 2, 2, 792, 7491, 3, 2, 2, 2, 794, 7501, 3, 2, 2, 2, 796, 7503, 3, 2, 2, 2, 798, 7509, 3, 2, 2, 2, 800, 7541, 3, 2, 2, 2, 802, 7548, 3, 2, 2, 2, 804, 7551, 3, 2, 2, 2, 806, 7560, 3, 2, 2, 2, 808, 7563, 3, 2, 2, 2, 810, 7567, 3, 2, 2, 2, 812, 7584, 3, 2, 2, 2, 814, 7586, 3, 2, 2, 2, 816, 7588, 3, 2, 2, 2, 818, 7603, 3, 2, 2, 2, 820, 7608, 3, 2, 2, 2, 822, 7624, 3, 2, 2, 2, 824, 7632, 3, 2, 2, 2, 826, 7634, 3, 2, 2, 2, 828, 7640, 3, 2, 2, 2, 830, 7645, 3, 2, 2, 2, 832, 7654, 3, 2, 2, 2, 834, 7681, 3, 2, 2, 2, 836, 7683, 3, 2, 2, 2, 838, 7762, 3, 2, 2, 2, 840, 7764, 3, 2, 2, 2, 842, 7766, 3, 2, 2, 2, 844, 7799, 3, 2, 2, 2, 846, 7801, 3, 2, 2, 2, 848, 7827, 3, 2, 2, 2, 850, 7843, 3, 2, 2, 2, 852, 7845, 3, 2, 2, 2, 854, 7853, 3, 2, 2, 2, 856, 7855, 3, 2, 2, 2, 858, 7861, 3, 2, 2, 2, 860, 7865, 3, 2, 2, 2, 862, 7867, 3, 2, 2, 2, 864, 7869, 3, 2, 2, 2, 866, 7871, 3, 2, 2, 2, 868, 7873, 3, 2, 2, 2, 870, 7875, 3, 2, 2, 2, 872, 7879, 3, 2, 2, 2, 874, 7883, 3, 2, 2, 2, 876, 7891, 3, 2, 2, 2, 878, 7911, 3, 2, 2, 2, 880, 7922, 3, 2, 2, 2, 882, 7924, 3, 2, 2, 2, 884, 7932, 3, 2, 2, 2, 886, 7938, 3, 2, 2, 2, 888, 7942, 3, 2, 2, 2, 890, 7944, 3, 2, 2, 2, 892, 7952, 3, 2, 2, 2, 894, 7960, 3, 2, 2, 2, 896, 8000, 3, 2, 2, 2, 898, 8002, 3, 2, 2, 2, 900, 8016, 3, 2, 2, 2, 902, 8019, 3, 2, 2, 2, 904, 8031, 3, 2, 2, 2, 906, 8055, 3, 2, 2, 2, 908, 8057, 3, 2, 2, 2, 910, 8059, 3, 2, 2, 2, 912, 8067, 3, 2, 2, 2, 914, 8070, 3, 2, 2, 2, 916, 8094, 3, 2, 2, 2, 918, 8096, 3, 2, 2, 2, 920, 8100, 3, 2, 2, 2, 922, 8114, 3, 2, 2, 2, 924, 8117, 3, 2, 2, 2, 926, 8128, 3, 2, 2, 2, 928, 8144, 3, 2, 2, 2, 930, 8146, 3, 2, 2, 2, 932, 8151, 3, 2, 2, 2, 934, 8154, 3, 2, 2, 2, 936, 8169, 3, 2, 2, 2, 938, 8187, 3, 2, 2, 2, 940, 8189, 3, 2, 2, 2, 942, 8192, 3, 2, 2, 2, 944, 8200, 3, 2, 2, 2, 946, 8208, 3, 2, 2, 2, 948, 8217, 3, 2, 2, 2, 950, 8225, 3, 2, 2, 2, 952, 8229, 3, 2, 2, 2, 954, 8239, 3, 2, 2, 2, 956, 8270, 3, 2, 2, 2, 958, 8274, 3, 2, 2, 2, 960, 8318, 3, 2, 2, 2, 962, 8333, 3, 2, 2, 2, 964, 8335, 3, 2, 2, 2, 966, 8339, 3, 2, 2, 2, 968, 8345, 3, 2, 2, 2, 970, 8353, 3, 2, 2, 2, 972, 8368, 3, 2, 2, 2, 974, 8370, 3, 2, 2, 2, 976, 8372, 3, 2, 2, 2, 978, 8381, 3, 2, 2, 2, 980, 8399, 3, 2, 2, 2, 982, 8401, 3, 2, 2, 2, 984, 8403, 3, 2, 2, 2, 986, 8405, 3, 2, 2, 2, 988, 8413, 3, 2, 2, 2, 990, 8415, 3, 2, 2, 2, 992, 8417, 3, 2, 2, 2, 994, 8421, 3, 2, 2, 2, 996, 8429, 3, 2, 2, 2, 998, 8448, 3, 2, 2, 2, 1000, 8450, 3, 2, 2, 2, 1002, 8475, 3, 2, 2, 2, 1004, 8477, 3, 2, 2, 2, 1006, 8486, 3, 2, 2, 2, 1008, 8488, 3, 2, 2, 2, 1010, 8495, 3, 2, 2, 2, 1012, 8499, 3, 2, 2, 2, 1014, 8501, 3, 2, 2, 2, 1016, 8503, 3, 2, 2, 2, 1018, 8505, 3, 2, 2, 2, 1020, 8509, 3, 2, 2, 2, 1022, 8522, 3, 2, 2, 2, 1024, 8524, 3, 2, 2, 2, 1026, 8527, 3, 2, 2, 2, 1028, 8532, 3, 2, 2, 2, 1030, 8537, 3, 2, 2, 2, 1032, 8543, 3, 2, 2, 2, 1034, 8550, 3, 2, 2, 2, 1036, 8552, 3, 2, 2, 2, 1038, 8555, 3, 2, 2, 2, 1040, 8559, 3, 2, 2, 2, 1042, 8566, 3, 2, 2, 2, 1044, 8578, 3, 2, 2, 2, 1046, 8581, 3, 2, 2, 2, 1048, 8595, 3, 2, 2, 2, 1050, 8598, 3, 2, 2, 2, 1052, 8664, 3, 2, 2, 2, 1054, 8688, 3, 2, 2, 2, 1056, 8697, 3, 2, 2, 2, 1058, 8711, 3, 2, 2, 2, 1060, 8713, 3, 2, 2, 2, 1062, 8724, 3, 2, 2, 2, 1064, 8738, 3, 2, 2, 2, 1066, 8740, 3, 2, 2, 2, 1068, 8748, 3, 2, 2, 2, 1070, 8755, 3, 2, 2, 2, 1072, 8763, 3, 2, 2, 2, 1074, 8780, 3, 2, 2, 2, 1076, 8782, 3, 2, 2, 2, 1078, 8786, 3, 2, 2, 2, 1080, 8794, 3, 2, 2, 2, 1082, 8799, 3, 2, 2, 2, 1084, 8802, 3, 2, 2, 2, 1086, 8805, 3, 2, 2, 2, 1088, 8812, 3, 2, 2, 2, 1090, 8814, 3, 2, 2, 2, 1092, 8822, 3, 2, 2, 2, 1094, 8827, 3, 2, 2, 2, 1096, 8848, 3, 2, 2, 2, 1098, 8856, 3, 2, 2, 2, 1100, 8866, 3, 2, 2, 2, 1102, 8878, 3, 2, 2, 2, 1104, 8880, 3, 2, 2, 2, 1106, 8894, 3, 2, 2, 2, 1108, 8914, 3, 2, 2, 2, 1110, 8923, 3, 2, 2, 2, 1112, 8941, 3, 2, 2, 2, 1114, 8947, 3, 2, 2, 2, 1116, 8949, 3, 2, 2, 2, 1118, 8956, 3, 2, 2, 2, 1120, 8984, 3, 2, 2, 2, 1122, 8986, 3, 2, 2, 2, 1124, 8992, 3, 2, 2, 2, 1126, 8996, 3, 2, 2, 2, 1128, 8998, 3, 2, 2, 2, 1130, 9006, 3, 2, 2, 2, 1132, 9010, 3, 2, 2, 2, 1134, 9017, 3, 2, 2, 2, 1136, 9034, 3, 2, 2, 2, 1138, 9036, 3, 2, 2, 2, 1140, 9038, 3, 2, 2, 2, 1142, 9048, 3, 2, 2, 2, 1144, 9056, 3, 2, 2, 2, 1146, 9083, 3, 2, 2, 2, 1148, 9085, 3, 2, 2, 2, 1150, 9092, 3, 2, 2, 2, 1152, 9095, 3, 2, 2, 2, 1154, 9097, 3, 2, 2, 2, 1156, 9101, 3, 2, 2, 2, 1158, 9109, 3, 2, 2, 2, 1160, 9117, 3, 2, 2, 2, 1162, 9125, 3, 2, 2, 2, 1164, 9134, 3, 2, 2, 2, 1166, 9138, 3, 2, 2, 2, 1168, 9142, 3, 2, 2, 2, 1170, 9168, 3, 2, 2, 2, 1172, 9182, 3, 2, 2, 2, 1174, 9202, 3, 2, 2, 2, 1176, 9212, 3, 2, 2, 2, 1178, 9216, 3, 2, 2, 2, 1180, 9224, 3, 2, 2, 2, 1182, 9232, 3, 2, 2, 2, 1184, 9238, 3, 2, 2, 2, 1186, 9242, 3, 2, 2, 2, 1188, 9249, 3, 2, 2, 2, 1190, 9254, 3, 2, 2, 2, 1192, 9269, 3, 2, 2, 2, 1194, 9349, 3, 2, 2, 2, 1196, 9351, 3, 2, 2, 2, 1198, 9353, 3, 2, 2, 2, 1200, 9391, 3, 2, 2, 2, 1202, 9395, 3, 2, 2, 2, 1204, 9581, 3, 2, 2, 2, 1206, 9588, 3, 2, 2, 2, 1208, 9600, 3, 2, 2, 2, 1210, 9602, 3, 2, 2, 2, 1212, 9607, 3, 2, 2, 2, 1214, 9615, 3, 2, 2, 2, 1216, 9620, 3, 2, 2, 2, 1218, 9626, 3, 2, 2, 2, 1220, 9643, 3, 2, 2, 2, 1222, 9645, 3, 2, 2, 2, 1224, 9648, 3, 2, 2, 2, 1226, 9654, 3, 2, 2, 2, 1228, 9660, 3, 2, 2, 2, 1230, 9663, 3, 2, 2, 2, 1232, 9671, 3, 2, 2, 2, 1234, 9675, 3, 2, 2, 2, 1236, 9680, 3, 2, 2, 2, 1238, 9695, 3, 2, 2, 2, 1240, 9697, 3, 2, 2, 2, 1242, 9716, 3, 2, 2, 2, 1244, 9724, 3, 2, 2, 2, 1246, 9733, 3, 2, 2, 2, 1248, 9735, 3, 2, 2, 2, 1250, 9756, 3, 2, 2, 2, 1252, 9758, 3, 2, 2, 2, 1254, 9765, 3, 2, 2, 2, 1256, 9771, 3, 2, 2, 2, 1258, 9775, 3, 2, 2, 2, 1260, 9777, 3, 2, 2, 2, 1262, 9785, 3, 2, 2, 2, 1264, 9793, 3, 2, 2, 2, 1266, 9807, 3, 2, 2, 2, 1268, 9809, 3, 2, 2, 2, 1270, 9817, 3, 2, 2, 2, 1272, 9830, 3, 2, 2, 2, 1274, 9832, 3, 2, 2, 2, 1276, 9840, 3, 2, 2, 2, 1278, 9847, 3, 2, 2, 2, 1280, 9855, 3, 2, 2, 2, 1282, 9867, 3, 2, 2, 2, 1284, 9869, 3, 2, 2, 2, 1286, 9871, 3, 2, 2, 2, 1288, 9880, 3, 2, 2, 2, 1290, 9911, 3, 2, 2, 2, 1292, 9920, 3, 2, 2, 2, 1294, 9927, 3, 2, 2, 2, 1296, 9929, 3, 2, 2, 2, 1298, 9940, 3, 2, 2, 2, 1300, 9944, 3, 2, 2, 2, 1302, 9949, 3, 2, 2, 2, 1304, 9952, 3, 2, 2, 2, 1306, 9954, 3, 2, 2, 2, 1308, 9975, 3, 2, 2, 2, 1310, 9977, 3, 2, 2, 2, 1312, 9980, 3, 2, 2, 2, 1314, 9987, 3, 2, 2, 2, 1316, 9990, 3, 2, 2, 2, 1318, 9992, 3, 2, 2, 2, 1320, 10008, 3, 2, 2, 2, 1322, 10010, 3, 2, 2, 2, 1324, 10018, 3, 2, 2, 2, 1326, 10022, 3, 2, 2, 2, 1328, 10030, 3, 2, 2, 2, 1330, 10032, 3, 2, 2, 2, 1332, 10034, 3, 2, 2, 2, 1334, 10040, 3, 2, 2, 2, 1336, 10077, 3, 2, 2, 2, 1338, 10079, 3, 2, 2, 2, 1340, 10081, 3, 2, 2, 2, 1342, 10083, 3, 2, 2, 2, 1344, 10085, 3, 2, 2, 2, 1346, 10087, 3, 2, 2, 2, 1348, 10102, 3, 2, 2, 2, 1350, 10104, 3, 2, 2, 2, 1352, 10112, 3, 2, 2, 2, 1354, 10114, 3, 2, 2, 2, 1356, 10119, 3, 2, 2, 2, 1358, 10121, 3, 2, 2, 2, 1360, 10133, 3, 2, 2, 2, 1362, 10139, 3, 2, 2, 2, 1364, 10145, 3, 2, 2, 2, 1366, 10153, 3, 2, 2, 2, 1368, 10164, 3, 2, 2, 2, 1370, 10166, 3, 2, 2, 2, 1372, 10168, 3, 2, 2, 2, 1374, 10221, 3, 2, 2, 2, 1376, 10223, 3, 2, 2, 2, 1378, 10225, 3, 2, 2, 2, 1380, 10227, 3, 2, 2, 2, 1382, 10234, 3, 2, 2, 2, 1384, 10257, 3, 2, 2, 2, 1386, 10259, 3, 2, 2, 2, 1388, 10265, 3, 2, 2, 2, 1390, 10269, 3, 2, 2, 2, 1392, 10271, 3, 2, 2, 2, 1394, 10278, 3, 2, 2, 2, 1396, 10285, 3, 2, 2, 2, 1398, 10288, 3, 2, 2, 2, 1400, 10292, 3, 2, 2, 2, 1402, 10299, 3, 2, 2, 2, 1404, 10301, 3, 2, 2, 2, 1406, 10325, 3, 2, 2, 2, 1408, 10327, 3, 2, 2, 2, 1410, 10334, 3, 2, 2, 2, 1412, 10336, 3, 2, 2, 2, 1414, 10344, 3, 2, 2, 2, 1416, 10347, 3, 2, 2, 2, 1418, 10351, 3, 2, 2, 2, 1420, 10353, 3, 2, 2, 2, 1422, 10357, 3, 2, 2, 2, 1424, 10359, 3, 2, 2, 2, 1426, 10364, 3, 2, 2, 2, 1428, 10369, 3, 2, 2, 2, 1430, 10375, 3, 2, 2, 2, 1432, 10379, 3, 2, 2, 2, 1434, 10381, 3, 2, 2, 2, 1436, 10386, 3, 2, 2, 2, 1438, 10416, 3, 2, 2, 2, 1440, 10418, 3, 2, 2, 2, 1442, 10436, 3, 2, 2, 2, 1444, 10440, 3, 2, 2, 2, 1446, 10442, 3, 2, 2, 2, 1448, 10447, 3, 2, 2, 2, 1450, 10456, 3, 2, 2, 2, 1452, 10458, 3, 2, 2, 2, 1454, 10466, 3, 2, 2, 2, 1456, 10470, 3, 2, 2, 2, 1458, 10472, 3, 2, 2, 2, 1460, 10476, 3, 2, 2, 2, 1462, 10487, 3, 2, 2, 2, 1464, 10504, 3, 2, 2, 2, 1466, 10510, 3, 2, 2, 2, 1468, 10512, 3, 2, 2, 2, 1470, 10522, 3, 2, 2, 2, 1472, 10525, 3, 2, 2, 2, 1474, 10529, 3, 2, 2, 2, 1476, 10537, 3, 2, 2, 2, 1478, 10539, 3, 2, 2, 2, 1480, 10542, 3, 2, 2, 2, 1482, 10547, 3, 2, 2, 2, 1484, 10552, 3, 2, 2, 2, 1486, 10574, 3, 2, 2, 2, 1488, 10588, 3, 2, 2, 2, 1490, 10592, 3, 2, 2, 2, 1492, 10597, 3, 2, 2, 2, 1494, 10599, 3, 2, 2, 2, 1496, 10601, 3, 2, 2, 2, 1498, 10613, 3, 2, 2, 2, 1500, 10615, 3, 2, 2, 2, 1502, 10622, 3, 2, 2, 2, 1504, 10624, 3, 2, 2, 2, 1506, 10642, 3, 2, 2, 2, 1508, 10678, 3, 2, 2, 2, 1510, 10680, 3, 2, 2, 2, 1512, 10689, 3, 2, 2, 2, 1514, 10694, 3, 2, 2, 2, 1516, 10696, 3, 2, 2, 2, 1518, 10700, 3, 2, 2, 2, 1520, 10708, 3, 2, 2, 2, 1522, 10716, 3, 2, 2, 2, 1524, 10718, 3, 2, 2, 2, 1526, 10725, 3, 2, 2, 2, 1528, 10728, 3, 2, 2, 2, 1530, 10744, 3, 2, 2, 2, 1532, 10746, 3, 2, 2, 2, 1534, 10760, 3, 2, 2, 2, 1536, 10762, 3, 2, 2, 2, 1538, 10789, 3, 2, 2, 2, 1540, 10791, 3, 2, 2, 2, 1542, 10802, 3, 2, 2, 2, 1544, 10808, 3, 2, 2, 2, 1546, 10812, 3, 2, 2, 2, 1548, 10814, 3, 2, 2, 2, 1550, 10824, 3, 2, 2, 2, 1552, 10829, 3, 2, 2, 2, 1554, 10846, 3, 2, 2, 2, 1556, 10848, 3, 2, 2, 2, 1558, 10855, 3, 2, 2, 2, 1560, 10859, 3, 2, 2, 2, 1562, 10862, 3, 2, 2, 2, 1564, 10868, 3, 2, 2, 2, 1566, 10874, 3, 2, 2, 2, 1568, 10892, 3, 2, 2, 2, 1570, 10896, 3, 2, 2, 2, 1572, 10901, 3, 2, 2, 2, 1574, 10904, 3, 2, 2, 2, 1576, 10908, 3, 2, 2, 2, 1578, 10913, 3, 2, 2, 2, 1580, 10924, 3, 2, 2, 2, 1582, 10928, 3, 2, 2, 2, 1584, 10932, 3, 2, 2, 2, 1586, 10936, 3, 2, 2, 2, 1588, 10938, 3, 2, 2, 2, 1590, 10943, 3, 2, 2, 2, 1592, 10945, 3, 2, 2, 2, 1594, 10948, 3, 2, 2, 2, 1596, 10968, 3, 2, 2, 2, 1598, 10970, 3, 2, 2, 2, 1600, 10972, 3, 2, 2, 2, 1602, 10974, 3, 2, 2, 2, 1604, 10976, 3, 2, 2, 2, 1606, 10980, 3, 2, 2, 2, 1608, 1609, 5, 6, 4, 2, 1609, 3, 3, 2, 2, 2, 1610, 1611, 5, 1380, 691, 2, 1611, 5, 3, 2, 2, 2, 1612, 1614, 5, 8, 5, 2, 1613, 1615, 7, 9, 2, 2, 1614, 1613, 3, 2, 2, 2, 1614, 1615, 3, 2, 2, 2, 1615, 1617, 3, 2, 2, 2, 1616, 1612, 3, 2, 2, 2, 1617, 1620, 3, 2, 2, 2, 1618, 1616, 3, 2, 2, 2, 1618, 1619, 3, 2, 2, 2, 1619, 7, 3, 2, 2, 2, 1620, 1618, 3, 2, 2, 2, 1621, 1746, 5, 452, 227, 2, 1622, 1746, 5, 826, 414, 2, 1623, 1746, 5, 816, 409, 2, 1624, 1746, 5, 818, 410, 2, 1625, 1746, 5, 578, 290, 2, 1626, 1746, 5, 832, 417, 2, 1627, 1746, 5, 478, 240, 2, 1628, 1746, 5, 322, 162, 2, 1629, 1746, 5, 328, 165, 2, 1630, 1746, 5, 338, 170, 2, 1631, 1746, 5, 364, 183, 2, 1632, 1746, 5, 670, 336, 2, 1633, 1746, 5, 38, 20, 2, 1634, 1746, 5, 728, 365, 2, 1635, 1746, 5, 732, 367, 2, 1636, 1746, 5, 744, 373, 2, 1637, 1746, 5, 734, 368, 2, 1638, 1746, 5, 742, 372, 2, 1639, 1746, 5, 384, 193, 2, 1640, 1746, 5, 280, 141, 2, 1641, 1746, 5, 828, 415, 2, 1642, 1746, 5, 96, 49, 2, 1643, 1746, 5, 720, 361, 2, 1644, 1746, 5, 134, 68, 2, 1645, 1746, 5, 752, 377, 2, 1646, 1746, 5, 32, 17, 2, 1647, 1746, 5, 28, 15, 2, 1648, 1746, 5, 760, 381, 2, 1649, 1746, 5, 262, 132, 2, 1650, 1746, 5, 838, 420, 2, 1651, 1746, 5, 836, 419, 2, 1652, 1746, 5, 380, 191, 2, 1653, 1746, 5, 850, 426, 2, 1654, 1746, 5, 12, 7, 2, 1655, 1746, 5, 92, 47, 2, 1656, 1746, 5, 140, 71, 2, 1657, 1746, 5, 844, 423, 2, 1658, 1746, 5, 534, 268, 2, 1659, 1746, 5, 86, 44, 2, 1660, 1746, 5, 142, 72, 2, 1661, 1746, 5, 400, 201, 2, 1662, 1746, 5, 264, 133, 2, 1663, 1746, 5, 456, 229, 2, 1664, 1746, 5, 696, 349, 2, 1665, 1746, 5, 842, 422, 2, 1666, 1746, 5, 830, 416, 2, 1667, 1746, 5, 316, 159, 2, 1668, 1746, 5, 330, 166, 2, 1669, 1746, 5, 356, 179, 2, 1670, 1746, 5, 366, 184, 2, 1671, 1746, 5, 616, 309, 2, 1672, 1746, 5, 36, 19, 2, 1673, 1746, 5, 270, 136, 2, 1674, 1746, 5, 482, 242, 2, 1675, 1746, 5, 496, 249, 2, 1676, 1746, 5, 746, 374, 2, 1677, 1746, 5, 498, 250, 2, 1678, 1746, 5, 382, 192, 2, 1679, 1746, 5, 296, 149, 2, 1680, 1746, 5, 42, 22, 2, 1681, 1746, 5, 278, 140, 2, 1682, 1746, 5, 172, 87, 2, 1683, 1746, 5, 754, 378, 2, 1684, 1746, 5, 260, 131, 2, 1685, 1746, 5, 310, 156, 2, 1686, 1746, 5, 704, 353, 2, 1687, 1746, 5, 404, 203, 2, 1688, 1746, 5, 444, 223, 2, 1689, 1746, 5, 14, 8, 2, 1690, 1746, 5, 26, 14, 2, 1691, 1746, 5, 374, 188, 2, 1692, 1746, 5, 804, 403, 2, 1693, 1746, 5, 900, 451, 2, 1694, 1746, 5, 944, 473, 2, 1695, 1746, 5, 458, 230, 2, 1696, 1746, 5, 920, 461, 2, 1697, 1746, 5, 94, 48, 2, 1698, 1746, 5, 690, 346, 2, 1699, 1746, 5, 700, 351, 2, 1700, 1746, 5, 504, 253, 2, 1701, 1746, 5, 506, 254, 2, 1702, 1746, 5, 508, 255, 2, 1703, 1746, 5, 512, 257, 2, 1704, 1746, 5, 762, 382, 2, 1705, 1746, 5, 314, 158, 2, 1706, 1746, 5, 708, 355, 2, 1707, 1746, 5, 34, 18, 2, 1708, 1746, 5, 378, 190, 2, 1709, 1746, 5, 820, 411, 2, 1710, 1746, 5, 896, 449, 2, 1711, 1746, 5, 878, 440, 2, 1712, 1746, 5, 544, 273, 2, 1713, 1746, 5, 552, 277, 2, 1714, 1746, 5, 570, 286, 2, 1715, 1746, 5, 368, 185, 2, 1716, 1746, 5, 588, 295, 2, 1717, 1746, 5, 902, 452, 2, 1718, 1746, 5, 782, 392, 2, 1719, 1746, 5, 276, 139, 2, 1720, 1746, 5, 802, 402, 2, 1721, 1746, 5, 924, 463, 2, 1722, 1746, 5, 778, 390, 2, 1723, 1746, 5, 890, 446, 2, 1724, 1746, 5, 510, 256, 2, 1725, 1746, 5, 710, 356, 2, 1726, 1746, 5, 678, 340, 2, 1727, 1746, 5, 676, 339, 2, 1728, 1746, 5, 680, 341, 2, 1729, 1746, 5, 722, 362, 2, 1730, 1746, 5, 554, 278, 2, 1731, 1746, 5, 572, 287, 2, 1732, 1746, 5, 764, 383, 2, 1733, 1746, 5, 538, 270, 2, 1734, 1746, 5, 952, 477, 2, 1735, 1746, 5, 786, 394, 2, 1736, 1746, 5, 530, 266, 2, 1737, 1746, 5, 784, 393, 2, 1738, 1746, 5, 934, 468, 2, 1739, 1746, 5, 848, 425, 2, 1740, 1746, 5, 74, 38, 2, 1741, 1746, 5, 50, 26, 2, 1742, 1746, 5, 84, 43, 2, 1743, 1746, 5, 798, 400, 2, 1744, 1746, 5, 10, 6, 2, 1745, 1621, 3, 2, 2, 2, 1745, 1622, 3, 2, 2, 2, 1745, 1623, 3, 2, 2, 2, 1745, 1624, 3, 2, 2, 2, 1745, 1625, 3, 2, 2, 2, 1745, 1626, 3, 2, 2, 2, 1745, 1627, 3, 2, 2, 2, 1745, 1628, 3, 2, 2, 2, 1745, 1629, 3, 2, 2, 2, 1745, 1630, 3, 2, 2, 2, 1745, 1631, 3, 2, 2, 2, 1745, 1632, 3, 2, 2, 2, 1745, 1633, 3, 2, 2, 2, 1745, 1634, 3, 2, 2, 2, 1745, 1635, 3, 2, 2, 2, 1745, 1636, 3, 2, 2, 2, 1745, 1637, 3, 2, 2, 2, 1745, 1638, 3, 2, 2, 2, 1745, 1639, 3, 2, 2, 2, 1745, 1640, 3, 2, 2, 2, 1745, 1641, 3, 2, 2, 2, 1745, 1642, 3, 2, 2, 2, 1745, 1643, 3, 2, 2, 2, 1745, 1644, 3, 2, 2, 2, 1745, 1645, 3, 2, 2, 2, 1745, 1646, 3, 2, 2, 2, 1745, 1647, 3, 2, 2, 2, 1745, 1648, 3, 2, 2, 2, 1745, 1649, 3, 2, 2, 2, 1745, 1650, 3, 2, 2, 2, 1745, 1651, 3, 2, 2, 2, 1745, 1652, 3, 2, 2, 2, 1745, 1653, 3, 2, 2, 2, 1745, 1654, 3, 2, 2, 2, 1745, 1655, 3, 2, 2, 2, 1745, 1656, 3, 2, 2, 2, 1745, 1657, 3, 2, 2, 2, 1745, 1658, 3, 2, 2, 2, 1745, 1659, 3, 2, 2, 2, 1745, 1660, 3, 2, 2, 2, 1745, 1661, 3, 2, 2, 2, 1745, 1662, 3, 2, 2, 2, 1745, 1663, 3, 2, 2, 2, 1745, 1664, 3, 2, 2, 2, 1745, 1665, 3, 2, 2, 2, 1745, 1666, 3, 2, 2, 2, 1745, 1667, 3, 2, 2, 2, 1745, 1668, 3, 2, 2, 2, 1745, 1669, 3, 2, 2, 2, 1745, 1670, 3, 2, 2, 2, 1745, 1671, 3, 2, 2, 2, 1745, 1672, 3, 2, 2, 2, 1745, 1673, 3, 2, 2, 2, 1745, 1674, 3, 2, 2, 2, 1745, 1675, 3, 2, 2, 2, 1745, 1676, 3, 2, 2, 2, 1745, 1677, 3, 2, 2, 2, 1745, 1678, 3, 2, 2, 2, 1745, 1679, 3, 2, 2, 2, 1745, 1680, 3, 2, 2, 2, 1745, 1681, 3, 2, 2, 2, 1745, 1682, 3, 2, 2, 2, 1745, 1683, 3, 2, 2, 2, 1745, 1684, 3, 2, 2, 2, 1745, 1685, 3, 2, 2, 2, 1745, 1686, 3, 2, 2, 2, 1745, 1687, 3, 2, 2, 2, 1745, 1688, 3, 2, 2, 2, 1745, 1689, 3, 2, 2, 2, 1745, 1690, 3, 2, 2, 2, 1745, 1691, 3, 2, 2, 2, 1745, 1692, 3, 2, 2, 2, 1745, 1693, 3, 2, 2, 2, 1745, 1694, 3, 2, 2, 2, 1745, 1695, 3, 2, 2, 2, 1745, 1696, 3, 2, 2, 2, 1745, 1697, 3, 2, 2, 2, 1745, 1698, 3, 2, 2, 2, 1745, 1699, 3, 2, 2, 2, 1745, 1700, 3, 2, 2, 2, 1745, 1701, 3, 2, 2, 2, 1745, 1702, 3, 2, 2, 2, 1745, 1703, 3, 2, 2, 2, 1745, 1704, 3, 2, 2, 2, 1745, 1705, 3, 2, 2, 2, 1745, 1706, 3, 2, 2, 2, 1745, 1707, 3, 2, 2, 2, 1745, 1708, 3, 2, 2, 2, 1745, 1709, 3, 2, 2, 2, 1745, 1710, 3, 2, 2, 2, 1745, 1711, 3, 2, 2, 2, 1745, 1712, 3, 2, 2, 2, 1745, 1713, 3, 2, 2, 2, 1745, 1714, 3, 2, 2, 2, 1745, 1715, 3, 2, 2, 2, 1745, 1716, 3, 2, 2, 2, 1745, 1717, 3, 2, 2, 2, 1745, 1718, 3, 2, 2, 2, 1745, 1719, 3, 2, 2, 2, 1745, 1720, 3, 2, 2, 2, 1745, 1721, 3, 2, 2, 2, 1745, 1722, 3, 2, 2, 2, 1745, 1723, 3, 2, 2, 2, 1745, 1724, 3, 2, 2, 2, 1745, 1725, 3, 2, 2, 2, 1745, 1726, 3, 2, 2, 2, 1745, 1727, 3, 2, 2, 2, 1745, 1728, 3, 2, 2, 2, 1745, 1729, 3, 2, 2, 2, 1745, 1730, 3, 2, 2, 2, 1745, 1731, 3, 2, 2, 2, 1745, 1732, 3, 2, 2, 2, 1745, 1733, 3, 2, 2, 2, 1745, 1734, 3, 2, 2, 2, 1745, 1735, 3, 2, 2, 2, 1745, 1736, 3, 2, 2, 2, 1745, 1737, 3, 2, 2, 2, 1745, 1738, 3, 2, 2, 2, 1745, 1739, 3, 2, 2, 2, 1745, 1740, 3, 2, 2, 2, 1745, 1741, 3, 2, 2, 2, 1745, 1742, 3, 2, 2, 2, 1745, 1743, 3, 2, 2, 2, 1745, 1744, 3, 2, 2, 2, 1746, 9, 3, 2, 2, 2, 1747, 1749, 7, 546, 2, 2, 1748, 1750, 7, 547, 2, 2, 1749, 1748, 3, 2, 2, 2, 1749, 1750, 3, 2, 2, 2, 1750, 11, 3, 2, 2, 2, 1751, 1752, 7, 426, 2, 2, 1752, 1753, 5, 1198, 600, 2, 1753, 13, 3, 2, 2, 2, 1754, 1755, 7, 48, 2, 2, 1755, 1756, 7, 311, 2, 2, 1756, 1758, 5, 1354, 678, 2, 1757, 1759, 5, 16, 9, 2, 1758, 1757, 3, 2, 2, 2, 1758, 1759, 3, 2, 2, 2, 1759, 1760, 3, 2, 2, 2, 1760, 1761, 5, 18, 10, 2, 1761, 15, 3, 2, 2, 2, 1762, 1763, 7, 107, 2, 2, 1763, 17, 3, 2, 2, 2, 1764, 1766, 5, 24, 13, 2, 1765, 1764, 3, 2, 2, 2, 1766, 1769, 3, 2, 2, 2, 1767, 1765, 3, 2, 2, 2, 1767, 1768, 3, 2, 2, 2, 1768, 19, 3, 2, 2, 2, 1769, 1767, 3, 2, 2, 2, 1770, 1772, 5, 22, 12, 2, 1771, 1770, 3, 2, 2, 2, 1772, 1775, 3, 2, 2, 2, 1773, 1771, 3, 2, 2, 2, 1773, 1774, 3, 2, 2, 2, 1774, 21, 3, 2, 2, 2, 1775, 1773, 3, 2, 2, 2, 1776, 1779, 7, 280, 2, 2, 1777, 1780, 5, 1346, 674, 2, 1778, 1780, 7, 80, 2, 2, 1779, 1777, 3, 2, 2, 2, 1779, 1778, 3, 2, 2, 2, 1780, 1795, 3, 2, 2, 2, 1781, 1782, 9, 2, 2, 2, 1782, 1783, 7, 280, 2, 2, 1783, 1795, 5, 1346, 674, 2, 1784, 1795, 7, 230, 2, 2, 1785, 1786, 7, 166, 2, 2, 1786, 1787, 7, 76, 2, 2, 1787, 1795, 5, 1352, 677, 2, 1788, 1789, 7, 364, 2, 2, 1789, 1790, 7, 361, 2, 2, 1790, 1795, 5, 1346, 674, 2, 1791, 1792, 7, 101, 2, 2, 1792, 1795, 5, 1358, 680, 2, 1793, 1795, 5, 1368, 685, 2, 1794, 1776, 3, 2, 2, 2, 1794, 1781, 3, 2, 2, 2, 1794, 1784, 3, 2, 2, 2, 1794, 1785, 3, 2, 2, 2, 1794, 1788, 3, 2, 2, 2, 1794, 1791, 3, 2, 2, 2, 1794, 1793, 3, 2, 2, 2, 1795, 23, 3, 2, 2, 2, 1796, 1807, 5, 22, 12, 2, 1797, 1798, 7, 341, 2, 2, 1798, 1807, 5, 1344, 673, 2, 1799, 1800, 7, 136, 2, 2, 1800, 1807, 5, 1358, 680, 2, 1801, 1802, 7, 311, 2, 2, 1802, 1807, 5, 1358, 680, 2, 1803, 1804, 7, 70, 2, 2, 1804, 1805, 9, 3, 2, 2, 1805, 1807, 5, 1358, 680, 2, 1806, 1796, 3, 2, 2, 2, 1806, 1797, 3, 2, 2, 2, 1806, 1799, 3, 2, 2, 2, 1806, 1801, 3, 2, 2, 2, 1806, 1803, 3, 2, 2, 2, 1807, 25, 3, 2, 2, 2, 1808, 1809, 7, 48, 2, 2, 1809, 1810, 7, 101, 2, 2, 1810, 1812, 5, 1354, 678, 2, 1811, 1813, 5, 16, 9, 2, 1812, 1811, 3, 2, 2, 2, 1812, 1813, 3, 2, 2, 2, 1813, 1814, 3, 2, 2, 2, 1814, 1815, 5, 18, 10, 2, 1815, 27, 3, 2, 2, 2, 1816, 1817, 7, 140, 2, 2, 1817, 1818, 9, 4, 2, 2, 1818, 1820, 5, 1356, 679, 2, 1819, 1821, 5, 16, 9, 2, 1820, 1819, 3, 2, 2, 2, 1820, 1821, 3, 2, 2, 2, 1821, 1822, 3, 2, 2, 2, 1822, 1823, 5, 20, 11, 2, 1823, 29, 3, 2, 2, 2, 1824, 1829, 3, 2, 2, 2, 1825, 1826, 7, 70, 2, 2, 1826, 1827, 7, 177, 2, 2, 1827, 1829, 5, 1328, 665, 2, 1828, 1824, 3, 2, 2, 2, 1828, 1825, 3, 2, 2, 2, 1829, 31, 3, 2, 2, 2, 1830, 1831, 7, 140, 2, 2, 1831, 1833, 9, 4, 2, 2, 1832, 1834, 7, 32, 2, 2, 1833, 1832, 3, 2, 2, 2, 1833, 1834, 3, 2, 2, 2, 1834, 1835, 3, 2, 2, 2, 1835, 1836, 5, 1356, 679, 2, 1836, 1837, 5, 30, 16, 2, 1837, 1838, 5, 80, 41, 2, 1838, 33, 3, 2, 2, 2, 1839, 1840, 7, 193, 2, 2, 1840, 1843, 9, 5, 2, 2, 1841, 1842, 7, 222, 2, 2, 1842, 1844, 7, 389, 2, 2, 1843, 1841, 3, 2, 2, 2, 1843, 1844, 3, 2, 2, 2, 1844, 1845, 3, 2, 2, 2, 1845, 1846, 5, 1358, 680, 2, 1846, 35, 3, 2, 2, 2, 1847, 1848, 7, 48, 2, 2, 1848, 1849, 7, 68, 2, 2, 1849, 1851, 5, 1354, 678, 2, 1850, 1852, 5, 16, 9, 2, 1851, 1850, 3, 2, 2, 2, 1851, 1852, 3, 2, 2, 2, 1852, 1853, 3, 2, 2, 2, 1853, 1854, 5, 18, 10, 2, 1854, 37, 3, 2, 2, 2, 1855, 1856, 7, 140, 2, 2, 1856, 1857, 7, 68, 2, 2, 1857, 1858, 5, 1356, 679, 2, 1858, 1859, 5, 40, 21, 2, 1859, 1860, 7, 101, 2, 2, 1860, 1861, 5, 1358, 680, 2, 1861, 39, 3, 2, 2, 2, 1862, 1863, 9, 6, 2, 2, 1863, 41, 3, 2, 2, 2, 1864, 1865, 7, 48, 2, 2, 1865, 1869, 7, 316, 2, 2, 1866, 1867, 7, 222, 2, 2, 1867, 1868, 7, 79, 2, 2, 1868, 1870, 7, 389, 2, 2, 1869, 1866, 3, 2, 2, 2, 1869, 1870, 3, 2, 2, 2, 1870, 1877, 3, 2, 2, 2, 1871, 1873, 5, 44, 23, 2, 1872, 1871, 3, 2, 2, 2, 1872, 1873, 3, 2, 2, 2, 1873, 1874, 3, 2, 2, 2, 1874, 1875, 7, 108, 2, 2, 1875, 1878, 5, 1356, 679, 2, 1876, 1878, 5, 1360, 681, 2, 1877, 1872, 3, 2, 2, 2, 1877, 1876, 3, 2, 2, 2, 1878, 1879, 3, 2, 2, 2, 1879, 1880, 5, 46, 24, 2, 1880, 43, 3, 2, 2, 2, 1881, 1882, 5, 1360, 681, 2, 1882, 45, 3, 2, 2, 2, 1883, 1885, 5, 48, 25, 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, 47, 3, 2, 2, 2, 1888, 1886, 3, 2, 2, 2, 1889, 1896, 5, 172, 87, 2, 1890, 1896, 5, 588, 295, 2, 1891, 1896, 5, 278, 140, 2, 1892, 1896, 5, 404, 203, 2, 1893, 1896, 5, 552, 277, 2, 1894, 1896, 5, 798, 400, 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, 49, 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, 52, 27, 2, 1902, 51, 3, 2, 2, 2, 1903, 1904, 7, 349, 2, 2, 1904, 1912, 5, 792, 397, 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, 792, 397, 2, 1910, 1912, 5, 56, 29, 2, 1911, 1903, 3, 2, 2, 2, 1911, 1905, 3, 2, 2, 2, 1911, 1910, 3, 2, 2, 2, 1912, 53, 3, 2, 2, 2, 1913, 1914, 5, 58, 30, 2, 1914, 1915, 9, 8, 2, 2, 1915, 1916, 5, 60, 31, 2, 1916, 55, 3, 2, 2, 2, 1917, 1945, 5, 54, 28, 2, 1918, 1919, 5, 58, 30, 2, 1919, 1920, 7, 66, 2, 2, 1920, 1921, 7, 427, 2, 2, 1921, 1945, 3, 2, 2, 2, 1922, 1923, 7, 411, 2, 2, 1923, 1924, 7, 379, 2, 2, 1924, 1945, 5, 68, 35, 2, 1925, 1926, 7, 154, 2, 2, 1926, 1945, 5, 1346, 674, 2, 1927, 1928, 7, 316, 2, 2, 1928, 1945, 5, 1346, 674, 2, 1929, 1931, 7, 260, 2, 2, 1930, 1932, 5, 70, 36, 2, 1931, 1930, 3, 2, 2, 2, 1931, 1932, 3, 2, 2, 2, 1932, 1945, 3, 2, 2, 2, 1933, 1934, 7, 311, 2, 2, 1934, 1945, 5, 72, 37, 2, 1935, 1936, 7, 325, 2, 2, 1936, 1937, 7, 108, 2, 2, 1937, 1945, 5, 72, 37, 2, 1938, 1939, 7, 376, 2, 2, 1939, 1940, 7, 272, 2, 2, 1940, 1945, 5, 1216, 609, 2, 1941, 1942, 7, 349, 2, 2, 1942, 1943, 7, 330, 2, 2, 1943, 1945, 5, 1346, 674, 2, 1944, 1917, 3, 2, 2, 2, 1944, 1918, 3, 2, 2, 2, 1944, 1922, 3, 2, 2, 2, 1944, 1925, 3, 2, 2, 2, 1944, 1927, 3, 2, 2, 2, 1944, 1929, 3, 2, 2, 2, 1944, 1933, 3, 2, 2, 2, 1944, 1935, 3, 2, 2, 2, 1944, 1938, 3, 2, 2, 2, 1944, 1941, 3, 2, 2, 2, 1945, 57, 3, 2, 2, 2, 1946, 1951, 5, 1360, 681, 2, 1947, 1948, 7, 13, 2, 2, 1948, 1950, 5, 1360, 681, 2, 1949, 1947, 3, 2, 2, 2, 1950, 1953, 3, 2, 2, 2, 1951, 1949, 3, 2, 2, 2, 1951, 1952, 3, 2, 2, 2, 1952, 59, 3, 2, 2, 2, 1953, 1951, 3, 2, 2, 2, 1954, 1959, 5, 62, 32, 2, 1955, 1956, 7, 8, 2, 2, 1956, 1958, 5, 62, 32, 2, 1957, 1955, 3, 2, 2, 2, 1958, 1961, 3, 2, 2, 2, 1959, 1957, 3, 2, 2, 2, 1959, 1960, 3, 2, 2, 2, 1960, 61, 3, 2, 2, 2, 1961, 1959, 3, 2, 2, 2, 1962, 1965, 5, 66, 34, 2, 1963, 1965, 5, 292, 147, 2, 1964, 1962, 3, 2, 2, 2, 1964, 1963, 3, 2, 2, 2, 1965, 63, 3, 2, 2, 2, 1966, 1967, 7, 293, 2, 2, 1967, 1972, 9, 9, 2, 2, 1968, 1969, 7, 303, 2, 2, 1969, 1972, 7, 293, 2, 2, 1970, 1972, 7, 323, 2, 2, 1971, 1966, 3, 2, 2, 2, 1971, 1968, 3, 2, 2, 2, 1971, 1970, 3, 2, 2, 2, 1972, 65, 3, 2, 2, 2, 1973, 1978, 7, 98, 2, 2, 1974, 1978, 7, 62, 2, 2, 1975, 1978, 7, 82, 2, 2, 1976, 1978, 5, 72, 37, 2, 1977, 1973, 3, 2, 2, 2, 1977, 1974, 3, 2, 2, 2, 1977, 1975, 3, 2, 2, 2, 1977, 1976, 3, 2, 2, 2, 1978, 67, 3, 2, 2, 2, 1979, 1996, 5, 1346, 674, 2, 1980, 1996, 5, 1368, 685, 2, 1981, 1982, 5, 1142, 572, 2, 1982, 1984, 5, 1346, 674, 2, 1983, 1985, 5, 1146, 574, 2, 1984, 1983, 3, 2, 2, 2, 1984, 1985, 3, 2, 2, 2, 1985, 1996, 3, 2, 2, 2, 1986, 1987, 5, 1142, 572, 2, 1987, 1988, 7, 4, 2, 2, 1988, 1989, 5, 1344, 673, 2, 1989, 1990, 7, 5, 2, 2, 1990, 1991, 5, 1346, 674, 2, 1991, 1996, 3, 2, 2, 2, 1992, 1996, 5, 292, 147, 2, 1993, 1996, 7, 55, 2, 2, 1994, 1996, 7, 247, 2, 2, 1995, 1979, 3, 2, 2, 2, 1995, 1980, 3, 2, 2, 2, 1995, 1981, 3, 2, 2, 2, 1995, 1986, 3, 2, 2, 2, 1995, 1992, 3, 2, 2, 2, 1995, 1993, 3, 2, 2, 2, 1995, 1994, 3, 2, 2, 2, 1996, 69, 3, 2, 2, 2, 1997, 2000, 5, 1346, 674, 2, 1998, 2000, 7, 55, 2, 2, 1999, 1997, 3, 2, 2, 2, 1999, 1998, 3, 2, 2, 2, 2000, 71, 3, 2, 2, 2, 2001, 2004, 5, 1364, 683, 2, 2002, 2004, 5, 1346, 674, 2, 2003, 2001, 3, 2, 2, 2, 2003, 2002, 3, 2, 2, 2, 2004, 73, 3, 2, 2, 2, 2005, 2006, 7, 306, 2, 2, 2006, 2007, 5, 76, 39, 2, 2007, 75, 3, 2, 2, 2, 2008, 2017, 5, 78, 40, 2, 2009, 2010, 7, 411, 2, 2, 2010, 2017, 7, 379, 2, 2, 2011, 2012, 7, 349, 2, 2, 2012, 2013, 7, 237, 2, 2, 2013, 2017, 7, 244, 2, 2, 2014, 2015, 7, 325, 2, 2, 2015, 2017, 7, 108, 2, 2, 2016, 2008, 3, 2, 2, 2, 2016, 2009, 3, 2, 2, 2, 2016, 2011, 3, 2, 2, 2, 2016, 2014, 3, 2, 2, 2, 2017, 77, 3, 2, 2, 2, 2018, 2021, 5, 58, 30, 2, 2019, 2021, 7, 32, 2, 2, 2020, 2018, 3, 2, 2, 2, 2020, 2019, 3, 2, 2, 2, 2021, 79, 3, 2, 2, 2, 2022, 2023, 7, 326, 2, 2, 2023, 2026, 5, 52, 27, 2, 2024, 2026, 5, 74, 38, 2, 2025, 2022, 3, 2, 2, 2, 2025, 2024, 3, 2, 2, 2, 2026, 81, 3, 2, 2, 2, 2027, 2028, 7, 326, 2, 2, 2028, 2031, 5, 56, 29, 2, 2029, 2031, 5, 74, 38, 2, 2030, 2027, 3, 2, 2, 2, 2030, 2029, 3, 2, 2, 2, 2031, 83, 3, 2, 2, 2, 2032, 2042, 7, 328, 2, 2, 2033, 2043, 5, 58, 30, 2, 2034, 2035, 7, 411, 2, 2, 2035, 2043, 7, 379, 2, 2, 2036, 2037, 7, 349, 2, 2, 2037, 2038, 7, 237, 2, 2, 2038, 2043, 7, 244, 2, 2, 2039, 2040, 7, 325, 2, 2, 2040, 2043, 7, 108, 2, 2, 2041, 2043, 7, 32, 2, 2, 2042, 2033, 3, 2, 2, 2, 2042, 2034, 3, 2, 2, 2, 2042, 2036, 3, 2, 2, 2, 2042, 2039, 3, 2, 2, 2, 2042, 2041, 3, 2, 2, 2, 2043, 85, 3, 2, 2, 2, 2044, 2045, 7, 326, 2, 2, 2045, 2046, 7, 167, 2, 2, 2046, 2047, 5, 88, 45, 2, 2047, 2048, 5, 90, 46, 2, 2048, 87, 3, 2, 2, 2, 2049, 2052, 7, 32, 2, 2, 2050, 2052, 5, 1322, 662, 2, 2051, 2049, 3, 2, 2, 2, 2051, 2050, 3, 2, 2, 2, 2052, 89, 3, 2, 2, 2, 2053, 2054, 9, 10, 2, 2, 2054, 91, 3, 2, 2, 2, 2055, 2056, 7, 157, 2, 2, 2056, 93, 3, 2, 2, 2, 2057, 2058, 7, 189, 2, 2, 2058, 2059, 9, 11, 2, 2, 2059, 95, 3, 2, 2, 2, 2060, 2061, 7, 140, 2, 2, 2061, 2064, 7, 94, 2, 2, 2062, 2063, 7, 222, 2, 2, 2063, 2065, 7, 389, 2, 2, 2064, 2062, 3, 2, 2, 2, 2064, 2065, 3, 2, 2, 2, 2065, 2066, 3, 2, 2, 2, 2066, 2069, 5, 1064, 533, 2, 2067, 2070, 5, 98, 50, 2, 2068, 2070, 5, 100, 51, 2, 2069, 2067, 3, 2, 2, 2, 2069, 2068, 3, 2, 2, 2, 2070, 2173, 3, 2, 2, 2, 2071, 2072, 7, 140, 2, 2, 2072, 2073, 7, 94, 2, 2, 2073, 2074, 7, 32, 2, 2, 2074, 2075, 7, 70, 2, 2, 2075, 2076, 7, 344, 2, 2, 2076, 2080, 5, 1328, 665, 2, 2077, 2078, 7, 274, 2, 2, 2078, 2079, 7, 149, 2, 2, 2079, 2081, 5, 1358, 680, 2, 2080, 2077, 3, 2, 2, 2, 2080, 2081, 3, 2, 2, 2, 2081, 2082, 3, 2, 2, 2, 2082, 2083, 7, 326, 2, 2, 2083, 2084, 7, 344, 2, 2, 2084, 2086, 5, 1328, 665, 2, 2085, 2087, 5, 930, 466, 2, 2086, 2085, 3, 2, 2, 2, 2086, 2087, 3, 2, 2, 2, 2087, 2173, 3, 2, 2, 2, 2088, 2089, 7, 140, 2, 2, 2089, 2092, 7, 228, 2, 2, 2090, 2091, 7, 222, 2, 2, 2091, 2093, 7, 389, 2, 2, 2092, 2090, 3, 2, 2, 2, 2092, 2093, 3, 2, 2, 2, 2093, 2094, 3, 2, 2, 2, 2094, 2097, 5, 1324, 663, 2, 2095, 2098, 5, 98, 50, 2, 2096, 2098, 5, 102, 52, 2, 2097, 2095, 3, 2, 2, 2, 2097, 2096, 3, 2, 2, 2, 2098, 2173, 3, 2, 2, 2, 2099, 2100, 7, 140, 2, 2, 2100, 2101, 7, 228, 2, 2, 2101, 2102, 7, 32, 2, 2, 2102, 2103, 7, 70, 2, 2, 2103, 2104, 7, 344, 2, 2, 2104, 2108, 5, 1328, 665, 2, 2105, 2106, 7, 274, 2, 2, 2106, 2107, 7, 149, 2, 2, 2107, 2109, 5, 1358, 680, 2, 2108, 2105, 3, 2, 2, 2, 2108, 2109, 3, 2, 2, 2, 2109, 2110, 3, 2, 2, 2, 2110, 2111, 7, 326, 2, 2, 2111, 2112, 7, 344, 2, 2, 2112, 2114, 5, 1328, 665, 2, 2113, 2115, 5, 930, 466, 2, 2114, 2113, 3, 2, 2, 2, 2114, 2115, 3, 2, 2, 2, 2115, 2173, 3, 2, 2, 2, 2116, 2117, 7, 140, 2, 2, 2117, 2120, 7, 321, 2, 2, 2118, 2119, 7, 222, 2, 2, 2119, 2121, 7, 389, 2, 2, 2120, 2118, 3, 2, 2, 2, 2120, 2121, 3, 2, 2, 2, 2121, 2122, 3, 2, 2, 2, 2122, 2123, 5, 1324, 663, 2, 2123, 2124, 5, 98, 50, 2, 2124, 2173, 3, 2, 2, 2, 2125, 2126, 7, 140, 2, 2, 2126, 2129, 7, 369, 2, 2, 2127, 2128, 7, 222, 2, 2, 2128, 2130, 7, 389, 2, 2, 2129, 2127, 3, 2, 2, 2, 2129, 2130, 3, 2, 2, 2, 2130, 2131, 3, 2, 2, 2, 2131, 2132, 5, 1324, 663, 2, 2132, 2133, 5, 98, 50, 2, 2133, 2173, 3, 2, 2, 2, 2134, 2135, 7, 140, 2, 2, 2135, 2136, 7, 252, 2, 2, 2136, 2139, 7, 369, 2, 2, 2137, 2138, 7, 222, 2, 2, 2138, 2140, 7, 389, 2, 2, 2139, 2137, 3, 2, 2, 2, 2139, 2140, 3, 2, 2, 2, 2140, 2141, 3, 2, 2, 2, 2141, 2142, 5, 1324, 663, 2, 2142, 2143, 5, 98, 50, 2, 2143, 2173, 3, 2, 2, 2, 2144, 2145, 7, 140, 2, 2, 2145, 2146, 7, 252, 2, 2, 2146, 2147, 7, 369, 2, 2, 2147, 2148, 7, 32, 2, 2, 2148, 2149, 7, 70, 2, 2, 2149, 2150, 7, 344, 2, 2, 2150, 2154, 5, 1328, 665, 2, 2151, 2152, 7, 274, 2, 2, 2152, 2153, 7, 149, 2, 2, 2153, 2155, 5, 1358, 680, 2, 2154, 2151, 3, 2, 2, 2, 2154, 2155, 3, 2, 2, 2, 2155, 2156, 3, 2, 2, 2, 2156, 2157, 7, 326, 2, 2, 2157, 2158, 7, 344, 2, 2, 2158, 2160, 5, 1328, 665, 2, 2159, 2161, 5, 930, 466, 2, 2160, 2159, 3, 2, 2, 2, 2160, 2161, 3, 2, 2, 2, 2161, 2173, 3, 2, 2, 2, 2162, 2163, 7, 140, 2, 2, 2163, 2164, 7, 65, 2, 2, 2164, 2167, 7, 94, 2, 2, 2165, 2166, 7, 222, 2, 2, 2166, 2168, 7, 389, 2, 2, 2167, 2165, 3, 2, 2, 2, 2167, 2168, 3, 2, 2, 2, 2168, 2169, 3, 2, 2, 2, 2169, 2170, 5, 1064, 533, 2, 2170, 2171, 5, 98, 50, 2, 2171, 2173, 3, 2, 2, 2, 2172, 2060, 3, 2, 2, 2, 2172, 2071, 3, 2, 2, 2, 2172, 2088, 3, 2, 2, 2, 2172, 2099, 3, 2, 2, 2, 2172, 2116, 3, 2, 2, 2, 2172, 2125, 3, 2, 2, 2, 2172, 2134, 3, 2, 2, 2, 2172, 2144, 3, 2, 2, 2, 2172, 2162, 3, 2, 2, 2, 2173, 97, 3, 2, 2, 2, 2174, 2179, 5, 104, 53, 2, 2175, 2176, 7, 8, 2, 2, 2176, 2178, 5, 104, 53, 2, 2177, 2175, 3, 2, 2, 2, 2178, 2181, 3, 2, 2, 2, 2179, 2177, 3, 2, 2, 2, 2179, 2180, 3, 2, 2, 2, 2180, 99, 3, 2, 2, 2, 2181, 2179, 3, 2, 2, 2, 2182, 2183, 7, 428, 2, 2, 2183, 2184, 7, 278, 2, 2, 2184, 2185, 5, 1324, 663, 2, 2185, 2186, 5, 128, 65, 2, 2186, 2191, 3, 2, 2, 2, 2187, 2188, 7, 429, 2, 2, 2188, 2189, 7, 278, 2, 2, 2189, 2191, 5, 1324, 663, 2, 2190, 2182, 3, 2, 2, 2, 2190, 2187, 3, 2, 2, 2, 2191, 101, 3, 2, 2, 2, 2192, 2193, 7, 428, 2, 2, 2193, 2194, 7, 278, 2, 2, 2194, 2195, 5, 1324, 663, 2, 2195, 103, 3, 2, 2, 2, 2196, 2197, 7, 135, 2, 2, 2197, 2495, 5, 188, 95, 2, 2198, 2199, 7, 135, 2, 2, 2199, 2200, 7, 222, 2, 2, 2200, 2201, 7, 79, 2, 2, 2201, 2202, 7, 389, 2, 2, 2202, 2495, 5, 188, 95, 2, 2203, 2204, 7, 135, 2, 2, 2204, 2205, 7, 46, 2, 2, 2205, 2495, 5, 188, 95, 2, 2206, 2207, 7, 135, 2, 2, 2207, 2208, 7, 46, 2, 2, 2208, 2209, 7, 222, 2, 2, 2209, 2210, 7, 79, 2, 2, 2210, 2211, 7, 389, 2, 2, 2211, 2495, 5, 188, 95, 2, 2212, 2214, 7, 140, 2, 2, 2213, 2215, 5, 724, 363, 2, 2214, 2213, 3, 2, 2, 2, 2214, 2215, 3, 2, 2, 2, 2215, 2216, 3, 2, 2, 2, 2216, 2217, 5, 1360, 681, 2, 2217, 2218, 5, 106, 54, 2, 2218, 2495, 3, 2, 2, 2, 2219, 2221, 7, 140, 2, 2, 2220, 2222, 5, 724, 363, 2, 2221, 2220, 3, 2, 2, 2, 2221, 2222, 3, 2, 2, 2, 2222, 2223, 3, 2, 2, 2, 2223, 2224, 5, 1360, 681, 2, 2224, 2225, 7, 193, 2, 2, 2225, 2226, 7, 79, 2, 2, 2226, 2227, 7, 80, 2, 2, 2227, 2495, 3, 2, 2, 2, 2228, 2230, 7, 140, 2, 2, 2229, 2231, 5, 724, 363, 2, 2230, 2229, 3, 2, 2, 2, 2230, 2231, 3, 2, 2, 2, 2231, 2232, 3, 2, 2, 2, 2232, 2233, 5, 1360, 681, 2, 2233, 2234, 7, 326, 2, 2, 2234, 2235, 7, 79, 2, 2, 2235, 2236, 7, 80, 2, 2, 2236, 2495, 3, 2, 2, 2, 2237, 2239, 7, 140, 2, 2, 2238, 2240, 5, 724, 363, 2, 2239, 2238, 3, 2, 2, 2, 2239, 2240, 3, 2, 2, 2, 2240, 2241, 3, 2, 2, 2, 2241, 2242, 5, 1360, 681, 2, 2242, 2243, 7, 193, 2, 2, 2243, 2244, 7, 430, 2, 2, 2244, 2495, 3, 2, 2, 2, 2245, 2247, 7, 140, 2, 2, 2246, 2248, 5, 724, 363, 2, 2247, 2246, 3, 2, 2, 2, 2247, 2248, 3, 2, 2, 2, 2248, 2249, 3, 2, 2, 2, 2249, 2250, 5, 1360, 681, 2, 2250, 2251, 7, 193, 2, 2, 2251, 2252, 7, 430, 2, 2, 2252, 2253, 7, 222, 2, 2, 2253, 2254, 7, 389, 2, 2, 2254, 2495, 3, 2, 2, 2, 2255, 2257, 7, 140, 2, 2, 2256, 2258, 5, 724, 363, 2, 2257, 2256, 3, 2, 2, 2, 2257, 2258, 3, 2, 2, 2, 2258, 2259, 3, 2, 2, 2, 2259, 2260, 5, 1360, 681, 2, 2260, 2261, 7, 326, 2, 2, 2261, 2262, 7, 335, 2, 2, 2262, 2263, 5, 1352, 677, 2, 2263, 2495, 3, 2, 2, 2, 2264, 2266, 7, 140, 2, 2, 2265, 2267, 5, 724, 363, 2, 2266, 2265, 3, 2, 2, 2, 2266, 2267, 3, 2, 2, 2, 2267, 2268, 3, 2, 2, 2, 2268, 2269, 5, 1344, 673, 2, 2269, 2270, 7, 326, 2, 2, 2270, 2271, 7, 335, 2, 2, 2271, 2272, 5, 1352, 677, 2, 2272, 2495, 3, 2, 2, 2, 2273, 2275, 7, 140, 2, 2, 2274, 2276, 5, 724, 363, 2, 2275, 2274, 3, 2, 2, 2, 2275, 2276, 3, 2, 2, 2, 2276, 2277, 3, 2, 2, 2, 2277, 2278, 5, 1360, 681, 2, 2278, 2279, 7, 326, 2, 2, 2279, 2280, 5, 116, 59, 2, 2280, 2495, 3, 2, 2, 2, 2281, 2283, 7, 140, 2, 2, 2282, 2284, 5, 724, 363, 2, 2283, 2282, 3, 2, 2, 2, 2283, 2284, 3, 2, 2, 2, 2284, 2285, 3, 2, 2, 2, 2285, 2286, 5, 1360, 681, 2, 2286, 2287, 7, 306, 2, 2, 2287, 2288, 5, 116, 59, 2, 2288, 2495, 3, 2, 2, 2, 2289, 2291, 7, 140, 2, 2, 2290, 2292, 5, 724, 363, 2, 2291, 2290, 3, 2, 2, 2, 2291, 2292, 3, 2, 2, 2, 2292, 2293, 3, 2, 2, 2, 2293, 2294, 5, 1360, 681, 2, 2294, 2295, 7, 326, 2, 2, 2295, 2296, 7, 338, 2, 2, 2296, 2297, 5, 1360, 681, 2, 2297, 2495, 3, 2, 2, 2, 2298, 2300, 7, 140, 2, 2, 2299, 2301, 5, 724, 363, 2, 2300, 2299, 3, 2, 2, 2, 2300, 2301, 3, 2, 2, 2, 2301, 2302, 3, 2, 2, 2, 2302, 2303, 5, 1360, 681, 2, 2303, 2304, 7, 135, 2, 2, 2304, 2305, 7, 431, 2, 2, 2305, 2306, 5, 198, 100, 2, 2306, 2307, 7, 38, 2, 2, 2307, 2309, 7, 221, 2, 2, 2308, 2310, 5, 284, 143, 2, 2309, 2308, 3, 2, 2, 2, 2309, 2310, 3, 2, 2, 2, 2310, 2495, 3, 2, 2, 2, 2311, 2313, 7, 140, 2, 2, 2312, 2314, 5, 724, 363, 2, 2313, 2312, 3, 2, 2, 2, 2313, 2314, 3, 2, 2, 2, 2314, 2315, 3, 2, 2, 2, 2315, 2316, 5, 1360, 681, 2, 2316, 2317, 5, 124, 63, 2, 2317, 2495, 3, 2, 2, 2, 2318, 2320, 7, 140, 2, 2, 2319, 2321, 5, 724, 363, 2, 2320, 2319, 3, 2, 2, 2, 2320, 2321, 3, 2, 2, 2, 2321, 2322, 3, 2, 2, 2, 2322, 2323, 5, 1360, 681, 2, 2323, 2324, 7, 193, 2, 2, 2324, 2325, 7, 221, 2, 2, 2325, 2495, 3, 2, 2, 2, 2326, 2328, 7, 140, 2, 2, 2327, 2329, 5, 724, 363, 2, 2328, 2327, 3, 2, 2, 2, 2328, 2329, 3, 2, 2, 2, 2329, 2330, 3, 2, 2, 2, 2330, 2331, 5, 1360, 681, 2, 2331, 2332, 7, 193, 2, 2, 2332, 2333, 7, 221, 2, 2, 2333, 2334, 7, 222, 2, 2, 2334, 2335, 7, 389, 2, 2, 2335, 2495, 3, 2, 2, 2, 2336, 2338, 7, 193, 2, 2, 2337, 2339, 5, 724, 363, 2, 2338, 2337, 3, 2, 2, 2, 2338, 2339, 3, 2, 2, 2, 2339, 2340, 3, 2, 2, 2, 2340, 2341, 7, 222, 2, 2, 2341, 2342, 7, 389, 2, 2, 2342, 2344, 5, 1360, 681, 2, 2343, 2345, 5, 108, 55, 2, 2344, 2343, 3, 2, 2, 2, 2344, 2345, 3, 2, 2, 2, 2345, 2495, 3, 2, 2, 2, 2346, 2348, 7, 193, 2, 2, 2347, 2349, 5, 724, 363, 2, 2348, 2347, 3, 2, 2, 2, 2348, 2349, 3, 2, 2, 2, 2349, 2350, 3, 2, 2, 2, 2350, 2352, 5, 1360, 681, 2, 2351, 2353, 5, 108, 55, 2, 2352, 2351, 3, 2, 2, 2, 2352, 2353, 3, 2, 2, 2, 2353, 2495, 3, 2, 2, 2, 2354, 2356, 7, 140, 2, 2, 2355, 2357, 5, 724, 363, 2, 2356, 2355, 3, 2, 2, 2, 2356, 2357, 3, 2, 2, 2, 2357, 2358, 3, 2, 2, 2, 2358, 2360, 5, 1360, 681, 2, 2359, 2361, 5, 726, 364, 2, 2360, 2359, 3, 2, 2, 2, 2360, 2361, 3, 2, 2, 2, 2361, 2362, 3, 2, 2, 2, 2362, 2363, 7, 353, 2, 2, 2363, 2365, 5, 1108, 555, 2, 2364, 2366, 5, 110, 56, 2, 2365, 2364, 3, 2, 2, 2, 2365, 2366, 3, 2, 2, 2, 2366, 2368, 3, 2, 2, 2, 2367, 2369, 5, 112, 57, 2, 2368, 2367, 3, 2, 2, 2, 2368, 2369, 3, 2, 2, 2, 2369, 2495, 3, 2, 2, 2, 2370, 2372, 7, 140, 2, 2, 2371, 2373, 5, 724, 363, 2, 2372, 2371, 3, 2, 2, 2, 2372, 2373, 3, 2, 2, 2, 2373, 2374, 3, 2, 2, 2, 2374, 2375, 5, 1360, 681, 2, 2375, 2376, 5, 344, 173, 2, 2376, 2495, 3, 2, 2, 2, 2377, 2378, 7, 135, 2, 2, 2378, 2495, 5, 208, 105, 2, 2379, 2380, 7, 140, 2, 2, 2380, 2381, 7, 47, 2, 2, 2381, 2382, 5, 1328, 665, 2, 2382, 2383, 5, 440, 221, 2, 2383, 2495, 3, 2, 2, 2, 2384, 2385, 7, 365, 2, 2, 2385, 2386, 7, 47, 2, 2, 2386, 2495, 5, 1328, 665, 2, 2387, 2388, 7, 193, 2, 2, 2388, 2389, 7, 47, 2, 2, 2389, 2390, 7, 222, 2, 2, 2390, 2391, 7, 389, 2, 2, 2391, 2393, 5, 1328, 665, 2, 2392, 2394, 5, 108, 55, 2, 2393, 2392, 3, 2, 2, 2, 2393, 2394, 3, 2, 2, 2, 2394, 2495, 3, 2, 2, 2, 2395, 2396, 7, 193, 2, 2, 2396, 2397, 7, 47, 2, 2, 2397, 2399, 5, 1328, 665, 2, 2398, 2400, 5, 108, 55, 2, 2399, 2398, 3, 2, 2, 2, 2399, 2400, 3, 2, 2, 2, 2400, 2495, 3, 2, 2, 2, 2401, 2402, 7, 326, 2, 2, 2402, 2403, 7, 372, 2, 2, 2403, 2495, 7, 270, 2, 2, 2404, 2405, 7, 160, 2, 2, 2405, 2406, 7, 82, 2, 2, 2406, 2495, 5, 1328, 665, 2, 2407, 2408, 7, 326, 2, 2, 2408, 2409, 7, 372, 2, 2, 2409, 2495, 7, 160, 2, 2, 2410, 2411, 7, 326, 2, 2, 2411, 2495, 7, 432, 2, 2, 2412, 2413, 7, 326, 2, 2, 2413, 2495, 7, 360, 2, 2, 2414, 2415, 7, 195, 2, 2, 2415, 2416, 7, 350, 2, 2, 2416, 2495, 5, 1328, 665, 2, 2417, 2418, 7, 195, 2, 2, 2418, 2419, 7, 141, 2, 2, 2419, 2420, 7, 350, 2, 2, 2420, 2495, 5, 1328, 665, 2, 2421, 2422, 7, 195, 2, 2, 2422, 2423, 7, 305, 2, 2, 2423, 2424, 7, 350, 2, 2, 2424, 2495, 5, 1328, 665, 2, 2425, 2426, 7, 195, 2, 2, 2426, 2427, 7, 350, 2, 2, 2427, 2495, 7, 32, 2, 2, 2428, 2429, 7, 195, 2, 2, 2429, 2430, 7, 350, 2, 2, 2430, 2495, 7, 101, 2, 2, 2431, 2432, 7, 188, 2, 2, 2432, 2433, 7, 350, 2, 2, 2433, 2495, 5, 1328, 665, 2, 2434, 2435, 7, 188, 2, 2, 2435, 2436, 7, 350, 2, 2, 2436, 2495, 7, 32, 2, 2, 2437, 2438, 7, 188, 2, 2, 2438, 2439, 7, 350, 2, 2, 2439, 2495, 7, 101, 2, 2, 2440, 2441, 7, 195, 2, 2, 2441, 2442, 7, 314, 2, 2, 2442, 2495, 5, 1328, 665, 2, 2443, 2444, 7, 195, 2, 2, 2444, 2445, 7, 141, 2, 2, 2445, 2446, 7, 314, 2, 2, 2446, 2495, 5, 1328, 665, 2, 2447, 2448, 7, 195, 2, 2, 2448, 2449, 7, 305, 2, 2, 2449, 2450, 7, 314, 2, 2, 2450, 2495, 5, 1328, 665, 2, 2451, 2452, 7, 188, 2, 2, 2452, 2453, 7, 314, 2, 2, 2453, 2495, 5, 1328, 665, 2, 2454, 2455, 7, 230, 2, 2, 2455, 2495, 5, 1324, 663, 2, 2456, 2457, 7, 262, 2, 2, 2457, 2458, 7, 230, 2, 2, 2458, 2495, 5, 1324, 663, 2, 2459, 2460, 7, 268, 2, 2, 2460, 2495, 5, 524, 263, 2, 2461, 2462, 7, 79, 2, 2, 2462, 2495, 7, 268, 2, 2, 2463, 2464, 7, 275, 2, 2, 2464, 2465, 7, 96, 2, 2, 2465, 2495, 5, 1356, 679, 2, 2466, 2467, 7, 326, 2, 2, 2467, 2468, 7, 344, 2, 2, 2468, 2495, 5, 1328, 665, 2, 2469, 2470, 7, 326, 2, 2, 2470, 2495, 5, 116, 59, 2, 2471, 2472, 7, 306, 2, 2, 2472, 2495, 5, 116, 59, 2, 2473, 2474, 7, 305, 2, 2, 2474, 2475, 7, 221, 2, 2, 2475, 2495, 5, 114, 58, 2, 2476, 2477, 7, 195, 2, 2, 2477, 2478, 7, 407, 2, 2, 2478, 2479, 7, 244, 2, 2, 2479, 2495, 7, 320, 2, 2, 2480, 2481, 7, 188, 2, 2, 2481, 2482, 7, 407, 2, 2, 2482, 2483, 7, 244, 2, 2, 2483, 2495, 7, 320, 2, 2, 2484, 2485, 7, 211, 2, 2, 2485, 2486, 7, 407, 2, 2, 2486, 2487, 7, 244, 2, 2, 2487, 2495, 7, 320, 2, 2, 2488, 2489, 7, 262, 2, 2, 2489, 2490, 7, 211, 2, 2, 2490, 2491, 7, 407, 2, 2, 2491, 2492, 7, 244, 2, 2, 2492, 2495, 7, 320, 2, 2, 2493, 2495, 5, 344, 173, 2, 2494, 2196, 3, 2, 2, 2, 2494, 2198, 3, 2, 2, 2, 2494, 2203, 3, 2, 2, 2, 2494, 2206, 3, 2, 2, 2, 2494, 2212, 3, 2, 2, 2, 2494, 2219, 3, 2, 2, 2, 2494, 2228, 3, 2, 2, 2, 2494, 2237, 3, 2, 2, 2, 2494, 2245, 3, 2, 2, 2, 2494, 2255, 3, 2, 2, 2, 2494, 2264, 3, 2, 2, 2, 2494, 2273, 3, 2, 2, 2, 2494, 2281, 3, 2, 2, 2, 2494, 2289, 3, 2, 2, 2, 2494, 2298, 3, 2, 2, 2, 2494, 2311, 3, 2, 2, 2, 2494, 2318, 3, 2, 2, 2, 2494, 2326, 3, 2, 2, 2, 2494, 2336, 3, 2, 2, 2, 2494, 2346, 3, 2, 2, 2, 2494, 2354, 3, 2, 2, 2, 2494, 2370, 3, 2, 2, 2, 2494, 2377, 3, 2, 2, 2, 2494, 2379, 3, 2, 2, 2, 2494, 2384, 3, 2, 2, 2, 2494, 2387, 3, 2, 2, 2, 2494, 2395, 3, 2, 2, 2, 2494, 2401, 3, 2, 2, 2, 2494, 2404, 3, 2, 2, 2, 2494, 2407, 3, 2, 2, 2, 2494, 2410, 3, 2, 2, 2, 2494, 2412, 3, 2, 2, 2, 2494, 2414, 3, 2, 2, 2, 2494, 2417, 3, 2, 2, 2, 2494, 2421, 3, 2, 2, 2, 2494, 2425, 3, 2, 2, 2, 2494, 2428, 3, 2, 2, 2, 2494, 2431, 3, 2, 2, 2, 2494, 2434, 3, 2, 2, 2, 2494, 2437, 3, 2, 2, 2, 2494, 2440, 3, 2, 2, 2, 2494, 2443, 3, 2, 2, 2, 2494, 2447, 3, 2, 2, 2, 2494, 2451, 3, 2, 2, 2, 2494, 2454, 3, 2, 2, 2, 2494, 2456, 3, 2, 2, 2, 2494, 2459, 3, 2, 2, 2, 2494, 2461, 3, 2, 2, 2, 2494, 2463, 3, 2, 2, 2, 2494, 2466, 3, 2, 2, 2, 2494, 2469, 3, 2, 2, 2, 2494, 2471, 3, 2, 2, 2, 2494, 2473, 3, 2, 2, 2, 2494, 2476, 3, 2, 2, 2, 2494, 2480, 3, 2, 2, 2, 2494, 2484, 3, 2, 2, 2, 2494, 2488, 3, 2, 2, 2, 2494, 2493, 3, 2, 2, 2, 2495, 105, 3, 2, 2, 2, 2496, 2497, 7, 326, 2, 2, 2497, 2498, 7, 55, 2, 2, 2498, 2502, 5, 1152, 577, 2, 2499, 2500, 7, 193, 2, 2, 2500, 2502, 7, 55, 2, 2, 2501, 2496, 3, 2, 2, 2, 2501, 2499, 3, 2, 2, 2, 2502, 107, 3, 2, 2, 2, 2503, 2504, 9, 12, 2, 2, 2504, 109, 3, 2, 2, 2, 2505, 2506, 7, 45, 2, 2, 2506, 2507, 5, 524, 263, 2, 2507, 111, 3, 2, 2, 2, 2508, 2509, 7, 102, 2, 2, 2509, 2510, 5, 1152, 577, 2, 2510, 113, 3, 2, 2, 2, 2511, 2518, 7, 263, 2, 2, 2512, 2518, 7, 115, 2, 2, 2513, 2518, 7, 55, 2, 2, 2514, 2515, 7, 102, 2, 2, 2515, 2516, 7, 228, 2, 2, 2516, 2518, 5, 1328, 665, 2, 2517, 2511, 3, 2, 2, 2, 2517, 2512, 3, 2, 2, 2, 2517, 2513, 3, 2, 2, 2, 2517, 2514, 3, 2, 2, 2, 2518, 115, 3, 2, 2, 2, 2519, 2520, 7, 4, 2, 2, 2520, 2521, 5, 120, 61, 2, 2521, 2522, 7, 5, 2, 2, 2522, 117, 3, 2, 2, 2, 2523, 2524, 7, 107, 2, 2, 2524, 2525, 5, 116, 59, 2, 2525, 119, 3, 2, 2, 2, 2526, 2531, 5, 122, 62, 2, 2527, 2528, 7, 8, 2, 2, 2528, 2530, 5, 122, 62, 2, 2529, 2527, 3, 2, 2, 2, 2530, 2533, 3, 2, 2, 2, 2531, 2529, 3, 2, 2, 2, 2531, 2532, 3, 2, 2, 2, 2532, 121, 3, 2, 2, 2, 2533, 2531, 3, 2, 2, 2, 2534, 2543, 5, 1366, 684, 2, 2535, 2536, 7, 12, 2, 2, 2536, 2544, 5, 466, 234, 2, 2537, 2538, 7, 13, 2, 2, 2538, 2541, 5, 1366, 684, 2, 2539, 2540, 7, 12, 2, 2, 2540, 2542, 5, 466, 234, 2, 2541, 2539, 3, 2, 2, 2, 2541, 2542, 3, 2, 2, 2, 2542, 2544, 3, 2, 2, 2, 2543, 2535, 3, 2, 2, 2, 2543, 2537, 3, 2, 2, 2, 2543, 2544, 3, 2, 2, 2, 2544, 123, 3, 2, 2, 2, 2545, 2547, 5, 126, 64, 2, 2546, 2545, 3, 2, 2, 2, 2547, 2548, 3, 2, 2, 2, 2548, 2546, 3, 2, 2, 2, 2548, 2549, 3, 2, 2, 2, 2549, 125, 3, 2, 2, 2, 2550, 2555, 7, 307, 2, 2, 2551, 2553, 5, 16, 9, 2, 2552, 2551, 3, 2, 2, 2, 2552, 2553, 3, 2, 2, 2, 2553, 2554, 3, 2, 2, 2, 2554, 2556, 5, 292, 147, 2, 2555, 2552, 3, 2, 2, 2, 2555, 2556, 3, 2, 2, 2, 2556, 2564, 3, 2, 2, 2, 2557, 2561, 7, 326, 2, 2, 2558, 2562, 5, 288, 145, 2, 2559, 2560, 7, 431, 2, 2, 2560, 2562, 5, 198, 100, 2, 2561, 2558, 3, 2, 2, 2, 2561, 2559, 3, 2, 2, 2, 2562, 2564, 3, 2, 2, 2, 2563, 2550, 3, 2, 2, 2, 2563, 2557, 3, 2, 2, 2, 2564, 127, 3, 2, 2, 2, 2565, 2566, 7, 64, 2, 2, 2566, 2567, 7, 415, 2, 2, 2567, 2568, 7, 107, 2, 2, 2568, 2569, 7, 4, 2, 2, 2569, 2570, 5, 132, 67, 2, 2570, 2571, 7, 5, 2, 2, 2571, 2592, 3, 2, 2, 2, 2572, 2573, 7, 64, 2, 2, 2573, 2574, 7, 415, 2, 2, 2574, 2575, 7, 70, 2, 2, 2575, 2576, 7, 4, 2, 2, 2576, 2577, 5, 1268, 635, 2, 2577, 2578, 7, 5, 2, 2, 2578, 2592, 3, 2, 2, 2, 2579, 2580, 7, 64, 2, 2, 2580, 2581, 7, 415, 2, 2, 2581, 2582, 7, 66, 2, 2, 2582, 2583, 7, 4, 2, 2, 2583, 2584, 5, 1268, 635, 2, 2584, 2585, 7, 5, 2, 2, 2585, 2586, 7, 96, 2, 2, 2586, 2587, 7, 4, 2, 2, 2587, 2588, 5, 1268, 635, 2, 2588, 2589, 7, 5, 2, 2, 2589, 2592, 3, 2, 2, 2, 2590, 2592, 7, 55, 2, 2, 2591, 2565, 3, 2, 2, 2, 2591, 2572, 3, 2, 2, 2, 2591, 2579, 3, 2, 2, 2, 2591, 2590, 3, 2, 2, 2, 2592, 129, 3, 2, 2, 2, 2593, 2594, 5, 1364, 683, 2, 2594, 2595, 5, 1344, 673, 2, 2595, 131, 3, 2, 2, 2, 2596, 2601, 5, 130, 66, 2, 2597, 2598, 7, 8, 2, 2, 2598, 2600, 5, 130, 66, 2, 2599, 2597, 3, 2, 2, 2, 2600, 2603, 3, 2, 2, 2, 2601, 2599, 3, 2, 2, 2, 2601, 2602, 3, 2, 2, 2, 2602, 133, 3, 2, 2, 2, 2603, 2601, 3, 2, 2, 2, 2604, 2605, 7, 140, 2, 2, 2605, 2606, 7, 353, 2, 2, 2606, 2607, 5, 524, 263, 2, 2607, 2608, 5, 136, 69, 2, 2608, 135, 3, 2, 2, 2, 2609, 2614, 5, 138, 70, 2, 2610, 2611, 7, 8, 2, 2, 2611, 2613, 5, 138, 70, 2, 2612, 2610, 3, 2, 2, 2, 2613, 2616, 3, 2, 2, 2, 2614, 2612, 3, 2, 2, 2, 2614, 2615, 3, 2, 2, 2, 2615, 137, 3, 2, 2, 2, 2616, 2614, 3, 2, 2, 2, 2617, 2618, 7, 135, 2, 2, 2618, 2619, 7, 145, 2, 2, 2619, 2621, 5, 1092, 547, 2, 2620, 2622, 5, 108, 55, 2, 2621, 2620, 3, 2, 2, 2, 2621, 2622, 3, 2, 2, 2, 2622, 2648, 3, 2, 2, 2, 2623, 2624, 7, 193, 2, 2, 2624, 2627, 7, 145, 2, 2, 2625, 2626, 7, 222, 2, 2, 2626, 2628, 7, 389, 2, 2, 2627, 2625, 3, 2, 2, 2, 2627, 2628, 3, 2, 2, 2, 2628, 2629, 3, 2, 2, 2, 2629, 2631, 5, 1360, 681, 2, 2630, 2632, 5, 108, 55, 2, 2631, 2630, 3, 2, 2, 2, 2631, 2632, 3, 2, 2, 2, 2632, 2648, 3, 2, 2, 2, 2633, 2634, 7, 140, 2, 2, 2634, 2635, 7, 145, 2, 2, 2635, 2637, 5, 1360, 681, 2, 2636, 2638, 5, 726, 364, 2, 2637, 2636, 3, 2, 2, 2, 2637, 2638, 3, 2, 2, 2, 2638, 2639, 3, 2, 2, 2, 2639, 2640, 7, 353, 2, 2, 2640, 2642, 5, 1108, 555, 2, 2641, 2643, 5, 110, 56, 2, 2642, 2641, 3, 2, 2, 2, 2642, 2643, 3, 2, 2, 2, 2643, 2645, 3, 2, 2, 2, 2644, 2646, 5, 108, 55, 2, 2645, 2644, 3, 2, 2, 2, 2645, 2646, 3, 2, 2, 2, 2646, 2648, 3, 2, 2, 2, 2647, 2617, 3, 2, 2, 2, 2647, 2623, 3, 2, 2, 2, 2647, 2633, 3, 2, 2, 2, 2648, 139, 3, 2, 2, 2, 2649, 2652, 7, 159, 2, 2, 2650, 2653, 5, 946, 474, 2, 2651, 2653, 7, 32, 2, 2, 2652, 2650, 3, 2, 2, 2, 2652, 2651, 3, 2, 2, 2, 2653, 141, 3, 2, 2, 2, 2654, 2656, 7, 171, 2, 2, 2655, 2657, 5, 156, 79, 2, 2656, 2655, 3, 2, 2, 2, 2656, 2657, 3, 2, 2, 2, 2657, 2658, 3, 2, 2, 2, 2658, 2660, 5, 1324, 663, 2, 2659, 2661, 5, 214, 108, 2, 2660, 2659, 3, 2, 2, 2, 2660, 2661, 3, 2, 2, 2, 2661, 2662, 3, 2, 2, 2, 2662, 2664, 5, 144, 73, 2, 2663, 2665, 5, 146, 74, 2, 2664, 2663, 3, 2, 2, 2, 2664, 2665, 3, 2, 2, 2, 2665, 2666, 3, 2, 2, 2, 2666, 2668, 5, 148, 75, 2, 2667, 2669, 5, 158, 80, 2, 2668, 2667, 3, 2, 2, 2, 2668, 2669, 3, 2, 2, 2, 2669, 2671, 3, 2, 2, 2, 2670, 2672, 5, 16, 9, 2, 2671, 2670, 3, 2, 2, 2, 2671, 2672, 3, 2, 2, 2, 2672, 2673, 3, 2, 2, 2, 2673, 2675, 5, 150, 76, 2, 2674, 2676, 5, 1084, 543, 2, 2675, 2674, 3, 2, 2, 2, 2675, 2676, 3, 2, 2, 2, 2676, 2692, 3, 2, 2, 2, 2677, 2678, 7, 171, 2, 2, 2678, 2679, 7, 4, 2, 2, 2679, 2680, 5, 894, 448, 2, 2680, 2681, 7, 5, 2, 2, 2681, 2683, 7, 96, 2, 2, 2682, 2684, 5, 146, 74, 2, 2683, 2682, 3, 2, 2, 2, 2683, 2684, 3, 2, 2, 2, 2684, 2685, 3, 2, 2, 2, 2685, 2687, 5, 148, 75, 2, 2686, 2688, 5, 16, 9, 2, 2687, 2686, 3, 2, 2, 2, 2687, 2688, 3, 2, 2, 2, 2688, 2689, 3, 2, 2, 2, 2689, 2690, 5, 150, 76, 2, 2690, 2692, 3, 2, 2, 2, 2691, 2654, 3, 2, 2, 2, 2691, 2677, 3, 2, 2, 2, 2692, 143, 3, 2, 2, 2, 2693, 2694, 9, 13, 2, 2, 2694, 145, 3, 2, 2, 2, 2695, 2696, 7, 290, 2, 2, 2696, 147, 3, 2, 2, 2, 2697, 2701, 5, 1346, 674, 2, 2698, 2701, 7, 336, 2, 2, 2699, 2701, 7, 337, 2, 2, 2700, 2697, 3, 2, 2, 2, 2700, 2698, 3, 2, 2, 2, 2700, 2699, 3, 2, 2, 2, 2701, 149, 3, 2, 2, 2, 2702, 2708, 5, 152, 77, 2, 2703, 2704, 7, 4, 2, 2, 2704, 2705, 5, 162, 82, 2, 2705, 2706, 7, 5, 2, 2, 2706, 2708, 3, 2, 2, 2, 2707, 2702, 3, 2, 2, 2, 2707, 2703, 3, 2, 2, 2, 2708, 151, 3, 2, 2, 2, 2709, 2711, 5, 154, 78, 2, 2710, 2709, 3, 2, 2, 2, 2711, 2714, 3, 2, 2, 2, 2712, 2710, 3, 2, 2, 2, 2712, 2713, 3, 2, 2, 2, 2713, 153, 3, 2, 2, 2, 2714, 2712, 3, 2, 2, 2, 2715, 2755, 7, 109, 2, 2, 2716, 2755, 7, 114, 2, 2, 2717, 2719, 7, 185, 2, 2, 2718, 2720, 5, 834, 418, 2, 2719, 2718, 3, 2, 2, 2, 2719, 2720, 3, 2, 2, 2, 2720, 2721, 3, 2, 2, 2, 2721, 2755, 5, 1346, 674, 2, 2722, 2724, 7, 80, 2, 2, 2723, 2725, 5, 834, 418, 2, 2724, 2723, 3, 2, 2, 2, 2724, 2725, 3, 2, 2, 2, 2725, 2726, 3, 2, 2, 2, 2726, 2755, 5, 1346, 674, 2, 2727, 2755, 7, 173, 2, 2, 2728, 2755, 7, 218, 2, 2, 2729, 2731, 7, 291, 2, 2, 2730, 2732, 5, 834, 418, 2, 2731, 2730, 3, 2, 2, 2, 2731, 2732, 3, 2, 2, 2, 2732, 2733, 3, 2, 2, 2, 2733, 2755, 5, 1346, 674, 2, 2734, 2736, 7, 199, 2, 2, 2735, 2737, 5, 834, 418, 2, 2736, 2735, 3, 2, 2, 2, 2736, 2737, 3, 2, 2, 2, 2737, 2738, 3, 2, 2, 2, 2738, 2755, 5, 1346, 674, 2, 2739, 2740, 7, 211, 2, 2, 2740, 2741, 7, 291, 2, 2, 2741, 2755, 5, 216, 109, 2, 2742, 2743, 7, 211, 2, 2, 2743, 2744, 7, 291, 2, 2, 2744, 2755, 7, 11, 2, 2, 2745, 2746, 7, 211, 2, 2, 2746, 2747, 7, 79, 2, 2, 2747, 2748, 7, 80, 2, 2, 2748, 2755, 5, 216, 109, 2, 2749, 2750, 7, 211, 2, 2, 2750, 2751, 7, 80, 2, 2, 2751, 2755, 5, 216, 109, 2, 2752, 2753, 7, 196, 2, 2, 2753, 2755, 5, 1346, 674, 2, 2754, 2715, 3, 2, 2, 2, 2754, 2716, 3, 2, 2, 2, 2754, 2717, 3, 2, 2, 2, 2754, 2722, 3, 2, 2, 2, 2754, 2727, 3, 2, 2, 2, 2754, 2728, 3, 2, 2, 2, 2754, 2729, 3, 2, 2, 2, 2754, 2734, 3, 2, 2, 2, 2754, 2739, 3, 2, 2, 2, 2754, 2742, 3, 2, 2, 2, 2754, 2745, 3, 2, 2, 2, 2754, 2749, 3, 2, 2, 2, 2754, 2752, 3, 2, 2, 2, 2755, 155, 3, 2, 2, 2, 2756, 2757, 7, 109, 2, 2, 2757, 157, 3, 2, 2, 2, 2758, 2760, 5, 160, 81, 2, 2759, 2758, 3, 2, 2, 2, 2759, 2760, 3, 2, 2, 2, 2760, 2761, 3, 2, 2, 2, 2761, 2762, 7, 186, 2, 2, 2762, 2763, 5, 1346, 674, 2, 2763, 159, 3, 2, 2, 2, 2764, 2765, 7, 102, 2, 2, 2765, 161, 3, 2, 2, 2, 2766, 2771, 5, 164, 83, 2, 2767, 2768, 7, 8, 2, 2, 2768, 2770, 5, 164, 83, 2, 2769, 2767, 3, 2, 2, 2, 2770, 2773, 3, 2, 2, 2, 2771, 2769, 3, 2, 2, 2, 2771, 2772, 3, 2, 2, 2, 2772, 163, 3, 2, 2, 2, 2773, 2771, 3, 2, 2, 2, 2774, 2776, 5, 1366, 684, 2, 2775, 2777, 5, 166, 84, 2, 2776, 2775, 3, 2, 2, 2, 2776, 2777, 3, 2, 2, 2, 2777, 165, 3, 2, 2, 2, 2778, 2786, 5, 66, 34, 2, 2779, 2786, 5, 292, 147, 2, 2780, 2786, 7, 11, 2, 2, 2781, 2782, 7, 4, 2, 2, 2782, 2783, 5, 168, 85, 2, 2783, 2784, 7, 5, 2, 2, 2784, 2786, 3, 2, 2, 2, 2785, 2778, 3, 2, 2, 2, 2785, 2779, 3, 2, 2, 2, 2785, 2780, 3, 2, 2, 2, 2785, 2781, 3, 2, 2, 2, 2786, 167, 3, 2, 2, 2, 2787, 2792, 5, 170, 86, 2, 2788, 2789, 7, 8, 2, 2, 2789, 2791, 5, 170, 86, 2, 2790, 2788, 3, 2, 2, 2, 2791, 2794, 3, 2, 2, 2, 2792, 2790, 3, 2, 2, 2, 2792, 2793, 3, 2, 2, 2, 2793, 169, 3, 2, 2, 2, 2794, 2792, 3, 2, 2, 2, 2795, 2796, 5, 66, 34, 2, 2796, 171, 3, 2, 2, 2, 2797, 2799, 7, 48, 2, 2, 2798, 2800, 5, 174, 88, 2, 2799, 2798, 3, 2, 2, 2, 2799, 2800, 3, 2, 2, 2, 2800, 2801, 3, 2, 2, 2, 2801, 2805, 7, 94, 2, 2, 2802, 2803, 7, 222, 2, 2, 2803, 2804, 7, 79, 2, 2, 2804, 2806, 7, 389, 2, 2, 2805, 2802, 3, 2, 2, 2, 2805, 2806, 3, 2, 2, 2, 2806, 2807, 3, 2, 2, 2, 2807, 2873, 5, 1324, 663, 2, 2808, 2810, 7, 4, 2, 2, 2809, 2811, 5, 176, 89, 2, 2810, 2809, 3, 2, 2, 2, 2810, 2811, 3, 2, 2, 2, 2811, 2812, 3, 2, 2, 2, 2812, 2814, 7, 5, 2, 2, 2813, 2815, 5, 238, 120, 2, 2814, 2813, 3, 2, 2, 2, 2814, 2815, 3, 2, 2, 2, 2815, 2817, 3, 2, 2, 2, 2816, 2818, 5, 240, 121, 2, 2817, 2816, 3, 2, 2, 2, 2817, 2818, 3, 2, 2, 2, 2818, 2820, 3, 2, 2, 2, 2819, 2821, 5, 248, 125, 2, 2820, 2819, 3, 2, 2, 2, 2820, 2821, 3, 2, 2, 2, 2821, 2823, 3, 2, 2, 2, 2822, 2824, 5, 250, 126, 2, 2823, 2822, 3, 2, 2, 2, 2823, 2824, 3, 2, 2, 2, 2824, 2826, 3, 2, 2, 2, 2825, 2827, 5, 252, 127, 2, 2826, 2825, 3, 2, 2, 2, 2826, 2827, 3, 2, 2, 2, 2827, 2829, 3, 2, 2, 2, 2828, 2830, 5, 254, 128, 2, 2829, 2828, 3, 2, 2, 2, 2829, 2830, 3, 2, 2, 2, 2830, 2874, 3, 2, 2, 2, 2831, 2832, 7, 268, 2, 2, 2832, 2834, 5, 524, 263, 2, 2833, 2835, 5, 178, 90, 2, 2834, 2833, 3, 2, 2, 2, 2834, 2835, 3, 2, 2, 2, 2835, 2837, 3, 2, 2, 2, 2836, 2838, 5, 240, 121, 2, 2837, 2836, 3, 2, 2, 2, 2837, 2838, 3, 2, 2, 2, 2838, 2840, 3, 2, 2, 2, 2839, 2841, 5, 248, 125, 2, 2840, 2839, 3, 2, 2, 2, 2840, 2841, 3, 2, 2, 2, 2841, 2843, 3, 2, 2, 2, 2842, 2844, 5, 250, 126, 2, 2843, 2842, 3, 2, 2, 2, 2843, 2844, 3, 2, 2, 2, 2844, 2846, 3, 2, 2, 2, 2845, 2847, 5, 252, 127, 2, 2846, 2845, 3, 2, 2, 2, 2846, 2847, 3, 2, 2, 2, 2847, 2849, 3, 2, 2, 2, 2848, 2850, 5, 254, 128, 2, 2849, 2848, 3, 2, 2, 2, 2849, 2850, 3, 2, 2, 2, 2850, 2874, 3, 2, 2, 2, 2851, 2852, 7, 278, 2, 2, 2852, 2853, 7, 268, 2, 2, 2853, 2855, 5, 1324, 663, 2, 2854, 2856, 5, 178, 90, 2, 2855, 2854, 3, 2, 2, 2, 2855, 2856, 3, 2, 2, 2, 2856, 2857, 3, 2, 2, 2, 2857, 2859, 5, 128, 65, 2, 2858, 2860, 5, 240, 121, 2, 2859, 2858, 3, 2, 2, 2, 2859, 2860, 3, 2, 2, 2, 2860, 2862, 3, 2, 2, 2, 2861, 2863, 5, 248, 125, 2, 2862, 2861, 3, 2, 2, 2, 2862, 2863, 3, 2, 2, 2, 2863, 2865, 3, 2, 2, 2, 2864, 2866, 5, 250, 126, 2, 2865, 2864, 3, 2, 2, 2, 2865, 2866, 3, 2, 2, 2, 2866, 2868, 3, 2, 2, 2, 2867, 2869, 5, 252, 127, 2, 2868, 2867, 3, 2, 2, 2, 2868, 2869, 3, 2, 2, 2, 2869, 2871, 3, 2, 2, 2, 2870, 2872, 5, 254, 128, 2, 2871, 2870, 3, 2, 2, 2, 2871, 2872, 3, 2, 2, 2, 2872, 2874, 3, 2, 2, 2, 2873, 2808, 3, 2, 2, 2, 2873, 2831, 3, 2, 2, 2, 2873, 2851, 3, 2, 2, 2, 2874, 173, 3, 2, 2, 2, 2875, 2883, 7, 347, 2, 2, 2876, 2883, 7, 345, 2, 2, 2877, 2878, 7, 247, 2, 2, 2878, 2883, 9, 14, 2, 2, 2879, 2880, 7, 215, 2, 2, 2880, 2883, 9, 14, 2, 2, 2881, 2883, 7, 360, 2, 2, 2882, 2875, 3, 2, 2, 2, 2882, 2876, 3, 2, 2, 2, 2882, 2877, 3, 2, 2, 2, 2882, 2879, 3, 2, 2, 2, 2882, 2881, 3, 2, 2, 2, 2883, 175, 3, 2, 2, 2, 2884, 2885, 5, 180, 91, 2, 2885, 177, 3, 2, 2, 2, 2886, 2887, 7, 4, 2, 2, 2887, 2888, 5, 182, 92, 2, 2888, 2889, 7, 5, 2, 2, 2889, 179, 3, 2, 2, 2, 2890, 2895, 5, 184, 93, 2, 2891, 2892, 7, 8, 2, 2, 2892, 2894, 5, 184, 93, 2, 2893, 2891, 3, 2, 2, 2, 2894, 2897, 3, 2, 2, 2, 2895, 2893, 3, 2, 2, 2, 2895, 2896, 3, 2, 2, 2, 2896, 181, 3, 2, 2, 2, 2897, 2895, 3, 2, 2, 2, 2898, 2903, 5, 186, 94, 2, 2899, 2900, 7, 8, 2, 2, 2900, 2902, 5, 186, 94, 2, 2901, 2899, 3, 2, 2, 2, 2902, 2905, 3, 2, 2, 2, 2903, 2901, 3, 2, 2, 2, 2903, 2904, 3, 2, 2, 2, 2904, 183, 3, 2, 2, 2, 2905, 2903, 3, 2, 2, 2, 2906, 2910, 5, 188, 95, 2, 2907, 2910, 5, 202, 102, 2, 2908, 2910, 5, 208, 105, 2, 2909, 2906, 3, 2, 2, 2, 2909, 2907, 3, 2, 2, 2, 2909, 2908, 3, 2, 2, 2, 2910, 185, 3, 2, 2, 2, 2911, 2914, 5, 190, 96, 2, 2912, 2914, 5, 208, 105, 2, 2913, 2911, 3, 2, 2, 2, 2913, 2912, 3, 2, 2, 2, 2914, 187, 3, 2, 2, 2, 2915, 2916, 5, 1360, 681, 2, 2916, 2918, 5, 1108, 555, 2, 2917, 2919, 5, 340, 171, 2, 2918, 2917, 3, 2, 2, 2, 2918, 2919, 3, 2, 2, 2, 2919, 2920, 3, 2, 2, 2, 2920, 2921, 5, 192, 97, 2, 2921, 189, 3, 2, 2, 2, 2922, 2925, 5, 1360, 681, 2, 2923, 2924, 7, 107, 2, 2, 2924, 2926, 7, 273, 2, 2, 2925, 2923, 3, 2, 2, 2, 2925, 2926, 3, 2, 2, 2, 2926, 2927, 3, 2, 2, 2, 2927, 2928, 5, 192, 97, 2, 2928, 191, 3, 2, 2, 2, 2929, 2931, 5, 194, 98, 2, 2930, 2929, 3, 2, 2, 2, 2931, 2934, 3, 2, 2, 2, 2932, 2930, 3, 2, 2, 2, 2932, 2933, 3, 2, 2, 2, 2933, 193, 3, 2, 2, 2, 2934, 2932, 3, 2, 2, 2, 2935, 2936, 7, 47, 2, 2, 2936, 2937, 5, 1328, 665, 2, 2937, 2938, 5, 196, 99, 2, 2938, 2944, 3, 2, 2, 2, 2939, 2944, 5, 196, 99, 2, 2940, 2944, 5, 200, 101, 2, 2941, 2942, 7, 45, 2, 2, 2942, 2944, 5, 524, 263, 2, 2943, 2935, 3, 2, 2, 2, 2943, 2939, 3, 2, 2, 2, 2943, 2940, 3, 2, 2, 2, 2943, 2941, 3, 2, 2, 2, 2944, 195, 3, 2, 2, 2, 2945, 2946, 7, 79, 2, 2, 2946, 2998, 7, 80, 2, 2, 2947, 2998, 7, 80, 2, 2, 2948, 2950, 7, 100, 2, 2, 2949, 2951, 5, 664, 333, 2, 2950, 2949, 3, 2, 2, 2, 2950, 2951, 3, 2, 2, 2, 2951, 2953, 3, 2, 2, 2, 2952, 2954, 5, 256, 129, 2, 2953, 2952, 3, 2, 2, 2, 2953, 2954, 3, 2, 2, 2, 2954, 2998, 3, 2, 2, 2, 2955, 2956, 7, 87, 2, 2, 2956, 2958, 7, 238, 2, 2, 2957, 2959, 5, 664, 333, 2, 2958, 2957, 3, 2, 2, 2, 2958, 2959, 3, 2, 2, 2, 2959, 2961, 3, 2, 2, 2, 2960, 2962, 5, 256, 129, 2, 2961, 2960, 3, 2, 2, 2, 2961, 2962, 3, 2, 2, 2, 2962, 2998, 3, 2, 2, 2, 2963, 2964, 7, 44, 2, 2, 2964, 2965, 7, 4, 2, 2, 2965, 2966, 5, 1152, 577, 2, 2966, 2968, 7, 5, 2, 2, 2967, 2969, 5, 212, 107, 2, 2968, 2967, 3, 2, 2, 2, 2968, 2969, 3, 2, 2, 2, 2969, 2998, 3, 2, 2, 2, 2970, 2971, 7, 55, 2, 2, 2971, 2998, 5, 1192, 597, 2, 2972, 2973, 7, 431, 2, 2, 2973, 2974, 5, 198, 100, 2, 2974, 2984, 7, 38, 2, 2, 2975, 2977, 7, 221, 2, 2, 2976, 2978, 5, 284, 143, 2, 2977, 2976, 3, 2, 2, 2, 2977, 2978, 3, 2, 2, 2, 2978, 2985, 3, 2, 2, 2, 2979, 2980, 7, 4, 2, 2, 2980, 2981, 5, 1152, 577, 2, 2981, 2982, 7, 5, 2, 2, 2982, 2983, 7, 433, 2, 2, 2983, 2985, 3, 2, 2, 2, 2984, 2975, 3, 2, 2, 2, 2984, 2979, 3, 2, 2, 2, 2985, 2998, 3, 2, 2, 2, 2986, 2987, 7, 88, 2, 2, 2987, 2989, 5, 1324, 663, 2, 2988, 2990, 5, 214, 108, 2, 2989, 2988, 3, 2, 2, 2, 2989, 2990, 3, 2, 2, 2, 2990, 2992, 3, 2, 2, 2, 2991, 2993, 5, 222, 112, 2, 2992, 2991, 3, 2, 2, 2, 2992, 2993, 3, 2, 2, 2, 2993, 2995, 3, 2, 2, 2, 2994, 2996, 5, 230, 116, 2, 2995, 2994, 3, 2, 2, 2, 2995, 2996, 3, 2, 2, 2, 2996, 2998, 3, 2, 2, 2, 2997, 2945, 3, 2, 2, 2, 2997, 2947, 3, 2, 2, 2, 2997, 2948, 3, 2, 2, 2, 2997, 2955, 3, 2, 2, 2, 2997, 2963, 3, 2, 2, 2, 2997, 2970, 3, 2, 2, 2, 2997, 2972, 3, 2, 2, 2, 2997, 2986, 3, 2, 2, 2, 2998, 197, 3, 2, 2, 2, 2999, 3003, 7, 141, 2, 2, 3000, 3001, 7, 149, 2, 2, 3001, 3003, 7, 55, 2, 2, 3002, 2999, 3, 2, 2, 2, 3002, 3000, 3, 2, 2, 2, 3003, 199, 3, 2, 2, 2, 3004, 3010, 7, 56, 2, 2, 3005, 3006, 7, 79, 2, 2, 3006, 3010, 7, 56, 2, 2, 3007, 3008, 7, 71, 2, 2, 3008, 3010, 9, 10, 2, 2, 3009, 3004, 3, 2, 2, 2, 3009, 3005, 3, 2, 2, 2, 3009, 3007, 3, 2, 2, 2, 3010, 201, 3, 2, 2, 2, 3011, 3012, 7, 122, 2, 2, 3012, 3013, 5, 1324, 663, 2, 3013, 3014, 5, 204, 103, 2, 3014, 203, 3, 2, 2, 2, 3015, 3016, 9, 15, 2, 2, 3016, 3018, 5, 206, 104, 2, 3017, 3015, 3, 2, 2, 2, 3018, 3021, 3, 2, 2, 2, 3019, 3017, 3, 2, 2, 2, 3019, 3020, 3, 2, 2, 2, 3020, 205, 3, 2, 2, 2, 3021, 3019, 3, 2, 2, 2, 3022, 3023, 9, 16, 2, 2, 3023, 207, 3, 2, 2, 2, 3024, 3025, 7, 47, 2, 2, 3025, 3026, 5, 1328, 665, 2, 3026, 3027, 5, 210, 106, 2, 3027, 3030, 3, 2, 2, 2, 3028, 3030, 5, 210, 106, 2, 3029, 3024, 3, 2, 2, 2, 3029, 3028, 3, 2, 2, 2, 3030, 209, 3, 2, 2, 2, 3031, 3032, 7, 44, 2, 2, 3032, 3033, 7, 4, 2, 2, 3033, 3034, 5, 1152, 577, 2, 3034, 3035, 7, 5, 2, 2, 3035, 3036, 5, 440, 221, 2, 3036, 3118, 3, 2, 2, 2, 3037, 3055, 7, 100, 2, 2, 3038, 3039, 7, 4, 2, 2, 3039, 3040, 5, 216, 109, 2, 3040, 3042, 7, 5, 2, 2, 3041, 3043, 5, 220, 111, 2, 3042, 3041, 3, 2, 2, 2, 3042, 3043, 3, 2, 2, 2, 3043, 3045, 3, 2, 2, 2, 3044, 3046, 5, 664, 333, 2, 3045, 3044, 3, 2, 2, 2, 3045, 3046, 3, 2, 2, 2, 3046, 3048, 3, 2, 2, 2, 3047, 3049, 5, 256, 129, 2, 3048, 3047, 3, 2, 2, 2, 3048, 3049, 3, 2, 2, 2, 3049, 3050, 3, 2, 2, 2, 3050, 3051, 5, 440, 221, 2, 3051, 3056, 3, 2, 2, 2, 3052, 3053, 5, 258, 130, 2, 3053, 3054, 5, 440, 221, 2, 3054, 3056, 3, 2, 2, 2, 3055, 3038, 3, 2, 2, 2, 3055, 3052, 3, 2, 2, 2, 3056, 3118, 3, 2, 2, 2, 3057, 3058, 7, 87, 2, 2, 3058, 3076, 7, 238, 2, 2, 3059, 3060, 7, 4, 2, 2, 3060, 3061, 5, 216, 109, 2, 3061, 3063, 7, 5, 2, 2, 3062, 3064, 5, 220, 111, 2, 3063, 3062, 3, 2, 2, 2, 3063, 3064, 3, 2, 2, 2, 3064, 3066, 3, 2, 2, 2, 3065, 3067, 5, 664, 333, 2, 3066, 3065, 3, 2, 2, 2, 3066, 3067, 3, 2, 2, 2, 3067, 3069, 3, 2, 2, 2, 3068, 3070, 5, 256, 129, 2, 3069, 3068, 3, 2, 2, 2, 3069, 3070, 3, 2, 2, 2, 3070, 3071, 3, 2, 2, 2, 3071, 3072, 5, 440, 221, 2, 3072, 3077, 3, 2, 2, 2, 3073, 3074, 5, 258, 130, 2, 3074, 3075, 5, 440, 221, 2, 3075, 3077, 3, 2, 2, 2, 3076, 3059, 3, 2, 2, 2, 3076, 3073, 3, 2, 2, 2, 3077, 3118, 3, 2, 2, 2, 3078, 3080, 7, 201, 2, 2, 3079, 3081, 5, 596, 299, 2, 3080, 3079, 3, 2, 2, 2, 3080, 3081, 3, 2, 2, 2, 3081, 3082, 3, 2, 2, 2, 3082, 3083, 7, 4, 2, 2, 3083, 3084, 5, 224, 113, 2, 3084, 3086, 7, 5, 2, 2, 3085, 3087, 5, 220, 111, 2, 3086, 3085, 3, 2, 2, 2, 3086, 3087, 3, 2, 2, 2, 3087, 3089, 3, 2, 2, 2, 3088, 3090, 5, 664, 333, 2, 3089, 3088, 3, 2, 2, 2, 3089, 3090, 3, 2, 2, 2, 3090, 3092, 3, 2, 2, 2, 3091, 3093, 5, 256, 129, 2, 3092, 3091, 3, 2, 2, 2, 3092, 3093, 3, 2, 2, 2, 3093, 3095, 3, 2, 2, 2, 3094, 3096, 5, 228, 115, 2, 3095, 3094, 3, 2, 2, 2, 3095, 3096, 3, 2, 2, 2, 3096, 3097, 3, 2, 2, 2, 3097, 3098, 5, 440, 221, 2, 3098, 3118, 3, 2, 2, 2, 3099, 3100, 7, 65, 2, 2, 3100, 3101, 7, 238, 2, 2, 3101, 3102, 7, 4, 2, 2, 3102, 3103, 5, 216, 109, 2, 3103, 3104, 7, 5, 2, 2, 3104, 3105, 7, 88, 2, 2, 3105, 3107, 5, 1324, 663, 2, 3106, 3108, 5, 214, 108, 2, 3107, 3106, 3, 2, 2, 2, 3107, 3108, 3, 2, 2, 2, 3108, 3110, 3, 2, 2, 2, 3109, 3111, 5, 222, 112, 2, 3110, 3109, 3, 2, 2, 2, 3110, 3111, 3, 2, 2, 2, 3111, 3113, 3, 2, 2, 2, 3112, 3114, 5, 230, 116, 2, 3113, 3112, 3, 2, 2, 2, 3113, 3114, 3, 2, 2, 2, 3114, 3115, 3, 2, 2, 2, 3115, 3116, 5, 440, 221, 2, 3116, 3118, 3, 2, 2, 2, 3117, 3031, 3, 2, 2, 2, 3117, 3037, 3, 2, 2, 2, 3117, 3057, 3, 2, 2, 2, 3117, 3078, 3, 2, 2, 2, 3117, 3099, 3, 2, 2, 2, 3118, 211, 3, 2, 2, 2, 3119, 3120, 7, 262, 2, 2, 3120, 3121, 7, 230, 2, 2, 3121, 213, 3, 2, 2, 2, 3122, 3123, 7, 4, 2, 2, 3123, 3124, 5, 216, 109, 2, 3124, 3125, 7, 5, 2, 2, 3125, 215, 3, 2, 2, 2, 3126, 3131, 5, 218, 110, 2, 3127, 3128, 7, 8, 2, 2, 3128, 3130, 5, 218, 110, 2, 3129, 3127, 3, 2, 2, 2, 3130, 3133, 3, 2, 2, 2, 3131, 3129, 3, 2, 2, 2, 3131, 3132, 3, 2, 2, 2, 3132, 217, 3, 2, 2, 2, 3133, 3131, 3, 2, 2, 2, 3134, 3135, 5, 1360, 681, 2, 3135, 219, 3, 2, 2, 2, 3136, 3137, 7, 434, 2, 2, 3137, 3138, 7, 4, 2, 2, 3138, 3139, 5, 216, 109, 2, 3139, 3140, 7, 5, 2, 2, 3140, 221, 3, 2, 2, 2, 3141, 3142, 7, 251, 2, 2, 3142, 3143, 9, 17, 2, 2, 3143, 223, 3, 2, 2, 2, 3144, 3149, 5, 226, 114, 2, 3145, 3146, 7, 8, 2, 2, 3146, 3148, 5, 226, 114, 2, 3147, 3145, 3, 2, 2, 2, 3148, 3151, 3, 2, 2, 2, 3149, 3147, 3, 2, 2, 2, 3149, 3150, 3, 2, 2, 2, 3150, 225, 3, 2, 2, 2, 3151, 3149, 3, 2, 2, 2, 3152, 3153, 5, 602, 302, 2, 3153, 3160, 7, 107, 2, 2, 3154, 3161, 5, 684, 343, 2, 3155, 3156, 7, 271, 2, 2, 3156, 3157, 7, 4, 2, 2, 3157, 3158, 5, 684, 343, 2, 3158, 3159, 7, 5, 2, 2, 3159, 3161, 3, 2, 2, 2, 3160, 3154, 3, 2, 2, 2, 3160, 3155, 3, 2, 2, 2, 3161, 227, 3, 2, 2, 2, 3162, 3163, 7, 105, 2, 2, 3163, 3164, 7, 4, 2, 2, 3164, 3165, 5, 1152, 577, 2, 3165, 3166, 7, 5, 2, 2, 3166, 229, 3, 2, 2, 2, 3167, 3176, 5, 232, 117, 2, 3168, 3176, 5, 234, 118, 2, 3169, 3170, 5, 232, 117, 2, 3170, 3171, 5, 234, 118, 2, 3171, 3176, 3, 2, 2, 2, 3172, 3173, 5, 234, 118, 2, 3173, 3174, 5, 232, 117, 2, 3174, 3176, 3, 2, 2, 2, 3175, 3167, 3, 2, 2, 2, 3175, 3168, 3, 2, 2, 2, 3175, 3169, 3, 2, 2, 2, 3175, 3172, 3, 2, 2, 2, 3176, 231, 3, 2, 2, 2, 3177, 3178, 7, 82, 2, 2, 3178, 3179, 7, 362, 2, 2, 3179, 3180, 5, 236, 119, 2, 3180, 233, 3, 2, 2, 2, 3181, 3182, 7, 82, 2, 2, 3182, 3183, 7, 184, 2, 2, 3183, 3184, 5, 236, 119, 2, 3184, 235, 3, 2, 2, 2, 3185, 3186, 7, 262, 2, 2, 3186, 3192, 7, 134, 2, 2, 3187, 3192, 7, 308, 2, 2, 3188, 3192, 7, 152, 2, 2, 3189, 3190, 7, 326, 2, 2, 3190, 3192, 9, 18, 2, 2, 3191, 3185, 3, 2, 2, 2, 3191, 3187, 3, 2, 2, 2, 3191, 3188, 3, 2, 2, 2, 3191, 3189, 3, 2, 2, 2, 3192, 237, 3, 2, 2, 2, 3193, 3194, 7, 231, 2, 2, 3194, 3195, 7, 4, 2, 2, 3195, 3196, 5, 1322, 662, 2, 3196, 3197, 7, 5, 2, 2, 3197, 239, 3, 2, 2, 2, 3198, 3199, 5, 242, 122, 2, 3199, 241, 3, 2, 2, 2, 3200, 3201, 7, 278, 2, 2, 3201, 3202, 7, 149, 2, 2, 3202, 3203, 5, 1360, 681, 2, 3203, 3204, 7, 4, 2, 2, 3204, 3205, 5, 244, 123, 2, 3205, 3206, 7, 5, 2, 2, 3206, 243, 3, 2, 2, 2, 3207, 3212, 5, 246, 124, 2, 3208, 3209, 7, 8, 2, 2, 3209, 3211, 5, 246, 124, 2, 3210, 3208, 3, 2, 2, 2, 3211, 3214, 3, 2, 2, 2, 3212, 3210, 3, 2, 2, 2, 3212, 3213, 3, 2, 2, 2, 3213, 245, 3, 2, 2, 2, 3214, 3212, 3, 2, 2, 2, 3215, 3217, 5, 1360, 681, 2, 3216, 3218, 5, 608, 305, 2, 3217, 3216, 3, 2, 2, 2, 3217, 3218, 3, 2, 2, 2, 3218, 3220, 3, 2, 2, 2, 3219, 3221, 5, 610, 306, 2, 3220, 3219, 3, 2, 2, 2, 3220, 3221, 3, 2, 2, 2, 3221, 3239, 3, 2, 2, 2, 3222, 3224, 5, 1202, 602, 2, 3223, 3225, 5, 608, 305, 2, 3224, 3223, 3, 2, 2, 2, 3224, 3225, 3, 2, 2, 2, 3225, 3227, 3, 2, 2, 2, 3226, 3228, 5, 610, 306, 2, 3227, 3226, 3, 2, 2, 2, 3227, 3228, 3, 2, 2, 2, 3228, 3239, 3, 2, 2, 2, 3229, 3230, 7, 4, 2, 2, 3230, 3231, 5, 1152, 577, 2, 3231, 3233, 7, 5, 2, 2, 3232, 3234, 5, 608, 305, 2, 3233, 3232, 3, 2, 2, 2, 3233, 3234, 3, 2, 2, 2, 3234, 3236, 3, 2, 2, 2, 3235, 3237, 5, 610, 306, 2, 3236, 3235, 3, 2, 2, 2, 3236, 3237, 3, 2, 2, 2, 3237, 3239, 3, 2, 2, 2, 3238, 3215, 3, 2, 2, 2, 3238, 3222, 3, 2, 2, 2, 3238, 3229, 3, 2, 2, 2, 3239, 247, 3, 2, 2, 2, 3240, 3241, 7, 102, 2, 2, 3241, 3242, 5, 1328, 665, 2, 3242, 249, 3, 2, 2, 2, 3243, 3244, 7, 107, 2, 2, 3244, 3248, 5, 116, 59, 2, 3245, 3246, 7, 372, 2, 2, 3246, 3248, 7, 270, 2, 2, 3247, 3243, 3, 2, 2, 2, 3247, 3245, 3, 2, 2, 2, 3248, 251, 3, 2, 2, 2, 3249, 3250, 7, 82, 2, 2, 3250, 3256, 7, 163, 2, 2, 3251, 3257, 7, 193, 2, 2, 3252, 3253, 7, 184, 2, 2, 3253, 3257, 7, 313, 2, 2, 3254, 3255, 7, 285, 2, 2, 3255, 3257, 7, 313, 2, 2, 3256, 3251, 3, 2, 2, 2, 3256, 3252, 3, 2, 2, 2, 3256, 3254, 3, 2, 2, 2, 3257, 253, 3, 2, 2, 2, 3258, 3259, 7, 344, 2, 2, 3259, 3260, 5, 1328, 665, 2, 3260, 255, 3, 2, 2, 2, 3261, 3262, 7, 102, 2, 2, 3262, 3263, 7, 228, 2, 2, 3263, 3264, 7, 344, 2, 2, 3264, 3265, 5, 1328, 665, 2, 3265, 257, 3, 2, 2, 2, 3266, 3267, 7, 102, 2, 2, 3267, 3268, 7, 228, 2, 2, 3268, 3269, 5, 1328, 665, 2, 3269, 259, 3, 2, 2, 2, 3270, 3271, 7, 48, 2, 2, 3271, 3275, 7, 335, 2, 2, 3272, 3273, 7, 222, 2, 2, 3273, 3274, 7, 79, 2, 2, 3274, 3276, 7, 389, 2, 2, 3275, 3272, 3, 2, 2, 2, 3275, 3276, 3, 2, 2, 2, 3276, 3277, 3, 2, 2, 2, 3277, 3279, 5, 524, 263, 2, 3278, 3280, 5, 870, 436, 2, 3279, 3278, 3, 2, 2, 2, 3279, 3280, 3, 2, 2, 2, 3280, 3281, 3, 2, 2, 2, 3281, 3282, 7, 82, 2, 2, 3282, 3283, 5, 1268, 635, 2, 3283, 3284, 7, 66, 2, 2, 3284, 3285, 5, 1050, 526, 2, 3285, 261, 3, 2, 2, 2, 3286, 3287, 7, 140, 2, 2, 3287, 3290, 7, 335, 2, 2, 3288, 3289, 7, 222, 2, 2, 3289, 3291, 7, 389, 2, 2, 3290, 3288, 3, 2, 2, 2, 3290, 3291, 3, 2, 2, 2, 3291, 3292, 3, 2, 2, 2, 3292, 3293, 5, 524, 263, 2, 3293, 3294, 7, 326, 2, 2, 3294, 3295, 7, 335, 2, 2, 3295, 3296, 5, 1352, 677, 2, 3296, 263, 3, 2, 2, 2, 3297, 3299, 7, 48, 2, 2, 3298, 3300, 5, 174, 88, 2, 3299, 3298, 3, 2, 2, 2, 3299, 3300, 3, 2, 2, 2, 3300, 3301, 3, 2, 2, 2, 3301, 3305, 7, 94, 2, 2, 3302, 3303, 7, 222, 2, 2, 3303, 3304, 7, 79, 2, 2, 3304, 3306, 7, 389, 2, 2, 3305, 3302, 3, 2, 2, 2, 3305, 3306, 3, 2, 2, 2, 3306, 3307, 3, 2, 2, 2, 3307, 3308, 5, 266, 134, 2, 3308, 3309, 7, 38, 2, 2, 3309, 3311, 5, 952, 477, 2, 3310, 3312, 5, 268, 135, 2, 3311, 3310, 3, 2, 2, 2, 3311, 3312, 3, 2, 2, 2, 3312, 265, 3, 2, 2, 2, 3313, 3315, 5, 1324, 663, 2, 3314, 3316, 5, 214, 108, 2, 3315, 3314, 3, 2, 2, 2, 3315, 3316, 3, 2, 2, 2, 3316, 3318, 3, 2, 2, 2, 3317, 3319, 5, 248, 125, 2, 3318, 3317, 3, 2, 2, 2, 3318, 3319, 3, 2, 2, 2, 3319, 3321, 3, 2, 2, 2, 3320, 3322, 5, 250, 126, 2, 3321, 3320, 3, 2, 2, 2, 3321, 3322, 3, 2, 2, 2, 3322, 3324, 3, 2, 2, 2, 3323, 3325, 5, 252, 127, 2, 3324, 3323, 3, 2, 2, 2, 3324, 3325, 3, 2, 2, 2, 3325, 3327, 3, 2, 2, 2, 3326, 3328, 5, 254, 128, 2, 3327, 3326, 3, 2, 2, 2, 3327, 3328, 3, 2, 2, 2, 3328, 267, 3, 2, 2, 2, 3329, 3333, 7, 107, 2, 2, 3330, 3334, 7, 176, 2, 2, 3331, 3332, 7, 262, 2, 2, 3332, 3334, 7, 176, 2, 2, 3333, 3330, 3, 2, 2, 2, 3333, 3331, 3, 2, 2, 2, 3334, 269, 3, 2, 2, 2, 3335, 3337, 7, 48, 2, 2, 3336, 3338, 5, 274, 138, 2, 3337, 3336, 3, 2, 2, 2, 3337, 3338, 3, 2, 2, 2, 3338, 3339, 3, 2, 2, 2, 3339, 3340, 7, 252, 2, 2, 3340, 3344, 7, 369, 2, 2, 3341, 3342, 7, 222, 2, 2, 3342, 3343, 7, 79, 2, 2, 3343, 3345, 7, 389, 2, 2, 3344, 3341, 3, 2, 2, 2, 3344, 3345, 3, 2, 2, 2, 3345, 3346, 3, 2, 2, 2, 3346, 3347, 5, 272, 137, 2, 3347, 3348, 7, 38, 2, 2, 3348, 3350, 5, 952, 477, 2, 3349, 3351, 5, 268, 135, 2, 3350, 3349, 3, 2, 2, 2, 3350, 3351, 3, 2, 2, 2, 3351, 271, 3, 2, 2, 2, 3352, 3354, 5, 1324, 663, 2, 3353, 3355, 5, 214, 108, 2, 3354, 3353, 3, 2, 2, 2, 3354, 3355, 3, 2, 2, 2, 3355, 3357, 3, 2, 2, 2, 3356, 3358, 5, 248, 125, 2, 3357, 3356, 3, 2, 2, 2, 3357, 3358, 3, 2, 2, 2, 3358, 3360, 3, 2, 2, 2, 3359, 3361, 5, 118, 60, 2, 3360, 3359, 3, 2, 2, 2, 3360, 3361, 3, 2, 2, 2, 3361, 3363, 3, 2, 2, 2, 3362, 3364, 5, 254, 128, 2, 3363, 3362, 3, 2, 2, 2, 3363, 3364, 3, 2, 2, 2, 3364, 273, 3, 2, 2, 2, 3365, 3366, 7, 360, 2, 2, 3366, 275, 3, 2, 2, 2, 3367, 3368, 7, 298, 2, 2, 3368, 3369, 7, 252, 2, 2, 3369, 3371, 7, 369, 2, 2, 3370, 3372, 5, 592, 297, 2, 3371, 3370, 3, 2, 2, 2, 3371, 3372, 3, 2, 2, 2, 3372, 3373, 3, 2, 2, 2, 3373, 3375, 5, 1324, 663, 2, 3374, 3376, 5, 268, 135, 2, 3375, 3374, 3, 2, 2, 2, 3375, 3376, 3, 2, 2, 2, 3376, 277, 3, 2, 2, 2, 3377, 3379, 7, 48, 2, 2, 3378, 3380, 5, 174, 88, 2, 3379, 3378, 3, 2, 2, 2, 3379, 3380, 3, 2, 2, 2, 3380, 3381, 3, 2, 2, 2, 3381, 3385, 7, 321, 2, 2, 3382, 3383, 7, 222, 2, 2, 3383, 3384, 7, 79, 2, 2, 3384, 3386, 7, 389, 2, 2, 3385, 3382, 3, 2, 2, 2, 3385, 3386, 3, 2, 2, 2, 3386, 3387, 3, 2, 2, 2, 3387, 3389, 5, 1324, 663, 2, 3388, 3390, 5, 282, 142, 2, 3389, 3388, 3, 2, 2, 2, 3389, 3390, 3, 2, 2, 2, 3390, 279, 3, 2, 2, 2, 3391, 3392, 7, 140, 2, 2, 3392, 3395, 7, 321, 2, 2, 3393, 3394, 7, 222, 2, 2, 3394, 3396, 7, 389, 2, 2, 3395, 3393, 3, 2, 2, 2, 3395, 3396, 3, 2, 2, 2, 3396, 3397, 3, 2, 2, 2, 3397, 3398, 5, 1324, 663, 2, 3398, 3399, 5, 286, 144, 2, 3399, 281, 3, 2, 2, 2, 3400, 3401, 5, 286, 144, 2, 3401, 283, 3, 2, 2, 2, 3402, 3403, 7, 4, 2, 2, 3403, 3404, 5, 286, 144, 2, 3404, 3405, 7, 5, 2, 2, 3405, 285, 3, 2, 2, 2, 3406, 3408, 5, 288, 145, 2, 3407, 3406, 3, 2, 2, 2, 3408, 3409, 3, 2, 2, 2, 3409, 3407, 3, 2, 2, 2, 3409, 3410, 3, 2, 2, 2, 3410, 287, 3, 2, 2, 2, 3411, 3412, 7, 38, 2, 2, 3412, 3446, 5, 1112, 557, 2, 3413, 3414, 7, 150, 2, 2, 3414, 3446, 5, 292, 147, 2, 3415, 3446, 7, 175, 2, 2, 3416, 3418, 7, 227, 2, 2, 3417, 3419, 5, 290, 146, 2, 3418, 3417, 3, 2, 2, 2, 3418, 3419, 3, 2, 2, 2, 3419, 3420, 3, 2, 2, 2, 3420, 3446, 5, 292, 147, 2, 3421, 3422, 7, 253, 2, 2, 3422, 3446, 5, 292, 147, 2, 3423, 3424, 7, 255, 2, 2, 3424, 3446, 5, 292, 147, 2, 3425, 3426, 7, 262, 2, 2, 3426, 3446, 9, 19, 2, 2, 3427, 3428, 7, 274, 2, 2, 3428, 3429, 7, 149, 2, 2, 3429, 3446, 5, 524, 263, 2, 3430, 3431, 7, 321, 2, 2, 3431, 3432, 7, 259, 2, 2, 3432, 3446, 5, 524, 263, 2, 3433, 3435, 7, 333, 2, 2, 3434, 3436, 5, 16, 9, 2, 3435, 3434, 3, 2, 2, 2, 3435, 3436, 3, 2, 2, 2, 3436, 3437, 3, 2, 2, 2, 3437, 3446, 5, 292, 147, 2, 3438, 3440, 7, 307, 2, 2, 3439, 3441, 5, 16, 9, 2, 3440, 3439, 3, 2, 2, 2, 3440, 3441, 3, 2, 2, 2, 3441, 3443, 3, 2, 2, 2, 3442, 3444, 5, 292, 147, 2, 3443, 3442, 3, 2, 2, 2, 3443, 3444, 3, 2, 2, 2, 3444, 3446, 3, 2, 2, 2, 3445, 3411, 3, 2, 2, 2, 3445, 3413, 3, 2, 2, 2, 3445, 3415, 3, 2, 2, 2, 3445, 3416, 3, 2, 2, 2, 3445, 3421, 3, 2, 2, 2, 3445, 3423, 3, 2, 2, 2, 3445, 3425, 3, 2, 2, 2, 3445, 3427, 3, 2, 2, 2, 3445, 3430, 3, 2, 2, 2, 3445, 3433, 3, 2, 2, 2, 3445, 3438, 3, 2, 2, 2, 3446, 289, 3, 2, 2, 2, 3447, 3448, 7, 149, 2, 2, 3448, 291, 3, 2, 2, 2, 3449, 3456, 5, 1342, 672, 2, 3450, 3451, 7, 14, 2, 2, 3451, 3456, 5, 1342, 672, 2, 3452, 3453, 7, 15, 2, 2, 3453, 3456, 5, 1342, 672, 2, 3454, 3456, 5, 1352, 677, 2, 3455, 3449, 3, 2, 2, 2, 3455, 3450, 3, 2, 2, 2, 3455, 3452, 3, 2, 2, 2, 3455, 3454, 3, 2, 2, 2, 3456, 293, 3, 2, 2, 2, 3457, 3462, 5, 292, 147, 2, 3458, 3459, 7, 8, 2, 2, 3459, 3461, 5, 292, 147, 2, 3460, 3458, 3, 2, 2, 2, 3461, 3464, 3, 2, 2, 2, 3462, 3460, 3, 2, 2, 2, 3462, 3463, 3, 2, 2, 2, 3463, 295, 3, 2, 2, 2, 3464, 3462, 3, 2, 2, 2, 3465, 3467, 7, 48, 2, 2, 3466, 3468, 5, 618, 310, 2, 3467, 3466, 3, 2, 2, 2, 3467, 3468, 3, 2, 2, 2, 3468, 3470, 3, 2, 2, 2, 3469, 3471, 5, 298, 150, 2, 3470, 3469, 3, 2, 2, 2, 3470, 3471, 3, 2, 2, 2, 3471, 3473, 3, 2, 2, 2, 3472, 3474, 5, 308, 155, 2, 3473, 3472, 3, 2, 2, 2, 3473, 3474, 3, 2, 2, 2, 3474, 3475, 3, 2, 2, 2, 3475, 3476, 7, 240, 2, 2, 3476, 3485, 5, 1328, 665, 2, 3477, 3478, 7, 217, 2, 2, 3478, 3480, 5, 300, 151, 2, 3479, 3481, 5, 302, 152, 2, 3480, 3479, 3, 2, 2, 2, 3480, 3481, 3, 2, 2, 2, 3481, 3483, 3, 2, 2, 2, 3482, 3484, 5, 306, 154, 2, 3483, 3482, 3, 2, 2, 2, 3483, 3484, 3, 2, 2, 2, 3484, 3486, 3, 2, 2, 2, 3485, 3477, 3, 2, 2, 2, 3485, 3486, 3, 2, 2, 2, 3486, 297, 3, 2, 2, 2, 3487, 3488, 7, 352, 2, 2, 3488, 299, 3, 2, 2, 2, 3489, 3491, 5, 1328, 665, 2, 3490, 3492, 5, 526, 264, 2, 3491, 3490, 3, 2, 2, 2, 3491, 3492, 3, 2, 2, 2, 3492, 301, 3, 2, 2, 2, 3493, 3494, 7, 232, 2, 2, 3494, 3495, 5, 300, 151, 2, 3495, 303, 3, 2, 2, 2, 3496, 3497, 7, 366, 2, 2, 3497, 3501, 5, 300, 151, 2, 3498, 3499, 7, 262, 2, 2, 3499, 3501, 7, 366, 2, 2, 3500, 3496, 3, 2, 2, 2, 3500, 3498, 3, 2, 2, 2, 3501, 305, 3, 2, 2, 2, 3502, 3503, 5, 304, 153, 2, 3503, 307, 3, 2, 2, 2, 3504, 3505, 7, 288, 2, 2, 3505, 309, 3, 2, 2, 2, 3506, 3507, 7, 48, 2, 2, 3507, 3508, 7, 344, 2, 2, 3508, 3510, 5, 1328, 665, 2, 3509, 3511, 5, 312, 157, 2, 3510, 3509, 3, 2, 2, 2, 3510, 3511, 3, 2, 2, 2, 3511, 3512, 3, 2, 2, 2, 3512, 3513, 7, 248, 2, 2, 3513, 3515, 5, 1346, 674, 2, 3514, 3516, 5, 118, 60, 2, 3515, 3514, 3, 2, 2, 2, 3515, 3516, 3, 2, 2, 2, 3516, 311, 3, 2, 2, 2, 3517, 3518, 7, 275, 2, 2, 3518, 3519, 5, 1356, 679, 2, 3519, 313, 3, 2, 2, 2, 3520, 3521, 7, 193, 2, 2, 3521, 3524, 7, 344, 2, 2, 3522, 3523, 7, 222, 2, 2, 3523, 3525, 7, 389, 2, 2, 3524, 3522, 3, 2, 2, 2, 3524, 3525, 3, 2, 2, 2, 3525, 3526, 3, 2, 2, 2, 3526, 3527, 5, 1328, 665, 2, 3527, 315, 3, 2, 2, 2, 3528, 3529, 7, 48, 2, 2, 3529, 3533, 7, 206, 2, 2, 3530, 3531, 7, 222, 2, 2, 3531, 3532, 7, 79, 2, 2, 3532, 3534, 7, 389, 2, 2, 3533, 3530, 3, 2, 2, 2, 3533, 3534, 3, 2, 2, 2, 3534, 3535, 3, 2, 2, 2, 3535, 3537, 5, 1328, 665, 2, 3536, 3538, 5, 16, 9, 2, 3537, 3536, 3, 2, 2, 2, 3537, 3538, 3, 2, 2, 2, 3538, 3539, 3, 2, 2, 2, 3539, 3540, 5, 318, 160, 2, 3540, 317, 3, 2, 2, 2, 3541, 3543, 5, 320, 161, 2, 3542, 3541, 3, 2, 2, 2, 3543, 3546, 3, 2, 2, 2, 3544, 3542, 3, 2, 2, 2, 3544, 3545, 3, 2, 2, 2, 3545, 319, 3, 2, 2, 2, 3546, 3544, 3, 2, 2, 2, 3547, 3548, 7, 316, 2, 2, 3548, 3555, 5, 1328, 665, 2, 3549, 3550, 7, 368, 2, 2, 3550, 3555, 5, 72, 37, 2, 3551, 3552, 7, 66, 2, 2, 3552, 3555, 5, 72, 37, 2, 3553, 3555, 7, 152, 2, 2, 3554, 3547, 3, 2, 2, 2, 3554, 3549, 3, 2, 2, 2, 3554, 3551, 3, 2, 2, 2, 3554, 3553, 3, 2, 2, 2, 3555, 321, 3, 2, 2, 2, 3556, 3557, 7, 140, 2, 2, 3557, 3558, 7, 206, 2, 2, 3558, 3559, 5, 1328, 665, 2, 3559, 3560, 7, 362, 2, 2, 3560, 3561, 5, 324, 163, 2, 3561, 323, 3, 2, 2, 2, 3562, 3564, 5, 326, 164, 2, 3563, 3562, 3, 2, 2, 2, 3564, 3567, 3, 2, 2, 2, 3565, 3563, 3, 2, 2, 2, 3565, 3566, 3, 2, 2, 2, 3566, 325, 3, 2, 2, 2, 3567, 3565, 3, 2, 2, 2, 3568, 3569, 7, 96, 2, 2, 3569, 3570, 5, 72, 37, 2, 3570, 327, 3, 2, 2, 2, 3571, 3572, 7, 140, 2, 2, 3572, 3573, 7, 206, 2, 2, 3573, 3574, 5, 1328, 665, 2, 3574, 3575, 5, 40, 21, 2, 3575, 3576, 5, 516, 259, 2, 3576, 3577, 5, 1328, 665, 2, 3577, 3676, 3, 2, 2, 2, 3578, 3579, 7, 140, 2, 2, 3579, 3580, 7, 206, 2, 2, 3580, 3581, 5, 1328, 665, 2, 3581, 3582, 5, 40, 21, 2, 3582, 3583, 5, 514, 258, 2, 3583, 3584, 5, 524, 263, 2, 3584, 3676, 3, 2, 2, 2, 3585, 3586, 7, 140, 2, 2, 3586, 3587, 7, 206, 2, 2, 3587, 3588, 5, 1328, 665, 2, 3588, 3589, 5, 40, 21, 2, 3589, 3590, 7, 138, 2, 2, 3590, 3591, 5, 650, 326, 2, 3591, 3676, 3, 2, 2, 2, 3592, 3593, 7, 140, 2, 2, 3593, 3594, 7, 206, 2, 2, 3594, 3595, 5, 1328, 665, 2, 3595, 3596, 5, 40, 21, 2, 3596, 3597, 7, 43, 2, 2, 3597, 3598, 7, 4, 2, 2, 3598, 3599, 5, 1108, 555, 2, 3599, 3600, 7, 38, 2, 2, 3600, 3601, 5, 1108, 555, 2, 3601, 3602, 7, 5, 2, 2, 3602, 3676, 3, 2, 2, 2, 3603, 3604, 7, 140, 2, 2, 3604, 3605, 7, 206, 2, 2, 3605, 3606, 5, 1328, 665, 2, 3606, 3607, 5, 40, 21, 2, 3607, 3608, 7, 191, 2, 2, 3608, 3609, 5, 1108, 555, 2, 3609, 3676, 3, 2, 2, 2, 3610, 3611, 7, 140, 2, 2, 3611, 3612, 7, 206, 2, 2, 3612, 3613, 5, 1328, 665, 2, 3613, 3614, 5, 40, 21, 2, 3614, 3615, 7, 213, 2, 2, 3615, 3616, 5, 626, 314, 2, 3616, 3676, 3, 2, 2, 2, 3617, 3618, 7, 140, 2, 2, 3618, 3619, 7, 206, 2, 2, 3619, 3620, 5, 1328, 665, 2, 3620, 3621, 5, 40, 21, 2, 3621, 3622, 7, 271, 2, 2, 3622, 3623, 5, 688, 345, 2, 3623, 3676, 3, 2, 2, 2, 3624, 3625, 7, 140, 2, 2, 3625, 3626, 7, 206, 2, 2, 3626, 3627, 5, 1328, 665, 2, 3627, 3628, 5, 40, 21, 2, 3628, 3629, 7, 271, 2, 2, 3629, 3630, 7, 158, 2, 2, 3630, 3631, 5, 524, 263, 2, 3631, 3632, 7, 102, 2, 2, 3632, 3633, 5, 1328, 665, 2, 3633, 3676, 3, 2, 2, 2, 3634, 3635, 7, 140, 2, 2, 3635, 3636, 7, 206, 2, 2, 3636, 3637, 5, 1328, 665, 2, 3637, 3638, 5, 40, 21, 2, 3638, 3639, 7, 271, 2, 2, 3639, 3640, 7, 208, 2, 2, 3640, 3641, 5, 524, 263, 2, 3641, 3642, 7, 102, 2, 2, 3642, 3643, 5, 1328, 665, 2, 3643, 3676, 3, 2, 2, 2, 3644, 3645, 7, 140, 2, 2, 3645, 3646, 7, 206, 2, 2, 3646, 3647, 5, 1328, 665, 2, 3647, 3648, 5, 40, 21, 2, 3648, 3649, 7, 289, 2, 2, 3649, 3650, 5, 626, 314, 2, 3650, 3676, 3, 2, 2, 2, 3651, 3652, 7, 140, 2, 2, 3652, 3653, 7, 206, 2, 2, 3653, 3654, 5, 1328, 665, 2, 3654, 3655, 5, 40, 21, 2, 3655, 3656, 7, 435, 2, 2, 3656, 3657, 5, 626, 314, 2, 3657, 3676, 3, 2, 2, 2, 3658, 3659, 7, 140, 2, 2, 3659, 3660, 7, 206, 2, 2, 3660, 3661, 5, 1328, 665, 2, 3661, 3662, 5, 40, 21, 2, 3662, 3663, 7, 436, 2, 2, 3663, 3664, 7, 64, 2, 2, 3664, 3665, 5, 1108, 555, 2, 3665, 3666, 7, 240, 2, 2, 3666, 3667, 5, 1328, 665, 2, 3667, 3676, 3, 2, 2, 2, 3668, 3669, 7, 140, 2, 2, 3669, 3670, 7, 206, 2, 2, 3670, 3671, 5, 1328, 665, 2, 3671, 3672, 5, 40, 21, 2, 3672, 3673, 7, 353, 2, 2, 3673, 3674, 5, 1108, 555, 2, 3674, 3676, 3, 2, 2, 2, 3675, 3571, 3, 2, 2, 2, 3675, 3578, 3, 2, 2, 2, 3675, 3585, 3, 2, 2, 2, 3675, 3592, 3, 2, 2, 2, 3675, 3603, 3, 2, 2, 2, 3675, 3610, 3, 2, 2, 2, 3675, 3617, 3, 2, 2, 2, 3675, 3624, 3, 2, 2, 2, 3675, 3634, 3, 2, 2, 2, 3675, 3644, 3, 2, 2, 2, 3675, 3651, 3, 2, 2, 2, 3675, 3658, 3, 2, 2, 2, 3675, 3668, 3, 2, 2, 2, 3676, 329, 3, 2, 2, 2, 3677, 3678, 7, 48, 2, 2, 3678, 3679, 7, 65, 2, 2, 3679, 3680, 7, 176, 2, 2, 3680, 3681, 7, 374, 2, 2, 3681, 3683, 5, 1328, 665, 2, 3682, 3684, 5, 336, 169, 2, 3683, 3682, 3, 2, 2, 2, 3683, 3684, 3, 2, 2, 2, 3684, 3686, 3, 2, 2, 2, 3685, 3687, 5, 340, 171, 2, 3686, 3685, 3, 2, 2, 2, 3686, 3687, 3, 2, 2, 2, 3687, 331, 3, 2, 2, 2, 3688, 3689, 7, 217, 2, 2, 3689, 3697, 5, 300, 151, 2, 3690, 3691, 7, 262, 2, 2, 3691, 3697, 7, 217, 2, 2, 3692, 3693, 7, 366, 2, 2, 3693, 3697, 5, 300, 151, 2, 3694, 3695, 7, 262, 2, 2, 3695, 3697, 7, 366, 2, 2, 3696, 3688, 3, 2, 2, 2, 3696, 3690, 3, 2, 2, 2, 3696, 3692, 3, 2, 2, 2, 3696, 3694, 3, 2, 2, 2, 3697, 333, 3, 2, 2, 2, 3698, 3700, 5, 332, 167, 2, 3699, 3698, 3, 2, 2, 2, 3700, 3701, 3, 2, 2, 2, 3701, 3699, 3, 2, 2, 2, 3701, 3702, 3, 2, 2, 2, 3702, 335, 3, 2, 2, 2, 3703, 3704, 5, 334, 168, 2, 3704, 337, 3, 2, 2, 2, 3705, 3706, 7, 140, 2, 2, 3706, 3707, 7, 65, 2, 2, 3707, 3708, 7, 176, 2, 2, 3708, 3709, 7, 374, 2, 2, 3709, 3711, 5, 1328, 665, 2, 3710, 3712, 5, 336, 169, 2, 3711, 3710, 3, 2, 2, 2, 3711, 3712, 3, 2, 2, 2, 3712, 3713, 3, 2, 2, 2, 3713, 3714, 5, 344, 173, 2, 3714, 3723, 3, 2, 2, 2, 3715, 3716, 7, 140, 2, 2, 3716, 3717, 7, 65, 2, 2, 3717, 3718, 7, 176, 2, 2, 3718, 3719, 7, 374, 2, 2, 3719, 3720, 5, 1328, 665, 2, 3720, 3721, 5, 334, 168, 2, 3721, 3723, 3, 2, 2, 2, 3722, 3705, 3, 2, 2, 2, 3722, 3715, 3, 2, 2, 2, 3723, 339, 3, 2, 2, 2, 3724, 3725, 7, 273, 2, 2, 3725, 3726, 7, 4, 2, 2, 3726, 3727, 5, 342, 172, 2, 3727, 3728, 7, 5, 2, 2, 3728, 341, 3, 2, 2, 2, 3729, 3734, 5, 350, 176, 2, 3730, 3731, 7, 8, 2, 2, 3731, 3733, 5, 350, 176, 2, 3732, 3730, 3, 2, 2, 2, 3733, 3736, 3, 2, 2, 2, 3734, 3732, 3, 2, 2, 2, 3734, 3735, 3, 2, 2, 2, 3735, 343, 3, 2, 2, 2, 3736, 3734, 3, 2, 2, 2, 3737, 3738, 7, 273, 2, 2, 3738, 3739, 7, 4, 2, 2, 3739, 3740, 5, 346, 174, 2, 3740, 3741, 7, 5, 2, 2, 3741, 345, 3, 2, 2, 2, 3742, 3747, 5, 348, 175, 2, 3743, 3744, 7, 8, 2, 2, 3744, 3746, 5, 348, 175, 2, 3745, 3743, 3, 2, 2, 2, 3746, 3749, 3, 2, 2, 2, 3747, 3745, 3, 2, 2, 2, 3747, 3748, 3, 2, 2, 2, 3748, 347, 3, 2, 2, 2, 3749, 3747, 3, 2, 2, 2, 3750, 3758, 5, 350, 176, 2, 3751, 3752, 7, 326, 2, 2, 3752, 3758, 5, 350, 176, 2, 3753, 3754, 7, 135, 2, 2, 3754, 3758, 5, 350, 176, 2, 3755, 3756, 7, 193, 2, 2, 3756, 3758, 5, 352, 177, 2, 3757, 3750, 3, 2, 2, 2, 3757, 3751, 3, 2, 2, 2, 3757, 3753, 3, 2, 2, 2, 3757, 3755, 3, 2, 2, 2, 3758, 349, 3, 2, 2, 2, 3759, 3760, 5, 352, 177, 2, 3760, 3761, 5, 354, 178, 2, 3761, 351, 3, 2, 2, 2, 3762, 3763, 5, 1366, 684, 2, 3763, 353, 3, 2, 2, 2, 3764, 3765, 5, 1346, 674, 2, 3765, 355, 3, 2, 2, 2, 3766, 3767, 7, 48, 2, 2, 3767, 3768, 7, 324, 2, 2, 3768, 3770, 5, 1328, 665, 2, 3769, 3771, 5, 358, 180, 2, 3770, 3769, 3, 2, 2, 2, 3770, 3771, 3, 2, 2, 2, 3771, 3773, 3, 2, 2, 2, 3772, 3774, 5, 362, 182, 2, 3773, 3772, 3, 2, 2, 2, 3773, 3774, 3, 2, 2, 2, 3774, 3775, 3, 2, 2, 2, 3775, 3776, 7, 65, 2, 2, 3776, 3777, 7, 176, 2, 2, 3777, 3778, 7, 374, 2, 2, 3778, 3780, 5, 1328, 665, 2, 3779, 3781, 5, 340, 171, 2, 3780, 3779, 3, 2, 2, 2, 3780, 3781, 3, 2, 2, 2, 3781, 3802, 3, 2, 2, 2, 3782, 3783, 7, 48, 2, 2, 3783, 3784, 7, 324, 2, 2, 3784, 3785, 7, 222, 2, 2, 3785, 3786, 7, 79, 2, 2, 3786, 3787, 7, 389, 2, 2, 3787, 3789, 5, 1328, 665, 2, 3788, 3790, 5, 358, 180, 2, 3789, 3788, 3, 2, 2, 2, 3789, 3790, 3, 2, 2, 2, 3790, 3792, 3, 2, 2, 2, 3791, 3793, 5, 362, 182, 2, 3792, 3791, 3, 2, 2, 2, 3792, 3793, 3, 2, 2, 2, 3793, 3794, 3, 2, 2, 2, 3794, 3795, 7, 65, 2, 2, 3795, 3796, 7, 176, 2, 2, 3796, 3797, 7, 374, 2, 2, 3797, 3799, 5, 1328, 665, 2, 3798, 3800, 5, 340, 171, 2, 3799, 3798, 3, 2, 2, 2, 3799, 3800, 3, 2, 2, 2, 3800, 3802, 3, 2, 2, 2, 3801, 3766, 3, 2, 2, 2, 3801, 3782, 3, 2, 2, 2, 3802, 357, 3, 2, 2, 2, 3803, 3804, 7, 353, 2, 2, 3804, 3805, 5, 1346, 674, 2, 3805, 359, 3, 2, 2, 2, 3806, 3809, 7, 368, 2, 2, 3807, 3810, 5, 1346, 674, 2, 3808, 3810, 7, 80, 2, 2, 3809, 3807, 3, 2, 2, 2, 3809, 3808, 3, 2, 2, 2, 3810, 361, 3, 2, 2, 2, 3811, 3812, 5, 360, 181, 2, 3812, 363, 3, 2, 2, 2, 3813, 3814, 7, 140, 2, 2, 3814, 3815, 7, 324, 2, 2, 3815, 3821, 5, 1328, 665, 2, 3816, 3822, 5, 344, 173, 2, 3817, 3819, 5, 360, 181, 2, 3818, 3820, 5, 344, 173, 2, 3819, 3818, 3, 2, 2, 2, 3819, 3820, 3, 2, 2, 2, 3820, 3822, 3, 2, 2, 2, 3821, 3816, 3, 2, 2, 2, 3821, 3817, 3, 2, 2, 2, 3822, 365, 3, 2, 2, 2, 3823, 3824, 7, 48, 2, 2, 3824, 3825, 7, 65, 2, 2, 3825, 3826, 7, 94, 2, 2, 3826, 3827, 5, 1324, 663, 2, 3827, 3829, 7, 4, 2, 2, 3828, 3830, 5, 176, 89, 2, 3829, 3828, 3, 2, 2, 2, 3829, 3830, 3, 2, 2, 2, 3830, 3831, 3, 2, 2, 2, 3831, 3833, 7, 5, 2, 2, 3832, 3834, 5, 238, 120, 2, 3833, 3832, 3, 2, 2, 2, 3833, 3834, 3, 2, 2, 2, 3834, 3835, 3, 2, 2, 2, 3835, 3836, 7, 324, 2, 2, 3836, 3838, 5, 1328, 665, 2, 3837, 3839, 5, 340, 171, 2, 3838, 3837, 3, 2, 2, 2, 3838, 3839, 3, 2, 2, 2, 3839, 3896, 3, 2, 2, 2, 3840, 3841, 7, 48, 2, 2, 3841, 3842, 7, 65, 2, 2, 3842, 3843, 7, 94, 2, 2, 3843, 3844, 7, 222, 2, 2, 3844, 3845, 7, 79, 2, 2, 3845, 3846, 7, 389, 2, 2, 3846, 3847, 5, 1324, 663, 2, 3847, 3849, 7, 4, 2, 2, 3848, 3850, 5, 176, 89, 2, 3849, 3848, 3, 2, 2, 2, 3849, 3850, 3, 2, 2, 2, 3850, 3851, 3, 2, 2, 2, 3851, 3853, 7, 5, 2, 2, 3852, 3854, 5, 238, 120, 2, 3853, 3852, 3, 2, 2, 2, 3853, 3854, 3, 2, 2, 2, 3854, 3855, 3, 2, 2, 2, 3855, 3856, 7, 324, 2, 2, 3856, 3858, 5, 1328, 665, 2, 3857, 3859, 5, 340, 171, 2, 3858, 3857, 3, 2, 2, 2, 3858, 3859, 3, 2, 2, 2, 3859, 3896, 3, 2, 2, 2, 3860, 3861, 7, 48, 2, 2, 3861, 3862, 7, 65, 2, 2, 3862, 3863, 7, 94, 2, 2, 3863, 3864, 5, 1324, 663, 2, 3864, 3865, 7, 278, 2, 2, 3865, 3866, 7, 268, 2, 2, 3866, 3868, 5, 1324, 663, 2, 3867, 3869, 5, 178, 90, 2, 3868, 3867, 3, 2, 2, 2, 3868, 3869, 3, 2, 2, 2, 3869, 3870, 3, 2, 2, 2, 3870, 3871, 5, 128, 65, 2, 3871, 3872, 7, 324, 2, 2, 3872, 3874, 5, 1328, 665, 2, 3873, 3875, 5, 340, 171, 2, 3874, 3873, 3, 2, 2, 2, 3874, 3875, 3, 2, 2, 2, 3875, 3896, 3, 2, 2, 2, 3876, 3877, 7, 48, 2, 2, 3877, 3878, 7, 65, 2, 2, 3878, 3879, 7, 94, 2, 2, 3879, 3880, 7, 222, 2, 2, 3880, 3881, 7, 79, 2, 2, 3881, 3882, 7, 389, 2, 2, 3882, 3883, 5, 1324, 663, 2, 3883, 3884, 7, 278, 2, 2, 3884, 3885, 7, 268, 2, 2, 3885, 3887, 5, 1324, 663, 2, 3886, 3888, 5, 178, 90, 2, 3887, 3886, 3, 2, 2, 2, 3887, 3888, 3, 2, 2, 2, 3888, 3889, 3, 2, 2, 2, 3889, 3890, 5, 128, 65, 2, 3890, 3891, 7, 324, 2, 2, 3891, 3893, 5, 1328, 665, 2, 3892, 3894, 5, 340, 171, 2, 3893, 3892, 3, 2, 2, 2, 3893, 3894, 3, 2, 2, 2, 3894, 3896, 3, 2, 2, 2, 3895, 3823, 3, 2, 2, 2, 3895, 3840, 3, 2, 2, 2, 3895, 3860, 3, 2, 2, 2, 3895, 3876, 3, 2, 2, 2, 3896, 367, 3, 2, 2, 2, 3897, 3898, 7, 437, 2, 2, 3898, 3899, 7, 65, 2, 2, 3899, 3900, 7, 316, 2, 2, 3900, 3902, 5, 1328, 665, 2, 3901, 3903, 5, 372, 187, 2, 3902, 3901, 3, 2, 2, 2, 3902, 3903, 3, 2, 2, 2, 3903, 3904, 3, 2, 2, 2, 3904, 3905, 7, 66, 2, 2, 3905, 3906, 7, 324, 2, 2, 3906, 3907, 5, 1328, 665, 2, 3907, 3908, 7, 73, 2, 2, 3908, 3910, 5, 1328, 665, 2, 3909, 3911, 5, 340, 171, 2, 3910, 3909, 3, 2, 2, 2, 3910, 3911, 3, 2, 2, 2, 3911, 369, 3, 2, 2, 2, 3912, 3913, 7, 76, 2, 2, 3913, 3916, 7, 96, 2, 2, 3914, 3916, 7, 61, 2, 2, 3915, 3912, 3, 2, 2, 2, 3915, 3914, 3, 2, 2, 2, 3916, 371, 3, 2, 2, 2, 3917, 3918, 5, 370, 186, 2, 3918, 3919, 7, 4, 2, 2, 3919, 3920, 5, 1066, 534, 2, 3920, 3921, 7, 5, 2, 2, 3921, 373, 3, 2, 2, 2, 3922, 3923, 7, 48, 2, 2, 3923, 3924, 7, 101, 2, 2, 3924, 3925, 7, 250, 2, 2, 3925, 3926, 7, 64, 2, 2, 3926, 3927, 5, 376, 189, 2, 3927, 3928, 7, 324, 2, 2, 3928, 3930, 5, 1328, 665, 2, 3929, 3931, 5, 340, 171, 2, 3930, 3929, 3, 2, 2, 2, 3930, 3931, 3, 2, 2, 2, 3931, 3946, 3, 2, 2, 2, 3932, 3933, 7, 48, 2, 2, 3933, 3934, 7, 101, 2, 2, 3934, 3935, 7, 250, 2, 2, 3935, 3936, 7, 222, 2, 2, 3936, 3937, 7, 79, 2, 2, 3937, 3938, 7, 389, 2, 2, 3938, 3939, 7, 64, 2, 2, 3939, 3940, 5, 376, 189, 2, 3940, 3941, 7, 324, 2, 2, 3941, 3943, 5, 1328, 665, 2, 3942, 3944, 5, 340, 171, 2, 3943, 3942, 3, 2, 2, 2, 3943, 3944, 3, 2, 2, 2, 3944, 3946, 3, 2, 2, 2, 3945, 3922, 3, 2, 2, 2, 3945, 3932, 3, 2, 2, 2, 3946, 375, 3, 2, 2, 2, 3947, 3950, 5, 1356, 679, 2, 3948, 3950, 7, 101, 2, 2, 3949, 3947, 3, 2, 2, 2, 3949, 3948, 3, 2, 2, 2, 3950, 377, 3, 2, 2, 2, 3951, 3952, 7, 193, 2, 2, 3952, 3953, 7, 101, 2, 2, 3953, 3954, 7, 250, 2, 2, 3954, 3955, 7, 64, 2, 2, 3955, 3956, 5, 376, 189, 2, 3956, 3957, 7, 324, 2, 2, 3957, 3958, 5, 1328, 665, 2, 3958, 3970, 3, 2, 2, 2, 3959, 3960, 7, 193, 2, 2, 3960, 3961, 7, 101, 2, 2, 3961, 3962, 7, 250, 2, 2, 3962, 3963, 7, 222, 2, 2, 3963, 3964, 7, 389, 2, 2, 3964, 3965, 7, 64, 2, 2, 3965, 3966, 5, 376, 189, 2, 3966, 3967, 7, 324, 2, 2, 3967, 3968, 5, 1328, 665, 2, 3968, 3970, 3, 2, 2, 2, 3969, 3951, 3, 2, 2, 2, 3969, 3959, 3, 2, 2, 2, 3970, 379, 3, 2, 2, 2, 3971, 3972, 7, 140, 2, 2, 3972, 3973, 7, 101, 2, 2, 3973, 3974, 7, 250, 2, 2, 3974, 3975, 7, 64, 2, 2, 3975, 3976, 5, 376, 189, 2, 3976, 3977, 7, 324, 2, 2, 3977, 3978, 5, 1328, 665, 2, 3978, 3979, 5, 344, 173, 2, 3979, 381, 3, 2, 2, 2, 3980, 3981, 7, 48, 2, 2, 3981, 3982, 7, 438, 2, 2, 3982, 3983, 5, 1328, 665, 2, 3983, 3984, 7, 82, 2, 2, 3984, 3986, 5, 1324, 663, 2, 3985, 3987, 5, 394, 198, 2, 3986, 3985, 3, 2, 2, 2, 3986, 3987, 3, 2, 2, 2, 3987, 3989, 3, 2, 2, 2, 3988, 3990, 5, 396, 199, 2, 3989, 3988, 3, 2, 2, 2, 3989, 3990, 3, 2, 2, 2, 3990, 3992, 3, 2, 2, 2, 3991, 3993, 5, 390, 196, 2, 3992, 3991, 3, 2, 2, 2, 3992, 3993, 3, 2, 2, 2, 3993, 3995, 3, 2, 2, 2, 3994, 3996, 5, 386, 194, 2, 3995, 3994, 3, 2, 2, 2, 3995, 3996, 3, 2, 2, 2, 3996, 3998, 3, 2, 2, 2, 3997, 3999, 5, 388, 195, 2, 3998, 3997, 3, 2, 2, 2, 3998, 3999, 3, 2, 2, 2, 3999, 383, 3, 2, 2, 2, 4000, 4001, 7, 140, 2, 2, 4001, 4002, 7, 438, 2, 2, 4002, 4003, 5, 1328, 665, 2, 4003, 4004, 7, 82, 2, 2, 4004, 4006, 5, 1324, 663, 2, 4005, 4007, 5, 392, 197, 2, 4006, 4005, 3, 2, 2, 2, 4006, 4007, 3, 2, 2, 2, 4007, 4009, 3, 2, 2, 2, 4008, 4010, 5, 386, 194, 2, 4009, 4008, 3, 2, 2, 2, 4009, 4010, 3, 2, 2, 2, 4010, 4012, 3, 2, 2, 2, 4011, 4013, 5, 388, 195, 2, 4012, 4011, 3, 2, 2, 2, 4012, 4013, 3, 2, 2, 2, 4013, 385, 3, 2, 2, 2, 4014, 4015, 7, 102, 2, 2, 4015, 4016, 7, 4, 2, 2, 4016, 4017, 5, 1152, 577, 2, 4017, 4018, 7, 5, 2, 2, 4018, 387, 3, 2, 2, 2, 4019, 4020, 7, 107, 2, 2, 4020, 4021, 7, 44, 2, 2, 4021, 4022, 7, 4, 2, 2, 4022, 4023, 5, 1152, 577, 2, 4023, 4024, 7, 5, 2, 2, 4024, 389, 3, 2, 2, 2, 4025, 4026, 7, 96, 2, 2, 4026, 4027, 5, 1358, 680, 2, 4027, 391, 3, 2, 2, 2, 4028, 4029, 7, 96, 2, 2, 4029, 4030, 5, 1358, 680, 2, 4030, 393, 3, 2, 2, 2, 4031, 4032, 7, 38, 2, 2, 4032, 4033, 5, 1368, 685, 2, 4033, 395, 3, 2, 2, 2, 4034, 4035, 7, 64, 2, 2, 4035, 4036, 5, 398, 200, 2, 4036, 397, 3, 2, 2, 2, 4037, 4038, 9, 20, 2, 2, 4038, 399, 3, 2, 2, 2, 4039, 4040, 7, 48, 2, 2, 4040, 4041, 7, 133, 2, 2, 4041, 4042, 7, 439, 2, 2, 4042, 4043, 5, 1328, 665, 2, 4043, 4044, 7, 353, 2, 2, 4044, 4045, 5, 402, 202, 2, 4045, 4046, 7, 217, 2, 2, 4046, 4047, 5, 300, 151, 2, 4047, 401, 3, 2, 2, 2, 4048, 4049, 9, 21, 2, 2, 4049, 403, 3, 2, 2, 2, 4050, 4051, 7, 48, 2, 2, 4051, 4052, 7, 350, 2, 2, 4052, 4053, 5, 1328, 665, 2, 4053, 4054, 5, 406, 204, 2, 4054, 4055, 5, 408, 205, 2, 4055, 4056, 7, 82, 2, 2, 4056, 4058, 5, 1324, 663, 2, 4057, 4059, 5, 412, 207, 2, 4058, 4057, 3, 2, 2, 2, 4058, 4059, 3, 2, 2, 2, 4059, 4061, 3, 2, 2, 2, 4060, 4062, 5, 424, 213, 2, 4061, 4060, 3, 2, 2, 2, 4061, 4062, 3, 2, 2, 2, 4062, 4064, 3, 2, 2, 2, 4063, 4065, 5, 430, 216, 2, 4064, 4063, 3, 2, 2, 2, 4064, 4065, 3, 2, 2, 2, 4065, 4066, 3, 2, 2, 2, 4066, 4067, 7, 204, 2, 2, 4067, 4068, 5, 432, 217, 2, 4068, 4069, 5, 1334, 668, 2, 4069, 4070, 7, 4, 2, 2, 4070, 4071, 5, 434, 218, 2, 4071, 4072, 7, 5, 2, 2, 4072, 4099, 3, 2, 2, 2, 4073, 4074, 7, 48, 2, 2, 4074, 4075, 7, 47, 2, 2, 4075, 4076, 7, 350, 2, 2, 4076, 4077, 5, 1328, 665, 2, 4077, 4078, 7, 137, 2, 2, 4078, 4079, 5, 408, 205, 2, 4079, 4080, 7, 82, 2, 2, 4080, 4082, 5, 1324, 663, 2, 4081, 4083, 5, 438, 220, 2, 4082, 4081, 3, 2, 2, 2, 4082, 4083, 3, 2, 2, 2, 4083, 4084, 3, 2, 2, 2, 4084, 4085, 5, 440, 221, 2, 4085, 4086, 7, 64, 2, 2, 4086, 4087, 7, 194, 2, 2, 4087, 4089, 7, 407, 2, 2, 4088, 4090, 5, 430, 216, 2, 4089, 4088, 3, 2, 2, 2, 4089, 4090, 3, 2, 2, 2, 4090, 4091, 3, 2, 2, 2, 4091, 4092, 7, 204, 2, 2, 4092, 4093, 5, 432, 217, 2, 4093, 4094, 5, 1334, 668, 2, 4094, 4095, 7, 4, 2, 2, 4095, 4096, 5, 434, 218, 2, 4096, 4097, 7, 5, 2, 2, 4097, 4099, 3, 2, 2, 2, 4098, 4050, 3, 2, 2, 2, 4098, 4073, 3, 2, 2, 2, 4099, 405, 3, 2, 2, 2, 4100, 4105, 7, 147, 2, 2, 4101, 4105, 7, 137, 2, 2, 4102, 4103, 7, 235, 2, 2, 4103, 4105, 7, 268, 2, 2, 4104, 4100, 3, 2, 2, 2, 4104, 4101, 3, 2, 2, 2, 4104, 4102, 3, 2, 2, 2, 4105, 407, 3, 2, 2, 2, 4106, 4111, 5, 410, 206, 2, 4107, 4108, 7, 84, 2, 2, 4108, 4110, 5, 410, 206, 2, 4109, 4107, 3, 2, 2, 2, 4110, 4113, 3, 2, 2, 2, 4111, 4109, 3, 2, 2, 2, 4111, 4112, 3, 2, 2, 2, 4112, 409, 3, 2, 2, 2, 4113, 4111, 3, 2, 2, 2, 4114, 4122, 7, 234, 2, 2, 4115, 4122, 7, 184, 2, 2, 4116, 4122, 7, 362, 2, 2, 4117, 4118, 7, 362, 2, 2, 4118, 4119, 7, 268, 2, 2, 4119, 4122, 5, 216, 109, 2, 4120, 4122, 7, 351, 2, 2, 4121, 4114, 3, 2, 2, 2, 4121, 4115, 3, 2, 2, 2, 4121, 4116, 3, 2, 2, 2, 4121, 4117, 3, 2, 2, 2, 4121, 4120, 3, 2, 2, 2, 4122, 411, 3, 2, 2, 2, 4123, 4124, 7, 440, 2, 2, 4124, 4125, 5, 414, 208, 2, 4125, 413, 3, 2, 2, 2, 4126, 4128, 5, 416, 209, 2, 4127, 4126, 3, 2, 2, 2, 4128, 4129, 3, 2, 2, 2, 4129, 4127, 3, 2, 2, 2, 4129, 4130, 3, 2, 2, 2, 4130, 415, 3, 2, 2, 2, 4131, 4132, 5, 418, 210, 2, 4132, 4134, 5, 420, 211, 2, 4133, 4135, 5, 834, 418, 2, 4134, 4133, 3, 2, 2, 2, 4134, 4135, 3, 2, 2, 2, 4135, 4136, 3, 2, 2, 2, 4136, 4137, 5, 422, 212, 2, 4137, 417, 3, 2, 2, 2, 4138, 4139, 9, 22, 2, 2, 4139, 419, 3, 2, 2, 2, 4140, 4141, 9, 23, 2, 2, 4141, 421, 3, 2, 2, 2, 4142, 4143, 5, 1360, 681, 2, 4143, 423, 3, 2, 2, 2, 4144, 4146, 7, 64, 2, 2, 4145, 4147, 5, 426, 214, 2, 4146, 4145, 3, 2, 2, 2, 4146, 4147, 3, 2, 2, 2, 4147, 4148, 3, 2, 2, 2, 4148, 4149, 5, 428, 215, 2, 4149, 425, 3, 2, 2, 2, 4150, 4151, 7, 194, 2, 2, 4151, 427, 3, 2, 2, 2, 4152, 4153, 9, 24, 2, 2, 4153, 429, 3, 2, 2, 2, 4154, 4155, 7, 104, 2, 2, 4155, 4156, 7, 4, 2, 2, 4156, 4157, 5, 1152, 577, 2, 4157, 4158, 7, 5, 2, 2, 4158, 431, 3, 2, 2, 2, 4159, 4160, 9, 25, 2, 2, 4160, 433, 3, 2, 2, 2, 4161, 4164, 5, 436, 219, 2, 4162, 4164, 3, 2, 2, 2, 4163, 4161, 3, 2, 2, 2, 4163, 4162, 3, 2, 2, 2, 4164, 4169, 3, 2, 2, 2, 4165, 4166, 7, 8, 2, 2, 4166, 4168, 5, 436, 219, 2, 4167, 4165, 3, 2, 2, 2, 4168, 4171, 3, 2, 2, 2, 4169, 4167, 3, 2, 2, 2, 4169, 4170, 3, 2, 2, 2, 4170, 435, 3, 2, 2, 2, 4171, 4169, 3, 2, 2, 2, 4172, 4177, 5, 1344, 673, 2, 4173, 4177, 5, 1342, 672, 2, 4174, 4177, 5, 1346, 674, 2, 4175, 4177, 5, 1366, 684, 2, 4176, 4172, 3, 2, 2, 2, 4176, 4173, 3, 2, 2, 2, 4176, 4174, 3, 2, 2, 2, 4176, 4175, 3, 2, 2, 2, 4177, 437, 3, 2, 2, 2, 4178, 4179, 7, 66, 2, 2, 4179, 4180, 5, 1324, 663, 2, 4180, 439, 3, 2, 2, 2, 4181, 4183, 5, 442, 222, 2, 4182, 4181, 3, 2, 2, 2, 4183, 4186, 3, 2, 2, 2, 4184, 4182, 3, 2, 2, 2, 4184, 4185, 3, 2, 2, 2, 4185, 441, 3, 2, 2, 2, 4186, 4184, 3, 2, 2, 2, 4187, 4188, 7, 79, 2, 2, 4188, 4199, 7, 56, 2, 2, 4189, 4199, 7, 56, 2, 2, 4190, 4191, 7, 71, 2, 2, 4191, 4199, 7, 223, 2, 2, 4192, 4193, 7, 71, 2, 2, 4193, 4199, 7, 182, 2, 2, 4194, 4195, 7, 79, 2, 2, 4195, 4199, 7, 364, 2, 2, 4196, 4197, 7, 262, 2, 2, 4197, 4199, 7, 230, 2, 2, 4198, 4187, 3, 2, 2, 2, 4198, 4189, 3, 2, 2, 2, 4198, 4190, 3, 2, 2, 2, 4198, 4192, 3, 2, 2, 2, 4198, 4194, 3, 2, 2, 2, 4198, 4196, 3, 2, 2, 2, 4199, 443, 3, 2, 2, 2, 4200, 4201, 7, 48, 2, 2, 4201, 4202, 7, 200, 2, 2, 4202, 4203, 7, 350, 2, 2, 4203, 4204, 5, 1328, 665, 2, 4204, 4205, 7, 82, 2, 2, 4205, 4206, 5, 1366, 684, 2, 4206, 4207, 7, 204, 2, 2, 4207, 4208, 5, 432, 217, 2, 4208, 4209, 5, 1334, 668, 2, 4209, 4210, 7, 4, 2, 2, 4210, 4211, 7, 5, 2, 2, 4211, 4227, 3, 2, 2, 2, 4212, 4213, 7, 48, 2, 2, 4213, 4214, 7, 200, 2, 2, 4214, 4215, 7, 350, 2, 2, 4215, 4216, 5, 1328, 665, 2, 4216, 4217, 7, 82, 2, 2, 4217, 4218, 5, 1366, 684, 2, 4218, 4219, 7, 104, 2, 2, 4219, 4220, 5, 446, 224, 2, 4220, 4221, 7, 204, 2, 2, 4221, 4222, 5, 432, 217, 2, 4222, 4223, 5, 1334, 668, 2, 4223, 4224, 7, 4, 2, 2, 4224, 4225, 7, 5, 2, 2, 4225, 4227, 3, 2, 2, 2, 4226, 4200, 3, 2, 2, 2, 4226, 4212, 3, 2, 2, 2, 4227, 445, 3, 2, 2, 2, 4228, 4233, 5, 448, 225, 2, 4229, 4230, 7, 35, 2, 2, 4230, 4232, 5, 448, 225, 2, 4231, 4229, 3, 2, 2, 2, 4232, 4235, 3, 2, 2, 2, 4233, 4231, 3, 2, 2, 2, 4233, 4234, 3, 2, 2, 2, 4234, 447, 3, 2, 2, 2, 4235, 4233, 3, 2, 2, 2, 4236, 4237, 5, 1360, 681, 2, 4237, 4238, 7, 70, 2, 2, 4238, 4239, 7, 4, 2, 2, 4239, 4240, 5, 450, 226, 2, 4240, 4241, 7, 5, 2, 2, 4241, 449, 3, 2, 2, 2, 4242, 4247, 5, 1346, 674, 2, 4243, 4244, 7, 8, 2, 2, 4244, 4246, 5, 1346, 674, 2, 4245, 4243, 3, 2, 2, 2, 4246, 4249, 3, 2, 2, 2, 4247, 4245, 3, 2, 2, 2, 4247, 4248, 3, 2, 2, 2, 4248, 451, 3, 2, 2, 2, 4249, 4247, 3, 2, 2, 2, 4250, 4251, 7, 140, 2, 2, 4251, 4252, 7, 200, 2, 2, 4252, 4253, 7, 350, 2, 2, 4253, 4254, 5, 1328, 665, 2, 4254, 4255, 5, 454, 228, 2, 4255, 453, 3, 2, 2, 2, 4256, 4263, 7, 195, 2, 2, 4257, 4258, 7, 195, 2, 2, 4258, 4263, 7, 305, 2, 2, 4259, 4260, 7, 195, 2, 2, 4260, 4263, 7, 141, 2, 2, 4261, 4263, 7, 188, 2, 2, 4262, 4256, 3, 2, 2, 2, 4262, 4257, 3, 2, 2, 2, 4262, 4259, 3, 2, 2, 2, 4262, 4261, 3, 2, 2, 2, 4263, 455, 3, 2, 2, 2, 4264, 4265, 7, 48, 2, 2, 4265, 4266, 7, 142, 2, 2, 4266, 4267, 5, 524, 263, 2, 4267, 4268, 7, 44, 2, 2, 4268, 4269, 7, 4, 2, 2, 4269, 4270, 5, 1152, 577, 2, 4270, 4271, 7, 5, 2, 2, 4271, 4272, 5, 440, 221, 2, 4272, 457, 3, 2, 2, 2, 4273, 4275, 7, 48, 2, 2, 4274, 4276, 5, 618, 310, 2, 4275, 4274, 3, 2, 2, 2, 4275, 4276, 3, 2, 2, 2, 4276, 4277, 3, 2, 2, 2, 4277, 4278, 7, 138, 2, 2, 4278, 4279, 5, 1334, 668, 2, 4279, 4280, 5, 646, 324, 2, 4280, 4281, 5, 460, 231, 2, 4281, 4388, 3, 2, 2, 2, 4282, 4284, 7, 48, 2, 2, 4283, 4285, 5, 618, 310, 2, 4284, 4283, 3, 2, 2, 2, 4284, 4285, 3, 2, 2, 2, 4285, 4286, 3, 2, 2, 2, 4286, 4287, 7, 138, 2, 2, 4287, 4288, 5, 1334, 668, 2, 4288, 4289, 5, 468, 235, 2, 4289, 4388, 3, 2, 2, 2, 4290, 4291, 7, 48, 2, 2, 4291, 4292, 7, 271, 2, 2, 4292, 4293, 5, 684, 343, 2, 4293, 4294, 5, 460, 231, 2, 4294, 4388, 3, 2, 2, 2, 4295, 4296, 7, 48, 2, 2, 4296, 4297, 7, 353, 2, 2, 4297, 4298, 5, 524, 263, 2, 4298, 4299, 5, 460, 231, 2, 4299, 4388, 3, 2, 2, 2, 4300, 4301, 7, 48, 2, 2, 4301, 4302, 7, 353, 2, 2, 4302, 4388, 5, 524, 263, 2, 4303, 4304, 7, 48, 2, 2, 4304, 4305, 7, 353, 2, 2, 4305, 4306, 5, 524, 263, 2, 4306, 4307, 7, 38, 2, 2, 4307, 4309, 7, 4, 2, 2, 4308, 4310, 5, 1088, 545, 2, 4309, 4308, 3, 2, 2, 2, 4309, 4310, 3, 2, 2, 2, 4310, 4311, 3, 2, 2, 2, 4311, 4312, 7, 5, 2, 2, 4312, 4388, 3, 2, 2, 2, 4313, 4314, 7, 48, 2, 2, 4314, 4315, 7, 353, 2, 2, 4315, 4316, 5, 524, 263, 2, 4316, 4317, 7, 38, 2, 2, 4317, 4318, 7, 198, 2, 2, 4318, 4320, 7, 4, 2, 2, 4319, 4321, 5, 474, 238, 2, 4320, 4319, 3, 2, 2, 2, 4320, 4321, 3, 2, 2, 2, 4321, 4322, 3, 2, 2, 2, 4322, 4323, 7, 5, 2, 2, 4323, 4388, 3, 2, 2, 2, 4324, 4325, 7, 48, 2, 2, 4325, 4326, 7, 353, 2, 2, 4326, 4327, 5, 524, 263, 2, 4327, 4328, 7, 38, 2, 2, 4328, 4329, 7, 292, 2, 2, 4329, 4330, 5, 460, 231, 2, 4330, 4388, 3, 2, 2, 2, 4331, 4332, 7, 48, 2, 2, 4332, 4333, 7, 348, 2, 2, 4333, 4334, 7, 318, 2, 2, 4334, 4335, 7, 276, 2, 2, 4335, 4336, 5, 524, 263, 2, 4336, 4337, 5, 460, 231, 2, 4337, 4388, 3, 2, 2, 2, 4338, 4339, 7, 48, 2, 2, 4339, 4340, 7, 348, 2, 2, 4340, 4341, 7, 318, 2, 2, 4341, 4342, 7, 187, 2, 2, 4342, 4343, 5, 524, 263, 2, 4343, 4344, 5, 460, 231, 2, 4344, 4388, 3, 2, 2, 2, 4345, 4346, 7, 48, 2, 2, 4346, 4347, 7, 348, 2, 2, 4347, 4348, 7, 318, 2, 2, 4348, 4349, 7, 346, 2, 2, 4349, 4350, 5, 524, 263, 2, 4350, 4351, 5, 460, 231, 2, 4351, 4388, 3, 2, 2, 2, 4352, 4353, 7, 48, 2, 2, 4353, 4354, 7, 348, 2, 2, 4354, 4355, 7, 318, 2, 2, 4355, 4356, 7, 165, 2, 2, 4356, 4357, 5, 524, 263, 2, 4357, 4358, 5, 460, 231, 2, 4358, 4388, 3, 2, 2, 2, 4359, 4360, 7, 48, 2, 2, 4360, 4361, 7, 110, 2, 2, 4361, 4362, 5, 524, 263, 2, 4362, 4363, 5, 460, 231, 2, 4363, 4388, 3, 2, 2, 2, 4364, 4365, 7, 48, 2, 2, 4365, 4366, 7, 110, 2, 2, 4366, 4367, 7, 222, 2, 2, 4367, 4368, 7, 79, 2, 2, 4368, 4369, 7, 389, 2, 2, 4369, 4370, 5, 524, 263, 2, 4370, 4371, 5, 460, 231, 2, 4371, 4388, 3, 2, 2, 2, 4372, 4373, 7, 48, 2, 2, 4373, 4374, 7, 110, 2, 2, 4374, 4375, 5, 524, 263, 2, 4375, 4376, 7, 66, 2, 2, 4376, 4377, 5, 524, 263, 2, 4377, 4388, 3, 2, 2, 2, 4378, 4379, 7, 48, 2, 2, 4379, 4380, 7, 110, 2, 2, 4380, 4381, 7, 222, 2, 2, 4381, 4382, 7, 79, 2, 2, 4382, 4383, 7, 389, 2, 2, 4383, 4384, 5, 524, 263, 2, 4384, 4385, 7, 66, 2, 2, 4385, 4386, 5, 524, 263, 2, 4386, 4388, 3, 2, 2, 2, 4387, 4273, 3, 2, 2, 2, 4387, 4282, 3, 2, 2, 2, 4387, 4290, 3, 2, 2, 2, 4387, 4295, 3, 2, 2, 2, 4387, 4300, 3, 2, 2, 2, 4387, 4303, 3, 2, 2, 2, 4387, 4313, 3, 2, 2, 2, 4387, 4324, 3, 2, 2, 2, 4387, 4331, 3, 2, 2, 2, 4387, 4338, 3, 2, 2, 2, 4387, 4345, 3, 2, 2, 2, 4387, 4352, 3, 2, 2, 2, 4387, 4359, 3, 2, 2, 2, 4387, 4364, 3, 2, 2, 2, 4387, 4372, 3, 2, 2, 2, 4387, 4378, 3, 2, 2, 2, 4388, 459, 3, 2, 2, 2, 4389, 4390, 7, 4, 2, 2, 4390, 4391, 5, 462, 232, 2, 4391, 4392, 7, 5, 2, 2, 4392, 461, 3, 2, 2, 2, 4393, 4398, 5, 464, 233, 2, 4394, 4395, 7, 8, 2, 2, 4395, 4397, 5, 464, 233, 2, 4396, 4394, 3, 2, 2, 2, 4397, 4400, 3, 2, 2, 2, 4398, 4396, 3, 2, 2, 2, 4398, 4399, 3, 2, 2, 2, 4399, 463, 3, 2, 2, 2, 4400, 4398, 3, 2, 2, 2, 4401, 4404, 5, 1366, 684, 2, 4402, 4403, 7, 12, 2, 2, 4403, 4405, 5, 466, 234, 2, 4404, 4402, 3, 2, 2, 2, 4404, 4405, 3, 2, 2, 2, 4405, 465, 3, 2, 2, 2, 4406, 4413, 5, 640, 321, 2, 4407, 4413, 5, 1378, 690, 2, 4408, 4413, 5, 1264, 633, 2, 4409, 4413, 5, 292, 147, 2, 4410, 4413, 5, 1346, 674, 2, 4411, 4413, 7, 400, 2, 2, 4412, 4406, 3, 2, 2, 2, 4412, 4407, 3, 2, 2, 2, 4412, 4408, 3, 2, 2, 2, 4412, 4409, 3, 2, 2, 2, 4412, 4410, 3, 2, 2, 2, 4412, 4411, 3, 2, 2, 2, 4413, 467, 3, 2, 2, 2, 4414, 4415, 7, 4, 2, 2, 4415, 4416, 5, 470, 236, 2, 4416, 4417, 7, 5, 2, 2, 4417, 469, 3, 2, 2, 2, 4418, 4423, 5, 472, 237, 2, 4419, 4420, 7, 8, 2, 2, 4420, 4422, 5, 472, 237, 2, 4421, 4419, 3, 2, 2, 2, 4422, 4425, 3, 2, 2, 2, 4423, 4421, 3, 2, 2, 2, 4423, 4424, 3, 2, 2, 2, 4424, 471, 3, 2, 2, 2, 4425, 4423, 3, 2, 2, 2, 4426, 4427, 5, 1368, 685, 2, 4427, 4428, 7, 12, 2, 2, 4428, 4429, 5, 466, 234, 2, 4429, 473, 3, 2, 2, 2, 4430, 4431, 5, 476, 239, 2, 4431, 475, 3, 2, 2, 2, 4432, 4437, 5, 1346, 674, 2, 4433, 4434, 7, 8, 2, 2, 4434, 4436, 5, 1346, 674, 2, 4435, 4433, 3, 2, 2, 2, 4436, 4439, 3, 2, 2, 2, 4437, 4435, 3, 2, 2, 2, 4437, 4438, 3, 2, 2, 2, 4438, 477, 3, 2, 2, 2, 4439, 4437, 3, 2, 2, 2, 4440, 4441, 7, 140, 2, 2, 4441, 4442, 7, 353, 2, 2, 4442, 4443, 5, 524, 263, 2, 4443, 4444, 7, 135, 2, 2, 4444, 4446, 7, 443, 2, 2, 4445, 4447, 5, 480, 241, 2, 4446, 4445, 3, 2, 2, 2, 4446, 4447, 3, 2, 2, 2, 4447, 4448, 3, 2, 2, 2, 4448, 4449, 5, 1346, 674, 2, 4449, 4484, 3, 2, 2, 2, 4450, 4451, 7, 140, 2, 2, 4451, 4452, 7, 353, 2, 2, 4452, 4453, 5, 524, 263, 2, 4453, 4454, 7, 135, 2, 2, 4454, 4456, 7, 443, 2, 2, 4455, 4457, 5, 480, 241, 2, 4456, 4455, 3, 2, 2, 2, 4456, 4457, 3, 2, 2, 2, 4457, 4458, 3, 2, 2, 2, 4458, 4459, 5, 1346, 674, 2, 4459, 4460, 7, 147, 2, 2, 4460, 4461, 5, 1346, 674, 2, 4461, 4484, 3, 2, 2, 2, 4462, 4463, 7, 140, 2, 2, 4463, 4464, 7, 353, 2, 2, 4464, 4465, 5, 524, 263, 2, 4465, 4466, 7, 135, 2, 2, 4466, 4468, 7, 443, 2, 2, 4467, 4469, 5, 480, 241, 2, 4468, 4467, 3, 2, 2, 2, 4468, 4469, 3, 2, 2, 2, 4469, 4470, 3, 2, 2, 2, 4470, 4471, 5, 1346, 674, 2, 4471, 4472, 7, 137, 2, 2, 4472, 4473, 5, 1346, 674, 2, 4473, 4484, 3, 2, 2, 2, 4474, 4475, 7, 140, 2, 2, 4475, 4476, 7, 353, 2, 2, 4476, 4477, 5, 524, 263, 2, 4477, 4478, 7, 302, 2, 2, 4478, 4479, 7, 443, 2, 2, 4479, 4480, 5, 1346, 674, 2, 4480, 4481, 7, 96, 2, 2, 4481, 4482, 5, 1346, 674, 2, 4482, 4484, 3, 2, 2, 2, 4483, 4440, 3, 2, 2, 2, 4483, 4450, 3, 2, 2, 2, 4483, 4462, 3, 2, 2, 2, 4483, 4474, 3, 2, 2, 2, 4484, 479, 3, 2, 2, 2, 4485, 4486, 7, 222, 2, 2, 4486, 4487, 7, 79, 2, 2, 4487, 4488, 7, 389, 2, 2, 4488, 481, 3, 2, 2, 2, 4489, 4490, 7, 48, 2, 2, 4490, 4491, 7, 271, 2, 2, 4491, 4492, 7, 158, 2, 2, 4492, 4494, 5, 524, 263, 2, 4493, 4495, 5, 488, 245, 2, 4494, 4493, 3, 2, 2, 2, 4494, 4495, 3, 2, 2, 2, 4495, 4496, 3, 2, 2, 2, 4496, 4497, 7, 64, 2, 2, 4497, 4498, 7, 353, 2, 2, 4498, 4499, 5, 1108, 555, 2, 4499, 4500, 7, 102, 2, 2, 4500, 4502, 5, 1328, 665, 2, 4501, 4503, 5, 490, 246, 2, 4502, 4501, 3, 2, 2, 2, 4502, 4503, 3, 2, 2, 2, 4503, 4504, 3, 2, 2, 2, 4504, 4505, 7, 38, 2, 2, 4505, 4506, 5, 484, 243, 2, 4506, 483, 3, 2, 2, 2, 4507, 4512, 5, 486, 244, 2, 4508, 4509, 7, 8, 2, 2, 4509, 4511, 5, 486, 244, 2, 4510, 4508, 3, 2, 2, 2, 4511, 4514, 3, 2, 2, 2, 4512, 4510, 3, 2, 2, 2, 4512, 4513, 3, 2, 2, 2, 4513, 485, 3, 2, 2, 2, 4514, 4512, 3, 2, 2, 2, 4515, 4516, 7, 271, 2, 2, 4516, 4517, 5, 1344, 673, 2, 4517, 4519, 5, 684, 343, 2, 4518, 4520, 5, 492, 247, 2, 4519, 4518, 3, 2, 2, 2, 4519, 4520, 3, 2, 2, 2, 4520, 4522, 3, 2, 2, 2, 4521, 4523, 5, 494, 248, 2, 4522, 4521, 3, 2, 2, 2, 4522, 4523, 3, 2, 2, 2, 4523, 4547, 3, 2, 2, 2, 4524, 4525, 7, 271, 2, 2, 4525, 4526, 5, 1344, 673, 2, 4526, 4528, 5, 688, 345, 2, 4527, 4529, 5, 492, 247, 2, 4528, 4527, 3, 2, 2, 2, 4528, 4529, 3, 2, 2, 2, 4529, 4531, 3, 2, 2, 2, 4530, 4532, 5, 494, 248, 2, 4531, 4530, 3, 2, 2, 2, 4531, 4532, 3, 2, 2, 2, 4532, 4547, 3, 2, 2, 2, 4533, 4534, 7, 213, 2, 2, 4534, 4535, 5, 1344, 673, 2, 4535, 4536, 5, 626, 314, 2, 4536, 4547, 3, 2, 2, 2, 4537, 4538, 7, 213, 2, 2, 4538, 4539, 5, 1344, 673, 2, 4539, 4540, 7, 4, 2, 2, 4540, 4541, 5, 1274, 638, 2, 4541, 4542, 7, 5, 2, 2, 4542, 4543, 5, 626, 314, 2, 4543, 4547, 3, 2, 2, 2, 4544, 4545, 7, 338, 2, 2, 4545, 4547, 5, 1108, 555, 2, 4546, 4515, 3, 2, 2, 2, 4546, 4524, 3, 2, 2, 2, 4546, 4533, 3, 2, 2, 2, 4546, 4537, 3, 2, 2, 2, 4546, 4544, 3, 2, 2, 2, 4547, 487, 3, 2, 2, 2, 4548, 4549, 7, 55, 2, 2, 4549, 489, 3, 2, 2, 2, 4550, 4551, 7, 208, 2, 2, 4551, 4552, 5, 524, 263, 2, 4552, 491, 3, 2, 2, 2, 4553, 4554, 7, 64, 2, 2, 4554, 4560, 7, 318, 2, 2, 4555, 4556, 7, 64, 2, 2, 4556, 4557, 7, 85, 2, 2, 4557, 4558, 7, 149, 2, 2, 4558, 4560, 5, 524, 263, 2, 4559, 4553, 3, 2, 2, 2, 4559, 4555, 3, 2, 2, 2, 4560, 493, 3, 2, 2, 2, 4561, 4562, 7, 295, 2, 2, 4562, 495, 3, 2, 2, 2, 4563, 4564, 7, 48, 2, 2, 4564, 4565, 7, 271, 2, 2, 4565, 4566, 7, 208, 2, 2, 4566, 4567, 5, 524, 263, 2, 4567, 4568, 7, 102, 2, 2, 4568, 4569, 5, 1328, 665, 2, 4569, 497, 3, 2, 2, 2, 4570, 4571, 7, 140, 2, 2, 4571, 4572, 7, 271, 2, 2, 4572, 4573, 7, 208, 2, 2, 4573, 4574, 5, 524, 263, 2, 4574, 4575, 7, 102, 2, 2, 4575, 4576, 5, 1328, 665, 2, 4576, 4577, 7, 135, 2, 2, 4577, 4578, 5, 484, 243, 2, 4578, 4589, 3, 2, 2, 2, 4579, 4580, 7, 140, 2, 2, 4580, 4581, 7, 271, 2, 2, 4581, 4582, 7, 208, 2, 2, 4582, 4583, 5, 524, 263, 2, 4583, 4584, 7, 102, 2, 2, 4584, 4585, 5, 1328, 665, 2, 4585, 4586, 7, 193, 2, 2, 4586, 4587, 5, 500, 251, 2, 4587, 4589, 3, 2, 2, 2, 4588, 4570, 3, 2, 2, 2, 4588, 4579, 3, 2, 2, 2, 4589, 499, 3, 2, 2, 2, 4590, 4595, 5, 502, 252, 2, 4591, 4592, 7, 8, 2, 2, 4592, 4594, 5, 502, 252, 2, 4593, 4591, 3, 2, 2, 2, 4594, 4597, 3, 2, 2, 2, 4595, 4593, 3, 2, 2, 2, 4595, 4596, 3, 2, 2, 2, 4596, 501, 3, 2, 2, 2, 4597, 4595, 3, 2, 2, 2, 4598, 4599, 7, 271, 2, 2, 4599, 4600, 5, 1344, 673, 2, 4600, 4601, 7, 4, 2, 2, 4601, 4602, 5, 1274, 638, 2, 4602, 4603, 7, 5, 2, 2, 4603, 4611, 3, 2, 2, 2, 4604, 4605, 7, 213, 2, 2, 4605, 4606, 5, 1344, 673, 2, 4606, 4607, 7, 4, 2, 2, 4607, 4608, 5, 1274, 638, 2, 4608, 4609, 7, 5, 2, 2, 4609, 4611, 3, 2, 2, 2, 4610, 4598, 3, 2, 2, 2, 4610, 4604, 3, 2, 2, 2, 4611, 503, 3, 2, 2, 2, 4612, 4613, 7, 193, 2, 2, 4613, 4614, 7, 271, 2, 2, 4614, 4615, 7, 158, 2, 2, 4615, 4616, 5, 524, 263, 2, 4616, 4617, 7, 102, 2, 2, 4617, 4619, 5, 1328, 665, 2, 4618, 4620, 5, 108, 55, 2, 4619, 4618, 3, 2, 2, 2, 4619, 4620, 3, 2, 2, 2, 4620, 4633, 3, 2, 2, 2, 4621, 4622, 7, 193, 2, 2, 4622, 4623, 7, 271, 2, 2, 4623, 4624, 7, 158, 2, 2, 4624, 4625, 7, 222, 2, 2, 4625, 4626, 7, 389, 2, 2, 4626, 4627, 5, 524, 263, 2, 4627, 4628, 7, 102, 2, 2, 4628, 4630, 5, 1328, 665, 2, 4629, 4631, 5, 108, 55, 2, 4630, 4629, 3, 2, 2, 2, 4630, 4631, 3, 2, 2, 2, 4631, 4633, 3, 2, 2, 2, 4632, 4612, 3, 2, 2, 2, 4632, 4621, 3, 2, 2, 2, 4633, 505, 3, 2, 2, 2, 4634, 4635, 7, 193, 2, 2, 4635, 4636, 7, 271, 2, 2, 4636, 4637, 7, 208, 2, 2, 4637, 4638, 5, 524, 263, 2, 4638, 4639, 7, 102, 2, 2, 4639, 4641, 5, 1328, 665, 2, 4640, 4642, 5, 108, 55, 2, 4641, 4640, 3, 2, 2, 2, 4641, 4642, 3, 2, 2, 2, 4642, 4655, 3, 2, 2, 2, 4643, 4644, 7, 193, 2, 2, 4644, 4645, 7, 271, 2, 2, 4645, 4646, 7, 208, 2, 2, 4646, 4647, 7, 222, 2, 2, 4647, 4648, 7, 389, 2, 2, 4648, 4649, 5, 524, 263, 2, 4649, 4650, 7, 102, 2, 2, 4650, 4652, 5, 1328, 665, 2, 4651, 4653, 5, 108, 55, 2, 4652, 4651, 3, 2, 2, 2, 4652, 4653, 3, 2, 2, 2, 4653, 4655, 3, 2, 2, 2, 4654, 4634, 3, 2, 2, 2, 4654, 4643, 3, 2, 2, 2, 4655, 507, 3, 2, 2, 2, 4656, 4657, 7, 193, 2, 2, 4657, 4658, 7, 274, 2, 2, 4658, 4659, 7, 149, 2, 2, 4659, 4661, 5, 1358, 680, 2, 4660, 4662, 5, 108, 55, 2, 4661, 4660, 3, 2, 2, 2, 4661, 4662, 3, 2, 2, 2, 4662, 509, 3, 2, 2, 2, 4663, 4664, 7, 294, 2, 2, 4664, 4665, 7, 274, 2, 2, 4665, 4666, 7, 149, 2, 2, 4666, 4667, 5, 1358, 680, 2, 4667, 4668, 7, 96, 2, 2, 4668, 4669, 5, 1356, 679, 2, 4669, 511, 3, 2, 2, 2, 4670, 4671, 7, 193, 2, 2, 4671, 4672, 5, 514, 258, 2, 4672, 4673, 7, 222, 2, 2, 4673, 4674, 7, 389, 2, 2, 4674, 4676, 5, 522, 262, 2, 4675, 4677, 5, 108, 55, 2, 4676, 4675, 3, 2, 2, 2, 4676, 4677, 3, 2, 2, 2, 4677, 4761, 3, 2, 2, 2, 4678, 4679, 7, 193, 2, 2, 4679, 4680, 5, 514, 258, 2, 4680, 4682, 5, 522, 262, 2, 4681, 4683, 5, 108, 55, 2, 4682, 4681, 3, 2, 2, 2, 4682, 4683, 3, 2, 2, 2, 4683, 4761, 3, 2, 2, 2, 4684, 4685, 7, 193, 2, 2, 4685, 4686, 5, 518, 260, 2, 4686, 4687, 7, 222, 2, 2, 4687, 4688, 7, 389, 2, 2, 4688, 4690, 5, 1326, 664, 2, 4689, 4691, 5, 108, 55, 2, 4690, 4689, 3, 2, 2, 2, 4690, 4691, 3, 2, 2, 2, 4691, 4761, 3, 2, 2, 2, 4692, 4693, 7, 193, 2, 2, 4693, 4694, 5, 518, 260, 2, 4694, 4696, 5, 1326, 664, 2, 4695, 4697, 5, 108, 55, 2, 4696, 4695, 3, 2, 2, 2, 4696, 4697, 3, 2, 2, 2, 4697, 4761, 3, 2, 2, 2, 4698, 4699, 7, 193, 2, 2, 4699, 4700, 5, 520, 261, 2, 4700, 4701, 5, 1328, 665, 2, 4701, 4702, 7, 82, 2, 2, 4702, 4704, 5, 524, 263, 2, 4703, 4705, 5, 108, 55, 2, 4704, 4703, 3, 2, 2, 2, 4704, 4705, 3, 2, 2, 2, 4705, 4761, 3, 2, 2, 2, 4706, 4707, 7, 193, 2, 2, 4707, 4708, 5, 520, 261, 2, 4708, 4709, 7, 222, 2, 2, 4709, 4710, 7, 389, 2, 2, 4710, 4711, 5, 1328, 665, 2, 4711, 4712, 7, 82, 2, 2, 4712, 4714, 5, 524, 263, 2, 4713, 4715, 5, 108, 55, 2, 4714, 4713, 3, 2, 2, 2, 4714, 4715, 3, 2, 2, 2, 4715, 4761, 3, 2, 2, 2, 4716, 4717, 7, 193, 2, 2, 4717, 4718, 7, 353, 2, 2, 4718, 4720, 5, 528, 265, 2, 4719, 4721, 5, 108, 55, 2, 4720, 4719, 3, 2, 2, 2, 4720, 4721, 3, 2, 2, 2, 4721, 4761, 3, 2, 2, 2, 4722, 4723, 7, 193, 2, 2, 4723, 4724, 7, 353, 2, 2, 4724, 4725, 7, 222, 2, 2, 4725, 4726, 7, 389, 2, 2, 4726, 4728, 5, 528, 265, 2, 4727, 4729, 5, 108, 55, 2, 4728, 4727, 3, 2, 2, 2, 4728, 4729, 3, 2, 2, 2, 4729, 4761, 3, 2, 2, 2, 4730, 4731, 7, 193, 2, 2, 4731, 4732, 7, 191, 2, 2, 4732, 4734, 5, 528, 265, 2, 4733, 4735, 5, 108, 55, 2, 4734, 4733, 3, 2, 2, 2, 4734, 4735, 3, 2, 2, 2, 4735, 4761, 3, 2, 2, 2, 4736, 4737, 7, 193, 2, 2, 4737, 4738, 7, 191, 2, 2, 4738, 4739, 7, 222, 2, 2, 4739, 4740, 7, 389, 2, 2, 4740, 4742, 5, 528, 265, 2, 4741, 4743, 5, 108, 55, 2, 4742, 4741, 3, 2, 2, 2, 4742, 4743, 3, 2, 2, 2, 4743, 4761, 3, 2, 2, 2, 4744, 4745, 7, 193, 2, 2, 4745, 4746, 7, 228, 2, 2, 4746, 4747, 7, 111, 2, 2, 4747, 4749, 5, 522, 262, 2, 4748, 4750, 5, 108, 55, 2, 4749, 4748, 3, 2, 2, 2, 4749, 4750, 3, 2, 2, 2, 4750, 4761, 3, 2, 2, 2, 4751, 4752, 7, 193, 2, 2, 4752, 4753, 7, 228, 2, 2, 4753, 4754, 7, 111, 2, 2, 4754, 4755, 7, 222, 2, 2, 4755, 4756, 7, 389, 2, 2, 4756, 4758, 5, 522, 262, 2, 4757, 4759, 5, 108, 55, 2, 4758, 4757, 3, 2, 2, 2, 4758, 4759, 3, 2, 2, 2, 4759, 4761, 3, 2, 2, 2, 4760, 4670, 3, 2, 2, 2, 4760, 4678, 3, 2, 2, 2, 4760, 4684, 3, 2, 2, 2, 4760, 4692, 3, 2, 2, 2, 4760, 4698, 3, 2, 2, 2, 4760, 4706, 3, 2, 2, 2, 4760, 4716, 3, 2, 2, 2, 4760, 4722, 3, 2, 2, 2, 4760, 4730, 3, 2, 2, 2, 4760, 4736, 3, 2, 2, 2, 4760, 4744, 3, 2, 2, 2, 4760, 4751, 3, 2, 2, 2, 4761, 513, 3, 2, 2, 2, 4762, 4786, 7, 94, 2, 2, 4763, 4786, 7, 321, 2, 2, 4764, 4786, 7, 369, 2, 2, 4765, 4766, 7, 252, 2, 2, 4766, 4786, 7, 369, 2, 2, 4767, 4786, 7, 228, 2, 2, 4768, 4769, 7, 65, 2, 2, 4769, 4786, 7, 94, 2, 2, 4770, 4786, 7, 110, 2, 2, 4771, 4786, 7, 170, 2, 2, 4772, 4786, 7, 335, 2, 2, 4773, 4774, 7, 348, 2, 2, 4774, 4775, 7, 318, 2, 2, 4775, 4786, 7, 276, 2, 2, 4776, 4777, 7, 348, 2, 2, 4777, 4778, 7, 318, 2, 2, 4778, 4786, 7, 187, 2, 2, 4779, 4780, 7, 348, 2, 2, 4780, 4781, 7, 318, 2, 2, 4781, 4786, 7, 346, 2, 2, 4782, 4783, 7, 348, 2, 2, 4783, 4784, 7, 318, 2, 2, 4784, 4786, 7, 165, 2, 2, 4785, 4762, 3, 2, 2, 2, 4785, 4763, 3, 2, 2, 2, 4785, 4764, 3, 2, 2, 2, 4785, 4765, 3, 2, 2, 2, 4785, 4767, 3, 2, 2, 2, 4785, 4768, 3, 2, 2, 2, 4785, 4770, 3, 2, 2, 2, 4785, 4771, 3, 2, 2, 2, 4785, 4772, 3, 2, 2, 2, 4785, 4773, 3, 2, 2, 2, 4785, 4776, 3, 2, 2, 2, 4785, 4779, 3, 2, 2, 2, 4785, 4782, 3, 2, 2, 2, 4786, 515, 3, 2, 2, 2, 4787, 4793, 5, 518, 260, 2, 4788, 4793, 7, 177, 2, 2, 4789, 4793, 7, 311, 2, 2, 4790, 4793, 7, 444, 2, 2, 4791, 4793, 7, 344, 2, 2, 4792, 4787, 3, 2, 2, 2, 4792, 4788, 3, 2, 2, 2, 4792, 4789, 3, 2, 2, 2, 4792, 4790, 3, 2, 2, 2, 4792, 4791, 3, 2, 2, 2, 4793, 517, 3, 2, 2, 2, 4794, 4795, 7, 133, 2, 2, 4795, 4810, 7, 439, 2, 2, 4796, 4797, 7, 200, 2, 2, 4797, 4810, 7, 350, 2, 2, 4798, 4810, 7, 206, 2, 2, 4799, 4800, 7, 65, 2, 2, 4800, 4801, 7, 176, 2, 2, 4801, 4810, 7, 374, 2, 2, 4802, 4804, 5, 308, 155, 2, 4803, 4802, 3, 2, 2, 2, 4803, 4804, 3, 2, 2, 2, 4804, 4805, 3, 2, 2, 2, 4805, 4810, 7, 240, 2, 2, 4806, 4810, 7, 445, 2, 2, 4807, 4810, 7, 316, 2, 2, 4808, 4810, 7, 324, 2, 2, 4809, 4794, 3, 2, 2, 2, 4809, 4796, 3, 2, 2, 2, 4809, 4798, 3, 2, 2, 2, 4809, 4799, 3, 2, 2, 2, 4809, 4803, 3, 2, 2, 2, 4809, 4806, 3, 2, 2, 2, 4809, 4807, 3, 2, 2, 2, 4809, 4808, 3, 2, 2, 2, 4810, 519, 3, 2, 2, 2, 4811, 4812, 9, 26, 2, 2, 4812, 521, 3, 2, 2, 2, 4813, 4818, 5, 524, 263, 2, 4814, 4815, 7, 8, 2, 2, 4815, 4817, 5, 524, 263, 2, 4816, 4814, 3, 2, 2, 2, 4817, 4820, 3, 2, 2, 2, 4818, 4816, 3, 2, 2, 2, 4818, 4819, 3, 2, 2, 2, 4819, 523, 3, 2, 2, 2, 4820, 4818, 3, 2, 2, 2, 4821, 4823, 5, 1360, 681, 2, 4822, 4824, 5, 526, 264, 2, 4823, 4822, 3, 2, 2, 2, 4823, 4824, 3, 2, 2, 2, 4824, 525, 3, 2, 2, 2, 4825, 4826, 7, 13, 2, 2, 4826, 4828, 5, 1330, 666, 2, 4827, 4825, 3, 2, 2, 2, 4828, 4829, 3, 2, 2, 2, 4829, 4827, 3, 2, 2, 2, 4829, 4830, 3, 2, 2, 2, 4830, 527, 3, 2, 2, 2, 4831, 4836, 5, 1108, 555, 2, 4832, 4833, 7, 8, 2, 2, 4833, 4835, 5, 1108, 555, 2, 4834, 4832, 3, 2, 2, 2, 4835, 4838, 3, 2, 2, 2, 4836, 4834, 3, 2, 2, 2, 4836, 4837, 3, 2, 2, 2, 4837, 529, 3, 2, 2, 2, 4838, 4836, 3, 2, 2, 2, 4839, 4841, 7, 351, 2, 2, 4840, 4842, 5, 982, 492, 2, 4841, 4840, 3, 2, 2, 2, 4841, 4842, 3, 2, 2, 2, 4842, 4843, 3, 2, 2, 2, 4843, 4845, 5, 1066, 534, 2, 4844, 4846, 5, 532, 267, 2, 4845, 4844, 3, 2, 2, 2, 4845, 4846, 3, 2, 2, 2, 4846, 4848, 3, 2, 2, 2, 4847, 4849, 5, 108, 55, 2, 4848, 4847, 3, 2, 2, 2, 4848, 4849, 3, 2, 2, 2, 4849, 531, 3, 2, 2, 2, 4850, 4851, 7, 169, 2, 2, 4851, 4855, 7, 221, 2, 2, 4852, 4853, 7, 307, 2, 2, 4853, 4855, 7, 221, 2, 2, 4854, 4850, 3, 2, 2, 2, 4854, 4852, 3, 2, 2, 2, 4855, 533, 3, 2, 2, 2, 4856, 4857, 7, 161, 2, 2, 4857, 4858, 7, 82, 2, 2, 4858, 4859, 5, 514, 258, 2, 4859, 4860, 5, 524, 263, 2, 4860, 4861, 7, 118, 2, 2, 4861, 4862, 5, 536, 269, 2, 4862, 5004, 3, 2, 2, 2, 4863, 4864, 7, 161, 2, 2, 4864, 4865, 7, 82, 2, 2, 4865, 4866, 7, 46, 2, 2, 4866, 4867, 5, 524, 263, 2, 4867, 4868, 7, 118, 2, 2, 4868, 4869, 5, 536, 269, 2, 4869, 5004, 3, 2, 2, 2, 4870, 4871, 7, 161, 2, 2, 4871, 4872, 7, 82, 2, 2, 4872, 4873, 5, 516, 259, 2, 4873, 4874, 5, 1328, 665, 2, 4874, 4875, 7, 118, 2, 2, 4875, 4876, 5, 536, 269, 2, 4876, 5004, 3, 2, 2, 2, 4877, 4878, 7, 161, 2, 2, 4878, 4879, 7, 82, 2, 2, 4879, 4880, 7, 353, 2, 2, 4880, 4881, 5, 1108, 555, 2, 4881, 4882, 7, 118, 2, 2, 4882, 4883, 5, 536, 269, 2, 4883, 5004, 3, 2, 2, 2, 4884, 4885, 7, 161, 2, 2, 4885, 4886, 7, 82, 2, 2, 4886, 4887, 7, 191, 2, 2, 4887, 4888, 5, 1108, 555, 2, 4888, 4889, 7, 118, 2, 2, 4889, 4890, 5, 536, 269, 2, 4890, 5004, 3, 2, 2, 2, 4891, 4892, 7, 161, 2, 2, 4892, 4893, 7, 82, 2, 2, 4893, 4894, 7, 138, 2, 2, 4894, 4895, 5, 650, 326, 2, 4895, 4896, 7, 118, 2, 2, 4896, 4897, 5, 536, 269, 2, 4897, 5004, 3, 2, 2, 2, 4898, 4899, 7, 161, 2, 2, 4899, 4900, 7, 82, 2, 2, 4900, 4901, 7, 213, 2, 2, 4901, 4902, 5, 626, 314, 2, 4902, 4903, 7, 118, 2, 2, 4903, 4904, 5, 536, 269, 2, 4904, 5004, 3, 2, 2, 2, 4905, 4906, 7, 161, 2, 2, 4906, 4907, 7, 82, 2, 2, 4907, 4908, 7, 271, 2, 2, 4908, 4909, 5, 688, 345, 2, 4909, 4910, 7, 118, 2, 2, 4910, 4911, 5, 536, 269, 2, 4911, 5004, 3, 2, 2, 2, 4912, 4913, 7, 161, 2, 2, 4913, 4914, 7, 82, 2, 2, 4914, 4915, 7, 47, 2, 2, 4915, 4916, 5, 1328, 665, 2, 4916, 4917, 7, 82, 2, 2, 4917, 4918, 5, 524, 263, 2, 4918, 4919, 7, 118, 2, 2, 4919, 4920, 5, 536, 269, 2, 4920, 5004, 3, 2, 2, 2, 4921, 4922, 7, 161, 2, 2, 4922, 4923, 7, 82, 2, 2, 4923, 4924, 7, 47, 2, 2, 4924, 4925, 5, 1328, 665, 2, 4925, 4926, 7, 82, 2, 2, 4926, 4927, 7, 191, 2, 2, 4927, 4928, 5, 524, 263, 2, 4928, 4929, 7, 118, 2, 2, 4929, 4930, 5, 536, 269, 2, 4930, 5004, 3, 2, 2, 2, 4931, 4932, 7, 161, 2, 2, 4932, 4933, 7, 82, 2, 2, 4933, 4934, 5, 520, 261, 2, 4934, 4935, 5, 1328, 665, 2, 4935, 4936, 7, 82, 2, 2, 4936, 4937, 5, 524, 263, 2, 4937, 4938, 7, 118, 2, 2, 4938, 4939, 5, 536, 269, 2, 4939, 5004, 3, 2, 2, 2, 4940, 4941, 7, 161, 2, 2, 4941, 4942, 7, 82, 2, 2, 4942, 4943, 7, 289, 2, 2, 4943, 4944, 5, 626, 314, 2, 4944, 4945, 7, 118, 2, 2, 4945, 4946, 5, 536, 269, 2, 4946, 5004, 3, 2, 2, 2, 4947, 4948, 7, 161, 2, 2, 4948, 4949, 7, 82, 2, 2, 4949, 4950, 7, 435, 2, 2, 4950, 4951, 5, 626, 314, 2, 4951, 4952, 7, 118, 2, 2, 4952, 4953, 5, 536, 269, 2, 4953, 5004, 3, 2, 2, 2, 4954, 4955, 7, 161, 2, 2, 4955, 4956, 7, 82, 2, 2, 4956, 4957, 7, 436, 2, 2, 4957, 4958, 7, 64, 2, 2, 4958, 4959, 5, 1108, 555, 2, 4959, 4960, 7, 240, 2, 2, 4960, 4961, 5, 1328, 665, 2, 4961, 4962, 7, 118, 2, 2, 4962, 4963, 5, 536, 269, 2, 4963, 5004, 3, 2, 2, 2, 4964, 4965, 7, 161, 2, 2, 4965, 4966, 7, 82, 2, 2, 4966, 4967, 7, 271, 2, 2, 4967, 4968, 7, 158, 2, 2, 4968, 4969, 5, 524, 263, 2, 4969, 4970, 7, 102, 2, 2, 4970, 4971, 5, 1328, 665, 2, 4971, 4972, 7, 118, 2, 2, 4972, 4973, 5, 536, 269, 2, 4973, 5004, 3, 2, 2, 2, 4974, 4975, 7, 161, 2, 2, 4975, 4976, 7, 82, 2, 2, 4976, 4977, 7, 271, 2, 2, 4977, 4978, 7, 208, 2, 2, 4978, 4979, 5, 524, 263, 2, 4979, 4980, 7, 102, 2, 2, 4980, 4981, 5, 1328, 665, 2, 4981, 4982, 7, 118, 2, 2, 4982, 4983, 5, 536, 269, 2, 4983, 5004, 3, 2, 2, 2, 4984, 4985, 7, 161, 2, 2, 4985, 4986, 7, 82, 2, 2, 4986, 4987, 7, 241, 2, 2, 4987, 4988, 7, 267, 2, 2, 4988, 4989, 5, 292, 147, 2, 4989, 4990, 7, 118, 2, 2, 4990, 4991, 5, 536, 269, 2, 4991, 5004, 3, 2, 2, 2, 4992, 4993, 7, 161, 2, 2, 4993, 4994, 7, 82, 2, 2, 4994, 4995, 7, 43, 2, 2, 4995, 4996, 7, 4, 2, 2, 4996, 4997, 5, 1108, 555, 2, 4997, 4998, 7, 38, 2, 2, 4998, 4999, 5, 1108, 555, 2, 4999, 5000, 7, 5, 2, 2, 5000, 5001, 7, 118, 2, 2, 5001, 5002, 5, 536, 269, 2, 5002, 5004, 3, 2, 2, 2, 5003, 4856, 3, 2, 2, 2, 5003, 4863, 3, 2, 2, 2, 5003, 4870, 3, 2, 2, 2, 5003, 4877, 3, 2, 2, 2, 5003, 4884, 3, 2, 2, 2, 5003, 4891, 3, 2, 2, 2, 5003, 4898, 3, 2, 2, 2, 5003, 4905, 3, 2, 2, 2, 5003, 4912, 3, 2, 2, 2, 5003, 4921, 3, 2, 2, 2, 5003, 4931, 3, 2, 2, 2, 5003, 4940, 3, 2, 2, 2, 5003, 4947, 3, 2, 2, 2, 5003, 4954, 3, 2, 2, 2, 5003, 4964, 3, 2, 2, 2, 5003, 4974, 3, 2, 2, 2, 5003, 4984, 3, 2, 2, 2, 5003, 4992, 3, 2, 2, 2, 5004, 535, 3, 2, 2, 2, 5005, 5008, 5, 1346, 674, 2, 5006, 5008, 7, 80, 2, 2, 5007, 5005, 3, 2, 2, 2, 5007, 5006, 3, 2, 2, 2, 5008, 537, 3, 2, 2, 2, 5009, 5010, 7, 320, 2, 2, 5010, 5012, 7, 239, 2, 2, 5011, 5013, 5, 540, 271, 2, 5012, 5011, 3, 2, 2, 2, 5012, 5013, 3, 2, 2, 2, 5013, 5014, 3, 2, 2, 2, 5014, 5015, 7, 82, 2, 2, 5015, 5016, 5, 514, 258, 2, 5016, 5017, 5, 524, 263, 2, 5017, 5018, 7, 118, 2, 2, 5018, 5019, 5, 542, 272, 2, 5019, 5121, 3, 2, 2, 2, 5020, 5021, 7, 320, 2, 2, 5021, 5023, 7, 239, 2, 2, 5022, 5024, 5, 540, 271, 2, 5023, 5022, 3, 2, 2, 2, 5023, 5024, 3, 2, 2, 2, 5024, 5025, 3, 2, 2, 2, 5025, 5026, 7, 82, 2, 2, 5026, 5027, 7, 46, 2, 2, 5027, 5028, 5, 524, 263, 2, 5028, 5029, 7, 118, 2, 2, 5029, 5030, 5, 542, 272, 2, 5030, 5121, 3, 2, 2, 2, 5031, 5032, 7, 320, 2, 2, 5032, 5034, 7, 239, 2, 2, 5033, 5035, 5, 540, 271, 2, 5034, 5033, 3, 2, 2, 2, 5034, 5035, 3, 2, 2, 2, 5035, 5036, 3, 2, 2, 2, 5036, 5037, 7, 82, 2, 2, 5037, 5038, 5, 516, 259, 2, 5038, 5039, 5, 1328, 665, 2, 5039, 5040, 7, 118, 2, 2, 5040, 5041, 5, 542, 272, 2, 5041, 5121, 3, 2, 2, 2, 5042, 5043, 7, 320, 2, 2, 5043, 5045, 7, 239, 2, 2, 5044, 5046, 5, 540, 271, 2, 5045, 5044, 3, 2, 2, 2, 5045, 5046, 3, 2, 2, 2, 5046, 5047, 3, 2, 2, 2, 5047, 5048, 7, 82, 2, 2, 5048, 5049, 7, 353, 2, 2, 5049, 5050, 5, 1108, 555, 2, 5050, 5051, 7, 118, 2, 2, 5051, 5052, 5, 542, 272, 2, 5052, 5121, 3, 2, 2, 2, 5053, 5054, 7, 320, 2, 2, 5054, 5056, 7, 239, 2, 2, 5055, 5057, 5, 540, 271, 2, 5056, 5055, 3, 2, 2, 2, 5056, 5057, 3, 2, 2, 2, 5057, 5058, 3, 2, 2, 2, 5058, 5059, 7, 82, 2, 2, 5059, 5060, 7, 191, 2, 2, 5060, 5061, 5, 1108, 555, 2, 5061, 5062, 7, 118, 2, 2, 5062, 5063, 5, 542, 272, 2, 5063, 5121, 3, 2, 2, 2, 5064, 5065, 7, 320, 2, 2, 5065, 5067, 7, 239, 2, 2, 5066, 5068, 5, 540, 271, 2, 5067, 5066, 3, 2, 2, 2, 5067, 5068, 3, 2, 2, 2, 5068, 5069, 3, 2, 2, 2, 5069, 5070, 7, 82, 2, 2, 5070, 5071, 7, 138, 2, 2, 5071, 5072, 5, 650, 326, 2, 5072, 5073, 7, 118, 2, 2, 5073, 5074, 5, 542, 272, 2, 5074, 5121, 3, 2, 2, 2, 5075, 5076, 7, 320, 2, 2, 5076, 5078, 7, 239, 2, 2, 5077, 5079, 5, 540, 271, 2, 5078, 5077, 3, 2, 2, 2, 5078, 5079, 3, 2, 2, 2, 5079, 5080, 3, 2, 2, 2, 5080, 5081, 7, 82, 2, 2, 5081, 5082, 7, 213, 2, 2, 5082, 5083, 5, 626, 314, 2, 5083, 5084, 7, 118, 2, 2, 5084, 5085, 5, 542, 272, 2, 5085, 5121, 3, 2, 2, 2, 5086, 5087, 7, 320, 2, 2, 5087, 5089, 7, 239, 2, 2, 5088, 5090, 5, 540, 271, 2, 5089, 5088, 3, 2, 2, 2, 5089, 5090, 3, 2, 2, 2, 5090, 5091, 3, 2, 2, 2, 5091, 5092, 7, 82, 2, 2, 5092, 5093, 7, 241, 2, 2, 5093, 5094, 7, 267, 2, 2, 5094, 5095, 5, 292, 147, 2, 5095, 5096, 7, 118, 2, 2, 5096, 5097, 5, 542, 272, 2, 5097, 5121, 3, 2, 2, 2, 5098, 5099, 7, 320, 2, 2, 5099, 5101, 7, 239, 2, 2, 5100, 5102, 5, 540, 271, 2, 5101, 5100, 3, 2, 2, 2, 5101, 5102, 3, 2, 2, 2, 5102, 5103, 3, 2, 2, 2, 5103, 5104, 7, 82, 2, 2, 5104, 5105, 7, 289, 2, 2, 5105, 5106, 5, 626, 314, 2, 5106, 5107, 7, 118, 2, 2, 5107, 5108, 5, 542, 272, 2, 5108, 5121, 3, 2, 2, 2, 5109, 5110, 7, 320, 2, 2, 5110, 5112, 7, 239, 2, 2, 5111, 5113, 5, 540, 271, 2, 5112, 5111, 3, 2, 2, 2, 5112, 5113, 3, 2, 2, 2, 5113, 5114, 3, 2, 2, 2, 5114, 5115, 7, 82, 2, 2, 5115, 5116, 7, 435, 2, 2, 5116, 5117, 5, 626, 314, 2, 5117, 5118, 7, 118, 2, 2, 5118, 5119, 5, 542, 272, 2, 5119, 5121, 3, 2, 2, 2, 5120, 5009, 3, 2, 2, 2, 5120, 5020, 3, 2, 2, 2, 5120, 5031, 3, 2, 2, 2, 5120, 5042, 3, 2, 2, 2, 5120, 5053, 3, 2, 2, 2, 5120, 5064, 3, 2, 2, 2, 5120, 5075, 3, 2, 2, 2, 5120, 5086, 3, 2, 2, 2, 5120, 5098, 3, 2, 2, 2, 5120, 5109, 3, 2, 2, 2, 5121, 539, 3, 2, 2, 2, 5122, 5123, 7, 64, 2, 2, 5123, 5124, 5, 72, 37, 2, 5124, 541, 3, 2, 2, 2, 5125, 5128, 5, 1346, 674, 2, 5126, 5128, 7, 80, 2, 2, 5127, 5125, 3, 2, 2, 2, 5127, 5126, 3, 2, 2, 2, 5128, 543, 3, 2, 2, 2, 5129, 5130, 7, 63, 2, 2, 5130, 5134, 5, 546, 274, 2, 5131, 5132, 7, 258, 2, 2, 5132, 5134, 5, 546, 274, 2, 5133, 5129, 3, 2, 2, 2, 5133, 5131, 3, 2, 2, 2, 5134, 545, 3, 2, 2, 2, 5135, 5221, 5, 946, 474, 2, 5136, 5137, 5, 548, 275, 2, 5137, 5138, 5, 946, 474, 2, 5138, 5221, 3, 2, 2, 2, 5139, 5141, 7, 261, 2, 2, 5140, 5142, 5, 550, 276, 2, 5141, 5140, 3, 2, 2, 2, 5141, 5142, 3, 2, 2, 2, 5142, 5143, 3, 2, 2, 2, 5143, 5221, 5, 946, 474, 2, 5144, 5146, 7, 286, 2, 2, 5145, 5147, 5, 550, 276, 2, 5146, 5145, 3, 2, 2, 2, 5146, 5147, 3, 2, 2, 2, 5147, 5148, 3, 2, 2, 2, 5148, 5221, 5, 946, 474, 2, 5149, 5151, 7, 209, 2, 2, 5150, 5152, 5, 550, 276, 2, 5151, 5150, 3, 2, 2, 2, 5151, 5152, 3, 2, 2, 2, 5152, 5153, 3, 2, 2, 2, 5153, 5221, 5, 946, 474, 2, 5154, 5156, 7, 242, 2, 2, 5155, 5157, 5, 550, 276, 2, 5156, 5155, 3, 2, 2, 2, 5156, 5157, 3, 2, 2, 2, 5157, 5158, 3, 2, 2, 2, 5158, 5221, 5, 946, 474, 2, 5159, 5160, 7, 132, 2, 2, 5160, 5162, 5, 1352, 677, 2, 5161, 5163, 5, 550, 276, 2, 5162, 5161, 3, 2, 2, 2, 5162, 5163, 3, 2, 2, 2, 5163, 5164, 3, 2, 2, 2, 5164, 5165, 5, 946, 474, 2, 5165, 5221, 3, 2, 2, 2, 5166, 5167, 7, 300, 2, 2, 5167, 5169, 5, 1352, 677, 2, 5168, 5170, 5, 550, 276, 2, 5169, 5168, 3, 2, 2, 2, 5169, 5170, 3, 2, 2, 2, 5170, 5171, 3, 2, 2, 2, 5171, 5172, 5, 946, 474, 2, 5172, 5221, 3, 2, 2, 2, 5173, 5175, 5, 1352, 677, 2, 5174, 5176, 5, 550, 276, 2, 5175, 5174, 3, 2, 2, 2, 5175, 5176, 3, 2, 2, 2, 5176, 5177, 3, 2, 2, 2, 5177, 5178, 5, 946, 474, 2, 5178, 5221, 3, 2, 2, 2, 5179, 5181, 7, 32, 2, 2, 5180, 5182, 5, 550, 276, 2, 5181, 5180, 3, 2, 2, 2, 5181, 5182, 3, 2, 2, 2, 5182, 5183, 3, 2, 2, 2, 5183, 5221, 5, 946, 474, 2, 5184, 5186, 7, 212, 2, 2, 5185, 5187, 5, 550, 276, 2, 5186, 5185, 3, 2, 2, 2, 5186, 5187, 3, 2, 2, 2, 5187, 5188, 3, 2, 2, 2, 5188, 5221, 5, 946, 474, 2, 5189, 5190, 7, 212, 2, 2, 5190, 5192, 5, 1352, 677, 2, 5191, 5193, 5, 550, 276, 2, 5192, 5191, 3, 2, 2, 2, 5192, 5193, 3, 2, 2, 2, 5193, 5194, 3, 2, 2, 2, 5194, 5195, 5, 946, 474, 2, 5195, 5221, 3, 2, 2, 2, 5196, 5197, 7, 212, 2, 2, 5197, 5199, 7, 32, 2, 2, 5198, 5200, 5, 550, 276, 2, 5199, 5198, 3, 2, 2, 2, 5199, 5200, 3, 2, 2, 2, 5200, 5201, 3, 2, 2, 2, 5201, 5221, 5, 946, 474, 2, 5202, 5204, 7, 146, 2, 2, 5203, 5205, 5, 550, 276, 2, 5204, 5203, 3, 2, 2, 2, 5204, 5205, 3, 2, 2, 2, 5205, 5206, 3, 2, 2, 2, 5206, 5221, 5, 946, 474, 2, 5207, 5208, 7, 146, 2, 2, 5208, 5210, 5, 1352, 677, 2, 5209, 5211, 5, 550, 276, 2, 5210, 5209, 3, 2, 2, 2, 5210, 5211, 3, 2, 2, 2, 5211, 5212, 3, 2, 2, 2, 5212, 5213, 5, 946, 474, 2, 5213, 5221, 3, 2, 2, 2, 5214, 5215, 7, 146, 2, 2, 5215, 5217, 7, 32, 2, 2, 5216, 5218, 5, 550, 276, 2, 5217, 5216, 3, 2, 2, 2, 5217, 5218, 3, 2, 2, 2, 5218, 5219, 3, 2, 2, 2, 5219, 5221, 5, 946, 474, 2, 5220, 5135, 3, 2, 2, 2, 5220, 5136, 3, 2, 2, 2, 5220, 5139, 3, 2, 2, 2, 5220, 5144, 3, 2, 2, 2, 5220, 5149, 3, 2, 2, 2, 5220, 5154, 3, 2, 2, 2, 5220, 5159, 3, 2, 2, 2, 5220, 5166, 3, 2, 2, 2, 5220, 5173, 3, 2, 2, 2, 5220, 5179, 3, 2, 2, 2, 5220, 5184, 3, 2, 2, 2, 5220, 5189, 3, 2, 2, 2, 5220, 5196, 3, 2, 2, 2, 5220, 5202, 3, 2, 2, 2, 5220, 5207, 3, 2, 2, 2, 5220, 5214, 3, 2, 2, 2, 5221, 547, 3, 2, 2, 2, 5222, 5223, 9, 27, 2, 2, 5223, 549, 3, 2, 2, 2, 5224, 5225, 5, 548, 275, 2, 5225, 551, 3, 2, 2, 2, 5226, 5227, 7, 67, 2, 2, 5227, 5228, 5, 556, 279, 2, 5228, 5229, 7, 82, 2, 2, 5229, 5230, 5, 562, 282, 2, 5230, 5231, 7, 96, 2, 2, 5231, 5233, 5, 564, 283, 2, 5232, 5234, 5, 568, 285, 2, 5233, 5232, 3, 2, 2, 2, 5233, 5234, 3, 2, 2, 2, 5234, 553, 3, 2, 2, 2, 5235, 5236, 7, 310, 2, 2, 5236, 5237, 5, 556, 279, 2, 5237, 5238, 7, 82, 2, 2, 5238, 5239, 5, 562, 282, 2, 5239, 5240, 7, 66, 2, 2, 5240, 5242, 5, 564, 283, 2, 5241, 5243, 5, 108, 55, 2, 5242, 5241, 3, 2, 2, 2, 5242, 5243, 3, 2, 2, 2, 5243, 5257, 3, 2, 2, 2, 5244, 5245, 7, 310, 2, 2, 5245, 5246, 7, 67, 2, 2, 5246, 5247, 7, 272, 2, 2, 5247, 5248, 7, 64, 2, 2, 5248, 5249, 5, 556, 279, 2, 5249, 5250, 7, 82, 2, 2, 5250, 5251, 5, 562, 282, 2, 5251, 5252, 7, 66, 2, 2, 5252, 5254, 5, 564, 283, 2, 5253, 5255, 5, 108, 55, 2, 5254, 5253, 3, 2, 2, 2, 5254, 5255, 3, 2, 2, 2, 5255, 5257, 3, 2, 2, 2, 5256, 5235, 3, 2, 2, 2, 5256, 5244, 3, 2, 2, 2, 5257, 555, 3, 2, 2, 2, 5258, 5274, 5, 558, 280, 2, 5259, 5274, 7, 32, 2, 2, 5260, 5261, 7, 32, 2, 2, 5261, 5274, 7, 287, 2, 2, 5262, 5263, 7, 32, 2, 2, 5263, 5264, 7, 4, 2, 2, 5264, 5265, 5, 216, 109, 2, 5265, 5266, 7, 5, 2, 2, 5266, 5274, 3, 2, 2, 2, 5267, 5268, 7, 32, 2, 2, 5268, 5269, 7, 287, 2, 2, 5269, 5270, 7, 4, 2, 2, 5270, 5271, 5, 216, 109, 2, 5271, 5272, 7, 5, 2, 2, 5272, 5274, 3, 2, 2, 2, 5273, 5258, 3, 2, 2, 2, 5273, 5259, 3, 2, 2, 2, 5273, 5260, 3, 2, 2, 2, 5273, 5262, 3, 2, 2, 2, 5273, 5267, 3, 2, 2, 2, 5274, 557, 3, 2, 2, 2, 5275, 5280, 5, 560, 281, 2, 5276, 5277, 7, 8, 2, 2, 5277, 5279, 5, 560, 281, 2, 5278, 5276, 3, 2, 2, 2, 5279, 5282, 3, 2, 2, 2, 5280, 5278, 3, 2, 2, 2, 5280, 5281, 3, 2, 2, 2, 5281, 559, 3, 2, 2, 2, 5282, 5280, 3, 2, 2, 2, 5283, 5285, 7, 90, 2, 2, 5284, 5286, 5, 214, 108, 2, 5285, 5284, 3, 2, 2, 2, 5285, 5286, 3, 2, 2, 2, 5286, 5300, 3, 2, 2, 2, 5287, 5289, 7, 88, 2, 2, 5288, 5290, 5, 214, 108, 2, 5289, 5288, 3, 2, 2, 2, 5289, 5290, 3, 2, 2, 2, 5290, 5300, 3, 2, 2, 2, 5291, 5293, 7, 48, 2, 2, 5292, 5294, 5, 214, 108, 2, 5293, 5292, 3, 2, 2, 2, 5293, 5294, 3, 2, 2, 2, 5294, 5300, 3, 2, 2, 2, 5295, 5297, 5, 1360, 681, 2, 5296, 5298, 5, 214, 108, 2, 5297, 5296, 3, 2, 2, 2, 5297, 5298, 3, 2, 2, 2, 5298, 5300, 3, 2, 2, 2, 5299, 5283, 3, 2, 2, 2, 5299, 5287, 3, 2, 2, 2, 5299, 5291, 3, 2, 2, 2, 5299, 5295, 3, 2, 2, 2, 5300, 561, 3, 2, 2, 2, 5301, 5360, 5, 1322, 662, 2, 5302, 5303, 7, 94, 2, 2, 5303, 5360, 5, 1322, 662, 2, 5304, 5305, 7, 321, 2, 2, 5305, 5360, 5, 1322, 662, 2, 5306, 5307, 7, 65, 2, 2, 5307, 5308, 7, 176, 2, 2, 5308, 5309, 7, 374, 2, 2, 5309, 5360, 5, 1326, 664, 2, 5310, 5311, 7, 65, 2, 2, 5311, 5312, 7, 324, 2, 2, 5312, 5360, 5, 1326, 664, 2, 5313, 5314, 7, 213, 2, 2, 5314, 5360, 5, 624, 313, 2, 5315, 5316, 7, 289, 2, 2, 5316, 5360, 5, 624, 313, 2, 5317, 5318, 7, 435, 2, 2, 5318, 5360, 5, 624, 313, 2, 5319, 5320, 7, 177, 2, 2, 5320, 5360, 5, 1326, 664, 2, 5321, 5322, 7, 191, 2, 2, 5322, 5360, 5, 522, 262, 2, 5323, 5324, 7, 240, 2, 2, 5324, 5360, 5, 1326, 664, 2, 5325, 5326, 7, 241, 2, 2, 5326, 5327, 7, 267, 2, 2, 5327, 5360, 5, 294, 148, 2, 5328, 5329, 7, 316, 2, 2, 5329, 5360, 5, 1326, 664, 2, 5330, 5331, 7, 344, 2, 2, 5331, 5360, 5, 1326, 664, 2, 5332, 5333, 7, 353, 2, 2, 5333, 5360, 5, 522, 262, 2, 5334, 5335, 7, 32, 2, 2, 5335, 5336, 7, 343, 2, 2, 5336, 5337, 7, 70, 2, 2, 5337, 5338, 7, 316, 2, 2, 5338, 5360, 5, 1326, 664, 2, 5339, 5340, 7, 32, 2, 2, 5340, 5341, 7, 322, 2, 2, 5341, 5342, 7, 70, 2, 2, 5342, 5343, 7, 316, 2, 2, 5343, 5360, 5, 1326, 664, 2, 5344, 5345, 7, 32, 2, 2, 5345, 5346, 7, 214, 2, 2, 5346, 5347, 7, 70, 2, 2, 5347, 5348, 7, 316, 2, 2, 5348, 5360, 5, 1326, 664, 2, 5349, 5350, 7, 32, 2, 2, 5350, 5351, 7, 450, 2, 2, 5351, 5352, 7, 70, 2, 2, 5352, 5353, 7, 316, 2, 2, 5353, 5360, 5, 1326, 664, 2, 5354, 5355, 7, 32, 2, 2, 5355, 5356, 7, 448, 2, 2, 5356, 5357, 7, 70, 2, 2, 5357, 5358, 7, 316, 2, 2, 5358, 5360, 5, 1326, 664, 2, 5359, 5301, 3, 2, 2, 2, 5359, 5302, 3, 2, 2, 2, 5359, 5304, 3, 2, 2, 2, 5359, 5306, 3, 2, 2, 2, 5359, 5310, 3, 2, 2, 2, 5359, 5313, 3, 2, 2, 2, 5359, 5315, 3, 2, 2, 2, 5359, 5317, 3, 2, 2, 2, 5359, 5319, 3, 2, 2, 2, 5359, 5321, 3, 2, 2, 2, 5359, 5323, 3, 2, 2, 2, 5359, 5325, 3, 2, 2, 2, 5359, 5328, 3, 2, 2, 2, 5359, 5330, 3, 2, 2, 2, 5359, 5332, 3, 2, 2, 2, 5359, 5334, 3, 2, 2, 2, 5359, 5339, 3, 2, 2, 2, 5359, 5344, 3, 2, 2, 2, 5359, 5349, 3, 2, 2, 2, 5359, 5354, 3, 2, 2, 2, 5360, 563, 3, 2, 2, 2, 5361, 5366, 5, 566, 284, 2, 5362, 5363, 7, 8, 2, 2, 5363, 5365, 5, 566, 284, 2, 5364, 5362, 3, 2, 2, 2, 5365, 5368, 3, 2, 2, 2, 5366, 5364, 3, 2, 2, 2, 5366, 5367, 3, 2, 2, 2, 5367, 565, 3, 2, 2, 2, 5368, 5366, 3, 2, 2, 2, 5369, 5373, 5, 1356, 679, 2, 5370, 5371, 7, 68, 2, 2, 5371, 5373, 5, 1356, 679, 2, 5372, 5369, 3, 2, 2, 2, 5372, 5370, 3, 2, 2, 2, 5373, 567, 3, 2, 2, 2, 5374, 5375, 7, 107, 2, 2, 5375, 5376, 7, 67, 2, 2, 5376, 5377, 7, 272, 2, 2, 5377, 569, 3, 2, 2, 2, 5378, 5379, 7, 67, 2, 2, 5379, 5380, 5, 558, 280, 2, 5380, 5381, 7, 96, 2, 2, 5381, 5383, 5, 1358, 680, 2, 5382, 5384, 5, 574, 288, 2, 5383, 5382, 3, 2, 2, 2, 5383, 5384, 3, 2, 2, 2, 5384, 5386, 3, 2, 2, 2, 5385, 5387, 5, 576, 289, 2, 5386, 5385, 3, 2, 2, 2, 5386, 5387, 3, 2, 2, 2, 5387, 571, 3, 2, 2, 2, 5388, 5389, 7, 310, 2, 2, 5389, 5390, 5, 558, 280, 2, 5390, 5391, 7, 66, 2, 2, 5391, 5393, 5, 1358, 680, 2, 5392, 5394, 5, 576, 289, 2, 5393, 5392, 3, 2, 2, 2, 5393, 5394, 3, 2, 2, 2, 5394, 5396, 3, 2, 2, 2, 5395, 5397, 5, 108, 55, 2, 5396, 5395, 3, 2, 2, 2, 5396, 5397, 3, 2, 2, 2, 5397, 5412, 3, 2, 2, 2, 5398, 5399, 7, 310, 2, 2, 5399, 5400, 7, 136, 2, 2, 5400, 5401, 7, 272, 2, 2, 5401, 5402, 7, 64, 2, 2, 5402, 5403, 5, 558, 280, 2, 5403, 5404, 7, 66, 2, 2, 5404, 5406, 5, 1358, 680, 2, 5405, 5407, 5, 576, 289, 2, 5406, 5405, 3, 2, 2, 2, 5406, 5407, 3, 2, 2, 2, 5407, 5409, 3, 2, 2, 2, 5408, 5410, 5, 108, 55, 2, 5409, 5408, 3, 2, 2, 2, 5409, 5410, 3, 2, 2, 2, 5410, 5412, 3, 2, 2, 2, 5411, 5388, 3, 2, 2, 2, 5411, 5398, 3, 2, 2, 2, 5412, 573, 3, 2, 2, 2, 5413, 5414, 7, 107, 2, 2, 5414, 5415, 7, 136, 2, 2, 5415, 5416, 7, 272, 2, 2, 5416, 575, 3, 2, 2, 2, 5417, 5418, 7, 216, 2, 2, 5418, 5419, 7, 149, 2, 2, 5419, 5420, 5, 1356, 679, 2, 5420, 577, 3, 2, 2, 2, 5421, 5422, 7, 140, 2, 2, 5422, 5423, 7, 55, 2, 2, 5423, 5424, 7, 287, 2, 2, 5424, 5425, 5, 580, 291, 2, 5425, 5426, 5, 584, 293, 2, 5426, 579, 3, 2, 2, 2, 5427, 5429, 5, 582, 292, 2, 5428, 5427, 3, 2, 2, 2, 5429, 5432, 3, 2, 2, 2, 5430, 5428, 3, 2, 2, 2, 5430, 5431, 3, 2, 2, 2, 5431, 581, 3, 2, 2, 2, 5432, 5430, 3, 2, 2, 2, 5433, 5434, 7, 70, 2, 2, 5434, 5435, 7, 316, 2, 2, 5435, 5443, 5, 1326, 664, 2, 5436, 5437, 7, 64, 2, 2, 5437, 5438, 7, 311, 2, 2, 5438, 5443, 5, 1358, 680, 2, 5439, 5440, 7, 64, 2, 2, 5440, 5441, 7, 101, 2, 2, 5441, 5443, 5, 1358, 680, 2, 5442, 5433, 3, 2, 2, 2, 5442, 5436, 3, 2, 2, 2, 5442, 5439, 3, 2, 2, 2, 5443, 583, 3, 2, 2, 2, 5444, 5445, 7, 67, 2, 2, 5445, 5446, 5, 556, 279, 2, 5446, 5447, 7, 82, 2, 2, 5447, 5448, 5, 586, 294, 2, 5448, 5449, 7, 96, 2, 2, 5449, 5451, 5, 564, 283, 2, 5450, 5452, 5, 568, 285, 2, 5451, 5450, 3, 2, 2, 2, 5451, 5452, 3, 2, 2, 2, 5452, 5475, 3, 2, 2, 2, 5453, 5454, 7, 310, 2, 2, 5454, 5455, 5, 556, 279, 2, 5455, 5456, 7, 82, 2, 2, 5456, 5457, 5, 586, 294, 2, 5457, 5458, 7, 66, 2, 2, 5458, 5460, 5, 564, 283, 2, 5459, 5461, 5, 108, 55, 2, 5460, 5459, 3, 2, 2, 2, 5460, 5461, 3, 2, 2, 2, 5461, 5475, 3, 2, 2, 2, 5462, 5463, 7, 310, 2, 2, 5463, 5464, 7, 67, 2, 2, 5464, 5465, 7, 272, 2, 2, 5465, 5466, 7, 64, 2, 2, 5466, 5467, 5, 556, 279, 2, 5467, 5468, 7, 82, 2, 2, 5468, 5469, 5, 586, 294, 2, 5469, 5470, 7, 66, 2, 2, 5470, 5472, 5, 564, 283, 2, 5471, 5473, 5, 108, 55, 2, 5472, 5471, 3, 2, 2, 2, 5472, 5473, 3, 2, 2, 2, 5473, 5475, 3, 2, 2, 2, 5474, 5444, 3, 2, 2, 2, 5474, 5453, 3, 2, 2, 2, 5474, 5462, 3, 2, 2, 2, 5475, 585, 3, 2, 2, 2, 5476, 5477, 9, 28, 2, 2, 5477, 587, 3, 2, 2, 2, 5478, 5480, 7, 48, 2, 2, 5479, 5481, 5, 590, 296, 2, 5480, 5479, 3, 2, 2, 2, 5480, 5481, 3, 2, 2, 2, 5481, 5482, 3, 2, 2, 2, 5482, 5484, 7, 228, 2, 2, 5483, 5485, 5, 592, 297, 2, 5484, 5483, 3, 2, 2, 2, 5484, 5485, 3, 2, 2, 2, 5485, 5487, 3, 2, 2, 2, 5486, 5488, 5, 594, 298, 2, 5487, 5486, 3, 2, 2, 2, 5487, 5488, 3, 2, 2, 2, 5488, 5489, 3, 2, 2, 2, 5489, 5490, 7, 82, 2, 2, 5490, 5492, 5, 1064, 533, 2, 5491, 5493, 5, 596, 299, 2, 5492, 5491, 3, 2, 2, 2, 5492, 5493, 3, 2, 2, 2, 5493, 5494, 3, 2, 2, 2, 5494, 5495, 7, 4, 2, 2, 5495, 5496, 5, 598, 300, 2, 5496, 5498, 7, 5, 2, 2, 5497, 5499, 5, 604, 303, 2, 5498, 5497, 3, 2, 2, 2, 5498, 5499, 3, 2, 2, 2, 5499, 5501, 3, 2, 2, 2, 5500, 5502, 5, 118, 60, 2, 5501, 5500, 3, 2, 2, 2, 5501, 5502, 3, 2, 2, 2, 5502, 5504, 3, 2, 2, 2, 5503, 5505, 5, 254, 128, 2, 5504, 5503, 3, 2, 2, 2, 5504, 5505, 3, 2, 2, 2, 5505, 5507, 3, 2, 2, 2, 5506, 5508, 5, 1084, 543, 2, 5507, 5506, 3, 2, 2, 2, 5507, 5508, 3, 2, 2, 2, 5508, 5542, 3, 2, 2, 2, 5509, 5511, 7, 48, 2, 2, 5510, 5512, 5, 590, 296, 2, 5511, 5510, 3, 2, 2, 2, 5511, 5512, 3, 2, 2, 2, 5512, 5513, 3, 2, 2, 2, 5513, 5515, 7, 228, 2, 2, 5514, 5516, 5, 592, 297, 2, 5515, 5514, 3, 2, 2, 2, 5515, 5516, 3, 2, 2, 2, 5516, 5517, 3, 2, 2, 2, 5517, 5518, 7, 222, 2, 2, 5518, 5519, 7, 79, 2, 2, 5519, 5520, 7, 389, 2, 2, 5520, 5521, 5, 1328, 665, 2, 5521, 5522, 7, 82, 2, 2, 5522, 5524, 5, 1064, 533, 2, 5523, 5525, 5, 596, 299, 2, 5524, 5523, 3, 2, 2, 2, 5524, 5525, 3, 2, 2, 2, 5525, 5526, 3, 2, 2, 2, 5526, 5527, 7, 4, 2, 2, 5527, 5528, 5, 598, 300, 2, 5528, 5530, 7, 5, 2, 2, 5529, 5531, 5, 604, 303, 2, 5530, 5529, 3, 2, 2, 2, 5530, 5531, 3, 2, 2, 2, 5531, 5533, 3, 2, 2, 2, 5532, 5534, 5, 118, 60, 2, 5533, 5532, 3, 2, 2, 2, 5533, 5534, 3, 2, 2, 2, 5534, 5536, 3, 2, 2, 2, 5535, 5537, 5, 254, 128, 2, 5536, 5535, 3, 2, 2, 2, 5536, 5537, 3, 2, 2, 2, 5537, 5539, 3, 2, 2, 2, 5538, 5540, 5, 1084, 543, 2, 5539, 5538, 3, 2, 2, 2, 5539, 5540, 3, 2, 2, 2, 5540, 5542, 3, 2, 2, 2, 5541, 5478, 3, 2, 2, 2, 5541, 5509, 3, 2, 2, 2, 5542, 589, 3, 2, 2, 2, 5543, 5544, 7, 100, 2, 2, 5544, 591, 3, 2, 2, 2, 5545, 5546, 7, 111, 2, 2, 5546, 593, 3, 2, 2, 2, 5547, 5548, 5, 1328, 665, 2, 5548, 595, 3, 2, 2, 2, 5549, 5550, 7, 102, 2, 2, 5550, 5551, 5, 1328, 665, 2, 5551, 597, 3, 2, 2, 2, 5552, 5557, 5, 602, 302, 2, 5553, 5554, 7, 8, 2, 2, 5554, 5556, 5, 602, 302, 2, 5555, 5553, 3, 2, 2, 2, 5556, 5559, 3, 2, 2, 2, 5557, 5555, 3, 2, 2, 2, 5557, 5558, 3, 2, 2, 2, 5558, 599, 3, 2, 2, 2, 5559, 5557, 3, 2, 2, 2, 5560, 5562, 5, 608, 305, 2, 5561, 5560, 3, 2, 2, 2, 5561, 5562, 3, 2, 2, 2, 5562, 5564, 3, 2, 2, 2, 5563, 5565, 5, 610, 306, 2, 5564, 5563, 3, 2, 2, 2, 5564, 5565, 3, 2, 2, 2, 5565, 5567, 3, 2, 2, 2, 5566, 5568, 5, 612, 307, 2, 5567, 5566, 3, 2, 2, 2, 5567, 5568, 3, 2, 2, 2, 5568, 5570, 3, 2, 2, 2, 5569, 5571, 5, 614, 308, 2, 5570, 5569, 3, 2, 2, 2, 5570, 5571, 3, 2, 2, 2, 5571, 5584, 3, 2, 2, 2, 5572, 5574, 5, 608, 305, 2, 5573, 5572, 3, 2, 2, 2, 5573, 5574, 3, 2, 2, 2, 5574, 5575, 3, 2, 2, 2, 5575, 5576, 5, 524, 263, 2, 5576, 5578, 5, 116, 59, 2, 5577, 5579, 5, 612, 307, 2, 5578, 5577, 3, 2, 2, 2, 5578, 5579, 3, 2, 2, 2, 5579, 5581, 3, 2, 2, 2, 5580, 5582, 5, 614, 308, 2, 5581, 5580, 3, 2, 2, 2, 5581, 5582, 3, 2, 2, 2, 5582, 5584, 3, 2, 2, 2, 5583, 5561, 3, 2, 2, 2, 5583, 5573, 3, 2, 2, 2, 5584, 601, 3, 2, 2, 2, 5585, 5586, 5, 1360, 681, 2, 5586, 5587, 5, 600, 301, 2, 5587, 5597, 3, 2, 2, 2, 5588, 5589, 5, 1202, 602, 2, 5589, 5590, 5, 600, 301, 2, 5590, 5597, 3, 2, 2, 2, 5591, 5592, 7, 4, 2, 2, 5592, 5593, 5, 1152, 577, 2, 5593, 5594, 7, 5, 2, 2, 5594, 5595, 5, 600, 301, 2, 5595, 5597, 3, 2, 2, 2, 5596, 5585, 3, 2, 2, 2, 5596, 5588, 3, 2, 2, 2, 5596, 5591, 3, 2, 2, 2, 5597, 603, 3, 2, 2, 2, 5598, 5599, 7, 434, 2, 2, 5599, 5600, 7, 4, 2, 2, 5600, 5601, 5, 606, 304, 2, 5601, 5602, 7, 5, 2, 2, 5602, 605, 3, 2, 2, 2, 5603, 5608, 5, 602, 302, 2, 5604, 5605, 7, 8, 2, 2, 5605, 5607, 5, 602, 302, 2, 5606, 5604, 3, 2, 2, 2, 5607, 5610, 3, 2, 2, 2, 5608, 5606, 3, 2, 2, 2, 5608, 5609, 3, 2, 2, 2, 5609, 607, 3, 2, 2, 2, 5610, 5608, 3, 2, 2, 2, 5611, 5612, 7, 45, 2, 2, 5612, 5613, 5, 524, 263, 2, 5613, 609, 3, 2, 2, 2, 5614, 5615, 5, 524, 263, 2, 5615, 611, 3, 2, 2, 2, 5616, 5617, 9, 29, 2, 2, 5617, 613, 3, 2, 2, 2, 5618, 5619, 7, 266, 2, 2, 5619, 5623, 7, 209, 2, 2, 5620, 5621, 7, 266, 2, 2, 5621, 5623, 7, 242, 2, 2, 5622, 5618, 3, 2, 2, 2, 5622, 5620, 3, 2, 2, 2, 5623, 615, 3, 2, 2, 2, 5624, 5626, 7, 48, 2, 2, 5625, 5627, 5, 618, 310, 2, 5626, 5625, 3, 2, 2, 2, 5626, 5627, 3, 2, 2, 2, 5627, 5628, 3, 2, 2, 2, 5628, 5629, 9, 25, 2, 2, 5629, 5630, 5, 1334, 668, 2, 5630, 5640, 5, 628, 315, 2, 5631, 5638, 7, 309, 2, 2, 5632, 5639, 5, 638, 320, 2, 5633, 5634, 7, 94, 2, 2, 5634, 5635, 7, 4, 2, 2, 5635, 5636, 5, 668, 335, 2, 5636, 5637, 7, 5, 2, 2, 5637, 5639, 3, 2, 2, 2, 5638, 5632, 3, 2, 2, 2, 5638, 5633, 3, 2, 2, 2, 5639, 5641, 3, 2, 2, 2, 5640, 5631, 3, 2, 2, 2, 5640, 5641, 3, 2, 2, 2, 5641, 5642, 3, 2, 2, 2, 5642, 5643, 5, 654, 328, 2, 5643, 617, 3, 2, 2, 2, 5644, 5645, 7, 84, 2, 2, 5645, 5646, 7, 304, 2, 2, 5646, 619, 3, 2, 2, 2, 5647, 5649, 7, 4, 2, 2, 5648, 5650, 5, 622, 312, 2, 5649, 5648, 3, 2, 2, 2, 5649, 5650, 3, 2, 2, 2, 5650, 5651, 3, 2, 2, 2, 5651, 5652, 7, 5, 2, 2, 5652, 621, 3, 2, 2, 2, 5653, 5658, 5, 632, 317, 2, 5654, 5655, 7, 8, 2, 2, 5655, 5657, 5, 632, 317, 2, 5656, 5654, 3, 2, 2, 2, 5657, 5660, 3, 2, 2, 2, 5658, 5656, 3, 2, 2, 2, 5658, 5659, 3, 2, 2, 2, 5659, 623, 3, 2, 2, 2, 5660, 5658, 3, 2, 2, 2, 5661, 5666, 5, 626, 314, 2, 5662, 5663, 7, 8, 2, 2, 5663, 5665, 5, 626, 314, 2, 5664, 5662, 3, 2, 2, 2, 5665, 5668, 3, 2, 2, 2, 5666, 5664, 3, 2, 2, 2, 5666, 5667, 3, 2, 2, 2, 5667, 625, 3, 2, 2, 2, 5668, 5666, 3, 2, 2, 2, 5669, 5670, 5, 1334, 668, 2, 5670, 5671, 5, 620, 311, 2, 5671, 5678, 3, 2, 2, 2, 5672, 5678, 5, 1376, 689, 2, 5673, 5675, 5, 1360, 681, 2, 5674, 5676, 5, 1312, 657, 2, 5675, 5674, 3, 2, 2, 2, 5675, 5676, 3, 2, 2, 2, 5676, 5678, 3, 2, 2, 2, 5677, 5669, 3, 2, 2, 2, 5677, 5672, 3, 2, 2, 2, 5677, 5673, 3, 2, 2, 2, 5678, 627, 3, 2, 2, 2, 5679, 5681, 7, 4, 2, 2, 5680, 5682, 5, 630, 316, 2, 5681, 5680, 3, 2, 2, 2, 5681, 5682, 3, 2, 2, 2, 5682, 5683, 3, 2, 2, 2, 5683, 5684, 7, 5, 2, 2, 5684, 629, 3, 2, 2, 2, 5685, 5690, 5, 642, 322, 2, 5686, 5687, 7, 8, 2, 2, 5687, 5689, 5, 642, 322, 2, 5688, 5686, 3, 2, 2, 2, 5689, 5692, 3, 2, 2, 2, 5690, 5688, 3, 2, 2, 2, 5690, 5691, 3, 2, 2, 2, 5691, 631, 3, 2, 2, 2, 5692, 5690, 3, 2, 2, 2, 5693, 5695, 5, 634, 318, 2, 5694, 5696, 5, 636, 319, 2, 5695, 5694, 3, 2, 2, 2, 5695, 5696, 3, 2, 2, 2, 5696, 5697, 3, 2, 2, 2, 5697, 5698, 5, 640, 321, 2, 5698, 5707, 3, 2, 2, 2, 5699, 5701, 5, 636, 319, 2, 5700, 5702, 5, 634, 318, 2, 5701, 5700, 3, 2, 2, 2, 5701, 5702, 3, 2, 2, 2, 5702, 5703, 3, 2, 2, 2, 5703, 5704, 5, 640, 321, 2, 5704, 5707, 3, 2, 2, 2, 5705, 5707, 5, 640, 321, 2, 5706, 5693, 3, 2, 2, 2, 5706, 5699, 3, 2, 2, 2, 5706, 5705, 3, 2, 2, 2, 5707, 633, 3, 2, 2, 2, 5708, 5710, 7, 70, 2, 2, 5709, 5711, 7, 446, 2, 2, 5710, 5709, 3, 2, 2, 2, 5710, 5711, 3, 2, 2, 2, 5711, 5716, 3, 2, 2, 2, 5712, 5716, 7, 446, 2, 2, 5713, 5716, 7, 393, 2, 2, 5714, 5716, 7, 103, 2, 2, 5715, 5708, 3, 2, 2, 2, 5715, 5712, 3, 2, 2, 2, 5715, 5713, 3, 2, 2, 2, 5715, 5714, 3, 2, 2, 2, 5716, 635, 3, 2, 2, 2, 5717, 5718, 5, 1362, 682, 2, 5718, 637, 3, 2, 2, 2, 5719, 5720, 5, 640, 321, 2, 5720, 639, 3, 2, 2, 2, 5721, 5734, 5, 1108, 555, 2, 5722, 5723, 5, 1362, 682, 2, 5723, 5724, 5, 526, 264, 2, 5724, 5725, 7, 29, 2, 2, 5725, 5726, 7, 353, 2, 2, 5726, 5734, 3, 2, 2, 2, 5727, 5728, 7, 408, 2, 2, 5728, 5729, 5, 1362, 682, 2, 5729, 5730, 5, 526, 264, 2, 5730, 5731, 7, 29, 2, 2, 5731, 5732, 7, 353, 2, 2, 5732, 5734, 3, 2, 2, 2, 5733, 5721, 3, 2, 2, 2, 5733, 5722, 3, 2, 2, 2, 5733, 5727, 3, 2, 2, 2, 5734, 641, 3, 2, 2, 2, 5735, 5738, 5, 632, 317, 2, 5736, 5737, 9, 30, 2, 2, 5737, 5739, 5, 1152, 577, 2, 5738, 5736, 3, 2, 2, 2, 5738, 5739, 3, 2, 2, 2, 5739, 643, 3, 2, 2, 2, 5740, 5741, 5, 632, 317, 2, 5741, 645, 3, 2, 2, 2, 5742, 5753, 7, 4, 2, 2, 5743, 5754, 7, 11, 2, 2, 5744, 5754, 5, 648, 325, 2, 5745, 5746, 7, 85, 2, 2, 5746, 5747, 7, 149, 2, 2, 5747, 5754, 5, 648, 325, 2, 5748, 5749, 5, 648, 325, 2, 5749, 5750, 7, 85, 2, 2, 5750, 5751, 7, 149, 2, 2, 5751, 5752, 5, 648, 325, 2, 5752, 5754, 3, 2, 2, 2, 5753, 5743, 3, 2, 2, 2, 5753, 5744, 3, 2, 2, 2, 5753, 5745, 3, 2, 2, 2, 5753, 5748, 3, 2, 2, 2, 5754, 5755, 3, 2, 2, 2, 5755, 5756, 7, 5, 2, 2, 5756, 647, 3, 2, 2, 2, 5757, 5762, 5, 644, 323, 2, 5758, 5759, 7, 8, 2, 2, 5759, 5761, 5, 644, 323, 2, 5760, 5758, 3, 2, 2, 2, 5761, 5764, 3, 2, 2, 2, 5762, 5760, 3, 2, 2, 2, 5762, 5763, 3, 2, 2, 2, 5763, 649, 3, 2, 2, 2, 5764, 5762, 3, 2, 2, 2, 5765, 5766, 5, 1334, 668, 2, 5766, 5767, 5, 646, 324, 2, 5767, 651, 3, 2, 2, 2, 5768, 5773, 5, 650, 326, 2, 5769, 5770, 7, 8, 2, 2, 5770, 5772, 5, 650, 326, 2, 5771, 5769, 3, 2, 2, 2, 5772, 5775, 3, 2, 2, 2, 5773, 5771, 3, 2, 2, 2, 5773, 5774, 3, 2, 2, 2, 5774, 653, 3, 2, 2, 2, 5775, 5773, 3, 2, 2, 2, 5776, 5778, 5, 658, 330, 2, 5777, 5776, 3, 2, 2, 2, 5778, 5779, 3, 2, 2, 2, 5779, 5777, 3, 2, 2, 2, 5779, 5780, 3, 2, 2, 2, 5780, 5781, 3, 2, 2, 2, 5781, 5782, 8, 328, 1, 2, 5782, 655, 3, 2, 2, 2, 5783, 5784, 7, 151, 2, 2, 5784, 5785, 7, 82, 2, 2, 5785, 5786, 7, 80, 2, 2, 5786, 5819, 7, 451, 2, 2, 5787, 5788, 7, 309, 2, 2, 5788, 5789, 7, 80, 2, 2, 5789, 5790, 7, 82, 2, 2, 5790, 5791, 7, 80, 2, 2, 5791, 5819, 7, 451, 2, 2, 5792, 5819, 7, 339, 2, 2, 5793, 5819, 7, 224, 2, 2, 5794, 5819, 7, 331, 2, 2, 5795, 5819, 7, 370, 2, 2, 5796, 5797, 7, 207, 2, 2, 5797, 5798, 7, 320, 2, 2, 5798, 5819, 7, 183, 2, 2, 5799, 5800, 7, 207, 2, 2, 5800, 5801, 7, 320, 2, 2, 5801, 5819, 7, 236, 2, 2, 5802, 5803, 7, 320, 2, 2, 5803, 5819, 7, 183, 2, 2, 5804, 5805, 7, 320, 2, 2, 5805, 5819, 7, 236, 2, 2, 5806, 5819, 7, 243, 2, 2, 5807, 5808, 7, 79, 2, 2, 5808, 5819, 7, 243, 2, 2, 5809, 5810, 7, 172, 2, 2, 5810, 5819, 5, 292, 147, 2, 5811, 5812, 7, 313, 2, 2, 5812, 5819, 5, 292, 147, 2, 5813, 5814, 7, 452, 2, 2, 5814, 5819, 5, 524, 263, 2, 5815, 5819, 5, 82, 42, 2, 5816, 5817, 7, 453, 2, 2, 5817, 5819, 5, 1360, 681, 2, 5818, 5783, 3, 2, 2, 2, 5818, 5787, 3, 2, 2, 2, 5818, 5792, 3, 2, 2, 2, 5818, 5793, 3, 2, 2, 2, 5818, 5794, 3, 2, 2, 2, 5818, 5795, 3, 2, 2, 2, 5818, 5796, 3, 2, 2, 2, 5818, 5799, 3, 2, 2, 2, 5818, 5802, 3, 2, 2, 2, 5818, 5804, 3, 2, 2, 2, 5818, 5806, 3, 2, 2, 2, 5818, 5807, 3, 2, 2, 2, 5818, 5809, 3, 2, 2, 2, 5818, 5811, 3, 2, 2, 2, 5818, 5813, 3, 2, 2, 2, 5818, 5815, 3, 2, 2, 2, 5818, 5816, 3, 2, 2, 2, 5819, 657, 3, 2, 2, 2, 5820, 5821, 7, 38, 2, 2, 5821, 5829, 5, 660, 331, 2, 5822, 5823, 7, 240, 2, 2, 5823, 5829, 5, 72, 37, 2, 5824, 5825, 7, 436, 2, 2, 5825, 5829, 5, 662, 332, 2, 5826, 5829, 7, 106, 2, 2, 5827, 5829, 5, 656, 329, 2, 5828, 5820, 3, 2, 2, 2, 5828, 5822, 3, 2, 2, 2, 5828, 5824, 3, 2, 2, 2, 5828, 5826, 3, 2, 2, 2, 5828, 5827, 3, 2, 2, 2, 5829, 659, 3, 2, 2, 2, 5830, 5836, 5, 1346, 674, 2, 5831, 5832, 5, 1346, 674, 2, 5832, 5833, 7, 8, 2, 2, 5833, 5834, 5, 1346, 674, 2, 5834, 5836, 3, 2, 2, 2, 5835, 5830, 3, 2, 2, 2, 5835, 5831, 3, 2, 2, 2, 5836, 661, 3, 2, 2, 2, 5837, 5838, 7, 64, 2, 2, 5838, 5839, 7, 353, 2, 2, 5839, 5846, 5, 1108, 555, 2, 5840, 5841, 7, 8, 2, 2, 5841, 5842, 7, 64, 2, 2, 5842, 5843, 7, 353, 2, 2, 5843, 5845, 5, 1108, 555, 2, 5844, 5840, 3, 2, 2, 2, 5845, 5848, 3, 2, 2, 2, 5846, 5844, 3, 2, 2, 2, 5846, 5847, 3, 2, 2, 2, 5847, 663, 3, 2, 2, 2, 5848, 5846, 3, 2, 2, 2, 5849, 5850, 7, 107, 2, 2, 5850, 5851, 5, 460, 231, 2, 5851, 665, 3, 2, 2, 2, 5852, 5853, 5, 636, 319, 2, 5853, 5854, 5, 640, 321, 2, 5854, 667, 3, 2, 2, 2, 5855, 5860, 5, 666, 334, 2, 5856, 5857, 7, 8, 2, 2, 5857, 5859, 5, 666, 334, 2, 5858, 5856, 3, 2, 2, 2, 5859, 5862, 3, 2, 2, 2, 5860, 5858, 3, 2, 2, 2, 5860, 5861, 3, 2, 2, 2, 5861, 669, 3, 2, 2, 2, 5862, 5860, 3, 2, 2, 2, 5863, 5864, 7, 140, 2, 2, 5864, 5865, 9, 31, 2, 2, 5865, 5866, 5, 626, 314, 2, 5866, 5868, 5, 672, 337, 2, 5867, 5869, 5, 674, 338, 2, 5868, 5867, 3, 2, 2, 2, 5868, 5869, 3, 2, 2, 2, 5869, 671, 3, 2, 2, 2, 5870, 5872, 5, 656, 329, 2, 5871, 5870, 3, 2, 2, 2, 5872, 5873, 3, 2, 2, 2, 5873, 5871, 3, 2, 2, 2, 5873, 5874, 3, 2, 2, 2, 5874, 673, 3, 2, 2, 2, 5875, 5876, 7, 308, 2, 2, 5876, 675, 3, 2, 2, 2, 5877, 5878, 7, 193, 2, 2, 5878, 5879, 7, 213, 2, 2, 5879, 5881, 5, 624, 313, 2, 5880, 5882, 5, 108, 55, 2, 5881, 5880, 3, 2, 2, 2, 5881, 5882, 3, 2, 2, 2, 5882, 5920, 3, 2, 2, 2, 5883, 5884, 7, 193, 2, 2, 5884, 5885, 7, 213, 2, 2, 5885, 5886, 7, 222, 2, 2, 5886, 5887, 7, 389, 2, 2, 5887, 5889, 5, 624, 313, 2, 5888, 5890, 5, 108, 55, 2, 5889, 5888, 3, 2, 2, 2, 5889, 5890, 3, 2, 2, 2, 5890, 5920, 3, 2, 2, 2, 5891, 5892, 7, 193, 2, 2, 5892, 5893, 7, 289, 2, 2, 5893, 5895, 5, 624, 313, 2, 5894, 5896, 5, 108, 55, 2, 5895, 5894, 3, 2, 2, 2, 5895, 5896, 3, 2, 2, 2, 5896, 5920, 3, 2, 2, 2, 5897, 5898, 7, 193, 2, 2, 5898, 5899, 7, 289, 2, 2, 5899, 5900, 7, 222, 2, 2, 5900, 5901, 7, 389, 2, 2, 5901, 5903, 5, 624, 313, 2, 5902, 5904, 5, 108, 55, 2, 5903, 5902, 3, 2, 2, 2, 5903, 5904, 3, 2, 2, 2, 5904, 5920, 3, 2, 2, 2, 5905, 5906, 7, 193, 2, 2, 5906, 5907, 7, 435, 2, 2, 5907, 5909, 5, 624, 313, 2, 5908, 5910, 5, 108, 55, 2, 5909, 5908, 3, 2, 2, 2, 5909, 5910, 3, 2, 2, 2, 5910, 5920, 3, 2, 2, 2, 5911, 5912, 7, 193, 2, 2, 5912, 5913, 7, 435, 2, 2, 5913, 5914, 7, 222, 2, 2, 5914, 5915, 7, 389, 2, 2, 5915, 5917, 5, 624, 313, 2, 5916, 5918, 5, 108, 55, 2, 5917, 5916, 3, 2, 2, 2, 5917, 5918, 3, 2, 2, 2, 5918, 5920, 3, 2, 2, 2, 5919, 5877, 3, 2, 2, 2, 5919, 5883, 3, 2, 2, 2, 5919, 5891, 3, 2, 2, 2, 5919, 5897, 3, 2, 2, 2, 5919, 5905, 3, 2, 2, 2, 5919, 5911, 3, 2, 2, 2, 5920, 677, 3, 2, 2, 2, 5921, 5922, 7, 193, 2, 2, 5922, 5923, 7, 138, 2, 2, 5923, 5925, 5, 652, 327, 2, 5924, 5926, 5, 108, 55, 2, 5925, 5924, 3, 2, 2, 2, 5925, 5926, 3, 2, 2, 2, 5926, 5936, 3, 2, 2, 2, 5927, 5928, 7, 193, 2, 2, 5928, 5929, 7, 138, 2, 2, 5929, 5930, 7, 222, 2, 2, 5930, 5931, 7, 389, 2, 2, 5931, 5933, 5, 652, 327, 2, 5932, 5934, 5, 108, 55, 2, 5933, 5932, 3, 2, 2, 2, 5933, 5934, 3, 2, 2, 2, 5934, 5936, 3, 2, 2, 2, 5935, 5921, 3, 2, 2, 2, 5935, 5927, 3, 2, 2, 2, 5936, 679, 3, 2, 2, 2, 5937, 5938, 7, 193, 2, 2, 5938, 5939, 7, 271, 2, 2, 5939, 5941, 5, 686, 344, 2, 5940, 5942, 5, 108, 55, 2, 5941, 5940, 3, 2, 2, 2, 5941, 5942, 3, 2, 2, 2, 5942, 5952, 3, 2, 2, 2, 5943, 5944, 7, 193, 2, 2, 5944, 5945, 7, 271, 2, 2, 5945, 5946, 7, 222, 2, 2, 5946, 5947, 7, 389, 2, 2, 5947, 5949, 5, 686, 344, 2, 5948, 5950, 5, 108, 55, 2, 5949, 5948, 3, 2, 2, 2, 5949, 5950, 3, 2, 2, 2, 5950, 5952, 3, 2, 2, 2, 5951, 5937, 3, 2, 2, 2, 5951, 5943, 3, 2, 2, 2, 5952, 681, 3, 2, 2, 2, 5953, 5954, 7, 4, 2, 2, 5954, 5955, 5, 1108, 555, 2, 5955, 5956, 7, 5, 2, 2, 5956, 5976, 3, 2, 2, 2, 5957, 5958, 7, 4, 2, 2, 5958, 5959, 5, 1108, 555, 2, 5959, 5960, 7, 8, 2, 2, 5960, 5961, 5, 1108, 555, 2, 5961, 5962, 7, 5, 2, 2, 5962, 5976, 3, 2, 2, 2, 5963, 5964, 7, 4, 2, 2, 5964, 5965, 7, 400, 2, 2, 5965, 5966, 7, 8, 2, 2, 5966, 5967, 5, 1108, 555, 2, 5967, 5968, 7, 5, 2, 2, 5968, 5976, 3, 2, 2, 2, 5969, 5970, 7, 4, 2, 2, 5970, 5971, 5, 1108, 555, 2, 5971, 5972, 7, 8, 2, 2, 5972, 5973, 7, 400, 2, 2, 5973, 5974, 7, 5, 2, 2, 5974, 5976, 3, 2, 2, 2, 5975, 5953, 3, 2, 2, 2, 5975, 5957, 3, 2, 2, 2, 5975, 5963, 3, 2, 2, 2, 5975, 5969, 3, 2, 2, 2, 5976, 683, 3, 2, 2, 2, 5977, 5978, 5, 1360, 681, 2, 5978, 5979, 7, 13, 2, 2, 5979, 5981, 3, 2, 2, 2, 5980, 5977, 3, 2, 2, 2, 5981, 5984, 3, 2, 2, 2, 5982, 5980, 3, 2, 2, 2, 5982, 5983, 3, 2, 2, 2, 5983, 5985, 3, 2, 2, 2, 5984, 5982, 3, 2, 2, 2, 5985, 5986, 5, 1258, 630, 2, 5986, 685, 3, 2, 2, 2, 5987, 5992, 5, 688, 345, 2, 5988, 5989, 7, 8, 2, 2, 5989, 5991, 5, 688, 345, 2, 5990, 5988, 3, 2, 2, 2, 5991, 5994, 3, 2, 2, 2, 5992, 5990, 3, 2, 2, 2, 5992, 5993, 3, 2, 2, 2, 5993, 687, 3, 2, 2, 2, 5994, 5992, 3, 2, 2, 2, 5995, 5996, 5, 684, 343, 2, 5996, 5997, 5, 682, 342, 2, 5997, 689, 3, 2, 2, 2, 5998, 5999, 7, 59, 2, 2, 5999, 6000, 5, 692, 347, 2, 6000, 691, 3, 2, 2, 2, 6001, 6003, 5, 694, 348, 2, 6002, 6001, 3, 2, 2, 2, 6003, 6004, 3, 2, 2, 2, 6004, 6002, 3, 2, 2, 2, 6004, 6005, 3, 2, 2, 2, 6005, 693, 3, 2, 2, 2, 6006, 6010, 5, 1346, 674, 2, 6007, 6008, 7, 240, 2, 2, 6008, 6010, 5, 72, 37, 2, 6009, 6006, 3, 2, 2, 2, 6009, 6007, 3, 2, 2, 2, 6010, 695, 3, 2, 2, 2, 6011, 6012, 7, 48, 2, 2, 6012, 6013, 7, 43, 2, 2, 6013, 6014, 7, 4, 2, 2, 6014, 6015, 5, 1108, 555, 2, 6015, 6016, 7, 38, 2, 2, 6016, 6017, 5, 1108, 555, 2, 6017, 6018, 7, 5, 2, 2, 6018, 6019, 7, 107, 2, 2, 6019, 6020, 7, 213, 2, 2, 6020, 6022, 5, 626, 314, 2, 6021, 6023, 5, 698, 350, 2, 6022, 6021, 3, 2, 2, 2, 6022, 6023, 3, 2, 2, 2, 6023, 6049, 3, 2, 2, 2, 6024, 6025, 7, 48, 2, 2, 6025, 6026, 7, 43, 2, 2, 6026, 6027, 7, 4, 2, 2, 6027, 6028, 5, 1108, 555, 2, 6028, 6029, 7, 38, 2, 2, 6029, 6030, 5, 1108, 555, 2, 6030, 6031, 7, 5, 2, 2, 6031, 6032, 7, 372, 2, 2, 6032, 6034, 7, 213, 2, 2, 6033, 6035, 5, 698, 350, 2, 6034, 6033, 3, 2, 2, 2, 6034, 6035, 3, 2, 2, 2, 6035, 6049, 3, 2, 2, 2, 6036, 6037, 7, 48, 2, 2, 6037, 6038, 7, 43, 2, 2, 6038, 6039, 7, 4, 2, 2, 6039, 6040, 5, 1108, 555, 2, 6040, 6041, 7, 38, 2, 2, 6041, 6042, 5, 1108, 555, 2, 6042, 6043, 7, 5, 2, 2, 6043, 6044, 7, 107, 2, 2, 6044, 6046, 7, 393, 2, 2, 6045, 6047, 5, 698, 350, 2, 6046, 6045, 3, 2, 2, 2, 6046, 6047, 3, 2, 2, 2, 6047, 6049, 3, 2, 2, 2, 6048, 6011, 3, 2, 2, 2, 6048, 6024, 3, 2, 2, 2, 6048, 6036, 3, 2, 2, 2, 6049, 697, 3, 2, 2, 2, 6050, 6051, 7, 38, 2, 2, 6051, 6055, 7, 225, 2, 2, 6052, 6053, 7, 38, 2, 2, 6053, 6055, 7, 143, 2, 2, 6054, 6050, 3, 2, 2, 2, 6054, 6052, 3, 2, 2, 2, 6055, 699, 3, 2, 2, 2, 6056, 6057, 7, 193, 2, 2, 6057, 6059, 7, 43, 2, 2, 6058, 6060, 5, 702, 352, 2, 6059, 6058, 3, 2, 2, 2, 6059, 6060, 3, 2, 2, 2, 6060, 6061, 3, 2, 2, 2, 6061, 6062, 7, 4, 2, 2, 6062, 6063, 5, 1108, 555, 2, 6063, 6064, 7, 38, 2, 2, 6064, 6065, 5, 1108, 555, 2, 6065, 6067, 7, 5, 2, 2, 6066, 6068, 5, 108, 55, 2, 6067, 6066, 3, 2, 2, 2, 6067, 6068, 3, 2, 2, 2, 6068, 701, 3, 2, 2, 2, 6069, 6070, 7, 222, 2, 2, 6070, 6071, 7, 389, 2, 2, 6071, 703, 3, 2, 2, 2, 6072, 6074, 7, 48, 2, 2, 6073, 6075, 5, 618, 310, 2, 6074, 6073, 3, 2, 2, 2, 6074, 6075, 3, 2, 2, 2, 6075, 6076, 3, 2, 2, 2, 6076, 6077, 7, 436, 2, 2, 6077, 6078, 7, 64, 2, 2, 6078, 6079, 5, 1108, 555, 2, 6079, 6080, 7, 240, 2, 2, 6080, 6081, 5, 1328, 665, 2, 6081, 6082, 7, 4, 2, 2, 6082, 6083, 5, 706, 354, 2, 6083, 6084, 7, 5, 2, 2, 6084, 705, 3, 2, 2, 2, 6085, 6086, 7, 66, 2, 2, 6086, 6087, 7, 454, 2, 2, 6087, 6088, 7, 107, 2, 2, 6088, 6089, 7, 213, 2, 2, 6089, 6090, 5, 626, 314, 2, 6090, 6091, 7, 8, 2, 2, 6091, 6092, 7, 96, 2, 2, 6092, 6093, 7, 454, 2, 2, 6093, 6094, 7, 107, 2, 2, 6094, 6095, 7, 213, 2, 2, 6095, 6096, 5, 626, 314, 2, 6096, 6120, 3, 2, 2, 2, 6097, 6098, 7, 96, 2, 2, 6098, 6099, 7, 454, 2, 2, 6099, 6100, 7, 107, 2, 2, 6100, 6101, 7, 213, 2, 2, 6101, 6102, 5, 626, 314, 2, 6102, 6103, 7, 8, 2, 2, 6103, 6104, 7, 66, 2, 2, 6104, 6105, 7, 454, 2, 2, 6105, 6106, 7, 107, 2, 2, 6106, 6107, 7, 213, 2, 2, 6107, 6108, 5, 626, 314, 2, 6108, 6120, 3, 2, 2, 2, 6109, 6110, 7, 66, 2, 2, 6110, 6111, 7, 454, 2, 2, 6111, 6112, 7, 107, 2, 2, 6112, 6113, 7, 213, 2, 2, 6113, 6120, 5, 626, 314, 2, 6114, 6115, 7, 96, 2, 2, 6115, 6116, 7, 454, 2, 2, 6116, 6117, 7, 107, 2, 2, 6117, 6118, 7, 213, 2, 2, 6118, 6120, 5, 626, 314, 2, 6119, 6085, 3, 2, 2, 2, 6119, 6097, 3, 2, 2, 2, 6119, 6109, 3, 2, 2, 2, 6119, 6114, 3, 2, 2, 2, 6120, 707, 3, 2, 2, 2, 6121, 6122, 7, 193, 2, 2, 6122, 6124, 7, 436, 2, 2, 6123, 6125, 5, 702, 352, 2, 6124, 6123, 3, 2, 2, 2, 6124, 6125, 3, 2, 2, 2, 6125, 6126, 3, 2, 2, 2, 6126, 6127, 7, 64, 2, 2, 6127, 6128, 5, 1108, 555, 2, 6128, 6129, 7, 240, 2, 2, 6129, 6131, 5, 1328, 665, 2, 6130, 6132, 5, 108, 55, 2, 6131, 6130, 3, 2, 2, 2, 6131, 6132, 3, 2, 2, 2, 6132, 709, 3, 2, 2, 2, 6133, 6134, 7, 299, 2, 2, 6134, 6136, 5, 712, 357, 2, 6135, 6137, 5, 592, 297, 2, 6136, 6135, 3, 2, 2, 2, 6136, 6137, 3, 2, 2, 2, 6137, 6138, 3, 2, 2, 2, 6138, 6139, 5, 1324, 663, 2, 6139, 6168, 3, 2, 2, 2, 6140, 6141, 7, 299, 2, 2, 6141, 6143, 5, 714, 358, 2, 6142, 6144, 5, 592, 297, 2, 6143, 6142, 3, 2, 2, 2, 6143, 6144, 3, 2, 2, 2, 6144, 6145, 3, 2, 2, 2, 6145, 6146, 5, 1328, 665, 2, 6146, 6168, 3, 2, 2, 2, 6147, 6148, 7, 299, 2, 2, 6148, 6149, 7, 4, 2, 2, 6149, 6150, 5, 716, 359, 2, 6150, 6151, 7, 5, 2, 2, 6151, 6153, 5, 712, 357, 2, 6152, 6154, 5, 592, 297, 2, 6153, 6152, 3, 2, 2, 2, 6153, 6154, 3, 2, 2, 2, 6154, 6155, 3, 2, 2, 2, 6155, 6156, 5, 1324, 663, 2, 6156, 6168, 3, 2, 2, 2, 6157, 6158, 7, 299, 2, 2, 6158, 6159, 7, 4, 2, 2, 6159, 6160, 5, 716, 359, 2, 6160, 6161, 7, 5, 2, 2, 6161, 6163, 5, 714, 358, 2, 6162, 6164, 5, 592, 297, 2, 6163, 6162, 3, 2, 2, 2, 6163, 6164, 3, 2, 2, 2, 6164, 6165, 3, 2, 2, 2, 6165, 6166, 5, 1328, 665, 2, 6166, 6168, 3, 2, 2, 2, 6167, 6133, 3, 2, 2, 2, 6167, 6140, 3, 2, 2, 2, 6167, 6147, 3, 2, 2, 2, 6167, 6157, 3, 2, 2, 2, 6168, 711, 3, 2, 2, 2, 6169, 6170, 9, 21, 2, 2, 6170, 713, 3, 2, 2, 2, 6171, 6172, 9, 32, 2, 2, 6172, 715, 3, 2, 2, 2, 6173, 6178, 5, 718, 360, 2, 6174, 6175, 7, 8, 2, 2, 6175, 6177, 5, 718, 360, 2, 6176, 6174, 3, 2, 2, 2, 6177, 6180, 3, 2, 2, 2, 6178, 6176, 3, 2, 2, 2, 6178, 6179, 3, 2, 2, 2, 6179, 717, 3, 2, 2, 2, 6180, 6178, 3, 2, 2, 2, 6181, 6182, 7, 130, 2, 2, 6182, 719, 3, 2, 2, 2, 6183, 6184, 7, 140, 2, 2, 6184, 6185, 7, 344, 2, 2, 6185, 6186, 5, 1328, 665, 2, 6186, 6187, 7, 326, 2, 2, 6187, 6188, 5, 116, 59, 2, 6188, 6196, 3, 2, 2, 2, 6189, 6190, 7, 140, 2, 2, 6190, 6191, 7, 344, 2, 2, 6191, 6192, 5, 1328, 665, 2, 6192, 6193, 7, 306, 2, 2, 6193, 6194, 5, 116, 59, 2, 6194, 6196, 3, 2, 2, 2, 6195, 6183, 3, 2, 2, 2, 6195, 6189, 3, 2, 2, 2, 6196, 721, 3, 2, 2, 2, 6197, 6198, 7, 140, 2, 2, 6198, 6199, 7, 138, 2, 2, 6199, 6200, 5, 650, 326, 2, 6200, 6201, 7, 302, 2, 2, 6201, 6202, 7, 96, 2, 2, 6202, 6203, 5, 1328, 665, 2, 6203, 6685, 3, 2, 2, 2, 6204, 6205, 7, 140, 2, 2, 6205, 6206, 7, 110, 2, 2, 6206, 6207, 5, 524, 263, 2, 6207, 6208, 7, 302, 2, 2, 6208, 6209, 7, 96, 2, 2, 6209, 6210, 5, 1328, 665, 2, 6210, 6685, 3, 2, 2, 2, 6211, 6212, 7, 140, 2, 2, 6212, 6213, 7, 170, 2, 2, 6213, 6214, 5, 524, 263, 2, 6214, 6215, 7, 302, 2, 2, 6215, 6216, 7, 96, 2, 2, 6216, 6217, 5, 1328, 665, 2, 6217, 6685, 3, 2, 2, 2, 6218, 6219, 7, 140, 2, 2, 6219, 6220, 7, 177, 2, 2, 6220, 6221, 5, 1328, 665, 2, 6221, 6222, 7, 302, 2, 2, 6222, 6223, 7, 96, 2, 2, 6223, 6224, 5, 1328, 665, 2, 6224, 6685, 3, 2, 2, 2, 6225, 6226, 7, 140, 2, 2, 6226, 6227, 7, 191, 2, 2, 6227, 6228, 5, 524, 263, 2, 6228, 6229, 7, 302, 2, 2, 6229, 6230, 7, 96, 2, 2, 6230, 6231, 5, 1328, 665, 2, 6231, 6685, 3, 2, 2, 2, 6232, 6233, 7, 140, 2, 2, 6233, 6234, 7, 191, 2, 2, 6234, 6235, 5, 524, 263, 2, 6235, 6236, 7, 302, 2, 2, 6236, 6237, 7, 47, 2, 2, 6237, 6238, 5, 1328, 665, 2, 6238, 6239, 7, 96, 2, 2, 6239, 6240, 5, 1328, 665, 2, 6240, 6685, 3, 2, 2, 2, 6241, 6242, 7, 140, 2, 2, 6242, 6243, 7, 65, 2, 2, 6243, 6244, 7, 176, 2, 2, 6244, 6245, 7, 374, 2, 2, 6245, 6246, 5, 1328, 665, 2, 6246, 6247, 7, 302, 2, 2, 6247, 6248, 7, 96, 2, 2, 6248, 6249, 5, 1328, 665, 2, 6249, 6685, 3, 2, 2, 2, 6250, 6251, 7, 140, 2, 2, 6251, 6252, 7, 213, 2, 2, 6252, 6253, 5, 626, 314, 2, 6253, 6254, 7, 302, 2, 2, 6254, 6255, 7, 96, 2, 2, 6255, 6256, 5, 1328, 665, 2, 6256, 6685, 3, 2, 2, 2, 6257, 6258, 7, 140, 2, 2, 6258, 6259, 7, 68, 2, 2, 6259, 6260, 5, 1354, 678, 2, 6260, 6261, 7, 302, 2, 2, 6261, 6262, 7, 96, 2, 2, 6262, 6263, 5, 1354, 678, 2, 6263, 6685, 3, 2, 2, 2, 6264, 6266, 7, 140, 2, 2, 6265, 6267, 5, 308, 155, 2, 6266, 6265, 3, 2, 2, 2, 6266, 6267, 3, 2, 2, 2, 6267, 6268, 3, 2, 2, 2, 6268, 6269, 7, 240, 2, 2, 6269, 6270, 5, 1328, 665, 2, 6270, 6271, 7, 302, 2, 2, 6271, 6272, 7, 96, 2, 2, 6272, 6273, 5, 1328, 665, 2, 6273, 6685, 3, 2, 2, 2, 6274, 6275, 7, 140, 2, 2, 6275, 6276, 7, 271, 2, 2, 6276, 6277, 7, 158, 2, 2, 6277, 6278, 5, 524, 263, 2, 6278, 6279, 7, 102, 2, 2, 6279, 6280, 5, 1328, 665, 2, 6280, 6281, 7, 302, 2, 2, 6281, 6282, 7, 96, 2, 2, 6282, 6283, 5, 1328, 665, 2, 6283, 6685, 3, 2, 2, 2, 6284, 6285, 7, 140, 2, 2, 6285, 6286, 7, 271, 2, 2, 6286, 6287, 7, 208, 2, 2, 6287, 6288, 5, 524, 263, 2, 6288, 6289, 7, 102, 2, 2, 6289, 6290, 5, 1328, 665, 2, 6290, 6291, 7, 302, 2, 2, 6291, 6292, 7, 96, 2, 2, 6292, 6293, 5, 1328, 665, 2, 6293, 6685, 3, 2, 2, 2, 6294, 6295, 7, 140, 2, 2, 6295, 6296, 7, 438, 2, 2, 6296, 6297, 5, 1328, 665, 2, 6297, 6298, 7, 82, 2, 2, 6298, 6299, 5, 1324, 663, 2, 6299, 6300, 7, 302, 2, 2, 6300, 6301, 7, 96, 2, 2, 6301, 6302, 5, 1328, 665, 2, 6302, 6685, 3, 2, 2, 2, 6303, 6304, 7, 140, 2, 2, 6304, 6305, 7, 438, 2, 2, 6305, 6306, 7, 222, 2, 2, 6306, 6307, 7, 389, 2, 2, 6307, 6308, 5, 1328, 665, 2, 6308, 6309, 7, 82, 2, 2, 6309, 6310, 5, 1324, 663, 2, 6310, 6311, 7, 302, 2, 2, 6311, 6312, 7, 96, 2, 2, 6312, 6313, 5, 1328, 665, 2, 6313, 6685, 3, 2, 2, 2, 6314, 6315, 7, 140, 2, 2, 6315, 6316, 7, 289, 2, 2, 6316, 6317, 5, 626, 314, 2, 6317, 6318, 7, 302, 2, 2, 6318, 6319, 7, 96, 2, 2, 6319, 6320, 5, 1328, 665, 2, 6320, 6685, 3, 2, 2, 2, 6321, 6322, 7, 140, 2, 2, 6322, 6323, 7, 445, 2, 2, 6323, 6324, 5, 1328, 665, 2, 6324, 6325, 7, 302, 2, 2, 6325, 6326, 7, 96, 2, 2, 6326, 6327, 5, 1328, 665, 2, 6327, 6685, 3, 2, 2, 2, 6328, 6329, 7, 140, 2, 2, 6329, 6330, 7, 435, 2, 2, 6330, 6331, 5, 626, 314, 2, 6331, 6332, 7, 302, 2, 2, 6332, 6333, 7, 96, 2, 2, 6333, 6334, 5, 1328, 665, 2, 6334, 6685, 3, 2, 2, 2, 6335, 6336, 7, 140, 2, 2, 6336, 6337, 7, 316, 2, 2, 6337, 6338, 5, 1328, 665, 2, 6338, 6339, 7, 302, 2, 2, 6339, 6340, 7, 96, 2, 2, 6340, 6341, 5, 1328, 665, 2, 6341, 6685, 3, 2, 2, 2, 6342, 6343, 7, 140, 2, 2, 6343, 6344, 7, 324, 2, 2, 6344, 6345, 5, 1328, 665, 2, 6345, 6346, 7, 302, 2, 2, 6346, 6347, 7, 96, 2, 2, 6347, 6348, 5, 1328, 665, 2, 6348, 6685, 3, 2, 2, 2, 6349, 6350, 7, 140, 2, 2, 6350, 6351, 7, 444, 2, 2, 6351, 6352, 5, 1328, 665, 2, 6352, 6353, 7, 302, 2, 2, 6353, 6354, 7, 96, 2, 2, 6354, 6355, 5, 1328, 665, 2, 6355, 6685, 3, 2, 2, 2, 6356, 6357, 7, 140, 2, 2, 6357, 6358, 7, 94, 2, 2, 6358, 6359, 5, 1064, 533, 2, 6359, 6360, 7, 302, 2, 2, 6360, 6361, 7, 96, 2, 2, 6361, 6362, 5, 1328, 665, 2, 6362, 6685, 3, 2, 2, 2, 6363, 6364, 7, 140, 2, 2, 6364, 6365, 7, 94, 2, 2, 6365, 6366, 7, 222, 2, 2, 6366, 6367, 7, 389, 2, 2, 6367, 6368, 5, 1064, 533, 2, 6368, 6369, 7, 302, 2, 2, 6369, 6370, 7, 96, 2, 2, 6370, 6371, 5, 1328, 665, 2, 6371, 6685, 3, 2, 2, 2, 6372, 6373, 7, 140, 2, 2, 6373, 6374, 7, 321, 2, 2, 6374, 6375, 5, 1324, 663, 2, 6375, 6376, 7, 302, 2, 2, 6376, 6377, 7, 96, 2, 2, 6377, 6378, 5, 1328, 665, 2, 6378, 6685, 3, 2, 2, 2, 6379, 6380, 7, 140, 2, 2, 6380, 6381, 7, 321, 2, 2, 6381, 6382, 7, 222, 2, 2, 6382, 6383, 7, 389, 2, 2, 6383, 6384, 5, 1324, 663, 2, 6384, 6385, 7, 302, 2, 2, 6385, 6386, 7, 96, 2, 2, 6386, 6387, 5, 1328, 665, 2, 6387, 6685, 3, 2, 2, 2, 6388, 6389, 7, 140, 2, 2, 6389, 6390, 7, 369, 2, 2, 6390, 6391, 5, 1324, 663, 2, 6391, 6392, 7, 302, 2, 2, 6392, 6393, 7, 96, 2, 2, 6393, 6394, 5, 1328, 665, 2, 6394, 6685, 3, 2, 2, 2, 6395, 6396, 7, 140, 2, 2, 6396, 6397, 7, 369, 2, 2, 6397, 6398, 7, 222, 2, 2, 6398, 6399, 7, 389, 2, 2, 6399, 6400, 5, 1324, 663, 2, 6400, 6401, 7, 302, 2, 2, 6401, 6402, 7, 96, 2, 2, 6402, 6403, 5, 1328, 665, 2, 6403, 6685, 3, 2, 2, 2, 6404, 6405, 7, 140, 2, 2, 6405, 6406, 7, 252, 2, 2, 6406, 6407, 7, 369, 2, 2, 6407, 6408, 5, 1324, 663, 2, 6408, 6409, 7, 302, 2, 2, 6409, 6410, 7, 96, 2, 2, 6410, 6411, 5, 1328, 665, 2, 6411, 6685, 3, 2, 2, 2, 6412, 6413, 7, 140, 2, 2, 6413, 6414, 7, 252, 2, 2, 6414, 6415, 7, 369, 2, 2, 6415, 6416, 7, 222, 2, 2, 6416, 6417, 7, 389, 2, 2, 6417, 6418, 5, 1324, 663, 2, 6418, 6419, 7, 302, 2, 2, 6419, 6420, 7, 96, 2, 2, 6420, 6421, 5, 1328, 665, 2, 6421, 6685, 3, 2, 2, 2, 6422, 6423, 7, 140, 2, 2, 6423, 6424, 7, 228, 2, 2, 6424, 6425, 5, 1324, 663, 2, 6425, 6426, 7, 302, 2, 2, 6426, 6427, 7, 96, 2, 2, 6427, 6428, 5, 1328, 665, 2, 6428, 6685, 3, 2, 2, 2, 6429, 6430, 7, 140, 2, 2, 6430, 6431, 7, 228, 2, 2, 6431, 6432, 7, 222, 2, 2, 6432, 6433, 7, 389, 2, 2, 6433, 6434, 5, 1324, 663, 2, 6434, 6435, 7, 302, 2, 2, 6435, 6436, 7, 96, 2, 2, 6436, 6437, 5, 1328, 665, 2, 6437, 6685, 3, 2, 2, 2, 6438, 6439, 7, 140, 2, 2, 6439, 6440, 7, 65, 2, 2, 6440, 6441, 7, 94, 2, 2, 6441, 6442, 5, 1064, 533, 2, 6442, 6443, 7, 302, 2, 2, 6443, 6444, 7, 96, 2, 2, 6444, 6445, 5, 1328, 665, 2, 6445, 6685, 3, 2, 2, 2, 6446, 6447, 7, 140, 2, 2, 6447, 6448, 7, 65, 2, 2, 6448, 6449, 7, 94, 2, 2, 6449, 6450, 7, 222, 2, 2, 6450, 6451, 7, 389, 2, 2, 6451, 6452, 5, 1064, 533, 2, 6452, 6453, 7, 302, 2, 2, 6453, 6454, 7, 96, 2, 2, 6454, 6455, 5, 1328, 665, 2, 6455, 6685, 3, 2, 2, 2, 6456, 6457, 7, 140, 2, 2, 6457, 6458, 7, 94, 2, 2, 6458, 6459, 5, 1064, 533, 2, 6459, 6461, 7, 302, 2, 2, 6460, 6462, 5, 724, 363, 2, 6461, 6460, 3, 2, 2, 2, 6461, 6462, 3, 2, 2, 2, 6462, 6463, 3, 2, 2, 2, 6463, 6464, 5, 1328, 665, 2, 6464, 6465, 7, 96, 2, 2, 6465, 6466, 5, 1328, 665, 2, 6466, 6685, 3, 2, 2, 2, 6467, 6468, 7, 140, 2, 2, 6468, 6469, 7, 94, 2, 2, 6469, 6470, 7, 222, 2, 2, 6470, 6471, 7, 389, 2, 2, 6471, 6472, 5, 1064, 533, 2, 6472, 6474, 7, 302, 2, 2, 6473, 6475, 5, 724, 363, 2, 6474, 6473, 3, 2, 2, 2, 6474, 6475, 3, 2, 2, 2, 6475, 6476, 3, 2, 2, 2, 6476, 6477, 5, 1328, 665, 2, 6477, 6478, 7, 96, 2, 2, 6478, 6479, 5, 1328, 665, 2, 6479, 6685, 3, 2, 2, 2, 6480, 6481, 7, 140, 2, 2, 6481, 6482, 7, 369, 2, 2, 6482, 6483, 5, 1324, 663, 2, 6483, 6485, 7, 302, 2, 2, 6484, 6486, 5, 724, 363, 2, 6485, 6484, 3, 2, 2, 2, 6485, 6486, 3, 2, 2, 2, 6486, 6487, 3, 2, 2, 2, 6487, 6488, 5, 1328, 665, 2, 6488, 6489, 7, 96, 2, 2, 6489, 6490, 5, 1328, 665, 2, 6490, 6685, 3, 2, 2, 2, 6491, 6492, 7, 140, 2, 2, 6492, 6493, 7, 369, 2, 2, 6493, 6494, 7, 222, 2, 2, 6494, 6495, 7, 389, 2, 2, 6495, 6496, 5, 1324, 663, 2, 6496, 6498, 7, 302, 2, 2, 6497, 6499, 5, 724, 363, 2, 6498, 6497, 3, 2, 2, 2, 6498, 6499, 3, 2, 2, 2, 6499, 6500, 3, 2, 2, 2, 6500, 6501, 5, 1328, 665, 2, 6501, 6502, 7, 96, 2, 2, 6502, 6503, 5, 1328, 665, 2, 6503, 6685, 3, 2, 2, 2, 6504, 6505, 7, 140, 2, 2, 6505, 6506, 7, 252, 2, 2, 6506, 6507, 7, 369, 2, 2, 6507, 6508, 5, 1324, 663, 2, 6508, 6510, 7, 302, 2, 2, 6509, 6511, 5, 724, 363, 2, 6510, 6509, 3, 2, 2, 2, 6510, 6511, 3, 2, 2, 2, 6511, 6512, 3, 2, 2, 2, 6512, 6513, 5, 1328, 665, 2, 6513, 6514, 7, 96, 2, 2, 6514, 6515, 5, 1328, 665, 2, 6515, 6685, 3, 2, 2, 2, 6516, 6517, 7, 140, 2, 2, 6517, 6518, 7, 252, 2, 2, 6518, 6519, 7, 369, 2, 2, 6519, 6520, 7, 222, 2, 2, 6520, 6521, 7, 389, 2, 2, 6521, 6522, 5, 1324, 663, 2, 6522, 6524, 7, 302, 2, 2, 6523, 6525, 5, 724, 363, 2, 6524, 6523, 3, 2, 2, 2, 6524, 6525, 3, 2, 2, 2, 6525, 6526, 3, 2, 2, 2, 6526, 6527, 5, 1328, 665, 2, 6527, 6528, 7, 96, 2, 2, 6528, 6529, 5, 1328, 665, 2, 6529, 6685, 3, 2, 2, 2, 6530, 6531, 7, 140, 2, 2, 6531, 6532, 7, 94, 2, 2, 6532, 6533, 5, 1064, 533, 2, 6533, 6534, 7, 302, 2, 2, 6534, 6535, 7, 47, 2, 2, 6535, 6536, 5, 1328, 665, 2, 6536, 6537, 7, 96, 2, 2, 6537, 6538, 5, 1328, 665, 2, 6538, 6685, 3, 2, 2, 2, 6539, 6540, 7, 140, 2, 2, 6540, 6541, 7, 94, 2, 2, 6541, 6542, 7, 222, 2, 2, 6542, 6543, 7, 389, 2, 2, 6543, 6544, 5, 1064, 533, 2, 6544, 6545, 7, 302, 2, 2, 6545, 6546, 7, 47, 2, 2, 6546, 6547, 5, 1328, 665, 2, 6547, 6548, 7, 96, 2, 2, 6548, 6549, 5, 1328, 665, 2, 6549, 6685, 3, 2, 2, 2, 6550, 6551, 7, 140, 2, 2, 6551, 6552, 7, 65, 2, 2, 6552, 6553, 7, 94, 2, 2, 6553, 6554, 5, 1064, 533, 2, 6554, 6556, 7, 302, 2, 2, 6555, 6557, 5, 724, 363, 2, 6556, 6555, 3, 2, 2, 2, 6556, 6557, 3, 2, 2, 2, 6557, 6558, 3, 2, 2, 2, 6558, 6559, 5, 1328, 665, 2, 6559, 6560, 7, 96, 2, 2, 6560, 6561, 5, 1328, 665, 2, 6561, 6685, 3, 2, 2, 2, 6562, 6563, 7, 140, 2, 2, 6563, 6564, 7, 65, 2, 2, 6564, 6565, 7, 94, 2, 2, 6565, 6566, 7, 222, 2, 2, 6566, 6567, 7, 389, 2, 2, 6567, 6568, 5, 1064, 533, 2, 6568, 6570, 7, 302, 2, 2, 6569, 6571, 5, 724, 363, 2, 6570, 6569, 3, 2, 2, 2, 6570, 6571, 3, 2, 2, 2, 6571, 6572, 3, 2, 2, 2, 6572, 6573, 5, 1328, 665, 2, 6573, 6574, 7, 96, 2, 2, 6574, 6575, 5, 1328, 665, 2, 6575, 6685, 3, 2, 2, 2, 6576, 6577, 7, 140, 2, 2, 6577, 6578, 7, 314, 2, 2, 6578, 6579, 5, 1328, 665, 2, 6579, 6580, 7, 82, 2, 2, 6580, 6581, 5, 1324, 663, 2, 6581, 6582, 7, 302, 2, 2, 6582, 6583, 7, 96, 2, 2, 6583, 6584, 5, 1328, 665, 2, 6584, 6685, 3, 2, 2, 2, 6585, 6586, 7, 140, 2, 2, 6586, 6587, 7, 350, 2, 2, 6587, 6588, 5, 1328, 665, 2, 6588, 6589, 7, 82, 2, 2, 6589, 6590, 5, 1324, 663, 2, 6590, 6591, 7, 302, 2, 2, 6591, 6592, 7, 96, 2, 2, 6592, 6593, 5, 1328, 665, 2, 6593, 6685, 3, 2, 2, 2, 6594, 6595, 7, 140, 2, 2, 6595, 6596, 7, 200, 2, 2, 6596, 6597, 7, 350, 2, 2, 6597, 6598, 5, 1328, 665, 2, 6598, 6599, 7, 302, 2, 2, 6599, 6600, 7, 96, 2, 2, 6600, 6601, 5, 1328, 665, 2, 6601, 6685, 3, 2, 2, 2, 6602, 6603, 7, 140, 2, 2, 6603, 6604, 7, 311, 2, 2, 6604, 6605, 5, 1354, 678, 2, 6605, 6606, 7, 302, 2, 2, 6606, 6607, 7, 96, 2, 2, 6607, 6608, 5, 1354, 678, 2, 6608, 6685, 3, 2, 2, 2, 6609, 6610, 7, 140, 2, 2, 6610, 6611, 7, 101, 2, 2, 6611, 6612, 5, 1354, 678, 2, 6612, 6613, 7, 302, 2, 2, 6613, 6614, 7, 96, 2, 2, 6614, 6615, 5, 1354, 678, 2, 6615, 6685, 3, 2, 2, 2, 6616, 6617, 7, 140, 2, 2, 6617, 6618, 7, 344, 2, 2, 6618, 6619, 5, 1328, 665, 2, 6619, 6620, 7, 302, 2, 2, 6620, 6621, 7, 96, 2, 2, 6621, 6622, 5, 1328, 665, 2, 6622, 6685, 3, 2, 2, 2, 6623, 6624, 7, 140, 2, 2, 6624, 6625, 7, 335, 2, 2, 6625, 6626, 5, 524, 263, 2, 6626, 6627, 7, 302, 2, 2, 6627, 6628, 7, 96, 2, 2, 6628, 6629, 5, 1328, 665, 2, 6629, 6685, 3, 2, 2, 2, 6630, 6631, 7, 140, 2, 2, 6631, 6632, 7, 348, 2, 2, 6632, 6633, 7, 318, 2, 2, 6633, 6634, 7, 276, 2, 2, 6634, 6635, 5, 524, 263, 2, 6635, 6636, 7, 302, 2, 2, 6636, 6637, 7, 96, 2, 2, 6637, 6638, 5, 1328, 665, 2, 6638, 6685, 3, 2, 2, 2, 6639, 6640, 7, 140, 2, 2, 6640, 6641, 7, 348, 2, 2, 6641, 6642, 7, 318, 2, 2, 6642, 6643, 7, 187, 2, 2, 6643, 6644, 5, 524, 263, 2, 6644, 6645, 7, 302, 2, 2, 6645, 6646, 7, 96, 2, 2, 6646, 6647, 5, 1328, 665, 2, 6647, 6685, 3, 2, 2, 2, 6648, 6649, 7, 140, 2, 2, 6649, 6650, 7, 348, 2, 2, 6650, 6651, 7, 318, 2, 2, 6651, 6652, 7, 346, 2, 2, 6652, 6653, 5, 524, 263, 2, 6653, 6654, 7, 302, 2, 2, 6654, 6655, 7, 96, 2, 2, 6655, 6656, 5, 1328, 665, 2, 6656, 6685, 3, 2, 2, 2, 6657, 6658, 7, 140, 2, 2, 6658, 6659, 7, 348, 2, 2, 6659, 6660, 7, 318, 2, 2, 6660, 6661, 7, 165, 2, 2, 6661, 6662, 5, 524, 263, 2, 6662, 6663, 7, 302, 2, 2, 6663, 6664, 7, 96, 2, 2, 6664, 6665, 5, 1328, 665, 2, 6665, 6685, 3, 2, 2, 2, 6666, 6667, 7, 140, 2, 2, 6667, 6668, 7, 353, 2, 2, 6668, 6669, 5, 524, 263, 2, 6669, 6670, 7, 302, 2, 2, 6670, 6671, 7, 96, 2, 2, 6671, 6672, 5, 1328, 665, 2, 6672, 6685, 3, 2, 2, 2, 6673, 6674, 7, 140, 2, 2, 6674, 6675, 7, 353, 2, 2, 6675, 6676, 5, 524, 263, 2, 6676, 6677, 7, 302, 2, 2, 6677, 6678, 7, 145, 2, 2, 6678, 6679, 5, 1328, 665, 2, 6679, 6680, 7, 96, 2, 2, 6680, 6682, 5, 1328, 665, 2, 6681, 6683, 5, 108, 55, 2, 6682, 6681, 3, 2, 2, 2, 6682, 6683, 3, 2, 2, 2, 6683, 6685, 3, 2, 2, 2, 6684, 6197, 3, 2, 2, 2, 6684, 6204, 3, 2, 2, 2, 6684, 6211, 3, 2, 2, 2, 6684, 6218, 3, 2, 2, 2, 6684, 6225, 3, 2, 2, 2, 6684, 6232, 3, 2, 2, 2, 6684, 6241, 3, 2, 2, 2, 6684, 6250, 3, 2, 2, 2, 6684, 6257, 3, 2, 2, 2, 6684, 6264, 3, 2, 2, 2, 6684, 6274, 3, 2, 2, 2, 6684, 6284, 3, 2, 2, 2, 6684, 6294, 3, 2, 2, 2, 6684, 6303, 3, 2, 2, 2, 6684, 6314, 3, 2, 2, 2, 6684, 6321, 3, 2, 2, 2, 6684, 6328, 3, 2, 2, 2, 6684, 6335, 3, 2, 2, 2, 6684, 6342, 3, 2, 2, 2, 6684, 6349, 3, 2, 2, 2, 6684, 6356, 3, 2, 2, 2, 6684, 6363, 3, 2, 2, 2, 6684, 6372, 3, 2, 2, 2, 6684, 6379, 3, 2, 2, 2, 6684, 6388, 3, 2, 2, 2, 6684, 6395, 3, 2, 2, 2, 6684, 6404, 3, 2, 2, 2, 6684, 6412, 3, 2, 2, 2, 6684, 6422, 3, 2, 2, 2, 6684, 6429, 3, 2, 2, 2, 6684, 6438, 3, 2, 2, 2, 6684, 6446, 3, 2, 2, 2, 6684, 6456, 3, 2, 2, 2, 6684, 6467, 3, 2, 2, 2, 6684, 6480, 3, 2, 2, 2, 6684, 6491, 3, 2, 2, 2, 6684, 6504, 3, 2, 2, 2, 6684, 6516, 3, 2, 2, 2, 6684, 6530, 3, 2, 2, 2, 6684, 6539, 3, 2, 2, 2, 6684, 6550, 3, 2, 2, 2, 6684, 6562, 3, 2, 2, 2, 6684, 6576, 3, 2, 2, 2, 6684, 6585, 3, 2, 2, 2, 6684, 6594, 3, 2, 2, 2, 6684, 6602, 3, 2, 2, 2, 6684, 6609, 3, 2, 2, 2, 6684, 6616, 3, 2, 2, 2, 6684, 6623, 3, 2, 2, 2, 6684, 6630, 3, 2, 2, 2, 6684, 6639, 3, 2, 2, 2, 6684, 6648, 3, 2, 2, 2, 6684, 6657, 3, 2, 2, 2, 6684, 6666, 3, 2, 2, 2, 6684, 6673, 3, 2, 2, 2, 6685, 723, 3, 2, 2, 2, 6686, 6687, 7, 46, 2, 2, 6687, 725, 3, 2, 2, 2, 6688, 6689, 7, 326, 2, 2, 6689, 6690, 7, 176, 2, 2, 6690, 727, 3, 2, 2, 2, 6691, 6692, 7, 140, 2, 2, 6692, 6693, 7, 213, 2, 2, 6693, 6695, 5, 626, 314, 2, 6694, 6696, 5, 730, 366, 2, 6695, 6694, 3, 2, 2, 2, 6695, 6696, 3, 2, 2, 2, 6696, 6697, 3, 2, 2, 2, 6697, 6698, 7, 455, 2, 2, 6698, 6699, 7, 82, 2, 2, 6699, 6700, 7, 206, 2, 2, 6700, 6701, 5, 1328, 665, 2, 6701, 6761, 3, 2, 2, 2, 6702, 6703, 7, 140, 2, 2, 6703, 6704, 7, 289, 2, 2, 6704, 6706, 5, 626, 314, 2, 6705, 6707, 5, 730, 366, 2, 6706, 6705, 3, 2, 2, 2, 6706, 6707, 3, 2, 2, 2, 6707, 6708, 3, 2, 2, 2, 6708, 6709, 7, 455, 2, 2, 6709, 6710, 7, 82, 2, 2, 6710, 6711, 7, 206, 2, 2, 6711, 6712, 5, 1328, 665, 2, 6712, 6761, 3, 2, 2, 2, 6713, 6714, 7, 140, 2, 2, 6714, 6715, 7, 435, 2, 2, 6715, 6717, 5, 626, 314, 2, 6716, 6718, 5, 730, 366, 2, 6717, 6716, 3, 2, 2, 2, 6717, 6718, 3, 2, 2, 2, 6718, 6719, 3, 2, 2, 2, 6719, 6720, 7, 455, 2, 2, 6720, 6721, 7, 82, 2, 2, 6721, 6722, 7, 206, 2, 2, 6722, 6723, 5, 1328, 665, 2, 6723, 6761, 3, 2, 2, 2, 6724, 6725, 7, 140, 2, 2, 6725, 6726, 7, 350, 2, 2, 6726, 6727, 5, 1328, 665, 2, 6727, 6728, 7, 82, 2, 2, 6728, 6730, 5, 1324, 663, 2, 6729, 6731, 5, 730, 366, 2, 6730, 6729, 3, 2, 2, 2, 6730, 6731, 3, 2, 2, 2, 6731, 6732, 3, 2, 2, 2, 6732, 6733, 7, 455, 2, 2, 6733, 6734, 7, 82, 2, 2, 6734, 6735, 7, 206, 2, 2, 6735, 6736, 5, 1328, 665, 2, 6736, 6761, 3, 2, 2, 2, 6737, 6738, 7, 140, 2, 2, 6738, 6739, 7, 252, 2, 2, 6739, 6740, 7, 369, 2, 2, 6740, 6742, 5, 1324, 663, 2, 6741, 6743, 5, 730, 366, 2, 6742, 6741, 3, 2, 2, 2, 6742, 6743, 3, 2, 2, 2, 6743, 6744, 3, 2, 2, 2, 6744, 6745, 7, 455, 2, 2, 6745, 6746, 7, 82, 2, 2, 6746, 6747, 7, 206, 2, 2, 6747, 6748, 5, 1328, 665, 2, 6748, 6761, 3, 2, 2, 2, 6749, 6750, 7, 140, 2, 2, 6750, 6751, 7, 228, 2, 2, 6751, 6753, 5, 1324, 663, 2, 6752, 6754, 5, 730, 366, 2, 6753, 6752, 3, 2, 2, 2, 6753, 6754, 3, 2, 2, 2, 6754, 6755, 3, 2, 2, 2, 6755, 6756, 7, 455, 2, 2, 6756, 6757, 7, 82, 2, 2, 6757, 6758, 7, 206, 2, 2, 6758, 6759, 5, 1328, 665, 2, 6759, 6761, 3, 2, 2, 2, 6760, 6691, 3, 2, 2, 2, 6760, 6702, 3, 2, 2, 2, 6760, 6713, 3, 2, 2, 2, 6760, 6724, 3, 2, 2, 2, 6760, 6737, 3, 2, 2, 2, 6760, 6749, 3, 2, 2, 2, 6761, 729, 3, 2, 2, 2, 6762, 6763, 7, 262, 2, 2, 6763, 731, 3, 2, 2, 2, 6764, 6765, 7, 140, 2, 2, 6765, 6766, 7, 138, 2, 2, 6766, 6767, 5, 650, 326, 2, 6767, 6768, 7, 326, 2, 2, 6768, 6769, 7, 316, 2, 2, 6769, 6770, 5, 1328, 665, 2, 6770, 6982, 3, 2, 2, 2, 6771, 6772, 7, 140, 2, 2, 6772, 6773, 7, 110, 2, 2, 6773, 6774, 5, 524, 263, 2, 6774, 6775, 7, 326, 2, 2, 6775, 6776, 7, 316, 2, 2, 6776, 6777, 5, 1328, 665, 2, 6777, 6982, 3, 2, 2, 2, 6778, 6779, 7, 140, 2, 2, 6779, 6780, 7, 170, 2, 2, 6780, 6781, 5, 524, 263, 2, 6781, 6782, 7, 326, 2, 2, 6782, 6783, 7, 316, 2, 2, 6783, 6784, 5, 1328, 665, 2, 6784, 6982, 3, 2, 2, 2, 6785, 6786, 7, 140, 2, 2, 6786, 6787, 7, 191, 2, 2, 6787, 6788, 5, 524, 263, 2, 6788, 6789, 7, 326, 2, 2, 6789, 6790, 7, 316, 2, 2, 6790, 6791, 5, 1328, 665, 2, 6791, 6982, 3, 2, 2, 2, 6792, 6793, 7, 140, 2, 2, 6793, 6794, 7, 206, 2, 2, 6794, 6795, 5, 1328, 665, 2, 6795, 6796, 7, 326, 2, 2, 6796, 6797, 7, 316, 2, 2, 6797, 6798, 5, 1328, 665, 2, 6798, 6982, 3, 2, 2, 2, 6799, 6800, 7, 140, 2, 2, 6800, 6801, 7, 213, 2, 2, 6801, 6802, 5, 626, 314, 2, 6802, 6803, 7, 326, 2, 2, 6803, 6804, 7, 316, 2, 2, 6804, 6805, 5, 1328, 665, 2, 6805, 6982, 3, 2, 2, 2, 6806, 6807, 7, 140, 2, 2, 6807, 6808, 7, 271, 2, 2, 6808, 6809, 5, 688, 345, 2, 6809, 6810, 7, 326, 2, 2, 6810, 6811, 7, 316, 2, 2, 6811, 6812, 5, 1328, 665, 2, 6812, 6982, 3, 2, 2, 2, 6813, 6814, 7, 140, 2, 2, 6814, 6815, 7, 271, 2, 2, 6815, 6816, 7, 158, 2, 2, 6816, 6817, 5, 524, 263, 2, 6817, 6818, 7, 102, 2, 2, 6818, 6819, 5, 1328, 665, 2, 6819, 6820, 7, 326, 2, 2, 6820, 6821, 7, 316, 2, 2, 6821, 6822, 5, 1328, 665, 2, 6822, 6982, 3, 2, 2, 2, 6823, 6824, 7, 140, 2, 2, 6824, 6825, 7, 271, 2, 2, 6825, 6826, 7, 208, 2, 2, 6826, 6827, 5, 524, 263, 2, 6827, 6828, 7, 102, 2, 2, 6828, 6829, 5, 1328, 665, 2, 6829, 6830, 7, 326, 2, 2, 6830, 6831, 7, 316, 2, 2, 6831, 6832, 5, 1328, 665, 2, 6832, 6982, 3, 2, 2, 2, 6833, 6834, 7, 140, 2, 2, 6834, 6835, 7, 289, 2, 2, 6835, 6836, 5, 626, 314, 2, 6836, 6837, 7, 326, 2, 2, 6837, 6838, 7, 316, 2, 2, 6838, 6839, 5, 1328, 665, 2, 6839, 6982, 3, 2, 2, 2, 6840, 6841, 7, 140, 2, 2, 6841, 6842, 7, 435, 2, 2, 6842, 6843, 5, 626, 314, 2, 6843, 6844, 7, 326, 2, 2, 6844, 6845, 7, 316, 2, 2, 6845, 6846, 5, 1328, 665, 2, 6846, 6982, 3, 2, 2, 2, 6847, 6848, 7, 140, 2, 2, 6848, 6849, 7, 94, 2, 2, 6849, 6850, 5, 1064, 533, 2, 6850, 6851, 7, 326, 2, 2, 6851, 6852, 7, 316, 2, 2, 6852, 6853, 5, 1328, 665, 2, 6853, 6982, 3, 2, 2, 2, 6854, 6855, 7, 140, 2, 2, 6855, 6856, 7, 94, 2, 2, 6856, 6857, 7, 222, 2, 2, 6857, 6858, 7, 389, 2, 2, 6858, 6859, 5, 1064, 533, 2, 6859, 6860, 7, 326, 2, 2, 6860, 6861, 7, 316, 2, 2, 6861, 6862, 5, 1328, 665, 2, 6862, 6982, 3, 2, 2, 2, 6863, 6864, 7, 140, 2, 2, 6864, 6865, 7, 335, 2, 2, 6865, 6866, 5, 524, 263, 2, 6866, 6867, 7, 326, 2, 2, 6867, 6868, 7, 316, 2, 2, 6868, 6869, 5, 1328, 665, 2, 6869, 6982, 3, 2, 2, 2, 6870, 6871, 7, 140, 2, 2, 6871, 6872, 7, 348, 2, 2, 6872, 6873, 7, 318, 2, 2, 6873, 6874, 7, 276, 2, 2, 6874, 6875, 5, 524, 263, 2, 6875, 6876, 7, 326, 2, 2, 6876, 6877, 7, 316, 2, 2, 6877, 6878, 5, 1328, 665, 2, 6878, 6982, 3, 2, 2, 2, 6879, 6880, 7, 140, 2, 2, 6880, 6881, 7, 348, 2, 2, 6881, 6882, 7, 318, 2, 2, 6882, 6883, 7, 187, 2, 2, 6883, 6884, 5, 524, 263, 2, 6884, 6885, 7, 326, 2, 2, 6885, 6886, 7, 316, 2, 2, 6886, 6887, 5, 1328, 665, 2, 6887, 6982, 3, 2, 2, 2, 6888, 6889, 7, 140, 2, 2, 6889, 6890, 7, 348, 2, 2, 6890, 6891, 7, 318, 2, 2, 6891, 6892, 7, 346, 2, 2, 6892, 6893, 5, 524, 263, 2, 6893, 6894, 7, 326, 2, 2, 6894, 6895, 7, 316, 2, 2, 6895, 6896, 5, 1328, 665, 2, 6896, 6982, 3, 2, 2, 2, 6897, 6898, 7, 140, 2, 2, 6898, 6899, 7, 348, 2, 2, 6899, 6900, 7, 318, 2, 2, 6900, 6901, 7, 165, 2, 2, 6901, 6902, 5, 524, 263, 2, 6902, 6903, 7, 326, 2, 2, 6903, 6904, 7, 316, 2, 2, 6904, 6905, 5, 1328, 665, 2, 6905, 6982, 3, 2, 2, 2, 6906, 6907, 7, 140, 2, 2, 6907, 6908, 7, 321, 2, 2, 6908, 6909, 5, 1324, 663, 2, 6909, 6910, 7, 326, 2, 2, 6910, 6911, 7, 316, 2, 2, 6911, 6912, 5, 1328, 665, 2, 6912, 6982, 3, 2, 2, 2, 6913, 6914, 7, 140, 2, 2, 6914, 6915, 7, 321, 2, 2, 6915, 6916, 7, 222, 2, 2, 6916, 6917, 7, 389, 2, 2, 6917, 6918, 5, 1324, 663, 2, 6918, 6919, 7, 326, 2, 2, 6919, 6920, 7, 316, 2, 2, 6920, 6921, 5, 1328, 665, 2, 6921, 6982, 3, 2, 2, 2, 6922, 6923, 7, 140, 2, 2, 6923, 6924, 7, 369, 2, 2, 6924, 6925, 5, 1324, 663, 2, 6925, 6926, 7, 326, 2, 2, 6926, 6927, 7, 316, 2, 2, 6927, 6928, 5, 1328, 665, 2, 6928, 6982, 3, 2, 2, 2, 6929, 6930, 7, 140, 2, 2, 6930, 6931, 7, 369, 2, 2, 6931, 6932, 7, 222, 2, 2, 6932, 6933, 7, 389, 2, 2, 6933, 6934, 5, 1324, 663, 2, 6934, 6935, 7, 326, 2, 2, 6935, 6936, 7, 316, 2, 2, 6936, 6937, 5, 1328, 665, 2, 6937, 6982, 3, 2, 2, 2, 6938, 6939, 7, 140, 2, 2, 6939, 6940, 7, 252, 2, 2, 6940, 6941, 7, 369, 2, 2, 6941, 6942, 5, 1324, 663, 2, 6942, 6943, 7, 326, 2, 2, 6943, 6944, 7, 316, 2, 2, 6944, 6945, 5, 1328, 665, 2, 6945, 6982, 3, 2, 2, 2, 6946, 6947, 7, 140, 2, 2, 6947, 6948, 7, 252, 2, 2, 6948, 6949, 7, 369, 2, 2, 6949, 6950, 7, 222, 2, 2, 6950, 6951, 7, 389, 2, 2, 6951, 6952, 5, 1324, 663, 2, 6952, 6953, 7, 326, 2, 2, 6953, 6954, 7, 316, 2, 2, 6954, 6955, 5, 1328, 665, 2, 6955, 6982, 3, 2, 2, 2, 6956, 6957, 7, 140, 2, 2, 6957, 6958, 7, 65, 2, 2, 6958, 6959, 7, 94, 2, 2, 6959, 6960, 5, 1064, 533, 2, 6960, 6961, 7, 326, 2, 2, 6961, 6962, 7, 316, 2, 2, 6962, 6963, 5, 1328, 665, 2, 6963, 6982, 3, 2, 2, 2, 6964, 6965, 7, 140, 2, 2, 6965, 6966, 7, 65, 2, 2, 6966, 6967, 7, 94, 2, 2, 6967, 6968, 7, 222, 2, 2, 6968, 6969, 7, 389, 2, 2, 6969, 6970, 5, 1064, 533, 2, 6970, 6971, 7, 326, 2, 2, 6971, 6972, 7, 316, 2, 2, 6972, 6973, 5, 1328, 665, 2, 6973, 6982, 3, 2, 2, 2, 6974, 6975, 7, 140, 2, 2, 6975, 6976, 7, 353, 2, 2, 6976, 6977, 5, 524, 263, 2, 6977, 6978, 7, 326, 2, 2, 6978, 6979, 7, 316, 2, 2, 6979, 6980, 5, 1328, 665, 2, 6980, 6982, 3, 2, 2, 2, 6981, 6764, 3, 2, 2, 2, 6981, 6771, 3, 2, 2, 2, 6981, 6778, 3, 2, 2, 2, 6981, 6785, 3, 2, 2, 2, 6981, 6792, 3, 2, 2, 2, 6981, 6799, 3, 2, 2, 2, 6981, 6806, 3, 2, 2, 2, 6981, 6813, 3, 2, 2, 2, 6981, 6823, 3, 2, 2, 2, 6981, 6833, 3, 2, 2, 2, 6981, 6840, 3, 2, 2, 2, 6981, 6847, 3, 2, 2, 2, 6981, 6854, 3, 2, 2, 2, 6981, 6863, 3, 2, 2, 2, 6981, 6870, 3, 2, 2, 2, 6981, 6879, 3, 2, 2, 2, 6981, 6888, 3, 2, 2, 2, 6981, 6897, 3, 2, 2, 2, 6981, 6906, 3, 2, 2, 2, 6981, 6913, 3, 2, 2, 2, 6981, 6922, 3, 2, 2, 2, 6981, 6929, 3, 2, 2, 2, 6981, 6938, 3, 2, 2, 2, 6981, 6946, 3, 2, 2, 2, 6981, 6956, 3, 2, 2, 2, 6981, 6964, 3, 2, 2, 2, 6981, 6974, 3, 2, 2, 2, 6982, 733, 3, 2, 2, 2, 6983, 6984, 7, 140, 2, 2, 6984, 6985, 7, 271, 2, 2, 6985, 6986, 5, 688, 345, 2, 6986, 6987, 7, 326, 2, 2, 6987, 6988, 7, 4, 2, 2, 6988, 6989, 5, 736, 369, 2, 6989, 6990, 7, 5, 2, 2, 6990, 735, 3, 2, 2, 2, 6991, 6996, 5, 738, 370, 2, 6992, 6993, 7, 8, 2, 2, 6993, 6995, 5, 738, 370, 2, 6994, 6992, 3, 2, 2, 2, 6995, 6998, 3, 2, 2, 2, 6996, 6994, 3, 2, 2, 2, 6996, 6997, 3, 2, 2, 2, 6997, 737, 3, 2, 2, 2, 6998, 6996, 3, 2, 2, 2, 6999, 7000, 5, 1366, 684, 2, 7000, 7001, 7, 12, 2, 2, 7001, 7002, 7, 400, 2, 2, 7002, 7008, 3, 2, 2, 2, 7003, 7004, 5, 1366, 684, 2, 7004, 7005, 7, 12, 2, 2, 7005, 7006, 5, 740, 371, 2, 7006, 7008, 3, 2, 2, 2, 7007, 6999, 3, 2, 2, 2, 7007, 7003, 3, 2, 2, 2, 7008, 739, 3, 2, 2, 2, 7009, 7015, 5, 640, 321, 2, 7010, 7015, 5, 1378, 690, 2, 7011, 7015, 5, 1264, 633, 2, 7012, 7015, 5, 292, 147, 2, 7013, 7015, 5, 1346, 674, 2, 7014, 7009, 3, 2, 2, 2, 7014, 7010, 3, 2, 2, 2, 7014, 7011, 3, 2, 2, 2, 7014, 7012, 3, 2, 2, 2, 7014, 7013, 3, 2, 2, 2, 7015, 741, 3, 2, 2, 2, 7016, 7017, 7, 140, 2, 2, 7017, 7018, 7, 353, 2, 2, 7018, 7019, 5, 524, 263, 2, 7019, 7020, 7, 326, 2, 2, 7020, 7021, 7, 4, 2, 2, 7021, 7022, 5, 736, 369, 2, 7022, 7023, 7, 5, 2, 2, 7023, 743, 3, 2, 2, 2, 7024, 7025, 7, 140, 2, 2, 7025, 7026, 7, 138, 2, 2, 7026, 7027, 5, 650, 326, 2, 7027, 7028, 7, 275, 2, 2, 7028, 7029, 7, 96, 2, 2, 7029, 7030, 5, 1356, 679, 2, 7030, 7210, 3, 2, 2, 2, 7031, 7032, 7, 140, 2, 2, 7032, 7033, 7, 110, 2, 2, 7033, 7034, 5, 524, 263, 2, 7034, 7035, 7, 275, 2, 2, 7035, 7036, 7, 96, 2, 2, 7036, 7037, 5, 1356, 679, 2, 7037, 7210, 3, 2, 2, 2, 7038, 7039, 7, 140, 2, 2, 7039, 7040, 7, 170, 2, 2, 7040, 7041, 5, 524, 263, 2, 7041, 7042, 7, 275, 2, 2, 7042, 7043, 7, 96, 2, 2, 7043, 7044, 5, 1356, 679, 2, 7044, 7210, 3, 2, 2, 2, 7045, 7046, 7, 140, 2, 2, 7046, 7047, 7, 177, 2, 2, 7047, 7048, 5, 1328, 665, 2, 7048, 7049, 7, 275, 2, 2, 7049, 7050, 7, 96, 2, 2, 7050, 7051, 5, 1356, 679, 2, 7051, 7210, 3, 2, 2, 2, 7052, 7053, 7, 140, 2, 2, 7053, 7054, 7, 191, 2, 2, 7054, 7055, 5, 524, 263, 2, 7055, 7056, 7, 275, 2, 2, 7056, 7057, 7, 96, 2, 2, 7057, 7058, 5, 1356, 679, 2, 7058, 7210, 3, 2, 2, 2, 7059, 7060, 7, 140, 2, 2, 7060, 7061, 7, 213, 2, 2, 7061, 7062, 5, 626, 314, 2, 7062, 7063, 7, 275, 2, 2, 7063, 7064, 7, 96, 2, 2, 7064, 7065, 5, 1356, 679, 2, 7065, 7210, 3, 2, 2, 2, 7066, 7068, 7, 140, 2, 2, 7067, 7069, 5, 308, 155, 2, 7068, 7067, 3, 2, 2, 2, 7068, 7069, 3, 2, 2, 2, 7069, 7070, 3, 2, 2, 2, 7070, 7071, 7, 240, 2, 2, 7071, 7072, 5, 1328, 665, 2, 7072, 7073, 7, 275, 2, 2, 7073, 7074, 7, 96, 2, 2, 7074, 7075, 5, 1356, 679, 2, 7075, 7210, 3, 2, 2, 2, 7076, 7077, 7, 140, 2, 2, 7077, 7078, 7, 241, 2, 2, 7078, 7079, 7, 267, 2, 2, 7079, 7080, 5, 292, 147, 2, 7080, 7081, 7, 275, 2, 2, 7081, 7082, 7, 96, 2, 2, 7082, 7083, 5, 1356, 679, 2, 7083, 7210, 3, 2, 2, 2, 7084, 7085, 7, 140, 2, 2, 7085, 7086, 7, 271, 2, 2, 7086, 7087, 5, 688, 345, 2, 7087, 7088, 7, 275, 2, 2, 7088, 7089, 7, 96, 2, 2, 7089, 7090, 5, 1356, 679, 2, 7090, 7210, 3, 2, 2, 2, 7091, 7092, 7, 140, 2, 2, 7092, 7093, 7, 271, 2, 2, 7093, 7094, 7, 158, 2, 2, 7094, 7095, 5, 524, 263, 2, 7095, 7096, 7, 102, 2, 2, 7096, 7097, 5, 1328, 665, 2, 7097, 7098, 7, 275, 2, 2, 7098, 7099, 7, 96, 2, 2, 7099, 7100, 5, 1356, 679, 2, 7100, 7210, 3, 2, 2, 2, 7101, 7102, 7, 140, 2, 2, 7102, 7103, 7, 271, 2, 2, 7103, 7104, 7, 208, 2, 2, 7104, 7105, 5, 524, 263, 2, 7105, 7106, 7, 102, 2, 2, 7106, 7107, 5, 1328, 665, 2, 7107, 7108, 7, 275, 2, 2, 7108, 7109, 7, 96, 2, 2, 7109, 7110, 5, 1356, 679, 2, 7110, 7210, 3, 2, 2, 2, 7111, 7112, 7, 140, 2, 2, 7112, 7113, 7, 289, 2, 2, 7113, 7114, 5, 626, 314, 2, 7114, 7115, 7, 275, 2, 2, 7115, 7116, 7, 96, 2, 2, 7116, 7117, 5, 1356, 679, 2, 7117, 7210, 3, 2, 2, 2, 7118, 7119, 7, 140, 2, 2, 7119, 7120, 7, 435, 2, 2, 7120, 7121, 5, 626, 314, 2, 7121, 7122, 7, 275, 2, 2, 7122, 7123, 7, 96, 2, 2, 7123, 7124, 5, 1356, 679, 2, 7124, 7210, 3, 2, 2, 2, 7125, 7126, 7, 140, 2, 2, 7126, 7127, 7, 316, 2, 2, 7127, 7128, 5, 1328, 665, 2, 7128, 7129, 7, 275, 2, 2, 7129, 7130, 7, 96, 2, 2, 7130, 7131, 5, 1356, 679, 2, 7131, 7210, 3, 2, 2, 2, 7132, 7133, 7, 140, 2, 2, 7133, 7134, 7, 353, 2, 2, 7134, 7135, 5, 524, 263, 2, 7135, 7136, 7, 275, 2, 2, 7136, 7137, 7, 96, 2, 2, 7137, 7138, 5, 1356, 679, 2, 7138, 7210, 3, 2, 2, 2, 7139, 7140, 7, 140, 2, 2, 7140, 7141, 7, 344, 2, 2, 7141, 7142, 5, 1328, 665, 2, 7142, 7143, 7, 275, 2, 2, 7143, 7144, 7, 96, 2, 2, 7144, 7145, 5, 1356, 679, 2, 7145, 7210, 3, 2, 2, 2, 7146, 7147, 7, 140, 2, 2, 7147, 7148, 7, 335, 2, 2, 7148, 7149, 5, 524, 263, 2, 7149, 7150, 7, 275, 2, 2, 7150, 7151, 7, 96, 2, 2, 7151, 7152, 5, 1356, 679, 2, 7152, 7210, 3, 2, 2, 2, 7153, 7154, 7, 140, 2, 2, 7154, 7155, 7, 348, 2, 2, 7155, 7156, 7, 318, 2, 2, 7156, 7157, 7, 187, 2, 2, 7157, 7158, 5, 524, 263, 2, 7158, 7159, 7, 275, 2, 2, 7159, 7160, 7, 96, 2, 2, 7160, 7161, 5, 1356, 679, 2, 7161, 7210, 3, 2, 2, 2, 7162, 7163, 7, 140, 2, 2, 7163, 7164, 7, 348, 2, 2, 7164, 7165, 7, 318, 2, 2, 7165, 7166, 7, 165, 2, 2, 7166, 7167, 5, 524, 263, 2, 7167, 7168, 7, 275, 2, 2, 7168, 7169, 7, 96, 2, 2, 7169, 7170, 5, 1356, 679, 2, 7170, 7210, 3, 2, 2, 2, 7171, 7172, 7, 140, 2, 2, 7172, 7173, 7, 65, 2, 2, 7173, 7174, 7, 176, 2, 2, 7174, 7175, 7, 374, 2, 2, 7175, 7176, 5, 1328, 665, 2, 7176, 7177, 7, 275, 2, 2, 7177, 7178, 7, 96, 2, 2, 7178, 7179, 5, 1356, 679, 2, 7179, 7210, 3, 2, 2, 2, 7180, 7181, 7, 140, 2, 2, 7181, 7182, 7, 324, 2, 2, 7182, 7183, 5, 1328, 665, 2, 7183, 7184, 7, 275, 2, 2, 7184, 7185, 7, 96, 2, 2, 7185, 7186, 5, 1356, 679, 2, 7186, 7210, 3, 2, 2, 2, 7187, 7188, 7, 140, 2, 2, 7188, 7189, 7, 200, 2, 2, 7189, 7190, 7, 350, 2, 2, 7190, 7191, 5, 1328, 665, 2, 7191, 7192, 7, 275, 2, 2, 7192, 7193, 7, 96, 2, 2, 7193, 7194, 5, 1356, 679, 2, 7194, 7210, 3, 2, 2, 2, 7195, 7196, 7, 140, 2, 2, 7196, 7197, 7, 445, 2, 2, 7197, 7198, 5, 1328, 665, 2, 7198, 7199, 7, 275, 2, 2, 7199, 7200, 7, 96, 2, 2, 7200, 7201, 5, 1356, 679, 2, 7201, 7210, 3, 2, 2, 2, 7202, 7203, 7, 140, 2, 2, 7203, 7204, 7, 444, 2, 2, 7204, 7205, 5, 1328, 665, 2, 7205, 7206, 7, 275, 2, 2, 7206, 7207, 7, 96, 2, 2, 7207, 7208, 5, 1356, 679, 2, 7208, 7210, 3, 2, 2, 2, 7209, 7024, 3, 2, 2, 2, 7209, 7031, 3, 2, 2, 2, 7209, 7038, 3, 2, 2, 2, 7209, 7045, 3, 2, 2, 2, 7209, 7052, 3, 2, 2, 2, 7209, 7059, 3, 2, 2, 2, 7209, 7066, 3, 2, 2, 2, 7209, 7076, 3, 2, 2, 2, 7209, 7084, 3, 2, 2, 2, 7209, 7091, 3, 2, 2, 2, 7209, 7101, 3, 2, 2, 2, 7209, 7111, 3, 2, 2, 2, 7209, 7118, 3, 2, 2, 2, 7209, 7125, 3, 2, 2, 2, 7209, 7132, 3, 2, 2, 2, 7209, 7139, 3, 2, 2, 2, 7209, 7146, 3, 2, 2, 2, 7209, 7153, 3, 2, 2, 2, 7209, 7162, 3, 2, 2, 2, 7209, 7171, 3, 2, 2, 2, 7209, 7180, 3, 2, 2, 2, 7209, 7187, 3, 2, 2, 2, 7209, 7195, 3, 2, 2, 2, 7209, 7202, 3, 2, 2, 2, 7210, 745, 3, 2, 2, 2, 7211, 7212, 7, 48, 2, 2, 7212, 7213, 7, 445, 2, 2, 7213, 7215, 5, 1328, 665, 2, 7214, 7216, 5, 748, 375, 2, 7215, 7214, 3, 2, 2, 2, 7215, 7216, 3, 2, 2, 2, 7216, 7218, 3, 2, 2, 2, 7217, 7219, 5, 664, 333, 2, 7218, 7217, 3, 2, 2, 2, 7218, 7219, 3, 2, 2, 2, 7219, 747, 3, 2, 2, 2, 7220, 7221, 5, 750, 376, 2, 7221, 749, 3, 2, 2, 2, 7222, 7223, 7, 64, 2, 2, 7223, 7224, 7, 94, 2, 2, 7224, 7229, 5, 1066, 534, 2, 7225, 7226, 7, 64, 2, 2, 7226, 7227, 7, 32, 2, 2, 7227, 7229, 7, 343, 2, 2, 7228, 7222, 3, 2, 2, 2, 7228, 7225, 3, 2, 2, 2, 7229, 751, 3, 2, 2, 2, 7230, 7231, 7, 140, 2, 2, 7231, 7232, 7, 445, 2, 2, 7232, 7233, 5, 1328, 665, 2, 7233, 7234, 7, 326, 2, 2, 7234, 7235, 5, 460, 231, 2, 7235, 7258, 3, 2, 2, 2, 7236, 7237, 7, 140, 2, 2, 7237, 7238, 7, 445, 2, 2, 7238, 7239, 5, 1328, 665, 2, 7239, 7240, 7, 135, 2, 2, 7240, 7241, 7, 94, 2, 2, 7241, 7242, 5, 1066, 534, 2, 7242, 7258, 3, 2, 2, 2, 7243, 7244, 7, 140, 2, 2, 7244, 7245, 7, 445, 2, 2, 7245, 7246, 5, 1328, 665, 2, 7246, 7247, 7, 326, 2, 2, 7247, 7248, 7, 94, 2, 2, 7248, 7249, 5, 1066, 534, 2, 7249, 7258, 3, 2, 2, 2, 7250, 7251, 7, 140, 2, 2, 7251, 7252, 7, 445, 2, 2, 7252, 7253, 5, 1328, 665, 2, 7253, 7254, 7, 193, 2, 2, 7254, 7255, 7, 94, 2, 2, 7255, 7256, 5, 1066, 534, 2, 7256, 7258, 3, 2, 2, 2, 7257, 7230, 3, 2, 2, 2, 7257, 7236, 3, 2, 2, 2, 7257, 7243, 3, 2, 2, 2, 7257, 7250, 3, 2, 2, 2, 7258, 753, 3, 2, 2, 2, 7259, 7260, 7, 48, 2, 2, 7260, 7261, 7, 444, 2, 2, 7261, 7262, 5, 1328, 665, 2, 7262, 7263, 7, 166, 2, 2, 7263, 7264, 5, 1346, 674, 2, 7264, 7265, 7, 445, 2, 2, 7265, 7267, 5, 756, 379, 2, 7266, 7268, 5, 664, 333, 2, 7267, 7266, 3, 2, 2, 2, 7267, 7268, 3, 2, 2, 2, 7268, 755, 3, 2, 2, 2, 7269, 7274, 5, 758, 380, 2, 7270, 7271, 7, 8, 2, 2, 7271, 7273, 5, 758, 380, 2, 7272, 7270, 3, 2, 2, 2, 7273, 7276, 3, 2, 2, 2, 7274, 7272, 3, 2, 2, 2, 7274, 7275, 3, 2, 2, 2, 7275, 757, 3, 2, 2, 2, 7276, 7274, 3, 2, 2, 2, 7277, 7278, 5, 1366, 684, 2, 7278, 759, 3, 2, 2, 2, 7279, 7280, 7, 140, 2, 2, 7280, 7281, 7, 444, 2, 2, 7281, 7282, 5, 1328, 665, 2, 7282, 7283, 7, 326, 2, 2, 7283, 7284, 5, 460, 231, 2, 7284, 7319, 3, 2, 2, 2, 7285, 7286, 7, 140, 2, 2, 7286, 7287, 7, 444, 2, 2, 7287, 7288, 5, 1328, 665, 2, 7288, 7289, 7, 166, 2, 2, 7289, 7290, 5, 1346, 674, 2, 7290, 7319, 3, 2, 2, 2, 7291, 7292, 7, 140, 2, 2, 7292, 7293, 7, 444, 2, 2, 7293, 7294, 5, 1328, 665, 2, 7294, 7295, 7, 298, 2, 2, 7295, 7297, 7, 445, 2, 2, 7296, 7298, 5, 664, 333, 2, 7297, 7296, 3, 2, 2, 2, 7297, 7298, 3, 2, 2, 2, 7298, 7319, 3, 2, 2, 2, 7299, 7300, 7, 140, 2, 2, 7300, 7301, 7, 444, 2, 2, 7301, 7302, 5, 1328, 665, 2, 7302, 7303, 7, 326, 2, 2, 7303, 7304, 7, 445, 2, 2, 7304, 7306, 5, 756, 379, 2, 7305, 7307, 5, 664, 333, 2, 7306, 7305, 3, 2, 2, 2, 7306, 7307, 3, 2, 2, 2, 7307, 7319, 3, 2, 2, 2, 7308, 7309, 7, 140, 2, 2, 7309, 7310, 7, 444, 2, 2, 7310, 7311, 5, 1328, 665, 2, 7311, 7312, 7, 195, 2, 2, 7312, 7319, 3, 2, 2, 2, 7313, 7314, 7, 140, 2, 2, 7314, 7315, 7, 444, 2, 2, 7315, 7316, 5, 1328, 665, 2, 7316, 7317, 7, 188, 2, 2, 7317, 7319, 3, 2, 2, 2, 7318, 7279, 3, 2, 2, 2, 7318, 7285, 3, 2, 2, 2, 7318, 7291, 3, 2, 2, 2, 7318, 7299, 3, 2, 2, 2, 7318, 7308, 3, 2, 2, 2, 7318, 7313, 3, 2, 2, 2, 7319, 761, 3, 2, 2, 2, 7320, 7321, 7, 193, 2, 2, 7321, 7322, 7, 444, 2, 2, 7322, 7324, 5, 1328, 665, 2, 7323, 7325, 5, 108, 55, 2, 7324, 7323, 3, 2, 2, 2, 7324, 7325, 3, 2, 2, 2, 7325, 7335, 3, 2, 2, 2, 7326, 7327, 7, 193, 2, 2, 7327, 7328, 7, 444, 2, 2, 7328, 7329, 7, 222, 2, 2, 7329, 7330, 7, 389, 2, 2, 7330, 7332, 5, 1328, 665, 2, 7331, 7333, 5, 108, 55, 2, 7332, 7331, 3, 2, 2, 2, 7332, 7333, 3, 2, 2, 2, 7333, 7335, 3, 2, 2, 2, 7334, 7320, 3, 2, 2, 2, 7334, 7326, 3, 2, 2, 2, 7335, 763, 3, 2, 2, 2, 7336, 7338, 7, 48, 2, 2, 7337, 7339, 5, 618, 310, 2, 7338, 7337, 3, 2, 2, 2, 7338, 7339, 3, 2, 2, 2, 7339, 7340, 3, 2, 2, 2, 7340, 7341, 7, 314, 2, 2, 7341, 7342, 5, 1328, 665, 2, 7342, 7343, 7, 38, 2, 2, 7343, 7344, 7, 82, 2, 2, 7344, 7345, 5, 774, 388, 2, 7345, 7346, 7, 96, 2, 2, 7346, 7348, 5, 1324, 663, 2, 7347, 7349, 5, 1084, 543, 2, 7348, 7347, 3, 2, 2, 2, 7348, 7349, 3, 2, 2, 2, 7349, 7350, 3, 2, 2, 2, 7350, 7352, 7, 59, 2, 2, 7351, 7353, 5, 776, 389, 2, 7352, 7351, 3, 2, 2, 2, 7352, 7353, 3, 2, 2, 2, 7353, 7354, 3, 2, 2, 2, 7354, 7355, 5, 766, 384, 2, 7355, 765, 3, 2, 2, 2, 7356, 7363, 7, 263, 2, 2, 7357, 7363, 5, 770, 386, 2, 7358, 7359, 7, 4, 2, 2, 7359, 7360, 5, 768, 385, 2, 7360, 7361, 7, 5, 2, 2, 7361, 7363, 3, 2, 2, 2, 7362, 7356, 3, 2, 2, 2, 7362, 7357, 3, 2, 2, 2, 7362, 7358, 3, 2, 2, 2, 7363, 767, 3, 2, 2, 2, 7364, 7366, 5, 772, 387, 2, 7365, 7364, 3, 2, 2, 2, 7365, 7366, 3, 2, 2, 2, 7366, 7373, 3, 2, 2, 2, 7367, 7369, 7, 9, 2, 2, 7368, 7370, 5, 772, 387, 2, 7369, 7368, 3, 2, 2, 2, 7369, 7370, 3, 2, 2, 2, 7370, 7372, 3, 2, 2, 2, 7371, 7367, 3, 2, 2, 2, 7372, 7375, 3, 2, 2, 2, 7373, 7371, 3, 2, 2, 2, 7373, 7374, 3, 2, 2, 2, 7374, 769, 3, 2, 2, 2, 7375, 7373, 3, 2, 2, 2, 7376, 7382, 5, 952, 477, 2, 7377, 7382, 5, 902, 452, 2, 7378, 7382, 5, 934, 468, 2, 7379, 7382, 5, 920, 461, 2, 7380, 7382, 5, 778, 390, 2, 7381, 7376, 3, 2, 2, 2, 7381, 7377, 3, 2, 2, 2, 7381, 7378, 3, 2, 2, 2, 7381, 7379, 3, 2, 2, 2, 7381, 7380, 3, 2, 2, 2, 7382, 771, 3, 2, 2, 2, 7383, 7384, 5, 770, 386, 2, 7384, 773, 3, 2, 2, 2, 7385, 7386, 9, 33, 2, 2, 7386, 775, 3, 2, 2, 2, 7387, 7388, 9, 34, 2, 2, 7388, 777, 3, 2, 2, 2, 7389, 7390, 7, 264, 2, 2, 7390, 7392, 5, 1360, 681, 2, 7391, 7393, 5, 780, 391, 2, 7392, 7391, 3, 2, 2, 2, 7392, 7393, 3, 2, 2, 2, 7393, 779, 3, 2, 2, 2, 7394, 7395, 7, 8, 2, 2, 7395, 7396, 5, 1346, 674, 2, 7396, 781, 3, 2, 2, 2, 7397, 7398, 7, 245, 2, 2, 7398, 7399, 5, 1360, 681, 2, 7399, 783, 3, 2, 2, 2, 7400, 7401, 7, 359, 2, 2, 7401, 7405, 5, 1360, 681, 2, 7402, 7403, 7, 359, 2, 2, 7403, 7405, 7, 11, 2, 2, 7404, 7400, 3, 2, 2, 2, 7404, 7402, 3, 2, 2, 2, 7405, 785, 3, 2, 2, 2, 7406, 7408, 7, 131, 2, 2, 7407, 7409, 5, 788, 395, 2, 7408, 7407, 3, 2, 2, 2, 7408, 7409, 3, 2, 2, 2, 7409, 7411, 3, 2, 2, 2, 7410, 7412, 5, 796, 399, 2, 7411, 7410, 3, 2, 2, 2, 7411, 7412, 3, 2, 2, 2, 7412, 7476, 3, 2, 2, 2, 7413, 7415, 7, 148, 2, 2, 7414, 7416, 5, 788, 395, 2, 7415, 7414, 3, 2, 2, 2, 7415, 7416, 3, 2, 2, 2, 7416, 7418, 3, 2, 2, 2, 7417, 7419, 5, 794, 398, 2, 7418, 7417, 3, 2, 2, 2, 7418, 7419, 3, 2, 2, 2, 7419, 7476, 3, 2, 2, 2, 7420, 7421, 7, 333, 2, 2, 7421, 7423, 7, 349, 2, 2, 7422, 7424, 5, 794, 398, 2, 7423, 7422, 3, 2, 2, 2, 7423, 7424, 3, 2, 2, 2, 7424, 7476, 3, 2, 2, 2, 7425, 7427, 7, 163, 2, 2, 7426, 7428, 5, 788, 395, 2, 7427, 7426, 3, 2, 2, 2, 7427, 7428, 3, 2, 2, 2, 7428, 7430, 3, 2, 2, 2, 7429, 7431, 5, 796, 399, 2, 7430, 7429, 3, 2, 2, 2, 7430, 7431, 3, 2, 2, 2, 7431, 7476, 3, 2, 2, 2, 7432, 7434, 7, 447, 2, 2, 7433, 7435, 5, 788, 395, 2, 7434, 7433, 3, 2, 2, 2, 7434, 7435, 3, 2, 2, 2, 7435, 7437, 3, 2, 2, 2, 7436, 7438, 5, 796, 399, 2, 7437, 7436, 3, 2, 2, 2, 7437, 7438, 3, 2, 2, 2, 7438, 7476, 3, 2, 2, 2, 7439, 7441, 7, 312, 2, 2, 7440, 7442, 5, 788, 395, 2, 7441, 7440, 3, 2, 2, 2, 7441, 7442, 3, 2, 2, 2, 7442, 7444, 3, 2, 2, 2, 7443, 7445, 5, 796, 399, 2, 7444, 7443, 3, 2, 2, 2, 7444, 7445, 3, 2, 2, 2, 7445, 7476, 3, 2, 2, 2, 7446, 7447, 7, 315, 2, 2, 7447, 7476, 5, 1360, 681, 2, 7448, 7449, 7, 301, 2, 2, 7449, 7450, 7, 315, 2, 2, 7450, 7476, 5, 1360, 681, 2, 7451, 7452, 7, 301, 2, 2, 7452, 7476, 5, 1360, 681, 2, 7453, 7455, 7, 312, 2, 2, 7454, 7456, 5, 788, 395, 2, 7455, 7454, 3, 2, 2, 2, 7455, 7456, 3, 2, 2, 2, 7456, 7457, 3, 2, 2, 2, 7457, 7458, 7, 96, 2, 2, 7458, 7459, 7, 315, 2, 2, 7459, 7476, 5, 1360, 681, 2, 7460, 7462, 7, 312, 2, 2, 7461, 7463, 5, 788, 395, 2, 7462, 7461, 3, 2, 2, 2, 7462, 7463, 3, 2, 2, 2, 7463, 7464, 3, 2, 2, 2, 7464, 7465, 7, 96, 2, 2, 7465, 7476, 5, 1360, 681, 2, 7466, 7467, 7, 283, 2, 2, 7467, 7468, 7, 349, 2, 2, 7468, 7476, 5, 1346, 674, 2, 7469, 7470, 7, 163, 2, 2, 7470, 7471, 7, 284, 2, 2, 7471, 7476, 5, 1346, 674, 2, 7472, 7473, 7, 312, 2, 2, 7473, 7474, 7, 284, 2, 2, 7474, 7476, 5, 1346, 674, 2, 7475, 7406, 3, 2, 2, 2, 7475, 7413, 3, 2, 2, 2, 7475, 7420, 3, 2, 2, 2, 7475, 7425, 3, 2, 2, 2, 7475, 7432, 3, 2, 2, 2, 7475, 7439, 3, 2, 2, 2, 7475, 7446, 3, 2, 2, 2, 7475, 7448, 3, 2, 2, 2, 7475, 7451, 3, 2, 2, 2, 7475, 7453, 3, 2, 2, 2, 7475, 7460, 3, 2, 2, 2, 7475, 7466, 3, 2, 2, 2, 7475, 7469, 3, 2, 2, 2, 7475, 7472, 3, 2, 2, 2, 7476, 787, 3, 2, 2, 2, 7477, 7478, 9, 35, 2, 2, 7478, 789, 3, 2, 2, 2, 7479, 7480, 7, 237, 2, 2, 7480, 7481, 7, 244, 2, 2, 7481, 7490, 5, 64, 33, 2, 7482, 7483, 7, 293, 2, 2, 7483, 7490, 7, 83, 2, 2, 7484, 7485, 7, 293, 2, 2, 7485, 7490, 7, 375, 2, 2, 7486, 7490, 7, 56, 2, 2, 7487, 7488, 7, 79, 2, 2, 7488, 7490, 7, 56, 2, 2, 7489, 7479, 3, 2, 2, 2, 7489, 7482, 3, 2, 2, 2, 7489, 7484, 3, 2, 2, 2, 7489, 7486, 3, 2, 2, 2, 7489, 7487, 3, 2, 2, 2, 7490, 791, 3, 2, 2, 2, 7491, 7498, 5, 790, 396, 2, 7492, 7494, 7, 8, 2, 2, 7493, 7492, 3, 2, 2, 2, 7493, 7494, 3, 2, 2, 2, 7494, 7495, 3, 2, 2, 2, 7495, 7497, 5, 790, 396, 2, 7496, 7493, 3, 2, 2, 2, 7497, 7500, 3, 2, 2, 2, 7498, 7496, 3, 2, 2, 2, 7498, 7499, 3, 2, 2, 2, 7499, 793, 3, 2, 2, 2, 7500, 7498, 3, 2, 2, 2, 7501, 7502, 5, 792, 397, 2, 7502, 795, 3, 2, 2, 2, 7503, 7505, 7, 35, 2, 2, 7504, 7506, 7, 262, 2, 2, 7505, 7504, 3, 2, 2, 2, 7505, 7506, 3, 2, 2, 2, 7506, 7507, 3, 2, 2, 2, 7507, 7508, 7, 155, 2, 2, 7508, 797, 3, 2, 2, 2, 7509, 7512, 7, 48, 2, 2, 7510, 7511, 7, 84, 2, 2, 7511, 7513, 7, 304, 2, 2, 7512, 7510, 3, 2, 2, 2, 7512, 7513, 3, 2, 2, 2, 7513, 7515, 3, 2, 2, 2, 7514, 7516, 5, 174, 88, 2, 7515, 7514, 3, 2, 2, 2, 7515, 7516, 3, 2, 2, 2, 7516, 7534, 3, 2, 2, 2, 7517, 7518, 7, 369, 2, 2, 7518, 7520, 5, 1324, 663, 2, 7519, 7521, 5, 214, 108, 2, 7520, 7519, 3, 2, 2, 2, 7520, 7521, 3, 2, 2, 2, 7521, 7523, 3, 2, 2, 2, 7522, 7524, 5, 118, 60, 2, 7523, 7522, 3, 2, 2, 2, 7523, 7524, 3, 2, 2, 2, 7524, 7535, 3, 2, 2, 2, 7525, 7526, 7, 296, 2, 2, 7526, 7527, 7, 369, 2, 2, 7527, 7528, 5, 1324, 663, 2, 7528, 7529, 7, 4, 2, 2, 7529, 7530, 5, 216, 109, 2, 7530, 7532, 7, 5, 2, 2, 7531, 7533, 5, 118, 60, 2, 7532, 7531, 3, 2, 2, 2, 7532, 7533, 3, 2, 2, 2, 7533, 7535, 3, 2, 2, 2, 7534, 7517, 3, 2, 2, 2, 7534, 7525, 3, 2, 2, 2, 7535, 7536, 3, 2, 2, 2, 7536, 7537, 7, 38, 2, 2, 7537, 7539, 5, 952, 477, 2, 7538, 7540, 5, 800, 401, 2, 7539, 7538, 3, 2, 2, 2, 7539, 7540, 3, 2, 2, 2, 7540, 799, 3, 2, 2, 2, 7541, 7543, 7, 107, 2, 2, 7542, 7544, 9, 36, 2, 2, 7543, 7542, 3, 2, 2, 2, 7543, 7544, 3, 2, 2, 2, 7544, 7545, 3, 2, 2, 2, 7545, 7546, 7, 44, 2, 2, 7546, 7547, 7, 272, 2, 2, 7547, 801, 3, 2, 2, 2, 7548, 7549, 7, 246, 2, 2, 7549, 7550, 5, 1332, 667, 2, 7550, 803, 3, 2, 2, 2, 7551, 7552, 7, 48, 2, 2, 7552, 7553, 7, 177, 2, 2, 7553, 7555, 5, 1328, 665, 2, 7554, 7556, 5, 16, 9, 2, 7555, 7554, 3, 2, 2, 2, 7555, 7556, 3, 2, 2, 2, 7556, 7558, 3, 2, 2, 2, 7557, 7559, 5, 806, 404, 2, 7558, 7557, 3, 2, 2, 2, 7558, 7559, 3, 2, 2, 2, 7559, 805, 3, 2, 2, 2, 7560, 7561, 5, 808, 405, 2, 7561, 807, 3, 2, 2, 2, 7562, 7564, 5, 810, 406, 2, 7563, 7562, 3, 2, 2, 2, 7564, 7565, 3, 2, 2, 2, 7565, 7563, 3, 2, 2, 2, 7565, 7566, 3, 2, 2, 2, 7566, 809, 3, 2, 2, 2, 7567, 7569, 5, 812, 407, 2, 7568, 7570, 5, 814, 408, 2, 7569, 7568, 3, 2, 2, 2, 7569, 7570, 3, 2, 2, 2, 7570, 7574, 3, 2, 2, 2, 7571, 7575, 5, 1352, 677, 2, 7572, 7575, 5, 66, 34, 2, 7573, 7575, 7, 55, 2, 2, 7574, 7571, 3, 2, 2, 2, 7574, 7572, 3, 2, 2, 2, 7574, 7573, 3, 2, 2, 2, 7575, 811, 3, 2, 2, 2, 7576, 7585, 5, 1368, 685, 2, 7577, 7578, 7, 166, 2, 2, 7578, 7585, 7, 76, 2, 2, 7579, 7585, 7, 196, 2, 2, 7580, 7585, 7, 248, 2, 2, 7581, 7585, 7, 275, 2, 2, 7582, 7585, 7, 344, 2, 2, 7583, 7585, 7, 346, 2, 2, 7584, 7576, 3, 2, 2, 2, 7584, 7577, 3, 2, 2, 2, 7584, 7579, 3, 2, 2, 2, 7584, 7580, 3, 2, 2, 2, 7584, 7581, 3, 2, 2, 2, 7584, 7582, 3, 2, 2, 2, 7584, 7583, 3, 2, 2, 2, 7585, 813, 3, 2, 2, 2, 7586, 7587, 7, 12, 2, 2, 7587, 815, 3, 2, 2, 2, 7588, 7589, 7, 140, 2, 2, 7589, 7590, 7, 177, 2, 2, 7590, 7601, 5, 1328, 665, 2, 7591, 7593, 7, 107, 2, 2, 7592, 7594, 5, 806, 404, 2, 7593, 7592, 3, 2, 2, 2, 7593, 7594, 3, 2, 2, 2, 7594, 7602, 3, 2, 2, 2, 7595, 7597, 5, 806, 404, 2, 7596, 7595, 3, 2, 2, 2, 7596, 7597, 3, 2, 2, 2, 7597, 7602, 3, 2, 2, 2, 7598, 7599, 7, 326, 2, 2, 7599, 7600, 7, 344, 2, 2, 7600, 7602, 5, 1328, 665, 2, 7601, 7591, 3, 2, 2, 2, 7601, 7596, 3, 2, 2, 2, 7601, 7598, 3, 2, 2, 2, 7602, 817, 3, 2, 2, 2, 7603, 7604, 7, 140, 2, 2, 7604, 7605, 7, 177, 2, 2, 7605, 7606, 5, 1328, 665, 2, 7606, 7607, 5, 80, 41, 2, 7607, 819, 3, 2, 2, 2, 7608, 7609, 7, 193, 2, 2, 7609, 7612, 7, 177, 2, 2, 7610, 7611, 7, 222, 2, 2, 7611, 7613, 7, 389, 2, 2, 7612, 7610, 3, 2, 2, 2, 7612, 7613, 3, 2, 2, 2, 7613, 7614, 3, 2, 2, 2, 7614, 7622, 5, 1328, 665, 2, 7615, 7617, 5, 16, 9, 2, 7616, 7615, 3, 2, 2, 2, 7616, 7617, 3, 2, 2, 2, 7617, 7618, 3, 2, 2, 2, 7618, 7619, 7, 4, 2, 2, 7619, 7620, 5, 822, 412, 2, 7620, 7621, 7, 5, 2, 2, 7621, 7623, 3, 2, 2, 2, 7622, 7616, 3, 2, 2, 2, 7622, 7623, 3, 2, 2, 2, 7623, 821, 3, 2, 2, 2, 7624, 7629, 5, 824, 413, 2, 7625, 7626, 7, 8, 2, 2, 7626, 7628, 5, 824, 413, 2, 7627, 7625, 3, 2, 2, 2, 7628, 7631, 3, 2, 2, 2, 7629, 7627, 3, 2, 2, 2, 7629, 7630, 3, 2, 2, 2, 7630, 823, 3, 2, 2, 2, 7631, 7629, 3, 2, 2, 2, 7632, 7633, 7, 211, 2, 2, 7633, 825, 3, 2, 2, 2, 7634, 7635, 7, 140, 2, 2, 7635, 7636, 7, 110, 2, 2, 7636, 7637, 5, 524, 263, 2, 7637, 7638, 7, 298, 2, 2, 7638, 7639, 7, 368, 2, 2, 7639, 827, 3, 2, 2, 2, 7640, 7641, 7, 140, 2, 2, 7641, 7642, 7, 342, 2, 2, 7642, 7643, 9, 37, 2, 2, 7643, 7644, 5, 54, 28, 2, 7644, 829, 3, 2, 2, 2, 7645, 7646, 7, 48, 2, 2, 7646, 7647, 7, 191, 2, 2, 7647, 7649, 5, 524, 263, 2, 7648, 7650, 5, 834, 418, 2, 7649, 7648, 3, 2, 2, 2, 7649, 7650, 3, 2, 2, 2, 7650, 7651, 3, 2, 2, 2, 7651, 7652, 5, 1108, 555, 2, 7652, 7653, 5, 192, 97, 2, 7653, 831, 3, 2, 2, 2, 7654, 7655, 7, 140, 2, 2, 7655, 7656, 7, 191, 2, 2, 7656, 7679, 5, 524, 263, 2, 7657, 7680, 5, 106, 54, 2, 7658, 7659, 7, 193, 2, 2, 7659, 7660, 7, 79, 2, 2, 7660, 7680, 7, 80, 2, 2, 7661, 7662, 7, 326, 2, 2, 7662, 7663, 7, 79, 2, 2, 7663, 7680, 7, 80, 2, 2, 7664, 7665, 7, 135, 2, 2, 7665, 7680, 5, 208, 105, 2, 7666, 7667, 7, 193, 2, 2, 7667, 7670, 7, 47, 2, 2, 7668, 7669, 7, 222, 2, 2, 7669, 7671, 7, 389, 2, 2, 7670, 7668, 3, 2, 2, 2, 7670, 7671, 3, 2, 2, 2, 7671, 7672, 3, 2, 2, 2, 7672, 7674, 5, 1328, 665, 2, 7673, 7675, 5, 108, 55, 2, 7674, 7673, 3, 2, 2, 2, 7674, 7675, 3, 2, 2, 2, 7675, 7680, 3, 2, 2, 2, 7676, 7677, 7, 365, 2, 2, 7677, 7678, 7, 47, 2, 2, 7678, 7680, 5, 1328, 665, 2, 7679, 7657, 3, 2, 2, 2, 7679, 7658, 3, 2, 2, 2, 7679, 7661, 3, 2, 2, 2, 7679, 7664, 3, 2, 2, 2, 7679, 7666, 3, 2, 2, 2, 7679, 7676, 3, 2, 2, 2, 7680, 833, 3, 2, 2, 2, 7681, 7682, 7, 38, 2, 2, 7682, 835, 3, 2, 2, 2, 7683, 7684, 7, 140, 2, 2, 7684, 7685, 7, 348, 2, 2, 7685, 7686, 7, 318, 2, 2, 7686, 7687, 7, 187, 2, 2, 7687, 7688, 5, 524, 263, 2, 7688, 7689, 5, 460, 231, 2, 7689, 837, 3, 2, 2, 2, 7690, 7691, 7, 140, 2, 2, 7691, 7692, 7, 348, 2, 2, 7692, 7693, 7, 318, 2, 2, 7693, 7694, 7, 165, 2, 2, 7694, 7695, 5, 524, 263, 2, 7695, 7696, 7, 135, 2, 2, 7696, 7697, 7, 250, 2, 2, 7697, 7698, 7, 64, 2, 2, 7698, 7699, 5, 1326, 664, 2, 7699, 7700, 5, 840, 421, 2, 7700, 7701, 5, 522, 262, 2, 7701, 7763, 3, 2, 2, 2, 7702, 7703, 7, 140, 2, 2, 7703, 7704, 7, 348, 2, 2, 7704, 7705, 7, 318, 2, 2, 7705, 7706, 7, 165, 2, 2, 7706, 7707, 5, 524, 263, 2, 7707, 7708, 7, 140, 2, 2, 7708, 7709, 7, 250, 2, 2, 7709, 7710, 7, 64, 2, 2, 7710, 7711, 5, 1326, 664, 2, 7711, 7712, 5, 840, 421, 2, 7712, 7713, 5, 522, 262, 2, 7713, 7763, 3, 2, 2, 2, 7714, 7715, 7, 140, 2, 2, 7715, 7716, 7, 348, 2, 2, 7716, 7717, 7, 318, 2, 2, 7717, 7718, 7, 165, 2, 2, 7718, 7719, 5, 524, 263, 2, 7719, 7720, 7, 140, 2, 2, 7720, 7721, 7, 250, 2, 2, 7721, 7722, 7, 304, 2, 2, 7722, 7723, 5, 524, 263, 2, 7723, 7724, 5, 840, 421, 2, 7724, 7725, 5, 524, 263, 2, 7725, 7763, 3, 2, 2, 2, 7726, 7727, 7, 140, 2, 2, 7727, 7728, 7, 348, 2, 2, 7728, 7729, 7, 318, 2, 2, 7729, 7730, 7, 165, 2, 2, 7730, 7731, 5, 524, 263, 2, 7731, 7732, 7, 140, 2, 2, 7732, 7733, 7, 250, 2, 2, 7733, 7734, 7, 64, 2, 2, 7734, 7735, 5, 1326, 664, 2, 7735, 7736, 7, 304, 2, 2, 7736, 7737, 5, 524, 263, 2, 7737, 7738, 5, 840, 421, 2, 7738, 7739, 5, 524, 263, 2, 7739, 7763, 3, 2, 2, 2, 7740, 7741, 7, 140, 2, 2, 7741, 7742, 7, 348, 2, 2, 7742, 7743, 7, 318, 2, 2, 7743, 7744, 7, 165, 2, 2, 7744, 7745, 5, 524, 263, 2, 7745, 7746, 7, 193, 2, 2, 7746, 7747, 7, 250, 2, 2, 7747, 7748, 7, 64, 2, 2, 7748, 7749, 5, 1326, 664, 2, 7749, 7763, 3, 2, 2, 2, 7750, 7751, 7, 140, 2, 2, 7751, 7752, 7, 348, 2, 2, 7752, 7753, 7, 318, 2, 2, 7753, 7754, 7, 165, 2, 2, 7754, 7755, 5, 524, 263, 2, 7755, 7756, 7, 193, 2, 2, 7756, 7757, 7, 250, 2, 2, 7757, 7758, 7, 222, 2, 2, 7758, 7759, 7, 389, 2, 2, 7759, 7760, 7, 64, 2, 2, 7760, 7761, 5, 1326, 664, 2, 7761, 7763, 3, 2, 2, 2, 7762, 7690, 3, 2, 2, 2, 7762, 7702, 3, 2, 2, 2, 7762, 7714, 3, 2, 2, 2, 7762, 7726, 3, 2, 2, 2, 7762, 7740, 3, 2, 2, 2, 7762, 7750, 3, 2, 2, 2, 7763, 839, 3, 2, 2, 2, 7764, 7765, 7, 107, 2, 2, 7765, 841, 3, 2, 2, 2, 7766, 7768, 7, 48, 2, 2, 7767, 7769, 5, 488, 245, 2, 7768, 7767, 3, 2, 2, 2, 7768, 7769, 3, 2, 2, 2, 7769, 7770, 3, 2, 2, 2, 7770, 7771, 7, 170, 2, 2, 7771, 7772, 5, 524, 263, 2, 7772, 7773, 7, 64, 2, 2, 7773, 7774, 5, 1346, 674, 2, 7774, 7775, 7, 96, 2, 2, 7775, 7776, 5, 1346, 674, 2, 7776, 7777, 7, 66, 2, 2, 7777, 7778, 5, 524, 263, 2, 7778, 843, 3, 2, 2, 2, 7779, 7781, 7, 160, 2, 2, 7780, 7782, 5, 864, 433, 2, 7781, 7780, 3, 2, 2, 2, 7781, 7782, 3, 2, 2, 2, 7782, 7783, 3, 2, 2, 2, 7783, 7785, 5, 1324, 663, 2, 7784, 7786, 5, 846, 424, 2, 7785, 7784, 3, 2, 2, 2, 7785, 7786, 3, 2, 2, 2, 7786, 7800, 3, 2, 2, 2, 7787, 7789, 7, 160, 2, 2, 7788, 7790, 5, 864, 433, 2, 7789, 7788, 3, 2, 2, 2, 7789, 7790, 3, 2, 2, 2, 7790, 7800, 3, 2, 2, 2, 7791, 7793, 7, 160, 2, 2, 7792, 7794, 5, 864, 433, 2, 7793, 7792, 3, 2, 2, 2, 7793, 7794, 3, 2, 2, 2, 7794, 7795, 3, 2, 2, 2, 7795, 7796, 5, 1328, 665, 2, 7796, 7797, 7, 82, 2, 2, 7797, 7798, 5, 1324, 663, 2, 7798, 7800, 3, 2, 2, 2, 7799, 7779, 3, 2, 2, 2, 7799, 7787, 3, 2, 2, 2, 7799, 7791, 3, 2, 2, 2, 7800, 845, 3, 2, 2, 2, 7801, 7802, 7, 102, 2, 2, 7802, 7803, 5, 1328, 665, 2, 7803, 847, 3, 2, 2, 2, 7804, 7806, 7, 363, 2, 2, 7805, 7807, 5, 866, 434, 2, 7806, 7805, 3, 2, 2, 2, 7806, 7807, 3, 2, 2, 2, 7807, 7809, 3, 2, 2, 2, 7808, 7810, 5, 868, 435, 2, 7809, 7808, 3, 2, 2, 2, 7809, 7810, 3, 2, 2, 2, 7810, 7812, 3, 2, 2, 2, 7811, 7813, 5, 864, 433, 2, 7812, 7811, 3, 2, 2, 2, 7812, 7813, 3, 2, 2, 2, 7813, 7815, 3, 2, 2, 2, 7814, 7816, 5, 862, 432, 2, 7815, 7814, 3, 2, 2, 2, 7815, 7816, 3, 2, 2, 2, 7816, 7818, 3, 2, 2, 2, 7817, 7819, 5, 876, 439, 2, 7818, 7817, 3, 2, 2, 2, 7818, 7819, 3, 2, 2, 2, 7819, 7828, 3, 2, 2, 2, 7820, 7821, 7, 363, 2, 2, 7821, 7822, 7, 4, 2, 2, 7822, 7823, 5, 852, 427, 2, 7823, 7825, 7, 5, 2, 2, 7824, 7826, 5, 876, 439, 2, 7825, 7824, 3, 2, 2, 2, 7825, 7826, 3, 2, 2, 2, 7826, 7828, 3, 2, 2, 2, 7827, 7804, 3, 2, 2, 2, 7827, 7820, 3, 2, 2, 2, 7828, 849, 3, 2, 2, 2, 7829, 7831, 5, 854, 428, 2, 7830, 7832, 5, 864, 433, 2, 7831, 7830, 3, 2, 2, 2, 7831, 7832, 3, 2, 2, 2, 7832, 7834, 3, 2, 2, 2, 7833, 7835, 5, 876, 439, 2, 7834, 7833, 3, 2, 2, 2, 7834, 7835, 3, 2, 2, 2, 7835, 7844, 3, 2, 2, 2, 7836, 7837, 5, 854, 428, 2, 7837, 7838, 7, 4, 2, 2, 7838, 7839, 5, 852, 427, 2, 7839, 7841, 7, 5, 2, 2, 7840, 7842, 5, 876, 439, 2, 7841, 7840, 3, 2, 2, 2, 7841, 7842, 3, 2, 2, 2, 7842, 7844, 3, 2, 2, 2, 7843, 7829, 3, 2, 2, 2, 7843, 7836, 3, 2, 2, 2, 7844, 851, 3, 2, 2, 2, 7845, 7850, 5, 856, 429, 2, 7846, 7847, 7, 8, 2, 2, 7847, 7849, 5, 856, 429, 2, 7848, 7846, 3, 2, 2, 2, 7849, 7852, 3, 2, 2, 2, 7850, 7848, 3, 2, 2, 2, 7850, 7851, 3, 2, 2, 2, 7851, 853, 3, 2, 2, 2, 7852, 7850, 3, 2, 2, 2, 7853, 7854, 9, 38, 2, 2, 7854, 855, 3, 2, 2, 2, 7855, 7857, 5, 858, 430, 2, 7856, 7858, 5, 860, 431, 2, 7857, 7856, 3, 2, 2, 2, 7857, 7858, 3, 2, 2, 2, 7858, 857, 3, 2, 2, 2, 7859, 7862, 5, 1364, 683, 2, 7860, 7862, 5, 854, 428, 2, 7861, 7859, 3, 2, 2, 2, 7861, 7860, 3, 2, 2, 2, 7862, 859, 3, 2, 2, 2, 7863, 7866, 5, 66, 34, 2, 7864, 7866, 5, 292, 147, 2, 7865, 7863, 3, 2, 2, 2, 7865, 7864, 3, 2, 2, 2, 7866, 861, 3, 2, 2, 2, 7867, 7868, 5, 854, 428, 2, 7868, 863, 3, 2, 2, 2, 7869, 7870, 7, 130, 2, 2, 7870, 865, 3, 2, 2, 2, 7871, 7872, 7, 115, 2, 2, 7872, 867, 3, 2, 2, 2, 7873, 7874, 7, 114, 2, 2, 7874, 869, 3, 2, 2, 2, 7875, 7876, 7, 4, 2, 2, 7876, 7877, 5, 1326, 664, 2, 7877, 7878, 7, 5, 2, 2, 7878, 871, 3, 2, 2, 2, 7879, 7881, 5, 1324, 663, 2, 7880, 7882, 5, 870, 436, 2, 7881, 7880, 3, 2, 2, 2, 7881, 7882, 3, 2, 2, 2, 7882, 873, 3, 2, 2, 2, 7883, 7888, 5, 872, 437, 2, 7884, 7885, 7, 8, 2, 2, 7885, 7887, 5, 872, 437, 2, 7886, 7884, 3, 2, 2, 2, 7887, 7890, 3, 2, 2, 2, 7888, 7886, 3, 2, 2, 2, 7888, 7889, 3, 2, 2, 2, 7889, 875, 3, 2, 2, 2, 7890, 7888, 3, 2, 2, 2, 7891, 7892, 5, 874, 438, 2, 7892, 877, 3, 2, 2, 2, 7893, 7894, 7, 205, 2, 2, 7894, 7912, 5, 880, 441, 2, 7895, 7896, 7, 205, 2, 2, 7896, 7898, 5, 854, 428, 2, 7897, 7899, 5, 864, 433, 2, 7898, 7897, 3, 2, 2, 2, 7898, 7899, 3, 2, 2, 2, 7899, 7900, 3, 2, 2, 2, 7900, 7901, 5, 880, 441, 2, 7901, 7912, 3, 2, 2, 2, 7902, 7903, 7, 205, 2, 2, 7903, 7904, 7, 130, 2, 2, 7904, 7912, 5, 880, 441, 2, 7905, 7906, 7, 205, 2, 2, 7906, 7907, 7, 4, 2, 2, 7907, 7908, 5, 882, 442, 2, 7908, 7909, 7, 5, 2, 2, 7909, 7910, 5, 880, 441, 2, 7910, 7912, 3, 2, 2, 2, 7911, 7893, 3, 2, 2, 2, 7911, 7895, 3, 2, 2, 2, 7911, 7902, 3, 2, 2, 2, 7911, 7905, 3, 2, 2, 2, 7912, 879, 3, 2, 2, 2, 7913, 7923, 5, 952, 477, 2, 7914, 7923, 5, 902, 452, 2, 7915, 7923, 5, 934, 468, 2, 7916, 7923, 5, 920, 461, 2, 7917, 7923, 5, 944, 473, 2, 7918, 7923, 5, 264, 133, 2, 7919, 7923, 5, 270, 136, 2, 7920, 7923, 5, 276, 139, 2, 7921, 7923, 5, 896, 449, 2, 7922, 7913, 3, 2, 2, 2, 7922, 7914, 3, 2, 2, 2, 7922, 7915, 3, 2, 2, 2, 7922, 7916, 3, 2, 2, 2, 7922, 7917, 3, 2, 2, 2, 7922, 7918, 3, 2, 2, 2, 7922, 7919, 3, 2, 2, 2, 7922, 7920, 3, 2, 2, 2, 7922, 7921, 3, 2, 2, 2, 7923, 881, 3, 2, 2, 2, 7924, 7929, 5, 884, 443, 2, 7925, 7926, 7, 8, 2, 2, 7926, 7928, 5, 884, 443, 2, 7927, 7925, 3, 2, 2, 2, 7928, 7931, 3, 2, 2, 2, 7929, 7927, 3, 2, 2, 2, 7929, 7930, 3, 2, 2, 2, 7930, 883, 3, 2, 2, 2, 7931, 7929, 3, 2, 2, 2, 7932, 7934, 5, 886, 444, 2, 7933, 7935, 5, 888, 445, 2, 7934, 7933, 3, 2, 2, 2, 7934, 7935, 3, 2, 2, 2, 7935, 885, 3, 2, 2, 2, 7936, 7939, 5, 1364, 683, 2, 7937, 7939, 5, 854, 428, 2, 7938, 7936, 3, 2, 2, 2, 7938, 7937, 3, 2, 2, 2, 7939, 887, 3, 2, 2, 2, 7940, 7943, 5, 66, 34, 2, 7941, 7943, 5, 292, 147, 2, 7942, 7940, 3, 2, 2, 2, 7942, 7941, 3, 2, 2, 2, 7943, 889, 3, 2, 2, 2, 7944, 7945, 7, 283, 2, 2, 7945, 7947, 5, 1328, 665, 2, 7946, 7948, 5, 892, 447, 2, 7947, 7946, 3, 2, 2, 2, 7947, 7948, 3, 2, 2, 2, 7948, 7949, 3, 2, 2, 2, 7949, 7950, 7, 38, 2, 2, 7950, 7951, 5, 894, 448, 2, 7951, 891, 3, 2, 2, 2, 7952, 7953, 7, 4, 2, 2, 7953, 7954, 5, 1274, 638, 2, 7954, 7955, 7, 5, 2, 2, 7955, 893, 3, 2, 2, 2, 7956, 7961, 5, 952, 477, 2, 7957, 7961, 5, 902, 452, 2, 7958, 7961, 5, 934, 468, 2, 7959, 7961, 5, 920, 461, 2, 7960, 7956, 3, 2, 2, 2, 7960, 7957, 3, 2, 2, 2, 7960, 7958, 3, 2, 2, 2, 7960, 7959, 3, 2, 2, 2, 7961, 895, 3, 2, 2, 2, 7962, 7963, 7, 204, 2, 2, 7963, 7965, 5, 1328, 665, 2, 7964, 7966, 5, 898, 450, 2, 7965, 7964, 3, 2, 2, 2, 7965, 7966, 3, 2, 2, 2, 7966, 8001, 3, 2, 2, 2, 7967, 7969, 7, 48, 2, 2, 7968, 7970, 5, 174, 88, 2, 7969, 7968, 3, 2, 2, 2, 7969, 7970, 3, 2, 2, 2, 7970, 7971, 3, 2, 2, 2, 7971, 7972, 7, 94, 2, 2, 7972, 7973, 5, 266, 134, 2, 7973, 7974, 7, 38, 2, 2, 7974, 7975, 7, 204, 2, 2, 7975, 7977, 5, 1328, 665, 2, 7976, 7978, 5, 898, 450, 2, 7977, 7976, 3, 2, 2, 2, 7977, 7978, 3, 2, 2, 2, 7978, 7980, 3, 2, 2, 2, 7979, 7981, 5, 268, 135, 2, 7980, 7979, 3, 2, 2, 2, 7980, 7981, 3, 2, 2, 2, 7981, 8001, 3, 2, 2, 2, 7982, 7984, 7, 48, 2, 2, 7983, 7985, 5, 174, 88, 2, 7984, 7983, 3, 2, 2, 2, 7984, 7985, 3, 2, 2, 2, 7985, 7986, 3, 2, 2, 2, 7986, 7987, 7, 94, 2, 2, 7987, 7988, 7, 222, 2, 2, 7988, 7989, 7, 79, 2, 2, 7989, 7990, 7, 389, 2, 2, 7990, 7991, 5, 266, 134, 2, 7991, 7992, 7, 38, 2, 2, 7992, 7993, 7, 204, 2, 2, 7993, 7995, 5, 1328, 665, 2, 7994, 7996, 5, 898, 450, 2, 7995, 7994, 3, 2, 2, 2, 7995, 7996, 3, 2, 2, 2, 7996, 7998, 3, 2, 2, 2, 7997, 7999, 5, 268, 135, 2, 7998, 7997, 3, 2, 2, 2, 7998, 7999, 3, 2, 2, 2, 7999, 8001, 3, 2, 2, 2, 8000, 7962, 3, 2, 2, 2, 8000, 7967, 3, 2, 2, 2, 8000, 7982, 3, 2, 2, 2, 8001, 897, 3, 2, 2, 2, 8002, 8003, 7, 4, 2, 2, 8003, 8004, 5, 1268, 635, 2, 8004, 8005, 7, 5, 2, 2, 8005, 899, 3, 2, 2, 2, 8006, 8007, 7, 179, 2, 2, 8007, 8017, 5, 1328, 665, 2, 8008, 8009, 7, 179, 2, 2, 8009, 8010, 7, 283, 2, 2, 8010, 8017, 5, 1328, 665, 2, 8011, 8012, 7, 179, 2, 2, 8012, 8017, 7, 32, 2, 2, 8013, 8014, 7, 179, 2, 2, 8014, 8015, 7, 283, 2, 2, 8015, 8017, 7, 32, 2, 2, 8016, 8006, 3, 2, 2, 2, 8016, 8008, 3, 2, 2, 2, 8016, 8011, 3, 2, 2, 2, 8016, 8013, 3, 2, 2, 2, 8017, 901, 3, 2, 2, 2, 8018, 8020, 5, 974, 488, 2, 8019, 8018, 3, 2, 2, 2, 8019, 8020, 3, 2, 2, 2, 8020, 8021, 3, 2, 2, 2, 8021, 8022, 7, 234, 2, 2, 8022, 8023, 7, 73, 2, 2, 8023, 8024, 5, 904, 453, 2, 8024, 8026, 5, 906, 454, 2, 8025, 8027, 5, 914, 458, 2, 8026, 8025, 3, 2, 2, 2, 8026, 8027, 3, 2, 2, 2, 8027, 8029, 3, 2, 2, 2, 8028, 8030, 5, 918, 460, 2, 8029, 8028, 3, 2, 2, 2, 8029, 8030, 3, 2, 2, 2, 8030, 903, 3, 2, 2, 2, 8031, 8034, 5, 1324, 663, 2, 8032, 8033, 7, 38, 2, 2, 8033, 8035, 5, 1360, 681, 2, 8034, 8032, 3, 2, 2, 2, 8034, 8035, 3, 2, 2, 2, 8035, 905, 3, 2, 2, 2, 8036, 8056, 5, 952, 477, 2, 8037, 8038, 7, 456, 2, 2, 8038, 8039, 5, 908, 455, 2, 8039, 8040, 7, 443, 2, 2, 8040, 8041, 5, 952, 477, 2, 8041, 8056, 3, 2, 2, 2, 8042, 8043, 7, 4, 2, 2, 8043, 8044, 5, 910, 456, 2, 8044, 8049, 7, 5, 2, 2, 8045, 8046, 7, 456, 2, 2, 8046, 8047, 5, 908, 455, 2, 8047, 8048, 7, 443, 2, 2, 8048, 8050, 3, 2, 2, 2, 8049, 8045, 3, 2, 2, 2, 8049, 8050, 3, 2, 2, 2, 8050, 8051, 3, 2, 2, 2, 8051, 8052, 5, 952, 477, 2, 8052, 8056, 3, 2, 2, 2, 8053, 8054, 7, 55, 2, 2, 8054, 8056, 7, 415, 2, 2, 8055, 8036, 3, 2, 2, 2, 8055, 8037, 3, 2, 2, 2, 8055, 8042, 3, 2, 2, 2, 8055, 8053, 3, 2, 2, 2, 8056, 907, 3, 2, 2, 2, 8057, 8058, 9, 39, 2, 2, 8058, 909, 3, 2, 2, 2, 8059, 8064, 5, 912, 457, 2, 8060, 8061, 7, 8, 2, 2, 8061, 8063, 5, 912, 457, 2, 8062, 8060, 3, 2, 2, 2, 8063, 8066, 3, 2, 2, 2, 8064, 8062, 3, 2, 2, 2, 8064, 8065, 3, 2, 2, 2, 8065, 911, 3, 2, 2, 2, 8066, 8064, 3, 2, 2, 2, 8067, 8068, 5, 1360, 681, 2, 8068, 8069, 5, 1314, 658, 2, 8069, 913, 3, 2, 2, 2, 8070, 8071, 7, 82, 2, 2, 8071, 8073, 7, 457, 2, 2, 8072, 8074, 5, 916, 459, 2, 8073, 8072, 3, 2, 2, 2, 8073, 8074, 3, 2, 2, 2, 8074, 8075, 3, 2, 2, 2, 8075, 8083, 7, 59, 2, 2, 8076, 8077, 7, 362, 2, 2, 8077, 8078, 7, 326, 2, 2, 8078, 8080, 5, 936, 469, 2, 8079, 8081, 5, 1084, 543, 2, 8080, 8079, 3, 2, 2, 2, 8080, 8081, 3, 2, 2, 2, 8081, 8084, 3, 2, 2, 2, 8082, 8084, 7, 263, 2, 2, 8083, 8076, 3, 2, 2, 2, 8083, 8082, 3, 2, 2, 2, 8084, 915, 3, 2, 2, 2, 8085, 8086, 7, 4, 2, 2, 8086, 8087, 5, 598, 300, 2, 8087, 8089, 7, 5, 2, 2, 8088, 8090, 5, 1084, 543, 2, 8089, 8088, 3, 2, 2, 2, 8089, 8090, 3, 2, 2, 2, 8090, 8095, 3, 2, 2, 2, 8091, 8092, 7, 82, 2, 2, 8092, 8093, 7, 47, 2, 2, 8093, 8095, 5, 1328, 665, 2, 8094, 8085, 3, 2, 2, 2, 8094, 8091, 3, 2, 2, 2, 8095, 917, 3, 2, 2, 2, 8096, 8097, 7, 89, 2, 2, 8097, 8098, 5, 1318, 660, 2, 8098, 919, 3, 2, 2, 2, 8099, 8101, 5, 974, 488, 2, 8100, 8099, 3, 2, 2, 2, 8100, 8101, 3, 2, 2, 2, 8101, 8102, 3, 2, 2, 2, 8102, 8103, 7, 184, 2, 2, 8103, 8104, 7, 66, 2, 2, 8104, 8106, 5, 1068, 535, 2, 8105, 8107, 5, 922, 462, 2, 8106, 8105, 3, 2, 2, 2, 8106, 8107, 3, 2, 2, 2, 8107, 8109, 3, 2, 2, 2, 8108, 8110, 5, 1086, 544, 2, 8109, 8108, 3, 2, 2, 2, 8109, 8110, 3, 2, 2, 2, 8110, 8112, 3, 2, 2, 2, 8111, 8113, 5, 918, 460, 2, 8112, 8111, 3, 2, 2, 2, 8112, 8113, 3, 2, 2, 2, 8113, 921, 3, 2, 2, 2, 8114, 8115, 7, 102, 2, 2, 8115, 8116, 5, 1050, 526, 2, 8116, 923, 3, 2, 2, 2, 8117, 8119, 7, 249, 2, 2, 8118, 8120, 5, 982, 492, 2, 8119, 8118, 3, 2, 2, 2, 8119, 8120, 3, 2, 2, 2, 8120, 8121, 3, 2, 2, 2, 8121, 8123, 5, 1066, 534, 2, 8122, 8124, 5, 926, 464, 2, 8123, 8122, 3, 2, 2, 2, 8123, 8124, 3, 2, 2, 2, 8124, 8126, 3, 2, 2, 2, 8125, 8127, 5, 930, 466, 2, 8126, 8125, 3, 2, 2, 2, 8126, 8127, 3, 2, 2, 2, 8127, 925, 3, 2, 2, 2, 8128, 8129, 7, 70, 2, 2, 8129, 8130, 5, 928, 465, 2, 8130, 8131, 7, 256, 2, 2, 8131, 927, 3, 2, 2, 2, 8132, 8133, 7, 133, 2, 2, 8133, 8145, 9, 40, 2, 2, 8134, 8135, 7, 407, 2, 2, 8135, 8145, 9, 40, 2, 2, 8136, 8141, 7, 327, 2, 2, 8137, 8138, 7, 362, 2, 2, 8138, 8142, 7, 203, 2, 2, 8139, 8140, 7, 407, 2, 2, 8140, 8142, 7, 203, 2, 2, 8141, 8137, 3, 2, 2, 2, 8141, 8139, 3, 2, 2, 2, 8141, 8142, 3, 2, 2, 2, 8142, 8145, 3, 2, 2, 2, 8143, 8145, 7, 203, 2, 2, 8144, 8132, 3, 2, 2, 2, 8144, 8134, 3, 2, 2, 2, 8144, 8136, 3, 2, 2, 2, 8144, 8143, 3, 2, 2, 2, 8145, 929, 3, 2, 2, 2, 8146, 8147, 7, 265, 2, 2, 8147, 931, 3, 2, 2, 2, 8148, 8152, 7, 265, 2, 2, 8149, 8150, 7, 458, 2, 2, 8150, 8152, 7, 459, 2, 2, 8151, 8148, 3, 2, 2, 2, 8151, 8149, 3, 2, 2, 2, 8152, 933, 3, 2, 2, 2, 8153, 8155, 5, 974, 488, 2, 8154, 8153, 3, 2, 2, 2, 8154, 8155, 3, 2, 2, 2, 8155, 8156, 3, 2, 2, 2, 8156, 8157, 7, 362, 2, 2, 8157, 8158, 5, 1068, 535, 2, 8158, 8159, 7, 326, 2, 2, 8159, 8161, 5, 936, 469, 2, 8160, 8162, 5, 1048, 525, 2, 8161, 8160, 3, 2, 2, 2, 8161, 8162, 3, 2, 2, 2, 8162, 8164, 3, 2, 2, 2, 8163, 8165, 5, 1086, 544, 2, 8164, 8163, 3, 2, 2, 2, 8164, 8165, 3, 2, 2, 2, 8165, 8167, 3, 2, 2, 2, 8166, 8168, 5, 918, 460, 2, 8167, 8166, 3, 2, 2, 2, 8167, 8168, 3, 2, 2, 2, 8168, 935, 3, 2, 2, 2, 8169, 8174, 5, 938, 470, 2, 8170, 8171, 7, 8, 2, 2, 8171, 8173, 5, 938, 470, 2, 8172, 8170, 3, 2, 2, 2, 8173, 8176, 3, 2, 2, 2, 8174, 8172, 3, 2, 2, 2, 8174, 8175, 3, 2, 2, 2, 8175, 937, 3, 2, 2, 2, 8176, 8174, 3, 2, 2, 2, 8177, 8178, 5, 940, 471, 2, 8178, 8179, 7, 12, 2, 2, 8179, 8180, 5, 1152, 577, 2, 8180, 8188, 3, 2, 2, 2, 8181, 8182, 7, 4, 2, 2, 8182, 8183, 5, 942, 472, 2, 8183, 8184, 7, 5, 2, 2, 8184, 8185, 7, 12, 2, 2, 8185, 8186, 5, 1152, 577, 2, 8186, 8188, 3, 2, 2, 2, 8187, 8177, 3, 2, 2, 2, 8187, 8181, 3, 2, 2, 2, 8188, 939, 3, 2, 2, 2, 8189, 8190, 5, 1360, 681, 2, 8190, 8191, 5, 1314, 658, 2, 8191, 941, 3, 2, 2, 2, 8192, 8197, 5, 940, 471, 2, 8193, 8194, 7, 8, 2, 2, 8194, 8196, 5, 940, 471, 2, 8195, 8193, 3, 2, 2, 2, 8196, 8199, 3, 2, 2, 2, 8197, 8195, 3, 2, 2, 2, 8197, 8198, 3, 2, 2, 2, 8198, 943, 3, 2, 2, 2, 8199, 8197, 3, 2, 2, 2, 8200, 8201, 7, 180, 2, 2, 8201, 8202, 5, 946, 474, 2, 8202, 8203, 5, 948, 475, 2, 8203, 8204, 7, 174, 2, 2, 8204, 8205, 5, 950, 476, 2, 8205, 8206, 7, 64, 2, 2, 8206, 8207, 5, 952, 477, 2, 8207, 945, 3, 2, 2, 2, 8208, 8209, 5, 1328, 665, 2, 8209, 947, 3, 2, 2, 2, 8210, 8211, 7, 262, 2, 2, 8211, 8216, 7, 317, 2, 2, 8212, 8216, 7, 317, 2, 2, 8213, 8216, 7, 109, 2, 2, 8214, 8216, 7, 233, 2, 2, 8215, 8210, 3, 2, 2, 2, 8215, 8212, 3, 2, 2, 2, 8215, 8213, 3, 2, 2, 2, 8215, 8214, 3, 2, 2, 2, 8216, 8219, 3, 2, 2, 2, 8217, 8215, 3, 2, 2, 2, 8217, 8218, 3, 2, 2, 2, 8218, 949, 3, 2, 2, 2, 8219, 8217, 3, 2, 2, 2, 8220, 8226, 3, 2, 2, 2, 8221, 8222, 7, 107, 2, 2, 8222, 8226, 7, 219, 2, 2, 8223, 8224, 7, 372, 2, 2, 8224, 8226, 7, 219, 2, 2, 8225, 8220, 3, 2, 2, 2, 8225, 8221, 3, 2, 2, 2, 8225, 8223, 3, 2, 2, 2, 8226, 951, 3, 2, 2, 2, 8227, 8230, 5, 956, 479, 2, 8228, 8230, 5, 954, 478, 2, 8229, 8227, 3, 2, 2, 2, 8229, 8228, 3, 2, 2, 2, 8230, 953, 3, 2, 2, 2, 8231, 8232, 7, 4, 2, 2, 8232, 8233, 5, 956, 479, 2, 8233, 8234, 7, 5, 2, 2, 8234, 8240, 3, 2, 2, 2, 8235, 8236, 7, 4, 2, 2, 8236, 8237, 5, 954, 478, 2, 8237, 8238, 7, 5, 2, 2, 8238, 8240, 3, 2, 2, 2, 8239, 8231, 3, 2, 2, 2, 8239, 8235, 3, 2, 2, 2, 8240, 955, 3, 2, 2, 2, 8241, 8243, 5, 958, 480, 2, 8242, 8244, 5, 990, 496, 2, 8243, 8242, 3, 2, 2, 2, 8243, 8244, 3, 2, 2, 2, 8244, 8253, 3, 2, 2, 2, 8245, 8247, 5, 1034, 518, 2, 8246, 8248, 5, 1000, 501, 2, 8247, 8246, 3, 2, 2, 2, 8247, 8248, 3, 2, 2, 2, 8248, 8254, 3, 2, 2, 2, 8249, 8251, 5, 998, 500, 2, 8250, 8252, 5, 1036, 519, 2, 8251, 8250, 3, 2, 2, 2, 8251, 8252, 3, 2, 2, 2, 8252, 8254, 3, 2, 2, 2, 8253, 8245, 3, 2, 2, 2, 8253, 8249, 3, 2, 2, 2, 8253, 8254, 3, 2, 2, 2, 8254, 8271, 3, 2, 2, 2, 8255, 8256, 5, 966, 484, 2, 8256, 8258, 5, 958, 480, 2, 8257, 8259, 5, 990, 496, 2, 8258, 8257, 3, 2, 2, 2, 8258, 8259, 3, 2, 2, 2, 8259, 8268, 3, 2, 2, 2, 8260, 8262, 5, 1034, 518, 2, 8261, 8263, 5, 1000, 501, 2, 8262, 8261, 3, 2, 2, 2, 8262, 8263, 3, 2, 2, 2, 8263, 8269, 3, 2, 2, 2, 8264, 8266, 5, 998, 500, 2, 8265, 8267, 5, 1036, 519, 2, 8266, 8265, 3, 2, 2, 2, 8266, 8267, 3, 2, 2, 2, 8267, 8269, 3, 2, 2, 2, 8268, 8260, 3, 2, 2, 2, 8268, 8264, 3, 2, 2, 2, 8268, 8269, 3, 2, 2, 2, 8269, 8271, 3, 2, 2, 2, 8270, 8241, 3, 2, 2, 2, 8270, 8255, 3, 2, 2, 2, 8271, 957, 3, 2, 2, 2, 8272, 8275, 5, 960, 481, 2, 8273, 8275, 5, 954, 478, 2, 8274, 8272, 3, 2, 2, 2, 8274, 8273, 3, 2, 2, 2, 8275, 959, 3, 2, 2, 2, 8276, 8289, 7, 90, 2, 2, 8277, 8279, 5, 988, 495, 2, 8278, 8277, 3, 2, 2, 2, 8278, 8279, 3, 2, 2, 2, 8279, 8281, 3, 2, 2, 2, 8280, 8282, 5, 976, 489, 2, 8281, 8280, 3, 2, 2, 2, 8281, 8282, 3, 2, 2, 2, 8282, 8284, 3, 2, 2, 2, 8283, 8285, 5, 1316, 659, 2, 8284, 8283, 3, 2, 2, 2, 8284, 8285, 3, 2, 2, 2, 8285, 8290, 3, 2, 2, 2, 8286, 8287, 5, 986, 494, 2, 8287, 8288, 5, 1318, 660, 2, 8288, 8290, 3, 2, 2, 2, 8289, 8278, 3, 2, 2, 2, 8289, 8286, 3, 2, 2, 2, 8290, 8292, 3, 2, 2, 2, 8291, 8293, 5, 976, 489, 2, 8292, 8291, 3, 2, 2, 2, 8292, 8293, 3, 2, 2, 2, 8293, 8295, 3, 2, 2, 2, 8294, 8296, 5, 1048, 525, 2, 8295, 8294, 3, 2, 2, 2, 8295, 8296, 3, 2, 2, 2, 8296, 8298, 3, 2, 2, 2, 8297, 8299, 5, 1084, 543, 2, 8298, 8297, 3, 2, 2, 2, 8298, 8299, 3, 2, 2, 2, 8299, 8301, 3, 2, 2, 2, 8300, 8302, 5, 1018, 510, 2, 8301, 8300, 3, 2, 2, 2, 8301, 8302, 3, 2, 2, 2, 8302, 8304, 3, 2, 2, 2, 8303, 8305, 5, 1032, 517, 2, 8304, 8303, 3, 2, 2, 2, 8304, 8305, 3, 2, 2, 2, 8305, 8307, 3, 2, 2, 2, 8306, 8308, 5, 1228, 615, 2, 8307, 8306, 3, 2, 2, 2, 8307, 8308, 3, 2, 2, 2, 8308, 8319, 3, 2, 2, 2, 8309, 8319, 5, 1046, 524, 2, 8310, 8311, 7, 94, 2, 2, 8311, 8319, 5, 1064, 533, 2, 8312, 8313, 5, 954, 478, 2, 8313, 8316, 5, 964, 483, 2, 8314, 8317, 5, 960, 481, 2, 8315, 8317, 5, 954, 478, 2, 8316, 8314, 3, 2, 2, 2, 8316, 8315, 3, 2, 2, 2, 8317, 8319, 3, 2, 2, 2, 8318, 8276, 3, 2, 2, 2, 8318, 8309, 3, 2, 2, 2, 8318, 8310, 3, 2, 2, 2, 8318, 8312, 3, 2, 2, 2, 8319, 8327, 3, 2, 2, 2, 8320, 8323, 5, 964, 483, 2, 8321, 8324, 5, 960, 481, 2, 8322, 8324, 5, 954, 478, 2, 8323, 8321, 3, 2, 2, 2, 8323, 8322, 3, 2, 2, 2, 8324, 8326, 3, 2, 2, 2, 8325, 8320, 3, 2, 2, 2, 8326, 8329, 3, 2, 2, 2, 8327, 8325, 3, 2, 2, 2, 8327, 8328, 3, 2, 2, 2, 8328, 961, 3, 2, 2, 2, 8329, 8327, 3, 2, 2, 2, 8330, 8334, 7, 99, 2, 2, 8331, 8334, 7, 72, 2, 2, 8332, 8334, 7, 61, 2, 2, 8333, 8330, 3, 2, 2, 2, 8333, 8331, 3, 2, 2, 2, 8333, 8332, 3, 2, 2, 2, 8334, 963, 3, 2, 2, 2, 8335, 8337, 5, 962, 482, 2, 8336, 8338, 5, 984, 493, 2, 8337, 8336, 3, 2, 2, 2, 8337, 8338, 3, 2, 2, 2, 8338, 965, 3, 2, 2, 2, 8339, 8341, 7, 107, 2, 2, 8340, 8342, 7, 296, 2, 2, 8341, 8340, 3, 2, 2, 2, 8341, 8342, 3, 2, 2, 2, 8342, 8343, 3, 2, 2, 2, 8343, 8344, 5, 968, 485, 2, 8344, 967, 3, 2, 2, 2, 8345, 8350, 5, 970, 486, 2, 8346, 8347, 7, 8, 2, 2, 8347, 8349, 5, 970, 486, 2, 8348, 8346, 3, 2, 2, 2, 8349, 8352, 3, 2, 2, 2, 8350, 8348, 3, 2, 2, 2, 8350, 8351, 3, 2, 2, 2, 8351, 969, 3, 2, 2, 2, 8352, 8350, 3, 2, 2, 2, 8353, 8355, 5, 1328, 665, 2, 8354, 8356, 5, 870, 436, 2, 8355, 8354, 3, 2, 2, 2, 8355, 8356, 3, 2, 2, 2, 8356, 8357, 3, 2, 2, 2, 8357, 8359, 7, 38, 2, 2, 8358, 8360, 5, 972, 487, 2, 8359, 8358, 3, 2, 2, 2, 8359, 8360, 3, 2, 2, 2, 8360, 8361, 3, 2, 2, 2, 8361, 8362, 7, 4, 2, 2, 8362, 8363, 5, 894, 448, 2, 8363, 8364, 7, 5, 2, 2, 8364, 971, 3, 2, 2, 2, 8365, 8369, 7, 252, 2, 2, 8366, 8367, 7, 79, 2, 2, 8367, 8369, 7, 252, 2, 2, 8368, 8365, 3, 2, 2, 2, 8368, 8366, 3, 2, 2, 2, 8369, 973, 3, 2, 2, 2, 8370, 8371, 5, 966, 484, 2, 8371, 975, 3, 2, 2, 2, 8372, 8377, 7, 73, 2, 2, 8373, 8374, 5, 978, 490, 2, 8374, 8375, 5, 980, 491, 2, 8375, 8378, 3, 2, 2, 2, 8376, 8378, 5, 1550, 776, 2, 8377, 8373, 3, 2, 2, 2, 8377, 8376, 3, 2, 2, 2, 8378, 977, 3, 2, 2, 2, 8379, 8382, 3, 2, 2, 2, 8380, 8382, 7, 339, 2, 2, 8381, 8379, 3, 2, 2, 2, 8381, 8380, 3, 2, 2, 2, 8382, 979, 3, 2, 2, 2, 8383, 8385, 9, 41, 2, 2, 8384, 8383, 3, 2, 2, 2, 8384, 8385, 3, 2, 2, 2, 8385, 8386, 3, 2, 2, 2, 8386, 8388, 9, 14, 2, 2, 8387, 8389, 5, 982, 492, 2, 8388, 8387, 3, 2, 2, 2, 8388, 8389, 3, 2, 2, 2, 8389, 8390, 3, 2, 2, 2, 8390, 8400, 5, 1324, 663, 2, 8391, 8393, 7, 360, 2, 2, 8392, 8394, 5, 982, 492, 2, 8393, 8392, 3, 2, 2, 2, 8393, 8394, 3, 2, 2, 2, 8394, 8395, 3, 2, 2, 2, 8395, 8400, 5, 1324, 663, 2, 8396, 8397, 7, 94, 2, 2, 8397, 8400, 5, 1324, 663, 2, 8398, 8400, 5, 1324, 663, 2, 8399, 8384, 3, 2, 2, 2, 8399, 8391, 3, 2, 2, 2, 8399, 8396, 3, 2, 2, 2, 8399, 8398, 3, 2, 2, 2, 8400, 981, 3, 2, 2, 2, 8401, 8402, 7, 94, 2, 2, 8402, 983, 3, 2, 2, 2, 8403, 8404, 9, 42, 2, 2, 8404, 985, 3, 2, 2, 2, 8405, 8411, 7, 58, 2, 2, 8406, 8407, 7, 82, 2, 2, 8407, 8408, 7, 4, 2, 2, 8408, 8409, 5, 1268, 635, 2, 8409, 8410, 7, 5, 2, 2, 8410, 8412, 3, 2, 2, 2, 8411, 8406, 3, 2, 2, 2, 8411, 8412, 3, 2, 2, 2, 8412, 987, 3, 2, 2, 2, 8413, 8414, 7, 32, 2, 2, 8414, 989, 3, 2, 2, 2, 8415, 8416, 5, 992, 497, 2, 8416, 991, 3, 2, 2, 2, 8417, 8418, 7, 85, 2, 2, 8418, 8419, 7, 149, 2, 2, 8419, 8420, 5, 994, 498, 2, 8420, 993, 3, 2, 2, 2, 8421, 8426, 5, 996, 499, 2, 8422, 8423, 7, 8, 2, 2, 8423, 8425, 5, 996, 499, 2, 8424, 8422, 3, 2, 2, 2, 8425, 8428, 3, 2, 2, 2, 8426, 8424, 3, 2, 2, 2, 8426, 8427, 3, 2, 2, 2, 8427, 995, 3, 2, 2, 2, 8428, 8426, 3, 2, 2, 2, 8429, 8435, 5, 1152, 577, 2, 8430, 8431, 7, 102, 2, 2, 8431, 8436, 5, 1264, 633, 2, 8432, 8434, 5, 612, 307, 2, 8433, 8432, 3, 2, 2, 2, 8433, 8434, 3, 2, 2, 2, 8434, 8436, 3, 2, 2, 2, 8435, 8430, 3, 2, 2, 2, 8435, 8433, 3, 2, 2, 2, 8436, 8438, 3, 2, 2, 2, 8437, 8439, 5, 614, 308, 2, 8438, 8437, 3, 2, 2, 2, 8438, 8439, 3, 2, 2, 2, 8439, 997, 3, 2, 2, 2, 8440, 8442, 5, 1002, 502, 2, 8441, 8443, 5, 1004, 503, 2, 8442, 8441, 3, 2, 2, 2, 8442, 8443, 3, 2, 2, 2, 8443, 8449, 3, 2, 2, 2, 8444, 8446, 5, 1004, 503, 2, 8445, 8447, 5, 1002, 502, 2, 8446, 8445, 3, 2, 2, 2, 8446, 8447, 3, 2, 2, 2, 8447, 8449, 3, 2, 2, 2, 8448, 8440, 3, 2, 2, 2, 8448, 8444, 3, 2, 2, 2, 8449, 999, 3, 2, 2, 2, 8450, 8451, 5, 998, 500, 2, 8451, 1001, 3, 2, 2, 2, 8452, 8453, 7, 76, 2, 2, 8453, 8456, 5, 1006, 504, 2, 8454, 8455, 7, 8, 2, 2, 8455, 8457, 5, 1008, 505, 2, 8456, 8454, 3, 2, 2, 2, 8456, 8457, 3, 2, 2, 2, 8457, 8476, 3, 2, 2, 2, 8458, 8459, 7, 63, 2, 2, 8459, 8473, 5, 1016, 509, 2, 8460, 8461, 5, 1010, 506, 2, 8461, 8465, 5, 1014, 508, 2, 8462, 8466, 7, 83, 2, 2, 8463, 8464, 7, 107, 2, 2, 8464, 8466, 7, 460, 2, 2, 8465, 8462, 3, 2, 2, 2, 8465, 8463, 3, 2, 2, 2, 8466, 8474, 3, 2, 2, 2, 8467, 8471, 5, 1014, 508, 2, 8468, 8472, 7, 83, 2, 2, 8469, 8470, 7, 107, 2, 2, 8470, 8472, 7, 460, 2, 2, 8471, 8468, 3, 2, 2, 2, 8471, 8469, 3, 2, 2, 2, 8472, 8474, 3, 2, 2, 2, 8473, 8460, 3, 2, 2, 2, 8473, 8467, 3, 2, 2, 2, 8474, 8476, 3, 2, 2, 2, 8475, 8452, 3, 2, 2, 2, 8475, 8458, 3, 2, 2, 2, 8476, 1003, 3, 2, 2, 2, 8477, 8482, 7, 81, 2, 2, 8478, 8483, 5, 1008, 505, 2, 8479, 8480, 5, 1010, 506, 2, 8480, 8481, 5, 1014, 508, 2, 8481, 8483, 3, 2, 2, 2, 8482, 8478, 3, 2, 2, 2, 8482, 8479, 3, 2, 2, 2, 8483, 1005, 3, 2, 2, 2, 8484, 8487, 5, 1152, 577, 2, 8485, 8487, 7, 32, 2, 2, 8486, 8484, 3, 2, 2, 2, 8486, 8485, 3, 2, 2, 2, 8487, 1007, 3, 2, 2, 2, 8488, 8489, 5, 1152, 577, 2, 8489, 1009, 3, 2, 2, 2, 8490, 8496, 5, 1194, 598, 2, 8491, 8492, 7, 14, 2, 2, 8492, 8496, 5, 1012, 507, 2, 8493, 8494, 7, 15, 2, 2, 8494, 8496, 5, 1012, 507, 2, 8495, 8490, 3, 2, 2, 2, 8495, 8491, 3, 2, 2, 2, 8495, 8493, 3, 2, 2, 2, 8496, 1011, 3, 2, 2, 2, 8497, 8500, 5, 1344, 673, 2, 8498, 8500, 5, 1342, 672, 2, 8499, 8497, 3, 2, 2, 2, 8499, 8498, 3, 2, 2, 2, 8500, 1013, 3, 2, 2, 2, 8501, 8502, 9, 43, 2, 2, 8502, 1015, 3, 2, 2, 2, 8503, 8504, 9, 44, 2, 2, 8504, 1017, 3, 2, 2, 2, 8505, 8506, 7, 68, 2, 2, 8506, 8507, 7, 149, 2, 2, 8507, 8508, 5, 1020, 511, 2, 8508, 1019, 3, 2, 2, 2, 8509, 8514, 5, 1022, 512, 2, 8510, 8511, 7, 8, 2, 2, 8511, 8513, 5, 1022, 512, 2, 8512, 8510, 3, 2, 2, 2, 8513, 8516, 3, 2, 2, 2, 8514, 8512, 3, 2, 2, 2, 8514, 8515, 3, 2, 2, 2, 8515, 1021, 3, 2, 2, 2, 8516, 8514, 3, 2, 2, 2, 8517, 8523, 5, 1152, 577, 2, 8518, 8523, 5, 1024, 513, 2, 8519, 8523, 5, 1028, 515, 2, 8520, 8523, 5, 1026, 514, 2, 8521, 8523, 5, 1030, 516, 2, 8522, 8517, 3, 2, 2, 2, 8522, 8518, 3, 2, 2, 2, 8522, 8519, 3, 2, 2, 2, 8522, 8520, 3, 2, 2, 2, 8522, 8521, 3, 2, 2, 2, 8523, 1023, 3, 2, 2, 2, 8524, 8525, 7, 4, 2, 2, 8525, 8526, 7, 5, 2, 2, 8526, 1025, 3, 2, 2, 2, 8527, 8528, 7, 461, 2, 2, 8528, 8529, 7, 4, 2, 2, 8529, 8530, 5, 1268, 635, 2, 8530, 8531, 7, 5, 2, 2, 8531, 1027, 3, 2, 2, 2, 8532, 8533, 7, 462, 2, 2, 8533, 8534, 7, 4, 2, 2, 8534, 8535, 5, 1268, 635, 2, 8535, 8536, 7, 5, 2, 2, 8536, 1029, 3, 2, 2, 2, 8537, 8538, 7, 463, 2, 2, 8538, 8539, 7, 464, 2, 2, 8539, 8540, 7, 4, 2, 2, 8540, 8541, 5, 1020, 511, 2, 8541, 8542, 7, 5, 2, 2, 8542, 1031, 3, 2, 2, 2, 8543, 8544, 7, 69, 2, 2, 8544, 8545, 5, 1152, 577, 2, 8545, 1033, 3, 2, 2, 2, 8546, 8551, 5, 1038, 520, 2, 8547, 8548, 7, 64, 2, 2, 8548, 8549, 7, 293, 2, 2, 8549, 8551, 7, 83, 2, 2, 8550, 8546, 3, 2, 2, 2, 8550, 8547, 3, 2, 2, 2, 8551, 1035, 3, 2, 2, 2, 8552, 8553, 5, 1034, 518, 2, 8553, 1037, 3, 2, 2, 2, 8554, 8556, 5, 1040, 521, 2, 8555, 8554, 3, 2, 2, 2, 8556, 8557, 3, 2, 2, 2, 8557, 8555, 3, 2, 2, 2, 8557, 8558, 3, 2, 2, 2, 8558, 1039, 3, 2, 2, 2, 8559, 8561, 5, 1042, 522, 2, 8560, 8562, 5, 1044, 523, 2, 8561, 8560, 3, 2, 2, 2, 8561, 8562, 3, 2, 2, 2, 8562, 8564, 3, 2, 2, 2, 8563, 8565, 5, 932, 467, 2, 8564, 8563, 3, 2, 2, 2, 8564, 8565, 3, 2, 2, 2, 8565, 1041, 3, 2, 2, 2, 8566, 8576, 7, 64, 2, 2, 8567, 8568, 7, 262, 2, 2, 8568, 8570, 7, 238, 2, 2, 8569, 8567, 3, 2, 2, 2, 8569, 8570, 3, 2, 2, 2, 8570, 8571, 3, 2, 2, 2, 8571, 8577, 7, 362, 2, 2, 8572, 8574, 7, 238, 2, 2, 8573, 8572, 3, 2, 2, 2, 8573, 8574, 3, 2, 2, 2, 8574, 8575, 3, 2, 2, 2, 8575, 8577, 7, 327, 2, 2, 8576, 8569, 3, 2, 2, 2, 8576, 8573, 3, 2, 2, 2, 8577, 1043, 3, 2, 2, 2, 8578, 8579, 7, 268, 2, 2, 8579, 8580, 5, 1322, 662, 2, 8580, 1045, 3, 2, 2, 2, 8581, 8582, 7, 415, 2, 2, 8582, 8583, 7, 4, 2, 2, 8583, 8584, 5, 1268, 635, 2, 8584, 8592, 7, 5, 2, 2, 8585, 8586, 7, 8, 2, 2, 8586, 8587, 7, 4, 2, 2, 8587, 8588, 5, 1268, 635, 2, 8588, 8589, 7, 5, 2, 2, 8589, 8591, 3, 2, 2, 2, 8590, 8585, 3, 2, 2, 2, 8591, 8594, 3, 2, 2, 2, 8592, 8590, 3, 2, 2, 2, 8592, 8593, 3, 2, 2, 2, 8593, 1047, 3, 2, 2, 2, 8594, 8592, 3, 2, 2, 2, 8595, 8596, 7, 66, 2, 2, 8596, 8597, 5, 1050, 526, 2, 8597, 1049, 3, 2, 2, 2, 8598, 8603, 5, 1052, 527, 2, 8599, 8600, 7, 8, 2, 2, 8600, 8602, 5, 1052, 527, 2, 8601, 8599, 3, 2, 2, 2, 8602, 8605, 3, 2, 2, 2, 8603, 8601, 3, 2, 2, 2, 8603, 8604, 3, 2, 2, 2, 8604, 1051, 3, 2, 2, 2, 8605, 8603, 3, 2, 2, 2, 8606, 8608, 5, 1064, 533, 2, 8607, 8609, 5, 1056, 529, 2, 8608, 8607, 3, 2, 2, 2, 8608, 8609, 3, 2, 2, 2, 8609, 8611, 3, 2, 2, 2, 8610, 8612, 5, 1070, 536, 2, 8611, 8610, 3, 2, 2, 2, 8611, 8612, 3, 2, 2, 2, 8612, 8665, 3, 2, 2, 2, 8613, 8615, 5, 1074, 538, 2, 8614, 8616, 5, 1058, 530, 2, 8615, 8614, 3, 2, 2, 2, 8615, 8616, 3, 2, 2, 2, 8616, 8665, 3, 2, 2, 2, 8617, 8619, 5, 1094, 548, 2, 8618, 8620, 5, 1056, 529, 2, 8619, 8618, 3, 2, 2, 2, 8619, 8620, 3, 2, 2, 2, 8620, 8665, 3, 2, 2, 2, 8621, 8623, 5, 954, 478, 2, 8622, 8624, 5, 1056, 529, 2, 8623, 8622, 3, 2, 2, 2, 8623, 8624, 3, 2, 2, 2, 8624, 8665, 3, 2, 2, 2, 8625, 8638, 7, 74, 2, 2, 8626, 8628, 5, 1094, 548, 2, 8627, 8629, 5, 1056, 529, 2, 8628, 8627, 3, 2, 2, 2, 8628, 8629, 3, 2, 2, 2, 8629, 8639, 3, 2, 2, 2, 8630, 8632, 5, 1074, 538, 2, 8631, 8633, 5, 1058, 530, 2, 8632, 8631, 3, 2, 2, 2, 8632, 8633, 3, 2, 2, 2, 8633, 8639, 3, 2, 2, 2, 8634, 8636, 5, 954, 478, 2, 8635, 8637, 5, 1056, 529, 2, 8636, 8635, 3, 2, 2, 2, 8636, 8637, 3, 2, 2, 2, 8637, 8639, 3, 2, 2, 2, 8638, 8626, 3, 2, 2, 2, 8638, 8630, 3, 2, 2, 2, 8638, 8634, 3, 2, 2, 2, 8639, 8665, 3, 2, 2, 2, 8640, 8641, 7, 4, 2, 2, 8641, 8658, 5, 1052, 527, 2, 8642, 8643, 7, 112, 2, 2, 8643, 8644, 7, 120, 2, 2, 8644, 8659, 5, 1052, 527, 2, 8645, 8647, 7, 123, 2, 2, 8646, 8648, 5, 1060, 531, 2, 8647, 8646, 3, 2, 2, 2, 8647, 8648, 3, 2, 2, 2, 8648, 8649, 3, 2, 2, 2, 8649, 8650, 7, 120, 2, 2, 8650, 8659, 5, 1052, 527, 2, 8651, 8653, 5, 1060, 531, 2, 8652, 8651, 3, 2, 2, 2, 8652, 8653, 3, 2, 2, 2, 8653, 8654, 3, 2, 2, 2, 8654, 8655, 7, 120, 2, 2, 8655, 8656, 5, 1052, 527, 2, 8656, 8657, 5, 1062, 532, 2, 8657, 8659, 3, 2, 2, 2, 8658, 8642, 3, 2, 2, 2, 8658, 8645, 3, 2, 2, 2, 8658, 8652, 3, 2, 2, 2, 8658, 8659, 3, 2, 2, 2, 8659, 8660, 3, 2, 2, 2, 8660, 8662, 7, 5, 2, 2, 8661, 8663, 5, 1056, 529, 2, 8662, 8661, 3, 2, 2, 2, 8662, 8663, 3, 2, 2, 2, 8663, 8665, 3, 2, 2, 2, 8664, 8606, 3, 2, 2, 2, 8664, 8613, 3, 2, 2, 2, 8664, 8617, 3, 2, 2, 2, 8664, 8621, 3, 2, 2, 2, 8664, 8625, 3, 2, 2, 2, 8664, 8640, 3, 2, 2, 2, 8665, 8684, 3, 2, 2, 2, 8666, 8667, 7, 112, 2, 2, 8667, 8668, 7, 120, 2, 2, 8668, 8683, 5, 1052, 527, 2, 8669, 8671, 7, 123, 2, 2, 8670, 8672, 5, 1060, 531, 2, 8671, 8670, 3, 2, 2, 2, 8671, 8672, 3, 2, 2, 2, 8672, 8673, 3, 2, 2, 2, 8673, 8674, 7, 120, 2, 2, 8674, 8683, 5, 1052, 527, 2, 8675, 8677, 5, 1060, 531, 2, 8676, 8675, 3, 2, 2, 2, 8676, 8677, 3, 2, 2, 2, 8677, 8678, 3, 2, 2, 2, 8678, 8679, 7, 120, 2, 2, 8679, 8680, 5, 1052, 527, 2, 8680, 8681, 5, 1062, 532, 2, 8681, 8683, 3, 2, 2, 2, 8682, 8666, 3, 2, 2, 2, 8682, 8669, 3, 2, 2, 2, 8682, 8676, 3, 2, 2, 2, 8683, 8686, 3, 2, 2, 2, 8684, 8682, 3, 2, 2, 2, 8684, 8685, 3, 2, 2, 2, 8685, 1053, 3, 2, 2, 2, 8686, 8684, 3, 2, 2, 2, 8687, 8689, 7, 38, 2, 2, 8688, 8687, 3, 2, 2, 2, 8688, 8689, 3, 2, 2, 2, 8689, 8690, 3, 2, 2, 2, 8690, 8695, 5, 1360, 681, 2, 8691, 8692, 7, 4, 2, 2, 8692, 8693, 5, 1326, 664, 2, 8693, 8694, 7, 5, 2, 2, 8694, 8696, 3, 2, 2, 2, 8695, 8691, 3, 2, 2, 2, 8695, 8696, 3, 2, 2, 2, 8696, 1055, 3, 2, 2, 2, 8697, 8698, 5, 1054, 528, 2, 8698, 1057, 3, 2, 2, 2, 8699, 8712, 5, 1054, 528, 2, 8700, 8702, 7, 38, 2, 2, 8701, 8703, 5, 1360, 681, 2, 8702, 8701, 3, 2, 2, 2, 8702, 8703, 3, 2, 2, 2, 8703, 8706, 3, 2, 2, 2, 8704, 8706, 5, 1360, 681, 2, 8705, 8700, 3, 2, 2, 2, 8705, 8704, 3, 2, 2, 2, 8706, 8707, 3, 2, 2, 2, 8707, 8708, 7, 4, 2, 2, 8708, 8709, 5, 1090, 546, 2, 8709, 8710, 7, 5, 2, 2, 8710, 8712, 3, 2, 2, 2, 8711, 8699, 3, 2, 2, 2, 8711, 8705, 3, 2, 2, 2, 8712, 1059, 3, 2, 2, 2, 8713, 8715, 9, 45, 2, 2, 8714, 8716, 7, 125, 2, 2, 8715, 8714, 3, 2, 2, 2, 8715, 8716, 3, 2, 2, 2, 8716, 1061, 3, 2, 2, 2, 8717, 8718, 7, 102, 2, 2, 8718, 8719, 7, 4, 2, 2, 8719, 8720, 5, 1326, 664, 2, 8720, 8721, 7, 5, 2, 2, 8721, 8725, 3, 2, 2, 2, 8722, 8723, 7, 82, 2, 2, 8723, 8725, 5, 1152, 577, 2, 8724, 8717, 3, 2, 2, 2, 8724, 8722, 3, 2, 2, 2, 8725, 1063, 3, 2, 2, 2, 8726, 8728, 5, 1324, 663, 2, 8727, 8729, 7, 11, 2, 2, 8728, 8727, 3, 2, 2, 2, 8728, 8729, 3, 2, 2, 2, 8729, 8739, 3, 2, 2, 2, 8730, 8736, 7, 83, 2, 2, 8731, 8737, 5, 1324, 663, 2, 8732, 8733, 7, 4, 2, 2, 8733, 8734, 5, 1324, 663, 2, 8734, 8735, 7, 5, 2, 2, 8735, 8737, 3, 2, 2, 2, 8736, 8731, 3, 2, 2, 2, 8736, 8732, 3, 2, 2, 2, 8737, 8739, 3, 2, 2, 2, 8738, 8726, 3, 2, 2, 2, 8738, 8730, 3, 2, 2, 2, 8739, 1065, 3, 2, 2, 2, 8740, 8745, 5, 1064, 533, 2, 8741, 8742, 7, 8, 2, 2, 8742, 8744, 5, 1064, 533, 2, 8743, 8741, 3, 2, 2, 2, 8744, 8747, 3, 2, 2, 2, 8745, 8743, 3, 2, 2, 2, 8745, 8746, 3, 2, 2, 2, 8746, 1067, 3, 2, 2, 2, 8747, 8745, 3, 2, 2, 2, 8748, 8753, 5, 1064, 533, 2, 8749, 8751, 7, 38, 2, 2, 8750, 8749, 3, 2, 2, 2, 8750, 8751, 3, 2, 2, 2, 8751, 8752, 3, 2, 2, 2, 8752, 8754, 5, 1360, 681, 2, 8753, 8750, 3, 2, 2, 2, 8753, 8754, 3, 2, 2, 2, 8754, 1069, 3, 2, 2, 2, 8755, 8756, 7, 465, 2, 2, 8756, 8757, 5, 1334, 668, 2, 8757, 8758, 7, 4, 2, 2, 8758, 8759, 5, 1268, 635, 2, 8759, 8761, 7, 5, 2, 2, 8760, 8762, 5, 1072, 537, 2, 8761, 8760, 3, 2, 2, 2, 8761, 8762, 3, 2, 2, 2, 8762, 1071, 3, 2, 2, 2, 8763, 8764, 7, 303, 2, 2, 8764, 8765, 7, 4, 2, 2, 8765, 8766, 5, 1152, 577, 2, 8766, 8767, 7, 5, 2, 2, 8767, 1073, 3, 2, 2, 2, 8768, 8770, 5, 1202, 602, 2, 8769, 8771, 5, 1082, 542, 2, 8770, 8769, 3, 2, 2, 2, 8770, 8771, 3, 2, 2, 2, 8771, 8781, 3, 2, 2, 2, 8772, 8773, 7, 313, 2, 2, 8773, 8774, 7, 66, 2, 2, 8774, 8775, 7, 4, 2, 2, 8775, 8776, 5, 1078, 540, 2, 8776, 8778, 7, 5, 2, 2, 8777, 8779, 5, 1082, 542, 2, 8778, 8777, 3, 2, 2, 2, 8778, 8779, 3, 2, 2, 2, 8779, 8781, 3, 2, 2, 2, 8780, 8768, 3, 2, 2, 2, 8780, 8772, 3, 2, 2, 2, 8781, 1075, 3, 2, 2, 2, 8782, 8784, 5, 1202, 602, 2, 8783, 8785, 5, 1080, 541, 2, 8784, 8783, 3, 2, 2, 2, 8784, 8785, 3, 2, 2, 2, 8785, 1077, 3, 2, 2, 2, 8786, 8791, 5, 1076, 539, 2, 8787, 8788, 7, 8, 2, 2, 8788, 8790, 5, 1076, 539, 2, 8789, 8787, 3, 2, 2, 2, 8790, 8793, 3, 2, 2, 2, 8791, 8789, 3, 2, 2, 2, 8791, 8792, 3, 2, 2, 2, 8792, 1079, 3, 2, 2, 2, 8793, 8791, 3, 2, 2, 2, 8794, 8795, 7, 38, 2, 2, 8795, 8796, 7, 4, 2, 2, 8796, 8797, 5, 1090, 546, 2, 8797, 8798, 7, 5, 2, 2, 8798, 1081, 3, 2, 2, 2, 8799, 8800, 7, 107, 2, 2, 8800, 8801, 7, 466, 2, 2, 8801, 1083, 3, 2, 2, 2, 8802, 8803, 7, 105, 2, 2, 8803, 8804, 5, 1152, 577, 2, 8804, 1085, 3, 2, 2, 2, 8805, 8810, 7, 105, 2, 2, 8806, 8807, 7, 427, 2, 2, 8807, 8808, 7, 268, 2, 2, 8808, 8811, 5, 946, 474, 2, 8809, 8811, 5, 1152, 577, 2, 8810, 8806, 3, 2, 2, 2, 8810, 8809, 3, 2, 2, 2, 8811, 1087, 3, 2, 2, 2, 8812, 8813, 5, 1090, 546, 2, 8813, 1089, 3, 2, 2, 2, 8814, 8819, 5, 1092, 547, 2, 8815, 8816, 7, 8, 2, 2, 8816, 8818, 5, 1092, 547, 2, 8817, 8815, 3, 2, 2, 2, 8818, 8821, 3, 2, 2, 2, 8819, 8817, 3, 2, 2, 2, 8819, 8820, 3, 2, 2, 2, 8820, 1091, 3, 2, 2, 2, 8821, 8819, 3, 2, 2, 2, 8822, 8823, 5, 1360, 681, 2, 8823, 8825, 5, 1108, 555, 2, 8824, 8826, 5, 110, 56, 2, 8825, 8824, 3, 2, 2, 2, 8825, 8826, 3, 2, 2, 2, 8826, 1093, 3, 2, 2, 2, 8827, 8828, 7, 467, 2, 2, 8828, 8844, 7, 4, 2, 2, 8829, 8830, 5, 1194, 598, 2, 8830, 8831, 5, 1220, 611, 2, 8831, 8832, 7, 468, 2, 2, 8832, 8833, 5, 1096, 549, 2, 8833, 8845, 3, 2, 2, 2, 8834, 8835, 7, 469, 2, 2, 8835, 8836, 7, 4, 2, 2, 8836, 8837, 5, 1104, 553, 2, 8837, 8838, 7, 5, 2, 2, 8838, 8839, 7, 8, 2, 2, 8839, 8840, 5, 1194, 598, 2, 8840, 8841, 5, 1220, 611, 2, 8841, 8842, 7, 468, 2, 2, 8842, 8843, 5, 1096, 549, 2, 8843, 8845, 3, 2, 2, 2, 8844, 8829, 3, 2, 2, 2, 8844, 8834, 3, 2, 2, 2, 8845, 8846, 3, 2, 2, 2, 8846, 8847, 7, 5, 2, 2, 8847, 1095, 3, 2, 2, 2, 8848, 8853, 5, 1098, 550, 2, 8849, 8850, 7, 8, 2, 2, 8850, 8852, 5, 1098, 550, 2, 8851, 8849, 3, 2, 2, 2, 8852, 8855, 3, 2, 2, 2, 8853, 8851, 3, 2, 2, 2, 8853, 8854, 3, 2, 2, 2, 8854, 1097, 3, 2, 2, 2, 8855, 8853, 3, 2, 2, 2, 8856, 8863, 5, 1360, 681, 2, 8857, 8859, 5, 1108, 555, 2, 8858, 8860, 5, 1100, 551, 2, 8859, 8858, 3, 2, 2, 2, 8859, 8860, 3, 2, 2, 2, 8860, 8864, 3, 2, 2, 2, 8861, 8862, 7, 64, 2, 2, 8862, 8864, 7, 466, 2, 2, 8863, 8857, 3, 2, 2, 2, 8863, 8861, 3, 2, 2, 2, 8864, 1099, 3, 2, 2, 2, 8865, 8867, 5, 1102, 552, 2, 8866, 8865, 3, 2, 2, 2, 8867, 8868, 3, 2, 2, 2, 8868, 8866, 3, 2, 2, 2, 8868, 8869, 3, 2, 2, 2, 8869, 1101, 3, 2, 2, 2, 8870, 8871, 7, 55, 2, 2, 8871, 8879, 5, 1152, 577, 2, 8872, 8873, 5, 1368, 685, 2, 8873, 8874, 5, 1152, 577, 2, 8874, 8879, 3, 2, 2, 2, 8875, 8876, 7, 79, 2, 2, 8876, 8879, 7, 80, 2, 2, 8877, 8879, 7, 80, 2, 2, 8878, 8870, 3, 2, 2, 2, 8878, 8872, 3, 2, 2, 2, 8878, 8875, 3, 2, 2, 2, 8878, 8877, 3, 2, 2, 2, 8879, 1103, 3, 2, 2, 2, 8880, 8885, 5, 1106, 554, 2, 8881, 8882, 7, 8, 2, 2, 8882, 8884, 5, 1106, 554, 2, 8883, 8881, 3, 2, 2, 2, 8884, 8887, 3, 2, 2, 2, 8885, 8883, 3, 2, 2, 2, 8885, 8886, 3, 2, 2, 2, 8886, 1105, 3, 2, 2, 2, 8887, 8885, 3, 2, 2, 2, 8888, 8889, 5, 1192, 597, 2, 8889, 8890, 7, 38, 2, 2, 8890, 8891, 5, 1366, 684, 2, 8891, 8895, 3, 2, 2, 2, 8892, 8893, 7, 55, 2, 2, 8893, 8895, 5, 1192, 597, 2, 8894, 8888, 3, 2, 2, 2, 8894, 8892, 3, 2, 2, 2, 8895, 1107, 3, 2, 2, 2, 8896, 8898, 7, 408, 2, 2, 8897, 8896, 3, 2, 2, 2, 8897, 8898, 3, 2, 2, 2, 8898, 8899, 3, 2, 2, 2, 8899, 8908, 5, 1112, 557, 2, 8900, 8909, 5, 1110, 556, 2, 8901, 8906, 7, 37, 2, 2, 8902, 8903, 7, 6, 2, 2, 8903, 8904, 5, 1344, 673, 2, 8904, 8905, 7, 7, 2, 2, 8905, 8907, 3, 2, 2, 2, 8906, 8902, 3, 2, 2, 2, 8906, 8907, 3, 2, 2, 2, 8907, 8909, 3, 2, 2, 2, 8908, 8900, 3, 2, 2, 2, 8908, 8901, 3, 2, 2, 2, 8909, 8915, 3, 2, 2, 2, 8910, 8911, 5, 1324, 663, 2, 8911, 8912, 7, 29, 2, 2, 8912, 8913, 9, 46, 2, 2, 8913, 8915, 3, 2, 2, 2, 8914, 8897, 3, 2, 2, 2, 8914, 8910, 3, 2, 2, 2, 8915, 1109, 3, 2, 2, 2, 8916, 8918, 7, 6, 2, 2, 8917, 8919, 5, 1344, 673, 2, 8918, 8917, 3, 2, 2, 2, 8918, 8919, 3, 2, 2, 2, 8919, 8920, 3, 2, 2, 2, 8920, 8922, 7, 7, 2, 2, 8921, 8916, 3, 2, 2, 2, 8922, 8925, 3, 2, 2, 2, 8923, 8921, 3, 2, 2, 2, 8923, 8924, 3, 2, 2, 2, 8924, 1111, 3, 2, 2, 2, 8925, 8923, 3, 2, 2, 2, 8926, 8942, 5, 1116, 559, 2, 8927, 8942, 5, 1120, 561, 2, 8928, 8942, 5, 1124, 563, 2, 8929, 8942, 5, 1132, 567, 2, 8930, 8942, 5, 1140, 571, 2, 8931, 8939, 5, 1142, 572, 2, 8932, 8934, 5, 1146, 574, 2, 8933, 8932, 3, 2, 2, 2, 8933, 8934, 3, 2, 2, 2, 8934, 8940, 3, 2, 2, 2, 8935, 8936, 7, 4, 2, 2, 8936, 8937, 5, 1344, 673, 2, 8937, 8938, 7, 5, 2, 2, 8938, 8940, 3, 2, 2, 2, 8939, 8933, 3, 2, 2, 2, 8939, 8935, 3, 2, 2, 2, 8940, 8942, 3, 2, 2, 2, 8941, 8926, 3, 2, 2, 2, 8941, 8927, 3, 2, 2, 2, 8941, 8928, 3, 2, 2, 2, 8941, 8929, 3, 2, 2, 2, 8941, 8930, 3, 2, 2, 2, 8941, 8931, 3, 2, 2, 2, 8942, 1113, 3, 2, 2, 2, 8943, 8948, 5, 1120, 561, 2, 8944, 8948, 5, 1126, 564, 2, 8945, 8948, 5, 1134, 568, 2, 8946, 8948, 5, 1140, 571, 2, 8947, 8943, 3, 2, 2, 2, 8947, 8944, 3, 2, 2, 2, 8947, 8945, 3, 2, 2, 2, 8947, 8946, 3, 2, 2, 2, 8948, 1115, 3, 2, 2, 2, 8949, 8951, 5, 1362, 682, 2, 8950, 8952, 5, 526, 264, 2, 8951, 8950, 3, 2, 2, 2, 8951, 8952, 3, 2, 2, 2, 8952, 8954, 3, 2, 2, 2, 8953, 8955, 5, 1118, 560, 2, 8954, 8953, 3, 2, 2, 2, 8954, 8955, 3, 2, 2, 2, 8955, 1117, 3, 2, 2, 2, 8956, 8957, 7, 4, 2, 2, 8957, 8958, 5, 1268, 635, 2, 8958, 8959, 7, 5, 2, 2, 8959, 1119, 3, 2, 2, 2, 8960, 8985, 7, 394, 2, 2, 8961, 8985, 7, 395, 2, 2, 8962, 8985, 7, 409, 2, 2, 8963, 8985, 7, 381, 2, 2, 8964, 8985, 7, 406, 2, 2, 8965, 8967, 7, 391, 2, 2, 8966, 8968, 5, 1122, 562, 2, 8967, 8966, 3, 2, 2, 2, 8967, 8968, 3, 2, 2, 2, 8968, 8985, 3, 2, 2, 2, 8969, 8970, 7, 192, 2, 2, 8970, 8985, 7, 405, 2, 2, 8971, 8973, 7, 388, 2, 2, 8972, 8974, 5, 1118, 560, 2, 8973, 8972, 3, 2, 2, 2, 8973, 8974, 3, 2, 2, 2, 8974, 8985, 3, 2, 2, 2, 8975, 8977, 7, 387, 2, 2, 8976, 8978, 5, 1118, 560, 2, 8977, 8976, 3, 2, 2, 2, 8977, 8978, 3, 2, 2, 2, 8978, 8985, 3, 2, 2, 2, 8979, 8981, 7, 402, 2, 2, 8980, 8982, 5, 1118, 560, 2, 8981, 8980, 3, 2, 2, 2, 8981, 8982, 3, 2, 2, 2, 8982, 8985, 3, 2, 2, 2, 8983, 8985, 7, 383, 2, 2, 8984, 8960, 3, 2, 2, 2, 8984, 8961, 3, 2, 2, 2, 8984, 8962, 3, 2, 2, 2, 8984, 8963, 3, 2, 2, 2, 8984, 8964, 3, 2, 2, 2, 8984, 8965, 3, 2, 2, 2, 8984, 8969, 3, 2, 2, 2, 8984, 8971, 3, 2, 2, 2, 8984, 8975, 3, 2, 2, 2, 8984, 8979, 3, 2, 2, 2, 8984, 8983, 3, 2, 2, 2, 8985, 1121, 3, 2, 2, 2, 8986, 8987, 7, 4, 2, 2, 8987, 8988, 5, 1344, 673, 2, 8988, 8989, 7, 5, 2, 2, 8989, 1123, 3, 2, 2, 2, 8990, 8993, 5, 1128, 565, 2, 8991, 8993, 5, 1130, 566, 2, 8992, 8990, 3, 2, 2, 2, 8992, 8991, 3, 2, 2, 2, 8993, 1125, 3, 2, 2, 2, 8994, 8997, 5, 1128, 565, 2, 8995, 8997, 5, 1130, 566, 2, 8996, 8994, 3, 2, 2, 2, 8996, 8995, 3, 2, 2, 2, 8997, 1127, 3, 2, 2, 2, 8998, 9000, 7, 382, 2, 2, 8999, 9001, 5, 1138, 570, 2, 9000, 8999, 3, 2, 2, 2, 9000, 9001, 3, 2, 2, 2, 9001, 9002, 3, 2, 2, 2, 9002, 9003, 7, 4, 2, 2, 9003, 9004, 5, 1268, 635, 2, 9004, 9005, 7, 5, 2, 2, 9005, 1129, 3, 2, 2, 2, 9006, 9008, 7, 382, 2, 2, 9007, 9009, 5, 1138, 570, 2, 9008, 9007, 3, 2, 2, 2, 9008, 9009, 3, 2, 2, 2, 9009, 1131, 3, 2, 2, 2, 9010, 9015, 5, 1136, 569, 2, 9011, 9012, 7, 4, 2, 2, 9012, 9013, 5, 1344, 673, 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, 1133, 3, 2, 2, 2, 9017, 9022, 5, 1136, 569, 2, 9018, 9019, 7, 4, 2, 2, 9019, 9020, 5, 1344, 673, 2, 9020, 9021, 7, 5, 2, 2, 9021, 9023, 3, 2, 2, 2, 9022, 9018, 3, 2, 2, 2, 9022, 9023, 3, 2, 2, 2, 9023, 1135, 3, 2, 2, 2, 9024, 9026, 9, 47, 2, 2, 9025, 9027, 5, 1138, 570, 2, 9026, 9025, 3, 2, 2, 2, 9026, 9027, 3, 2, 2, 2, 9027, 9035, 3, 2, 2, 2, 9028, 9035, 7, 416, 2, 2, 9029, 9030, 7, 398, 2, 2, 9030, 9032, 9, 48, 2, 2, 9031, 9033, 5, 1138, 570, 2, 9032, 9031, 3, 2, 2, 2, 9032, 9033, 3, 2, 2, 2, 9033, 9035, 3, 2, 2, 2, 9034, 9024, 3, 2, 2, 2, 9034, 9028, 3, 2, 2, 2, 9034, 9029, 3, 2, 2, 2, 9035, 1137, 3, 2, 2, 2, 9036, 9037, 7, 367, 2, 2, 9037, 1139, 3, 2, 2, 2, 9038, 9043, 9, 49, 2, 2, 9039, 9040, 7, 4, 2, 2, 9040, 9041, 5, 1344, 673, 2, 9041, 9042, 7, 5, 2, 2, 9042, 9044, 3, 2, 2, 2, 9043, 9039, 3, 2, 2, 2, 9043, 9044, 3, 2, 2, 2, 9044, 9046, 3, 2, 2, 2, 9045, 9047, 5, 1144, 573, 2, 9046, 9045, 3, 2, 2, 2, 9046, 9047, 3, 2, 2, 2, 9047, 1141, 3, 2, 2, 2, 9048, 9049, 7, 396, 2, 2, 9049, 1143, 3, 2, 2, 2, 9050, 9051, 7, 107, 2, 2, 9051, 9052, 7, 411, 2, 2, 9052, 9057, 7, 379, 2, 2, 9053, 9054, 7, 372, 2, 2, 9054, 9055, 7, 411, 2, 2, 9055, 9057, 7, 379, 2, 2, 9056, 9050, 3, 2, 2, 2, 9056, 9053, 3, 2, 2, 2, 9057, 1145, 3, 2, 2, 2, 9058, 9084, 7, 377, 2, 2, 9059, 9084, 7, 257, 2, 2, 9060, 9084, 7, 178, 2, 2, 9061, 9084, 7, 220, 2, 2, 9062, 9084, 7, 254, 2, 2, 9063, 9084, 5, 1148, 575, 2, 9064, 9065, 7, 377, 2, 2, 9065, 9066, 7, 96, 2, 2, 9066, 9084, 7, 257, 2, 2, 9067, 9068, 7, 178, 2, 2, 9068, 9072, 7, 96, 2, 2, 9069, 9073, 7, 220, 2, 2, 9070, 9073, 7, 254, 2, 2, 9071, 9073, 5, 1148, 575, 2, 9072, 9069, 3, 2, 2, 2, 9072, 9070, 3, 2, 2, 2, 9072, 9071, 3, 2, 2, 2, 9073, 9084, 3, 2, 2, 2, 9074, 9075, 7, 220, 2, 2, 9075, 9078, 7, 96, 2, 2, 9076, 9079, 7, 254, 2, 2, 9077, 9079, 5, 1148, 575, 2, 9078, 9076, 3, 2, 2, 2, 9078, 9077, 3, 2, 2, 2, 9079, 9084, 3, 2, 2, 2, 9080, 9081, 7, 254, 2, 2, 9081, 9082, 7, 96, 2, 2, 9082, 9084, 5, 1148, 575, 2, 9083, 9058, 3, 2, 2, 2, 9083, 9059, 3, 2, 2, 2, 9083, 9060, 3, 2, 2, 2, 9083, 9061, 3, 2, 2, 2, 9083, 9062, 3, 2, 2, 2, 9083, 9063, 3, 2, 2, 2, 9083, 9064, 3, 2, 2, 2, 9083, 9067, 3, 2, 2, 2, 9083, 9074, 3, 2, 2, 2, 9083, 9080, 3, 2, 2, 2, 9084, 1147, 3, 2, 2, 2, 9085, 9090, 7, 319, 2, 2, 9086, 9087, 7, 4, 2, 2, 9087, 9088, 5, 1344, 673, 2, 9088, 9089, 7, 5, 2, 2, 9089, 9091, 3, 2, 2, 2, 9090, 9086, 3, 2, 2, 2, 9090, 9091, 3, 2, 2, 2, 9091, 1149, 3, 2, 2, 2, 9092, 9093, 7, 199, 2, 2, 9093, 9094, 5, 1152, 577, 2, 9094, 1151, 3, 2, 2, 2, 9095, 9096, 5, 1154, 578, 2, 9096, 1153, 3, 2, 2, 2, 9097, 9099, 5, 1156, 579, 2, 9098, 9100, 5, 1262, 632, 2, 9099, 9098, 3, 2, 2, 2, 9099, 9100, 3, 2, 2, 2, 9100, 1155, 3, 2, 2, 2, 9101, 9106, 5, 1158, 580, 2, 9102, 9103, 9, 50, 2, 2, 9103, 9105, 5, 1158, 580, 2, 9104, 9102, 3, 2, 2, 2, 9105, 9108, 3, 2, 2, 2, 9106, 9104, 3, 2, 2, 2, 9106, 9107, 3, 2, 2, 2, 9107, 1157, 3, 2, 2, 2, 9108, 9106, 3, 2, 2, 2, 9109, 9114, 5, 1160, 581, 2, 9110, 9111, 7, 84, 2, 2, 9111, 9113, 5, 1160, 581, 2, 9112, 9110, 3, 2, 2, 2, 9113, 9116, 3, 2, 2, 2, 9114, 9112, 3, 2, 2, 2, 9114, 9115, 3, 2, 2, 2, 9115, 1159, 3, 2, 2, 2, 9116, 9114, 3, 2, 2, 2, 9117, 9122, 5, 1162, 582, 2, 9118, 9119, 7, 35, 2, 2, 9119, 9121, 5, 1162, 582, 2, 9120, 9118, 3, 2, 2, 2, 9121, 9124, 3, 2, 2, 2, 9122, 9120, 3, 2, 2, 2, 9122, 9123, 3, 2, 2, 2, 9123, 1161, 3, 2, 2, 2, 9124, 9122, 3, 2, 2, 2, 9125, 9131, 5, 1164, 583, 2, 9126, 9128, 7, 79, 2, 2, 9127, 9126, 3, 2, 2, 2, 9127, 9128, 3, 2, 2, 2, 9128, 9129, 3, 2, 2, 2, 9129, 9130, 7, 70, 2, 2, 9130, 9132, 5, 1294, 648, 2, 9131, 9127, 3, 2, 2, 2, 9131, 9132, 3, 2, 2, 2, 9132, 1163, 3, 2, 2, 2, 9133, 9135, 7, 79, 2, 2, 9134, 9133, 3, 2, 2, 2, 9134, 9135, 3, 2, 2, 2, 9135, 9136, 3, 2, 2, 2, 9136, 9137, 5, 1166, 584, 2, 9137, 1165, 3, 2, 2, 2, 9138, 9140, 5, 1168, 585, 2, 9139, 9141, 9, 51, 2, 2, 9140, 9139, 3, 2, 2, 2, 9140, 9141, 3, 2, 2, 2, 9141, 1167, 3, 2, 2, 2, 9142, 9166, 5, 1170, 586, 2, 9143, 9145, 7, 118, 2, 2, 9144, 9146, 7, 79, 2, 2, 9145, 9144, 3, 2, 2, 2, 9145, 9146, 3, 2, 2, 2, 9146, 9164, 3, 2, 2, 2, 9147, 9165, 7, 80, 2, 2, 9148, 9165, 7, 98, 2, 2, 9149, 9165, 7, 62, 2, 2, 9150, 9165, 7, 358, 2, 2, 9151, 9152, 7, 58, 2, 2, 9152, 9153, 7, 66, 2, 2, 9153, 9165, 5, 1152, 577, 2, 9154, 9155, 7, 268, 2, 2, 9155, 9156, 7, 4, 2, 2, 9156, 9157, 5, 1274, 638, 2, 9157, 9158, 7, 5, 2, 2, 9158, 9165, 3, 2, 2, 2, 9159, 9165, 7, 190, 2, 2, 9160, 9162, 5, 1284, 643, 2, 9161, 9160, 3, 2, 2, 2, 9161, 9162, 3, 2, 2, 2, 9162, 9163, 3, 2, 2, 2, 9163, 9165, 7, 471, 2, 2, 9164, 9147, 3, 2, 2, 2, 9164, 9148, 3, 2, 2, 2, 9164, 9149, 3, 2, 2, 2, 9164, 9150, 3, 2, 2, 2, 9164, 9151, 3, 2, 2, 2, 9164, 9154, 3, 2, 2, 2, 9164, 9159, 3, 2, 2, 2, 9164, 9161, 3, 2, 2, 2, 9165, 9167, 3, 2, 2, 2, 9166, 9143, 3, 2, 2, 2, 9166, 9167, 3, 2, 2, 2, 9167, 1169, 3, 2, 2, 2, 9168, 9180, 5, 1172, 587, 2, 9169, 9170, 9, 52, 2, 2, 9170, 9181, 5, 1172, 587, 2, 9171, 9172, 5, 1266, 634, 2, 9172, 9178, 5, 1256, 629, 2, 9173, 9179, 5, 954, 478, 2, 9174, 9175, 7, 4, 2, 2, 9175, 9176, 5, 1152, 577, 2, 9176, 9177, 7, 5, 2, 2, 9177, 9179, 3, 2, 2, 2, 9178, 9173, 3, 2, 2, 2, 9178, 9174, 3, 2, 2, 2, 9179, 9181, 3, 2, 2, 2, 9180, 9169, 3, 2, 2, 2, 9180, 9171, 3, 2, 2, 2, 9180, 9181, 3, 2, 2, 2, 9181, 1171, 3, 2, 2, 2, 9182, 9200, 5, 1174, 588, 2, 9183, 9185, 7, 79, 2, 2, 9184, 9183, 3, 2, 2, 2, 9184, 9185, 3, 2, 2, 2, 9185, 9194, 3, 2, 2, 2, 9186, 9195, 7, 122, 2, 2, 9187, 9195, 7, 116, 2, 2, 9188, 9189, 7, 129, 2, 2, 9189, 9195, 7, 96, 2, 2, 9190, 9192, 7, 380, 2, 2, 9191, 9193, 7, 93, 2, 2, 9192, 9191, 3, 2, 2, 2, 9192, 9193, 3, 2, 2, 2, 9193, 9195, 3, 2, 2, 2, 9194, 9186, 3, 2, 2, 2, 9194, 9187, 3, 2, 2, 2, 9194, 9188, 3, 2, 2, 2, 9194, 9190, 3, 2, 2, 2, 9195, 9196, 3, 2, 2, 2, 9196, 9198, 5, 1174, 588, 2, 9197, 9199, 5, 1150, 576, 2, 9198, 9197, 3, 2, 2, 2, 9198, 9199, 3, 2, 2, 2, 9199, 9201, 3, 2, 2, 2, 9200, 9184, 3, 2, 2, 2, 9200, 9201, 3, 2, 2, 2, 9201, 1173, 3, 2, 2, 2, 9202, 9208, 5, 1176, 589, 2, 9203, 9204, 5, 1262, 632, 2, 9204, 9205, 5, 1176, 589, 2, 9205, 9207, 3, 2, 2, 2, 9206, 9203, 3, 2, 2, 2, 9207, 9210, 3, 2, 2, 2, 9208, 9206, 3, 2, 2, 2, 9208, 9209, 3, 2, 2, 2, 9209, 1175, 3, 2, 2, 2, 9210, 9208, 3, 2, 2, 2, 9211, 9213, 5, 1262, 632, 2, 9212, 9211, 3, 2, 2, 2, 9212, 9213, 3, 2, 2, 2, 9213, 9214, 3, 2, 2, 2, 9214, 9215, 5, 1178, 590, 2, 9215, 1177, 3, 2, 2, 2, 9216, 9221, 5, 1180, 591, 2, 9217, 9218, 9, 53, 2, 2, 9218, 9220, 5, 1180, 591, 2, 9219, 9217, 3, 2, 2, 2, 9220, 9223, 3, 2, 2, 2, 9221, 9219, 3, 2, 2, 2, 9221, 9222, 3, 2, 2, 2, 9222, 1179, 3, 2, 2, 2, 9223, 9221, 3, 2, 2, 2, 9224, 9229, 5, 1182, 592, 2, 9225, 9226, 9, 54, 2, 2, 9226, 9228, 5, 1182, 592, 2, 9227, 9225, 3, 2, 2, 2, 9228, 9231, 3, 2, 2, 2, 9229, 9227, 3, 2, 2, 2, 9229, 9230, 3, 2, 2, 2, 9230, 1181, 3, 2, 2, 2, 9231, 9229, 3, 2, 2, 2, 9232, 9235, 5, 1184, 593, 2, 9233, 9234, 7, 17, 2, 2, 9234, 9236, 5, 1152, 577, 2, 9235, 9233, 3, 2, 2, 2, 9235, 9236, 3, 2, 2, 2, 9236, 1183, 3, 2, 2, 2, 9237, 9239, 9, 53, 2, 2, 9238, 9237, 3, 2, 2, 2, 9238, 9239, 3, 2, 2, 2, 9239, 9240, 3, 2, 2, 2, 9240, 9241, 5, 1186, 594, 2, 9241, 1185, 3, 2, 2, 2, 9242, 9247, 5, 1188, 595, 2, 9243, 9244, 7, 144, 2, 2, 9244, 9245, 7, 411, 2, 2, 9245, 9246, 7, 379, 2, 2, 9246, 9248, 5, 1152, 577, 2, 9247, 9243, 3, 2, 2, 2, 9247, 9248, 3, 2, 2, 2, 9248, 1187, 3, 2, 2, 2, 9249, 9252, 5, 1190, 596, 2, 9250, 9251, 7, 45, 2, 2, 9251, 9253, 5, 524, 263, 2, 9252, 9250, 3, 2, 2, 2, 9252, 9253, 3, 2, 2, 2, 9253, 1189, 3, 2, 2, 2, 9254, 9259, 5, 1194, 598, 2, 9255, 9256, 7, 28, 2, 2, 9256, 9258, 5, 1108, 555, 2, 9257, 9255, 3, 2, 2, 2, 9258, 9261, 3, 2, 2, 2, 9259, 9257, 3, 2, 2, 2, 9259, 9260, 3, 2, 2, 2, 9260, 1191, 3, 2, 2, 2, 9261, 9259, 3, 2, 2, 2, 9262, 9263, 8, 597, 1, 2, 9263, 9270, 5, 1194, 598, 2, 9264, 9265, 9, 53, 2, 2, 9265, 9270, 5, 1192, 597, 11, 9266, 9267, 5, 1262, 632, 2, 9267, 9268, 5, 1192, 597, 5, 9268, 9270, 3, 2, 2, 2, 9269, 9262, 3, 2, 2, 2, 9269, 9264, 3, 2, 2, 2, 9269, 9266, 3, 2, 2, 2, 9270, 9310, 3, 2, 2, 2, 9271, 9272, 12, 10, 2, 2, 9272, 9273, 7, 17, 2, 2, 9273, 9309, 5, 1192, 597, 11, 9274, 9275, 12, 9, 2, 2, 9275, 9276, 9, 54, 2, 2, 9276, 9309, 5, 1192, 597, 10, 9277, 9278, 12, 8, 2, 2, 9278, 9279, 9, 53, 2, 2, 9279, 9309, 5, 1192, 597, 9, 9280, 9281, 12, 7, 2, 2, 9281, 9282, 5, 1262, 632, 2, 9282, 9283, 5, 1192, 597, 8, 9283, 9309, 3, 2, 2, 2, 9284, 9285, 12, 6, 2, 2, 9285, 9286, 9, 52, 2, 2, 9286, 9309, 5, 1192, 597, 7, 9287, 9288, 12, 12, 2, 2, 9288, 9289, 7, 28, 2, 2, 9289, 9309, 5, 1108, 555, 2, 9290, 9291, 12, 4, 2, 2, 9291, 9309, 5, 1262, 632, 2, 9292, 9293, 12, 3, 2, 2, 9293, 9295, 7, 118, 2, 2, 9294, 9296, 7, 79, 2, 2, 9295, 9294, 3, 2, 2, 2, 9295, 9296, 3, 2, 2, 2, 9296, 9306, 3, 2, 2, 2, 9297, 9298, 7, 58, 2, 2, 9298, 9299, 7, 66, 2, 2, 9299, 9307, 5, 1192, 597, 2, 9300, 9301, 7, 268, 2, 2, 9301, 9302, 7, 4, 2, 2, 9302, 9303, 5, 1274, 638, 2, 9303, 9304, 7, 5, 2, 2, 9304, 9307, 3, 2, 2, 2, 9305, 9307, 7, 190, 2, 2, 9306, 9297, 3, 2, 2, 2, 9306, 9300, 3, 2, 2, 2, 9306, 9305, 3, 2, 2, 2, 9307, 9309, 3, 2, 2, 2, 9308, 9271, 3, 2, 2, 2, 9308, 9274, 3, 2, 2, 2, 9308, 9277, 3, 2, 2, 2, 9308, 9280, 3, 2, 2, 2, 9308, 9284, 3, 2, 2, 2, 9308, 9287, 3, 2, 2, 2, 9308, 9290, 3, 2, 2, 2, 9308, 9292, 3, 2, 2, 2, 9309, 9312, 3, 2, 2, 2, 9310, 9308, 3, 2, 2, 2, 9310, 9311, 3, 2, 2, 2, 9311, 1193, 3, 2, 2, 2, 9312, 9310, 3, 2, 2, 2, 9313, 9314, 7, 389, 2, 2, 9314, 9350, 5, 954, 478, 2, 9315, 9318, 7, 37, 2, 2, 9316, 9319, 5, 954, 478, 2, 9317, 9319, 5, 1276, 639, 2, 9318, 9316, 3, 2, 2, 2, 9318, 9317, 3, 2, 2, 2, 9319, 9350, 3, 2, 2, 2, 9320, 9321, 7, 30, 2, 2, 9321, 9350, 5, 1314, 658, 2, 9322, 9323, 7, 463, 2, 2, 9323, 9324, 7, 4, 2, 2, 9324, 9325, 5, 1268, 635, 2, 9325, 9326, 7, 5, 2, 2, 9326, 9350, 3, 2, 2, 2, 9327, 9328, 7, 100, 2, 2, 9328, 9350, 5, 954, 478, 2, 9329, 9350, 5, 1306, 654, 2, 9330, 9350, 5, 1336, 669, 2, 9331, 9350, 5, 1196, 599, 2, 9332, 9333, 7, 4, 2, 2, 9333, 9334, 5, 1152, 577, 2, 9334, 9335, 7, 5, 2, 2, 9335, 9336, 5, 1314, 658, 2, 9336, 9350, 3, 2, 2, 2, 9337, 9350, 5, 1296, 649, 2, 9338, 9350, 5, 1200, 601, 2, 9339, 9341, 5, 954, 478, 2, 9340, 9342, 5, 1312, 657, 2, 9341, 9340, 3, 2, 2, 2, 9341, 9342, 3, 2, 2, 2, 9342, 9350, 3, 2, 2, 2, 9343, 9350, 5, 1252, 627, 2, 9344, 9350, 5, 1254, 628, 2, 9345, 9346, 5, 1250, 626, 2, 9346, 9347, 7, 127, 2, 2, 9347, 9348, 5, 1250, 626, 2, 9348, 9350, 3, 2, 2, 2, 9349, 9313, 3, 2, 2, 2, 9349, 9315, 3, 2, 2, 2, 9349, 9320, 3, 2, 2, 2, 9349, 9322, 3, 2, 2, 2, 9349, 9327, 3, 2, 2, 2, 9349, 9329, 3, 2, 2, 2, 9349, 9330, 3, 2, 2, 2, 9349, 9331, 3, 2, 2, 2, 9349, 9332, 3, 2, 2, 2, 9349, 9337, 3, 2, 2, 2, 9349, 9338, 3, 2, 2, 2, 9349, 9339, 3, 2, 2, 2, 9349, 9343, 3, 2, 2, 2, 9349, 9344, 3, 2, 2, 2, 9349, 9345, 3, 2, 2, 2, 9350, 1195, 3, 2, 2, 2, 9351, 9352, 7, 539, 2, 2, 9352, 1197, 3, 2, 2, 2, 9353, 9354, 5, 1334, 668, 2, 9354, 9376, 7, 4, 2, 2, 9355, 9359, 5, 1270, 636, 2, 9356, 9357, 7, 8, 2, 2, 9357, 9358, 7, 103, 2, 2, 9358, 9360, 5, 1272, 637, 2, 9359, 9356, 3, 2, 2, 2, 9359, 9360, 3, 2, 2, 2, 9360, 9362, 3, 2, 2, 2, 9361, 9363, 5, 990, 496, 2, 9362, 9361, 3, 2, 2, 2, 9362, 9363, 3, 2, 2, 2, 9363, 9377, 3, 2, 2, 2, 9364, 9365, 7, 103, 2, 2, 9365, 9367, 5, 1272, 637, 2, 9366, 9368, 5, 990, 496, 2, 9367, 9366, 3, 2, 2, 2, 9367, 9368, 3, 2, 2, 2, 9368, 9377, 3, 2, 2, 2, 9369, 9370, 9, 42, 2, 2, 9370, 9372, 5, 1270, 636, 2, 9371, 9373, 5, 990, 496, 2, 9372, 9371, 3, 2, 2, 2, 9372, 9373, 3, 2, 2, 2, 9373, 9377, 3, 2, 2, 2, 9374, 9377, 7, 11, 2, 2, 9375, 9377, 3, 2, 2, 2, 9376, 9355, 3, 2, 2, 2, 9376, 9364, 3, 2, 2, 2, 9376, 9369, 3, 2, 2, 2, 9376, 9374, 3, 2, 2, 2, 9376, 9375, 3, 2, 2, 2, 9377, 9378, 3, 2, 2, 2, 9378, 9379, 7, 5, 2, 2, 9379, 1199, 3, 2, 2, 2, 9380, 9382, 5, 1198, 600, 2, 9381, 9383, 5, 1224, 613, 2, 9382, 9381, 3, 2, 2, 2, 9382, 9383, 3, 2, 2, 2, 9383, 9385, 3, 2, 2, 2, 9384, 9386, 5, 1226, 614, 2, 9385, 9384, 3, 2, 2, 2, 9385, 9386, 3, 2, 2, 2, 9386, 9388, 3, 2, 2, 2, 9387, 9389, 5, 1234, 618, 2, 9388, 9387, 3, 2, 2, 2, 9388, 9389, 3, 2, 2, 2, 9389, 9392, 3, 2, 2, 2, 9390, 9392, 5, 1204, 603, 2, 9391, 9380, 3, 2, 2, 2, 9391, 9390, 3, 2, 2, 2, 9392, 1201, 3, 2, 2, 2, 9393, 9396, 5, 1198, 600, 2, 9394, 9396, 5, 1204, 603, 2, 9395, 9393, 3, 2, 2, 2, 9395, 9394, 3, 2, 2, 2, 9396, 1203, 3, 2, 2, 2, 9397, 9398, 7, 110, 2, 2, 9398, 9399, 7, 64, 2, 2, 9399, 9400, 7, 4, 2, 2, 9400, 9401, 5, 1152, 577, 2, 9401, 9402, 7, 5, 2, 2, 9402, 9582, 3, 2, 2, 2, 9403, 9582, 7, 50, 2, 2, 9404, 9409, 7, 52, 2, 2, 9405, 9406, 7, 4, 2, 2, 9406, 9407, 5, 1344, 673, 2, 9407, 9408, 7, 5, 2, 2, 9408, 9410, 3, 2, 2, 2, 9409, 9405, 3, 2, 2, 2, 9409, 9410, 3, 2, 2, 2, 9410, 9582, 3, 2, 2, 2, 9411, 9416, 7, 53, 2, 2, 9412, 9413, 7, 4, 2, 2, 9413, 9414, 5, 1344, 673, 2, 9414, 9415, 7, 5, 2, 2, 9415, 9417, 3, 2, 2, 2, 9416, 9412, 3, 2, 2, 2, 9416, 9417, 3, 2, 2, 2, 9417, 9582, 3, 2, 2, 2, 9418, 9423, 7, 77, 2, 2, 9419, 9420, 7, 4, 2, 2, 9420, 9421, 5, 1344, 673, 2, 9421, 9422, 7, 5, 2, 2, 9422, 9424, 3, 2, 2, 2, 9423, 9419, 3, 2, 2, 2, 9423, 9424, 3, 2, 2, 2, 9424, 9582, 3, 2, 2, 2, 9425, 9430, 7, 78, 2, 2, 9426, 9427, 7, 4, 2, 2, 9427, 9428, 5, 1344, 673, 2, 9428, 9429, 7, 5, 2, 2, 9429, 9431, 3, 2, 2, 2, 9430, 9426, 3, 2, 2, 2, 9430, 9431, 3, 2, 2, 2, 9431, 9582, 3, 2, 2, 2, 9432, 9582, 7, 51, 2, 2, 9433, 9582, 7, 54, 2, 2, 9434, 9582, 7, 91, 2, 2, 9435, 9582, 7, 101, 2, 2, 9436, 9582, 7, 49, 2, 2, 9437, 9582, 7, 113, 2, 2, 9438, 9439, 7, 43, 2, 2, 9439, 9440, 7, 4, 2, 2, 9440, 9441, 5, 1152, 577, 2, 9441, 9442, 7, 38, 2, 2, 9442, 9443, 5, 1108, 555, 2, 9443, 9444, 7, 5, 2, 2, 9444, 9582, 3, 2, 2, 2, 9445, 9446, 7, 390, 2, 2, 9446, 9448, 7, 4, 2, 2, 9447, 9449, 5, 1280, 641, 2, 9448, 9447, 3, 2, 2, 2, 9448, 9449, 3, 2, 2, 2, 9449, 9450, 3, 2, 2, 2, 9450, 9582, 7, 5, 2, 2, 9451, 9452, 7, 482, 2, 2, 9452, 9453, 7, 4, 2, 2, 9453, 9456, 5, 1152, 577, 2, 9454, 9455, 7, 8, 2, 2, 9455, 9457, 5, 1284, 643, 2, 9456, 9454, 3, 2, 2, 2, 9456, 9457, 3, 2, 2, 2, 9457, 9458, 3, 2, 2, 2, 9458, 9459, 7, 5, 2, 2, 9459, 9582, 3, 2, 2, 2, 9460, 9461, 7, 403, 2, 2, 9461, 9462, 7, 4, 2, 2, 9462, 9463, 5, 1286, 644, 2, 9463, 9464, 7, 5, 2, 2, 9464, 9582, 3, 2, 2, 2, 9465, 9466, 7, 404, 2, 2, 9466, 9468, 7, 4, 2, 2, 9467, 9469, 5, 1288, 645, 2, 9468, 9467, 3, 2, 2, 2, 9468, 9469, 3, 2, 2, 2, 9469, 9470, 3, 2, 2, 2, 9470, 9582, 7, 5, 2, 2, 9471, 9472, 7, 410, 2, 2, 9472, 9474, 7, 4, 2, 2, 9473, 9475, 5, 1290, 646, 2, 9474, 9473, 3, 2, 2, 2, 9474, 9475, 3, 2, 2, 2, 9475, 9476, 3, 2, 2, 2, 9476, 9582, 7, 5, 2, 2, 9477, 9478, 7, 413, 2, 2, 9478, 9479, 7, 4, 2, 2, 9479, 9480, 5, 1152, 577, 2, 9480, 9481, 7, 38, 2, 2, 9481, 9482, 5, 1108, 555, 2, 9482, 9483, 7, 5, 2, 2, 9483, 9582, 3, 2, 2, 2, 9484, 9485, 7, 414, 2, 2, 9485, 9487, 7, 4, 2, 2, 9486, 9488, 9, 55, 2, 2, 9487, 9486, 3, 2, 2, 2, 9487, 9488, 3, 2, 2, 2, 9488, 9489, 3, 2, 2, 2, 9489, 9490, 5, 1292, 647, 2, 9490, 9491, 7, 5, 2, 2, 9491, 9582, 3, 2, 2, 2, 9492, 9493, 7, 401, 2, 2, 9493, 9494, 7, 4, 2, 2, 9494, 9495, 5, 1152, 577, 2, 9495, 9496, 7, 8, 2, 2, 9496, 9497, 5, 1152, 577, 2, 9497, 9498, 7, 5, 2, 2, 9498, 9582, 3, 2, 2, 2, 9499, 9500, 7, 386, 2, 2, 9500, 9501, 7, 4, 2, 2, 9501, 9502, 5, 1268, 635, 2, 9502, 9503, 7, 5, 2, 2, 9503, 9582, 3, 2, 2, 2, 9504, 9505, 7, 392, 2, 2, 9505, 9506, 7, 4, 2, 2, 9506, 9507, 5, 1268, 635, 2, 9507, 9508, 7, 5, 2, 2, 9508, 9582, 3, 2, 2, 2, 9509, 9510, 7, 397, 2, 2, 9510, 9511, 7, 4, 2, 2, 9511, 9512, 5, 1268, 635, 2, 9512, 9513, 7, 5, 2, 2, 9513, 9582, 3, 2, 2, 2, 9514, 9515, 7, 418, 2, 2, 9515, 9516, 7, 4, 2, 2, 9516, 9517, 5, 1268, 635, 2, 9517, 9518, 7, 5, 2, 2, 9518, 9582, 3, 2, 2, 2, 9519, 9520, 7, 419, 2, 2, 9520, 9521, 7, 4, 2, 2, 9521, 9522, 7, 259, 2, 2, 9522, 9528, 5, 1366, 684, 2, 9523, 9526, 7, 8, 2, 2, 9524, 9527, 5, 1210, 606, 2, 9525, 9527, 5, 1268, 635, 2, 9526, 9524, 3, 2, 2, 2, 9526, 9525, 3, 2, 2, 2, 9527, 9529, 3, 2, 2, 2, 9528, 9523, 3, 2, 2, 2, 9528, 9529, 3, 2, 2, 2, 9529, 9530, 3, 2, 2, 2, 9530, 9531, 7, 5, 2, 2, 9531, 9582, 3, 2, 2, 2, 9532, 9533, 7, 420, 2, 2, 9533, 9534, 7, 4, 2, 2, 9534, 9535, 5, 1194, 598, 2, 9535, 9536, 5, 1220, 611, 2, 9536, 9537, 7, 5, 2, 2, 9537, 9582, 3, 2, 2, 2, 9538, 9539, 7, 421, 2, 2, 9539, 9540, 7, 4, 2, 2, 9540, 9541, 5, 1212, 607, 2, 9541, 9542, 7, 5, 2, 2, 9542, 9582, 3, 2, 2, 2, 9543, 9544, 7, 422, 2, 2, 9544, 9545, 7, 4, 2, 2, 9545, 9546, 5, 1216, 609, 2, 9546, 9548, 5, 1152, 577, 2, 9547, 9549, 5, 1218, 610, 2, 9548, 9547, 3, 2, 2, 2, 9548, 9549, 3, 2, 2, 2, 9549, 9550, 3, 2, 2, 2, 9550, 9551, 7, 5, 2, 2, 9551, 9582, 3, 2, 2, 2, 9552, 9553, 7, 423, 2, 2, 9553, 9554, 7, 4, 2, 2, 9554, 9555, 7, 259, 2, 2, 9555, 9558, 5, 1366, 684, 2, 9556, 9557, 7, 8, 2, 2, 9557, 9559, 5, 1152, 577, 2, 9558, 9556, 3, 2, 2, 2, 9558, 9559, 3, 2, 2, 2, 9559, 9560, 3, 2, 2, 2, 9560, 9561, 7, 5, 2, 2, 9561, 9582, 3, 2, 2, 2, 9562, 9563, 7, 424, 2, 2, 9563, 9564, 7, 4, 2, 2, 9564, 9565, 7, 376, 2, 2, 9565, 9566, 5, 1152, 577, 2, 9566, 9567, 7, 8, 2, 2, 9567, 9569, 5, 1206, 604, 2, 9568, 9570, 5, 1208, 605, 2, 9569, 9568, 3, 2, 2, 2, 9569, 9570, 3, 2, 2, 2, 9570, 9571, 3, 2, 2, 2, 9571, 9572, 7, 5, 2, 2, 9572, 9582, 3, 2, 2, 2, 9573, 9574, 7, 425, 2, 2, 9574, 9575, 7, 4, 2, 2, 9575, 9576, 5, 1216, 609, 2, 9576, 9577, 5, 1152, 577, 2, 9577, 9578, 7, 38, 2, 2, 9578, 9579, 5, 1112, 557, 2, 9579, 9580, 7, 5, 2, 2, 9580, 9582, 3, 2, 2, 2, 9581, 9397, 3, 2, 2, 2, 9581, 9403, 3, 2, 2, 2, 9581, 9404, 3, 2, 2, 2, 9581, 9411, 3, 2, 2, 2, 9581, 9418, 3, 2, 2, 2, 9581, 9425, 3, 2, 2, 2, 9581, 9432, 3, 2, 2, 2, 9581, 9433, 3, 2, 2, 2, 9581, 9434, 3, 2, 2, 2, 9581, 9435, 3, 2, 2, 2, 9581, 9436, 3, 2, 2, 2, 9581, 9437, 3, 2, 2, 2, 9581, 9438, 3, 2, 2, 2, 9581, 9445, 3, 2, 2, 2, 9581, 9451, 3, 2, 2, 2, 9581, 9460, 3, 2, 2, 2, 9581, 9465, 3, 2, 2, 2, 9581, 9471, 3, 2, 2, 2, 9581, 9477, 3, 2, 2, 2, 9581, 9484, 3, 2, 2, 2, 9581, 9492, 3, 2, 2, 2, 9581, 9499, 3, 2, 2, 2, 9581, 9504, 3, 2, 2, 2, 9581, 9509, 3, 2, 2, 2, 9581, 9514, 3, 2, 2, 2, 9581, 9519, 3, 2, 2, 2, 9581, 9532, 3, 2, 2, 2, 9581, 9538, 3, 2, 2, 2, 9581, 9543, 3, 2, 2, 2, 9581, 9552, 3, 2, 2, 2, 9581, 9562, 3, 2, 2, 2, 9581, 9573, 3, 2, 2, 2, 9582, 1205, 3, 2, 2, 2, 9583, 9584, 7, 368, 2, 2, 9584, 9589, 5, 1152, 577, 2, 9585, 9586, 7, 368, 2, 2, 9586, 9587, 7, 262, 2, 2, 9587, 9589, 7, 443, 2, 2, 9588, 9583, 3, 2, 2, 2, 9588, 9585, 3, 2, 2, 2, 9589, 1207, 3, 2, 2, 2, 9590, 9591, 7, 8, 2, 2, 9591, 9592, 7, 332, 2, 2, 9592, 9601, 7, 378, 2, 2, 9593, 9594, 7, 8, 2, 2, 9594, 9595, 7, 332, 2, 2, 9595, 9601, 7, 262, 2, 2, 9596, 9597, 7, 8, 2, 2, 9597, 9598, 7, 332, 2, 2, 9598, 9599, 7, 262, 2, 2, 9599, 9601, 7, 443, 2, 2, 9600, 9590, 3, 2, 2, 2, 9600, 9593, 3, 2, 2, 2, 9600, 9596, 3, 2, 2, 2, 9601, 1209, 3, 2, 2, 2, 9602, 9603, 7, 417, 2, 2, 9603, 9604, 7, 4, 2, 2, 9604, 9605, 5, 1212, 607, 2, 9605, 9606, 7, 5, 2, 2, 9606, 1211, 3, 2, 2, 2, 9607, 9612, 5, 1214, 608, 2, 9608, 9609, 7, 8, 2, 2, 9609, 9611, 5, 1214, 608, 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, 1213, 3, 2, 2, 2, 9614, 9612, 3, 2, 2, 2, 9615, 9618, 5, 1152, 577, 2, 9616, 9617, 7, 38, 2, 2, 9617, 9619, 5, 1366, 684, 2, 9618, 9616, 3, 2, 2, 2, 9618, 9619, 3, 2, 2, 2, 9619, 1215, 3, 2, 2, 2, 9620, 9621, 9, 56, 2, 2, 9621, 1217, 3, 2, 2, 2, 9622, 9623, 7, 285, 2, 2, 9623, 9627, 7, 371, 2, 2, 9624, 9625, 7, 340, 2, 2, 9625, 9627, 7, 371, 2, 2, 9626, 9622, 3, 2, 2, 2, 9626, 9624, 3, 2, 2, 2, 9627, 1219, 3, 2, 2, 2, 9628, 9629, 7, 279, 2, 2, 9629, 9644, 5, 1194, 598, 2, 9630, 9631, 7, 279, 2, 2, 9631, 9632, 5, 1194, 598, 2, 9632, 9633, 5, 1222, 612, 2, 9633, 9644, 3, 2, 2, 2, 9634, 9635, 7, 279, 2, 2, 9635, 9636, 5, 1222, 612, 2, 9636, 9637, 5, 1194, 598, 2, 9637, 9644, 3, 2, 2, 2, 9638, 9639, 7, 279, 2, 2, 9639, 9640, 5, 1222, 612, 2, 9640, 9641, 5, 1194, 598, 2, 9641, 9642, 5, 1222, 612, 2, 9642, 9644, 3, 2, 2, 2, 9643, 9628, 3, 2, 2, 2, 9643, 9630, 3, 2, 2, 2, 9643, 9634, 3, 2, 2, 2, 9643, 9638, 3, 2, 2, 2, 9644, 1221, 3, 2, 2, 2, 9645, 9646, 7, 149, 2, 2, 9646, 9647, 9, 57, 2, 2, 9647, 1223, 3, 2, 2, 2, 9648, 9649, 7, 472, 2, 2, 9649, 9650, 7, 68, 2, 2, 9650, 9651, 7, 4, 2, 2, 9651, 9652, 5, 992, 497, 2, 9652, 9653, 7, 5, 2, 2, 9653, 1225, 3, 2, 2, 2, 9654, 9655, 7, 473, 2, 2, 9655, 9656, 7, 4, 2, 2, 9656, 9657, 7, 105, 2, 2, 9657, 9658, 5, 1152, 577, 2, 9658, 9659, 7, 5, 2, 2, 9659, 1227, 3, 2, 2, 2, 9660, 9661, 7, 106, 2, 2, 9661, 9662, 5, 1230, 616, 2, 9662, 1229, 3, 2, 2, 2, 9663, 9668, 5, 1232, 617, 2, 9664, 9665, 7, 8, 2, 2, 9665, 9667, 5, 1232, 617, 2, 9666, 9664, 3, 2, 2, 2, 9667, 9670, 3, 2, 2, 2, 9668, 9666, 3, 2, 2, 2, 9668, 9669, 3, 2, 2, 2, 9669, 1231, 3, 2, 2, 2, 9670, 9668, 3, 2, 2, 2, 9671, 9672, 5, 1360, 681, 2, 9672, 9673, 7, 38, 2, 2, 9673, 9674, 5, 1236, 619, 2, 9674, 1233, 3, 2, 2, 2, 9675, 9678, 7, 126, 2, 2, 9676, 9679, 5, 1236, 619, 2, 9677, 9679, 5, 1360, 681, 2, 9678, 9676, 3, 2, 2, 2, 9678, 9677, 3, 2, 2, 2, 9679, 1235, 3, 2, 2, 2, 9680, 9682, 7, 4, 2, 2, 9681, 9683, 5, 1238, 620, 2, 9682, 9681, 3, 2, 2, 2, 9682, 9683, 3, 2, 2, 2, 9683, 9685, 3, 2, 2, 2, 9684, 9686, 5, 1240, 621, 2, 9685, 9684, 3, 2, 2, 2, 9685, 9686, 3, 2, 2, 2, 9686, 9688, 3, 2, 2, 2, 9687, 9689, 5, 990, 496, 2, 9688, 9687, 3, 2, 2, 2, 9688, 9689, 3, 2, 2, 2, 9689, 9691, 3, 2, 2, 2, 9690, 9692, 5, 1242, 622, 2, 9691, 9690, 3, 2, 2, 2, 9691, 9692, 3, 2, 2, 2, 9692, 9693, 3, 2, 2, 2, 9693, 9694, 7, 5, 2, 2, 9694, 1237, 3, 2, 2, 2, 9695, 9696, 5, 1360, 681, 2, 9696, 1239, 3, 2, 2, 2, 9697, 9698, 7, 278, 2, 2, 9698, 9699, 7, 149, 2, 2, 9699, 9700, 5, 1268, 635, 2, 9700, 1241, 3, 2, 2, 2, 9701, 9702, 7, 292, 2, 2, 9702, 9704, 5, 1244, 623, 2, 9703, 9705, 5, 1248, 625, 2, 9704, 9703, 3, 2, 2, 2, 9704, 9705, 3, 2, 2, 2, 9705, 9717, 3, 2, 2, 2, 9706, 9707, 7, 313, 2, 2, 9707, 9709, 5, 1244, 623, 2, 9708, 9710, 5, 1248, 625, 2, 9709, 9708, 3, 2, 2, 2, 9709, 9710, 3, 2, 2, 2, 9710, 9717, 3, 2, 2, 2, 9711, 9712, 7, 474, 2, 2, 9712, 9714, 5, 1244, 623, 2, 9713, 9715, 5, 1248, 625, 2, 9714, 9713, 3, 2, 2, 2, 9714, 9715, 3, 2, 2, 2, 9715, 9717, 3, 2, 2, 2, 9716, 9701, 3, 2, 2, 2, 9716, 9706, 3, 2, 2, 2, 9716, 9711, 3, 2, 2, 2, 9717, 1243, 3, 2, 2, 2, 9718, 9725, 5, 1246, 624, 2, 9719, 9720, 7, 380, 2, 2, 9720, 9721, 5, 1246, 624, 2, 9721, 9722, 7, 35, 2, 2, 9722, 9723, 5, 1246, 624, 2, 9723, 9725, 3, 2, 2, 2, 9724, 9718, 3, 2, 2, 2, 9724, 9719, 3, 2, 2, 2, 9725, 1245, 3, 2, 2, 2, 9726, 9727, 7, 355, 2, 2, 9727, 9734, 9, 58, 2, 2, 9728, 9729, 7, 427, 2, 2, 9729, 9734, 7, 407, 2, 2, 9730, 9731, 5, 1152, 577, 2, 9731, 9732, 9, 58, 2, 2, 9732, 9734, 3, 2, 2, 2, 9733, 9726, 3, 2, 2, 2, 9733, 9728, 3, 2, 2, 2, 9733, 9730, 3, 2, 2, 2, 9734, 1247, 3, 2, 2, 2, 9735, 9742, 7, 201, 2, 2, 9736, 9737, 7, 427, 2, 2, 9737, 9743, 7, 407, 2, 2, 9738, 9743, 7, 68, 2, 2, 9739, 9743, 7, 460, 2, 2, 9740, 9741, 7, 262, 2, 2, 9741, 9743, 7, 475, 2, 2, 9742, 9736, 3, 2, 2, 2, 9742, 9738, 3, 2, 2, 2, 9742, 9739, 3, 2, 2, 2, 9742, 9740, 3, 2, 2, 2, 9743, 1249, 3, 2, 2, 2, 9744, 9745, 7, 407, 2, 2, 9745, 9747, 7, 4, 2, 2, 9746, 9748, 5, 1268, 635, 2, 9747, 9746, 3, 2, 2, 2, 9747, 9748, 3, 2, 2, 2, 9748, 9749, 3, 2, 2, 2, 9749, 9757, 7, 5, 2, 2, 9750, 9751, 7, 4, 2, 2, 9751, 9752, 5, 1268, 635, 2, 9752, 9753, 7, 8, 2, 2, 9753, 9754, 5, 1152, 577, 2, 9754, 9755, 7, 5, 2, 2, 9755, 9757, 3, 2, 2, 2, 9756, 9744, 3, 2, 2, 2, 9756, 9750, 3, 2, 2, 2, 9757, 1251, 3, 2, 2, 2, 9758, 9759, 7, 407, 2, 2, 9759, 9761, 7, 4, 2, 2, 9760, 9762, 5, 1268, 635, 2, 9761, 9760, 3, 2, 2, 2, 9761, 9762, 3, 2, 2, 2, 9762, 9763, 3, 2, 2, 2, 9763, 9764, 7, 5, 2, 2, 9764, 1253, 3, 2, 2, 2, 9765, 9766, 7, 4, 2, 2, 9766, 9767, 5, 1268, 635, 2, 9767, 9768, 7, 8, 2, 2, 9768, 9769, 5, 1152, 577, 2, 9769, 9770, 7, 5, 2, 2, 9770, 1255, 3, 2, 2, 2, 9771, 9772, 9, 59, 2, 2, 9772, 1257, 3, 2, 2, 2, 9773, 9776, 7, 31, 2, 2, 9774, 9776, 5, 1260, 631, 2, 9775, 9773, 3, 2, 2, 2, 9775, 9774, 3, 2, 2, 2, 9776, 1259, 3, 2, 2, 2, 9777, 9778, 9, 60, 2, 2, 9778, 1261, 3, 2, 2, 2, 9779, 9786, 7, 31, 2, 2, 9780, 9781, 7, 271, 2, 2, 9781, 9782, 7, 4, 2, 2, 9782, 9783, 5, 684, 343, 2, 9783, 9784, 7, 5, 2, 2, 9784, 9786, 3, 2, 2, 2, 9785, 9779, 3, 2, 2, 2, 9785, 9780, 3, 2, 2, 2, 9786, 1263, 3, 2, 2, 2, 9787, 9794, 5, 1258, 630, 2, 9788, 9789, 7, 271, 2, 2, 9789, 9790, 7, 4, 2, 2, 9790, 9791, 5, 684, 343, 2, 9791, 9792, 7, 5, 2, 2, 9792, 9794, 3, 2, 2, 2, 9793, 9787, 3, 2, 2, 2, 9793, 9788, 3, 2, 2, 2, 9794, 1265, 3, 2, 2, 2, 9795, 9808, 5, 1258, 630, 2, 9796, 9797, 7, 271, 2, 2, 9797, 9798, 7, 4, 2, 2, 9798, 9799, 5, 684, 343, 2, 9799, 9800, 7, 5, 2, 2, 9800, 9808, 3, 2, 2, 2, 9801, 9808, 7, 122, 2, 2, 9802, 9803, 7, 79, 2, 2, 9803, 9808, 7, 122, 2, 2, 9804, 9808, 7, 116, 2, 2, 9805, 9806, 7, 79, 2, 2, 9806, 9808, 7, 116, 2, 2, 9807, 9795, 3, 2, 2, 2, 9807, 9796, 3, 2, 2, 2, 9807, 9801, 3, 2, 2, 2, 9807, 9802, 3, 2, 2, 2, 9807, 9804, 3, 2, 2, 2, 9807, 9805, 3, 2, 2, 2, 9808, 1267, 3, 2, 2, 2, 9809, 9814, 5, 1152, 577, 2, 9810, 9811, 7, 8, 2, 2, 9811, 9813, 5, 1152, 577, 2, 9812, 9810, 3, 2, 2, 2, 9813, 9816, 3, 2, 2, 2, 9814, 9812, 3, 2, 2, 2, 9814, 9815, 3, 2, 2, 2, 9815, 1269, 3, 2, 2, 2, 9816, 9814, 3, 2, 2, 2, 9817, 9822, 5, 1272, 637, 2, 9818, 9819, 7, 8, 2, 2, 9819, 9821, 5, 1272, 637, 2, 9820, 9818, 3, 2, 2, 2, 9821, 9824, 3, 2, 2, 2, 9822, 9820, 3, 2, 2, 2, 9822, 9823, 3, 2, 2, 2, 9823, 1271, 3, 2, 2, 2, 9824, 9822, 3, 2, 2, 2, 9825, 9831, 5, 1152, 577, 2, 9826, 9827, 5, 636, 319, 2, 9827, 9828, 9, 61, 2, 2, 9828, 9829, 5, 1152, 577, 2, 9829, 9831, 3, 2, 2, 2, 9830, 9825, 3, 2, 2, 2, 9830, 9826, 3, 2, 2, 2, 9831, 1273, 3, 2, 2, 2, 9832, 9837, 5, 1108, 555, 2, 9833, 9834, 7, 8, 2, 2, 9834, 9836, 5, 1108, 555, 2, 9835, 9833, 3, 2, 2, 2, 9836, 9839, 3, 2, 2, 2, 9837, 9835, 3, 2, 2, 2, 9837, 9838, 3, 2, 2, 2, 9838, 1275, 3, 2, 2, 2, 9839, 9837, 3, 2, 2, 2, 9840, 9843, 7, 6, 2, 2, 9841, 9844, 5, 1268, 635, 2, 9842, 9844, 5, 1278, 640, 2, 9843, 9841, 3, 2, 2, 2, 9843, 9842, 3, 2, 2, 2, 9843, 9844, 3, 2, 2, 2, 9844, 9845, 3, 2, 2, 2, 9845, 9846, 7, 7, 2, 2, 9846, 1277, 3, 2, 2, 2, 9847, 9852, 5, 1276, 639, 2, 9848, 9849, 7, 8, 2, 2, 9849, 9851, 5, 1276, 639, 2, 9850, 9848, 3, 2, 2, 2, 9851, 9854, 3, 2, 2, 2, 9852, 9850, 3, 2, 2, 2, 9852, 9853, 3, 2, 2, 2, 9853, 1279, 3, 2, 2, 2, 9854, 9852, 3, 2, 2, 2, 9855, 9856, 5, 1282, 642, 2, 9856, 9857, 7, 66, 2, 2, 9857, 9858, 5, 1152, 577, 2, 9858, 1281, 3, 2, 2, 2, 9859, 9868, 5, 1368, 685, 2, 9860, 9868, 7, 377, 2, 2, 9861, 9868, 7, 257, 2, 2, 9862, 9868, 7, 178, 2, 2, 9863, 9868, 7, 220, 2, 2, 9864, 9868, 7, 254, 2, 2, 9865, 9868, 7, 319, 2, 2, 9866, 9868, 5, 1346, 674, 2, 9867, 9859, 3, 2, 2, 2, 9867, 9860, 3, 2, 2, 2, 9867, 9861, 3, 2, 2, 2, 9867, 9862, 3, 2, 2, 2, 9867, 9863, 3, 2, 2, 2, 9867, 9864, 3, 2, 2, 2, 9867, 9865, 3, 2, 2, 2, 9867, 9866, 3, 2, 2, 2, 9868, 1283, 3, 2, 2, 2, 9869, 9870, 9, 62, 2, 2, 9870, 1285, 3, 2, 2, 2, 9871, 9872, 5, 1152, 577, 2, 9872, 9873, 7, 86, 2, 2, 9873, 9874, 5, 1152, 577, 2, 9874, 9875, 7, 66, 2, 2, 9875, 9878, 5, 1152, 577, 2, 9876, 9877, 7, 64, 2, 2, 9877, 9879, 5, 1152, 577, 2, 9878, 9876, 3, 2, 2, 2, 9878, 9879, 3, 2, 2, 2, 9879, 1287, 3, 2, 2, 2, 9880, 9881, 5, 1192, 597, 2, 9881, 9882, 7, 70, 2, 2, 9882, 9883, 5, 1192, 597, 2, 9883, 1289, 3, 2, 2, 2, 9884, 9885, 5, 1152, 577, 2, 9885, 9886, 7, 66, 2, 2, 9886, 9887, 5, 1152, 577, 2, 9887, 9888, 7, 64, 2, 2, 9888, 9889, 5, 1152, 577, 2, 9889, 9912, 3, 2, 2, 2, 9890, 9891, 5, 1152, 577, 2, 9891, 9892, 7, 64, 2, 2, 9892, 9893, 5, 1152, 577, 2, 9893, 9894, 7, 66, 2, 2, 9894, 9895, 5, 1152, 577, 2, 9895, 9912, 3, 2, 2, 2, 9896, 9897, 5, 1152, 577, 2, 9897, 9898, 7, 66, 2, 2, 9898, 9899, 5, 1152, 577, 2, 9899, 9912, 3, 2, 2, 2, 9900, 9901, 5, 1152, 577, 2, 9901, 9902, 7, 64, 2, 2, 9902, 9903, 5, 1152, 577, 2, 9903, 9912, 3, 2, 2, 2, 9904, 9905, 5, 1152, 577, 2, 9905, 9906, 7, 129, 2, 2, 9906, 9907, 5, 1152, 577, 2, 9907, 9908, 7, 199, 2, 2, 9908, 9909, 5, 1152, 577, 2, 9909, 9912, 3, 2, 2, 2, 9910, 9912, 5, 1268, 635, 2, 9911, 9884, 3, 2, 2, 2, 9911, 9890, 3, 2, 2, 2, 9911, 9896, 3, 2, 2, 2, 9911, 9900, 3, 2, 2, 2, 9911, 9904, 3, 2, 2, 2, 9911, 9910, 3, 2, 2, 2, 9912, 1291, 3, 2, 2, 2, 9913, 9914, 5, 1152, 577, 2, 9914, 9915, 7, 66, 2, 2, 9915, 9916, 5, 1268, 635, 2, 9916, 9921, 3, 2, 2, 2, 9917, 9918, 7, 66, 2, 2, 9918, 9921, 5, 1268, 635, 2, 9919, 9921, 5, 1268, 635, 2, 9920, 9913, 3, 2, 2, 2, 9920, 9917, 3, 2, 2, 2, 9920, 9919, 3, 2, 2, 2, 9921, 1293, 3, 2, 2, 2, 9922, 9928, 5, 954, 478, 2, 9923, 9924, 7, 4, 2, 2, 9924, 9925, 5, 1268, 635, 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, 1295, 3, 2, 2, 2, 9929, 9931, 7, 42, 2, 2, 9930, 9932, 5, 1304, 653, 2, 9931, 9930, 3, 2, 2, 2, 9931, 9932, 3, 2, 2, 2, 9932, 9933, 3, 2, 2, 2, 9933, 9935, 5, 1298, 650, 2, 9934, 9936, 5, 1302, 652, 2, 9935, 9934, 3, 2, 2, 2, 9935, 9936, 3, 2, 2, 2, 9936, 9937, 3, 2, 2, 2, 9937, 9938, 7, 447, 2, 2, 9938, 1297, 3, 2, 2, 2, 9939, 9941, 5, 1300, 651, 2, 9940, 9939, 3, 2, 2, 2, 9941, 9942, 3, 2, 2, 2, 9942, 9940, 3, 2, 2, 2, 9942, 9943, 3, 2, 2, 2, 9943, 1299, 3, 2, 2, 2, 9944, 9945, 7, 104, 2, 2, 9945, 9946, 5, 1152, 577, 2, 9946, 9947, 7, 95, 2, 2, 9947, 9948, 5, 1152, 577, 2, 9948, 1301, 3, 2, 2, 2, 9949, 9950, 7, 60, 2, 2, 9950, 9951, 5, 1152, 577, 2, 9951, 1303, 3, 2, 2, 2, 9952, 9953, 5, 1152, 577, 2, 9953, 1305, 3, 2, 2, 2, 9954, 9956, 5, 1360, 681, 2, 9955, 9957, 5, 1312, 657, 2, 9956, 9955, 3, 2, 2, 2, 9956, 9957, 3, 2, 2, 2, 9957, 1307, 3, 2, 2, 2, 9958, 9961, 7, 13, 2, 2, 9959, 9962, 5, 1330, 666, 2, 9960, 9962, 7, 11, 2, 2, 9961, 9959, 3, 2, 2, 2, 9961, 9960, 3, 2, 2, 2, 9962, 9976, 3, 2, 2, 2, 9963, 9972, 7, 6, 2, 2, 9964, 9973, 5, 1152, 577, 2, 9965, 9967, 5, 1310, 656, 2, 9966, 9965, 3, 2, 2, 2, 9966, 9967, 3, 2, 2, 2, 9967, 9968, 3, 2, 2, 2, 9968, 9970, 7, 10, 2, 2, 9969, 9971, 5, 1310, 656, 2, 9970, 9969, 3, 2, 2, 2, 9970, 9971, 3, 2, 2, 2, 9971, 9973, 3, 2, 2, 2, 9972, 9964, 3, 2, 2, 2, 9972, 9966, 3, 2, 2, 2, 9973, 9974, 3, 2, 2, 2, 9974, 9976, 7, 7, 2, 2, 9975, 9958, 3, 2, 2, 2, 9975, 9963, 3, 2, 2, 2, 9976, 1309, 3, 2, 2, 2, 9977, 9978, 5, 1152, 577, 2, 9978, 1311, 3, 2, 2, 2, 9979, 9981, 5, 1308, 655, 2, 9980, 9979, 3, 2, 2, 2, 9981, 9982, 3, 2, 2, 2, 9982, 9980, 3, 2, 2, 2, 9982, 9983, 3, 2, 2, 2, 9983, 1313, 3, 2, 2, 2, 9984, 9986, 5, 1308, 655, 2, 9985, 9984, 3, 2, 2, 2, 9986, 9989, 3, 2, 2, 2, 9987, 9985, 3, 2, 2, 2, 9987, 9988, 3, 2, 2, 2, 9988, 1315, 3, 2, 2, 2, 9989, 9987, 3, 2, 2, 2, 9990, 9991, 5, 1318, 660, 2, 9991, 1317, 3, 2, 2, 2, 9992, 9997, 5, 1320, 661, 2, 9993, 9994, 7, 8, 2, 2, 9994, 9996, 5, 1320, 661, 2, 9995, 9993, 3, 2, 2, 2, 9996, 9999, 3, 2, 2, 2, 9997, 9995, 3, 2, 2, 2, 9997, 9998, 3, 2, 2, 2, 9998, 1319, 3, 2, 2, 2, 9999, 9997, 3, 2, 2, 2, 10000, 10005, 5, 1152, 577, 2, 10001, 10002, 7, 38, 2, 2, 10002, 10006, 5, 1366, 684, 2, 10003, 10006, 5, 1368, 685, 2, 10004, 10006, 3, 2, 2, 2, 10005, 10001, 3, 2, 2, 2, 10005, 10003, 3, 2, 2, 2, 10005, 10004, 3, 2, 2, 2, 10006, 10009, 3, 2, 2, 2, 10007, 10009, 7, 11, 2, 2, 10008, 10000, 3, 2, 2, 2, 10008, 10007, 3, 2, 2, 2, 10009, 1321, 3, 2, 2, 2, 10010, 10015, 5, 1324, 663, 2, 10011, 10012, 7, 8, 2, 2, 10012, 10014, 5, 1324, 663, 2, 10013, 10011, 3, 2, 2, 2, 10014, 10017, 3, 2, 2, 2, 10015, 10013, 3, 2, 2, 2, 10015, 10016, 3, 2, 2, 2, 10016, 1323, 3, 2, 2, 2, 10017, 10015, 3, 2, 2, 2, 10018, 10020, 5, 1360, 681, 2, 10019, 10021, 5, 1312, 657, 2, 10020, 10019, 3, 2, 2, 2, 10020, 10021, 3, 2, 2, 2, 10021, 1325, 3, 2, 2, 2, 10022, 10027, 5, 1328, 665, 2, 10023, 10024, 7, 8, 2, 2, 10024, 10026, 5, 1328, 665, 2, 10025, 10023, 3, 2, 2, 2, 10026, 10029, 3, 2, 2, 2, 10027, 10025, 3, 2, 2, 2, 10027, 10028, 3, 2, 2, 2, 10028, 1327, 3, 2, 2, 2, 10029, 10027, 3, 2, 2, 2, 10030, 10031, 5, 1360, 681, 2, 10031, 1329, 3, 2, 2, 2, 10032, 10033, 5, 1366, 684, 2, 10033, 1331, 3, 2, 2, 2, 10034, 10035, 5, 1346, 674, 2, 10035, 1333, 3, 2, 2, 2, 10036, 10041, 5, 1362, 682, 2, 10037, 10038, 5, 1360, 681, 2, 10038, 10039, 5, 1312, 657, 2, 10039, 10041, 3, 2, 2, 2, 10040, 10036, 3, 2, 2, 2, 10040, 10037, 3, 2, 2, 2, 10041, 1335, 3, 2, 2, 2, 10042, 10078, 5, 1344, 673, 2, 10043, 10078, 5, 1342, 672, 2, 10044, 10078, 5, 1346, 674, 2, 10045, 10078, 5, 1340, 671, 2, 10046, 10078, 5, 1338, 670, 2, 10047, 10057, 5, 1334, 668, 2, 10048, 10058, 5, 1346, 674, 2, 10049, 10050, 7, 4, 2, 2, 10050, 10052, 5, 1270, 636, 2, 10051, 10053, 5, 990, 496, 2, 10052, 10051, 3, 2, 2, 2, 10052, 10053, 3, 2, 2, 2, 10053, 10054, 3, 2, 2, 2, 10054, 10055, 7, 5, 2, 2, 10055, 10056, 5, 1346, 674, 2, 10056, 10058, 3, 2, 2, 2, 10057, 10048, 3, 2, 2, 2, 10057, 10049, 3, 2, 2, 2, 10058, 10078, 3, 2, 2, 2, 10059, 10060, 5, 1114, 558, 2, 10060, 10061, 5, 1346, 674, 2, 10061, 10078, 3, 2, 2, 2, 10062, 10072, 5, 1142, 572, 2, 10063, 10065, 5, 1346, 674, 2, 10064, 10066, 5, 1146, 574, 2, 10065, 10064, 3, 2, 2, 2, 10065, 10066, 3, 2, 2, 2, 10066, 10073, 3, 2, 2, 2, 10067, 10068, 7, 4, 2, 2, 10068, 10069, 5, 1344, 673, 2, 10069, 10070, 7, 5, 2, 2, 10070, 10071, 5, 1346, 674, 2, 10071, 10073, 3, 2, 2, 2, 10072, 10063, 3, 2, 2, 2, 10072, 10067, 3, 2, 2, 2, 10073, 10078, 3, 2, 2, 2, 10074, 10078, 7, 98, 2, 2, 10075, 10078, 7, 62, 2, 2, 10076, 10078, 7, 80, 2, 2, 10077, 10042, 3, 2, 2, 2, 10077, 10043, 3, 2, 2, 2, 10077, 10044, 3, 2, 2, 2, 10077, 10045, 3, 2, 2, 2, 10077, 10046, 3, 2, 2, 2, 10077, 10047, 3, 2, 2, 2, 10077, 10059, 3, 2, 2, 2, 10077, 10062, 3, 2, 2, 2, 10077, 10074, 3, 2, 2, 2, 10077, 10075, 3, 2, 2, 2, 10077, 10076, 3, 2, 2, 2, 10078, 1337, 3, 2, 2, 2, 10079, 10080, 7, 532, 2, 2, 10080, 1339, 3, 2, 2, 2, 10081, 10082, 7, 528, 2, 2, 10082, 1341, 3, 2, 2, 2, 10083, 10084, 7, 538, 2, 2, 10084, 1343, 3, 2, 2, 2, 10085, 10086, 7, 536, 2, 2, 10086, 1345, 3, 2, 2, 2, 10087, 10089, 5, 1348, 675, 2, 10088, 10090, 5, 1350, 676, 2, 10089, 10088, 3, 2, 2, 2, 10089, 10090, 3, 2, 2, 2, 10090, 1347, 3, 2, 2, 2, 10091, 10103, 7, 523, 2, 2, 10092, 10103, 7, 525, 2, 2, 10093, 10097, 7, 527, 2, 2, 10094, 10096, 7, 553, 2, 2, 10095, 10094, 3, 2, 2, 2, 10096, 10099, 3, 2, 2, 2, 10097, 10095, 3, 2, 2, 2, 10097, 10098, 3, 2, 2, 2, 10098, 10100, 3, 2, 2, 2, 10099, 10097, 3, 2, 2, 2, 10100, 10103, 7, 554, 2, 2, 10101, 10103, 7, 549, 2, 2, 10102, 10091, 3, 2, 2, 2, 10102, 10092, 3, 2, 2, 2, 10102, 10093, 3, 2, 2, 2, 10102, 10101, 3, 2, 2, 2, 10103, 1349, 3, 2, 2, 2, 10104, 10105, 7, 480, 2, 2, 10105, 10106, 5, 1348, 675, 2, 10106, 1351, 3, 2, 2, 2, 10107, 10113, 5, 1344, 673, 2, 10108, 10109, 7, 14, 2, 2, 10109, 10113, 5, 1344, 673, 2, 10110, 10111, 7, 15, 2, 2, 10111, 10113, 5, 1344, 673, 2, 10112, 10107, 3, 2, 2, 2, 10112, 10108, 3, 2, 2, 2, 10112, 10110, 3, 2, 2, 2, 10113, 1353, 3, 2, 2, 2, 10114, 10115, 5, 1356, 679, 2, 10115, 1355, 3, 2, 2, 2, 10116, 10120, 5, 1364, 683, 2, 10117, 10120, 7, 54, 2, 2, 10118, 10120, 7, 91, 2, 2, 10119, 10116, 3, 2, 2, 2, 10119, 10117, 3, 2, 2, 2, 10119, 10118, 3, 2, 2, 2, 10120, 1357, 3, 2, 2, 2, 10121, 10126, 5, 1356, 679, 2, 10122, 10123, 7, 8, 2, 2, 10123, 10125, 5, 1356, 679, 2, 10124, 10122, 3, 2, 2, 2, 10125, 10128, 3, 2, 2, 2, 10126, 10124, 3, 2, 2, 2, 10126, 10127, 3, 2, 2, 2, 10127, 1359, 3, 2, 2, 2, 10128, 10126, 3, 2, 2, 2, 10129, 10134, 5, 1368, 685, 2, 10130, 10134, 5, 1372, 687, 2, 10131, 10134, 5, 1374, 688, 2, 10132, 10134, 5, 1592, 797, 2, 10133, 10129, 3, 2, 2, 2, 10133, 10130, 3, 2, 2, 2, 10133, 10131, 3, 2, 2, 2, 10133, 10132, 3, 2, 2, 2, 10134, 1361, 3, 2, 2, 2, 10135, 10140, 5, 1368, 685, 2, 10136, 10140, 5, 1372, 687, 2, 10137, 10140, 5, 1592, 797, 2, 10138, 10140, 5, 1376, 689, 2, 10139, 10135, 3, 2, 2, 2, 10139, 10136, 3, 2, 2, 2, 10139, 10137, 3, 2, 2, 2, 10139, 10138, 3, 2, 2, 2, 10140, 1363, 3, 2, 2, 2, 10141, 10146, 5, 1368, 685, 2, 10142, 10146, 5, 1372, 687, 2, 10143, 10146, 5, 1374, 688, 2, 10144, 10146, 5, 1376, 689, 2, 10145, 10141, 3, 2, 2, 2, 10145, 10142, 3, 2, 2, 2, 10145, 10143, 3, 2, 2, 2, 10145, 10144, 3, 2, 2, 2, 10146, 1365, 3, 2, 2, 2, 10147, 10154, 5, 1368, 685, 2, 10148, 10154, 5, 1592, 797, 2, 10149, 10154, 5, 1372, 687, 2, 10150, 10154, 5, 1374, 688, 2, 10151, 10154, 5, 1376, 689, 2, 10152, 10154, 5, 1378, 690, 2, 10153, 10147, 3, 2, 2, 2, 10153, 10148, 3, 2, 2, 2, 10153, 10149, 3, 2, 2, 2, 10153, 10150, 3, 2, 2, 2, 10153, 10151, 3, 2, 2, 2, 10153, 10152, 3, 2, 2, 2, 10154, 1367, 3, 2, 2, 2, 10155, 10157, 7, 514, 2, 2, 10156, 10158, 5, 1350, 676, 2, 10157, 10156, 3, 2, 2, 2, 10157, 10158, 3, 2, 2, 2, 10158, 10165, 3, 2, 2, 2, 10159, 10165, 7, 515, 2, 2, 10160, 10165, 7, 519, 2, 2, 10161, 10165, 5, 1196, 599, 2, 10162, 10165, 5, 1370, 686, 2, 10163, 10165, 5, 1592, 797, 2, 10164, 10155, 3, 2, 2, 2, 10164, 10159, 3, 2, 2, 2, 10164, 10160, 3, 2, 2, 2, 10164, 10161, 3, 2, 2, 2, 10164, 10162, 3, 2, 2, 2, 10164, 10163, 3, 2, 2, 2, 10165, 1369, 3, 2, 2, 2, 10166, 10167, 7, 540, 2, 2, 10167, 1371, 3, 2, 2, 2, 10168, 10169, 9, 63, 2, 2, 10169, 1373, 3, 2, 2, 2, 10170, 10222, 7, 380, 2, 2, 10171, 10222, 7, 381, 2, 2, 10172, 10222, 5, 1124, 563, 2, 10173, 10222, 7, 383, 2, 2, 10174, 10222, 7, 384, 2, 2, 10175, 10222, 5, 1132, 567, 2, 10176, 10222, 7, 386, 2, 2, 10177, 10222, 7, 387, 2, 2, 10178, 10222, 7, 388, 2, 2, 10179, 10222, 7, 389, 2, 2, 10180, 10222, 7, 390, 2, 2, 10181, 10222, 7, 391, 2, 2, 10182, 10222, 7, 392, 2, 2, 10183, 10222, 7, 463, 2, 2, 10184, 10222, 7, 393, 2, 2, 10185, 10222, 7, 394, 2, 2, 10186, 10222, 7, 395, 2, 2, 10187, 10222, 7, 396, 2, 2, 10188, 10222, 7, 397, 2, 2, 10189, 10222, 7, 398, 2, 2, 10190, 10222, 7, 399, 2, 2, 10191, 10222, 7, 400, 2, 2, 10192, 10222, 7, 482, 2, 2, 10193, 10222, 7, 401, 2, 2, 10194, 10222, 5, 1120, 561, 2, 10195, 10222, 7, 446, 2, 2, 10196, 10222, 7, 403, 2, 2, 10197, 10222, 7, 404, 2, 2, 10198, 10222, 7, 405, 2, 2, 10199, 10222, 7, 406, 2, 2, 10200, 10222, 7, 407, 2, 2, 10201, 10222, 7, 408, 2, 2, 10202, 10222, 7, 409, 2, 2, 10203, 10222, 7, 410, 2, 2, 10204, 10222, 7, 411, 2, 2, 10205, 10222, 7, 412, 2, 2, 10206, 10222, 7, 413, 2, 2, 10207, 10222, 7, 414, 2, 2, 10208, 10222, 7, 415, 2, 2, 10209, 10222, 7, 416, 2, 2, 10210, 10222, 7, 417, 2, 2, 10211, 10222, 7, 418, 2, 2, 10212, 10222, 7, 419, 2, 2, 10213, 10222, 7, 420, 2, 2, 10214, 10222, 7, 421, 2, 2, 10215, 10222, 7, 469, 2, 2, 10216, 10222, 7, 422, 2, 2, 10217, 10222, 7, 423, 2, 2, 10218, 10222, 7, 424, 2, 2, 10219, 10222, 7, 425, 2, 2, 10220, 10222, 7, 467, 2, 2, 10221, 10170, 3, 2, 2, 2, 10221, 10171, 3, 2, 2, 2, 10221, 10172, 3, 2, 2, 2, 10221, 10173, 3, 2, 2, 2, 10221, 10174, 3, 2, 2, 2, 10221, 10175, 3, 2, 2, 2, 10221, 10176, 3, 2, 2, 2, 10221, 10177, 3, 2, 2, 2, 10221, 10178, 3, 2, 2, 2, 10221, 10179, 3, 2, 2, 2, 10221, 10180, 3, 2, 2, 2, 10221, 10181, 3, 2, 2, 2, 10221, 10182, 3, 2, 2, 2, 10221, 10183, 3, 2, 2, 2, 10221, 10184, 3, 2, 2, 2, 10221, 10185, 3, 2, 2, 2, 10221, 10186, 3, 2, 2, 2, 10221, 10187, 3, 2, 2, 2, 10221, 10188, 3, 2, 2, 2, 10221, 10189, 3, 2, 2, 2, 10221, 10190, 3, 2, 2, 2, 10221, 10191, 3, 2, 2, 2, 10221, 10192, 3, 2, 2, 2, 10221, 10193, 3, 2, 2, 2, 10221, 10194, 3, 2, 2, 2, 10221, 10195, 3, 2, 2, 2, 10221, 10196, 3, 2, 2, 2, 10221, 10197, 3, 2, 2, 2, 10221, 10198, 3, 2, 2, 2, 10221, 10199, 3, 2, 2, 2, 10221, 10200, 3, 2, 2, 2, 10221, 10201, 3, 2, 2, 2, 10221, 10202, 3, 2, 2, 2, 10221, 10203, 3, 2, 2, 2, 10221, 10204, 3, 2, 2, 2, 10221, 10205, 3, 2, 2, 2, 10221, 10206, 3, 2, 2, 2, 10221, 10207, 3, 2, 2, 2, 10221, 10208, 3, 2, 2, 2, 10221, 10209, 3, 2, 2, 2, 10221, 10210, 3, 2, 2, 2, 10221, 10211, 3, 2, 2, 2, 10221, 10212, 3, 2, 2, 2, 10221, 10213, 3, 2, 2, 2, 10221, 10214, 3, 2, 2, 2, 10221, 10215, 3, 2, 2, 2, 10221, 10216, 3, 2, 2, 2, 10221, 10217, 3, 2, 2, 2, 10221, 10218, 3, 2, 2, 2, 10221, 10219, 3, 2, 2, 2, 10221, 10220, 3, 2, 2, 2, 10222, 1375, 3, 2, 2, 2, 10223, 10224, 9, 64, 2, 2, 10224, 1377, 3, 2, 2, 2, 10225, 10226, 9, 65, 2, 2, 10226, 1379, 3, 2, 2, 2, 10227, 10228, 5, 1382, 692, 2, 10228, 10229, 5, 1392, 697, 2, 10229, 10230, 5, 1390, 696, 2, 10230, 1381, 3, 2, 2, 2, 10231, 10233, 5, 1384, 693, 2, 10232, 10231, 3, 2, 2, 2, 10233, 10236, 3, 2, 2, 2, 10234, 10232, 3, 2, 2, 2, 10234, 10235, 3, 2, 2, 2, 10235, 1383, 3, 2, 2, 2, 10236, 10234, 3, 2, 2, 2, 10237, 10238, 5, 1386, 694, 2, 10238, 10239, 7, 272, 2, 2, 10239, 10240, 7, 483, 2, 2, 10240, 10258, 3, 2, 2, 2, 10241, 10242, 5, 1386, 694, 2, 10242, 10243, 7, 484, 2, 2, 10243, 10244, 5, 1388, 695, 2, 10244, 10258, 3, 2, 2, 2, 10245, 10246, 5, 1386, 694, 2, 10246, 10247, 7, 485, 2, 2, 10247, 10248, 7, 486, 2, 2, 10248, 10258, 3, 2, 2, 2, 10249, 10250, 5, 1386, 694, 2, 10250, 10251, 7, 485, 2, 2, 10251, 10252, 7, 487, 2, 2, 10252, 10258, 3, 2, 2, 2, 10253, 10254, 5, 1386, 694, 2, 10254, 10255, 7, 485, 2, 2, 10255, 10256, 7, 488, 2, 2, 10256, 10258, 3, 2, 2, 2, 10257, 10237, 3, 2, 2, 2, 10257, 10241, 3, 2, 2, 2, 10257, 10245, 3, 2, 2, 2, 10257, 10249, 3, 2, 2, 2, 10257, 10253, 3, 2, 2, 2, 10258, 1385, 3, 2, 2, 2, 10259, 10260, 7, 31, 2, 2, 10260, 1387, 3, 2, 2, 2, 10261, 10266, 5, 1346, 674, 2, 10262, 10266, 5, 1378, 690, 2, 10263, 10266, 5, 1592, 797, 2, 10264, 10266, 5, 1372, 687, 2, 10265, 10261, 3, 2, 2, 2, 10265, 10262, 3, 2, 2, 2, 10265, 10263, 3, 2, 2, 2, 10265, 10264, 3, 2, 2, 2, 10266, 1389, 3, 2, 2, 2, 10267, 10270, 3, 2, 2, 2, 10268, 10270, 7, 9, 2, 2, 10269, 10267, 3, 2, 2, 2, 10269, 10268, 3, 2, 2, 2, 10270, 1391, 3, 2, 2, 2, 10271, 10272, 5, 1394, 698, 2, 10272, 10273, 7, 148, 2, 2, 10273, 10274, 5, 1436, 719, 2, 10274, 10275, 5, 1572, 787, 2, 10275, 10276, 7, 447, 2, 2, 10276, 10277, 5, 1586, 794, 2, 10277, 1393, 3, 2, 2, 2, 10278, 10283, 5, 1582, 792, 2, 10279, 10281, 5, 1396, 699, 2, 10280, 10282, 5, 1398, 700, 2, 10281, 10280, 3, 2, 2, 2, 10281, 10282, 3, 2, 2, 2, 10282, 10284, 3, 2, 2, 2, 10283, 10279, 3, 2, 2, 2, 10283, 10284, 3, 2, 2, 2, 10284, 1395, 3, 2, 2, 2, 10285, 10286, 7, 180, 2, 2, 10286, 1397, 3, 2, 2, 2, 10287, 10289, 5, 1402, 702, 2, 10288, 10287, 3, 2, 2, 2, 10289, 10290, 3, 2, 2, 2, 10290, 10288, 3, 2, 2, 2, 10290, 10291, 3, 2, 2, 2, 10291, 1399, 3, 2, 2, 2, 10292, 10293, 7, 20, 2, 2, 10293, 10294, 5, 1590, 796, 2, 10294, 10295, 7, 21, 2, 2, 10295, 1401, 3, 2, 2, 2, 10296, 10300, 5, 1404, 703, 2, 10297, 10300, 7, 180, 2, 2, 10298, 10300, 5, 1400, 701, 2, 10299, 10296, 3, 2, 2, 2, 10299, 10297, 3, 2, 2, 2, 10299, 10298, 3, 2, 2, 2, 10300, 1403, 3, 2, 2, 2, 10301, 10317, 5, 1420, 711, 2, 10302, 10303, 7, 489, 2, 2, 10303, 10304, 7, 64, 2, 2, 10304, 10318, 5, 1418, 710, 2, 10305, 10306, 5, 1422, 712, 2, 10306, 10307, 5, 1424, 713, 2, 10307, 10308, 5, 1426, 714, 2, 10308, 10309, 5, 1428, 715, 2, 10309, 10310, 5, 1430, 716, 2, 10310, 10318, 3, 2, 2, 2, 10311, 10312, 5, 1406, 704, 2, 10312, 10313, 7, 174, 2, 2, 10313, 10314, 5, 1410, 706, 2, 10314, 10315, 5, 1416, 709, 2, 10315, 10316, 5, 1408, 705, 2, 10316, 10318, 3, 2, 2, 2, 10317, 10302, 3, 2, 2, 2, 10317, 10305, 3, 2, 2, 2, 10317, 10311, 3, 2, 2, 2, 10318, 10319, 3, 2, 2, 2, 10319, 10320, 7, 9, 2, 2, 10320, 1405, 3, 2, 2, 2, 10321, 10326, 3, 2, 2, 2, 10322, 10323, 7, 262, 2, 2, 10323, 10326, 7, 317, 2, 2, 10324, 10326, 7, 317, 2, 2, 10325, 10321, 3, 2, 2, 2, 10325, 10322, 3, 2, 2, 2, 10325, 10324, 3, 2, 2, 2, 10326, 1407, 3, 2, 2, 2, 10327, 10328, 5, 952, 477, 2, 10328, 1409, 3, 2, 2, 2, 10329, 10335, 3, 2, 2, 2, 10330, 10331, 7, 4, 2, 2, 10331, 10332, 5, 1412, 707, 2, 10332, 10333, 7, 5, 2, 2, 10333, 10335, 3, 2, 2, 2, 10334, 10329, 3, 2, 2, 2, 10334, 10330, 3, 2, 2, 2, 10335, 1411, 3, 2, 2, 2, 10336, 10341, 5, 1414, 708, 2, 10337, 10338, 7, 8, 2, 2, 10338, 10340, 5, 1414, 708, 2, 10339, 10337, 3, 2, 2, 2, 10340, 10343, 3, 2, 2, 2, 10341, 10339, 3, 2, 2, 2, 10341, 10342, 3, 2, 2, 2, 10342, 1413, 3, 2, 2, 2, 10343, 10341, 3, 2, 2, 2, 10344, 10345, 5, 1420, 711, 2, 10345, 10346, 5, 1424, 713, 2, 10346, 1415, 3, 2, 2, 2, 10347, 10348, 9, 66, 2, 2, 10348, 1417, 3, 2, 2, 2, 10349, 10352, 7, 30, 2, 2, 10350, 10352, 5, 1360, 681, 2, 10351, 10349, 3, 2, 2, 2, 10351, 10350, 3, 2, 2, 2, 10352, 1419, 3, 2, 2, 2, 10353, 10354, 5, 1590, 796, 2, 10354, 1421, 3, 2, 2, 2, 10355, 10358, 3, 2, 2, 2, 10356, 10358, 7, 490, 2, 2, 10357, 10355, 3, 2, 2, 2, 10357, 10356, 3, 2, 2, 2, 10358, 1423, 3, 2, 2, 2, 10359, 10360, 5, 1108, 555, 2, 10360, 1425, 3, 2, 2, 2, 10361, 10365, 3, 2, 2, 2, 10362, 10363, 7, 45, 2, 2, 10363, 10365, 5, 524, 263, 2, 10364, 10361, 3, 2, 2, 2, 10364, 10362, 3, 2, 2, 2, 10365, 1427, 3, 2, 2, 2, 10366, 10370, 3, 2, 2, 2, 10367, 10368, 7, 79, 2, 2, 10368, 10370, 7, 80, 2, 2, 10369, 10366, 3, 2, 2, 2, 10369, 10367, 3, 2, 2, 2, 10370, 1429, 3, 2, 2, 2, 10371, 10376, 3, 2, 2, 2, 10372, 10373, 5, 1432, 717, 2, 10373, 10374, 5, 1594, 798, 2, 10374, 10376, 3, 2, 2, 2, 10375, 10371, 3, 2, 2, 2, 10375, 10372, 3, 2, 2, 2, 10376, 1431, 3, 2, 2, 2, 10377, 10380, 5, 1434, 718, 2, 10378, 10380, 7, 55, 2, 2, 10379, 10377, 3, 2, 2, 2, 10379, 10378, 3, 2, 2, 2, 10380, 1433, 3, 2, 2, 2, 10381, 10382, 9, 67, 2, 2, 10382, 1435, 3, 2, 2, 2, 10383, 10385, 5, 1438, 720, 2, 10384, 10383, 3, 2, 2, 2, 10385, 10388, 3, 2, 2, 2, 10386, 10384, 3, 2, 2, 2, 10386, 10387, 3, 2, 2, 2, 10387, 1437, 3, 2, 2, 2, 10388, 10386, 3, 2, 2, 2, 10389, 10390, 5, 1392, 697, 2, 10390, 10391, 7, 9, 2, 2, 10391, 10417, 3, 2, 2, 2, 10392, 10417, 5, 1504, 753, 2, 10393, 10417, 5, 1508, 755, 2, 10394, 10417, 5, 1446, 724, 2, 10395, 10417, 5, 1462, 732, 2, 10396, 10417, 5, 1468, 735, 2, 10397, 10417, 5, 1478, 740, 2, 10398, 10417, 5, 1480, 741, 2, 10399, 10417, 5, 1482, 742, 2, 10400, 10417, 5, 1496, 749, 2, 10401, 10417, 5, 1500, 751, 2, 10402, 10417, 5, 1520, 761, 2, 10403, 10417, 5, 1526, 764, 2, 10404, 10417, 5, 1528, 765, 2, 10405, 10417, 5, 1440, 721, 2, 10406, 10417, 5, 1442, 722, 2, 10407, 10417, 5, 1448, 725, 2, 10408, 10417, 5, 1536, 769, 2, 10409, 10417, 5, 1548, 775, 2, 10410, 10417, 5, 1556, 779, 2, 10411, 10417, 5, 1558, 780, 2, 10412, 10417, 5, 1560, 781, 2, 10413, 10417, 5, 1562, 782, 2, 10414, 10417, 5, 1564, 783, 2, 10415, 10417, 5, 1568, 785, 2, 10416, 10389, 3, 2, 2, 2, 10416, 10392, 3, 2, 2, 2, 10416, 10393, 3, 2, 2, 2, 10416, 10394, 3, 2, 2, 2, 10416, 10395, 3, 2, 2, 2, 10416, 10396, 3, 2, 2, 2, 10416, 10397, 3, 2, 2, 2, 10416, 10398, 3, 2, 2, 2, 10416, 10399, 3, 2, 2, 2, 10416, 10400, 3, 2, 2, 2, 10416, 10401, 3, 2, 2, 2, 10416, 10402, 3, 2, 2, 2, 10416, 10403, 3, 2, 2, 2, 10416, 10404, 3, 2, 2, 2, 10416, 10405, 3, 2, 2, 2, 10416, 10406, 3, 2, 2, 2, 10416, 10407, 3, 2, 2, 2, 10416, 10408, 3, 2, 2, 2, 10416, 10409, 3, 2, 2, 2, 10416, 10410, 3, 2, 2, 2, 10416, 10411, 3, 2, 2, 2, 10416, 10412, 3, 2, 2, 2, 10416, 10413, 3, 2, 2, 2, 10416, 10414, 3, 2, 2, 2, 10416, 10415, 3, 2, 2, 2, 10417, 1439, 3, 2, 2, 2, 10418, 10419, 7, 491, 2, 2, 10419, 10420, 5, 1598, 800, 2, 10420, 10421, 7, 9, 2, 2, 10421, 1441, 3, 2, 2, 2, 10422, 10423, 7, 426, 2, 2, 10423, 10424, 5, 1590, 796, 2, 10424, 10425, 7, 4, 2, 2, 10425, 10426, 5, 1444, 723, 2, 10426, 10427, 7, 5, 2, 2, 10427, 10428, 7, 9, 2, 2, 10428, 10437, 3, 2, 2, 2, 10429, 10430, 7, 59, 2, 2, 10430, 10431, 5, 1590, 796, 2, 10431, 10432, 7, 4, 2, 2, 10432, 10433, 5, 1444, 723, 2, 10433, 10434, 7, 5, 2, 2, 10434, 10435, 7, 9, 2, 2, 10435, 10437, 3, 2, 2, 2, 10436, 10422, 3, 2, 2, 2, 10436, 10429, 3, 2, 2, 2, 10437, 1443, 3, 2, 2, 2, 10438, 10441, 3, 2, 2, 2, 10439, 10441, 5, 1268, 635, 2, 10440, 10438, 3, 2, 2, 2, 10440, 10439, 3, 2, 2, 2, 10441, 1445, 3, 2, 2, 2, 10442, 10443, 5, 1460, 731, 2, 10443, 10444, 5, 1434, 718, 2, 10444, 10445, 5, 1594, 798, 2, 10445, 10446, 7, 9, 2, 2, 10446, 1447, 3, 2, 2, 2, 10447, 10448, 7, 492, 2, 2, 10448, 10449, 5, 1450, 726, 2, 10449, 10450, 7, 493, 2, 2, 10450, 10451, 5, 1452, 727, 2, 10451, 10452, 7, 9, 2, 2, 10452, 1449, 3, 2, 2, 2, 10453, 10457, 3, 2, 2, 2, 10454, 10457, 7, 427, 2, 2, 10455, 10457, 7, 494, 2, 2, 10456, 10453, 3, 2, 2, 2, 10456, 10454, 3, 2, 2, 2, 10456, 10455, 3, 2, 2, 2, 10457, 1451, 3, 2, 2, 2, 10458, 10463, 5, 1454, 728, 2, 10459, 10460, 7, 8, 2, 2, 10460, 10462, 5, 1454, 728, 2, 10461, 10459, 3, 2, 2, 2, 10462, 10465, 3, 2, 2, 2, 10463, 10461, 3, 2, 2, 2, 10463, 10464, 3, 2, 2, 2, 10464, 1453, 3, 2, 2, 2, 10465, 10463, 3, 2, 2, 2, 10466, 10467, 5, 1458, 730, 2, 10467, 10468, 5, 1434, 718, 2, 10468, 10469, 5, 1456, 729, 2, 10469, 1455, 3, 2, 2, 2, 10470, 10471, 5, 1360, 681, 2, 10471, 1457, 3, 2, 2, 2, 10472, 10473, 5, 1460, 731, 2, 10473, 1459, 3, 2, 2, 2, 10474, 10477, 5, 524, 263, 2, 10475, 10477, 7, 30, 2, 2, 10476, 10474, 3, 2, 2, 2, 10476, 10475, 3, 2, 2, 2, 10477, 10484, 3, 2, 2, 2, 10478, 10479, 7, 6, 2, 2, 10479, 10480, 5, 1600, 801, 2, 10480, 10481, 7, 7, 2, 2, 10481, 10483, 3, 2, 2, 2, 10482, 10478, 3, 2, 2, 2, 10483, 10486, 3, 2, 2, 2, 10484, 10482, 3, 2, 2, 2, 10484, 10485, 3, 2, 2, 2, 10485, 1461, 3, 2, 2, 2, 10486, 10484, 3, 2, 2, 2, 10487, 10488, 7, 222, 2, 2, 10488, 10489, 5, 1596, 799, 2, 10489, 10490, 7, 95, 2, 2, 10490, 10491, 5, 1436, 719, 2, 10491, 10492, 5, 1464, 733, 2, 10492, 10493, 5, 1466, 734, 2, 10493, 10494, 7, 447, 2, 2, 10494, 10495, 7, 222, 2, 2, 10495, 10496, 7, 9, 2, 2, 10496, 1463, 3, 2, 2, 2, 10497, 10498, 7, 495, 2, 2, 10498, 10499, 5, 1152, 577, 2, 10499, 10500, 7, 95, 2, 2, 10500, 10501, 5, 1436, 719, 2, 10501, 10503, 3, 2, 2, 2, 10502, 10497, 3, 2, 2, 2, 10503, 10506, 3, 2, 2, 2, 10504, 10502, 3, 2, 2, 2, 10504, 10505, 3, 2, 2, 2, 10505, 1465, 3, 2, 2, 2, 10506, 10504, 3, 2, 2, 2, 10507, 10511, 3, 2, 2, 2, 10508, 10509, 7, 60, 2, 2, 10509, 10511, 5, 1436, 719, 2, 10510, 10507, 3, 2, 2, 2, 10510, 10508, 3, 2, 2, 2, 10511, 1467, 3, 2, 2, 2, 10512, 10513, 7, 42, 2, 2, 10513, 10514, 5, 1470, 736, 2, 10514, 10515, 5, 1472, 737, 2, 10515, 10516, 5, 1476, 739, 2, 10516, 10517, 7, 447, 2, 2, 10517, 10518, 7, 42, 2, 2, 10518, 10519, 7, 9, 2, 2, 10519, 1469, 3, 2, 2, 2, 10520, 10523, 3, 2, 2, 2, 10521, 10523, 5, 1594, 798, 2, 10522, 10520, 3, 2, 2, 2, 10522, 10521, 3, 2, 2, 2, 10523, 1471, 3, 2, 2, 2, 10524, 10526, 5, 1474, 738, 2, 10525, 10524, 3, 2, 2, 2, 10526, 10527, 3, 2, 2, 2, 10527, 10525, 3, 2, 2, 2, 10527, 10528, 3, 2, 2, 2, 10528, 1473, 3, 2, 2, 2, 10529, 10530, 7, 104, 2, 2, 10530, 10531, 5, 1268, 635, 2, 10531, 10532, 7, 95, 2, 2, 10532, 10533, 5, 1436, 719, 2, 10533, 1475, 3, 2, 2, 2, 10534, 10538, 3, 2, 2, 2, 10535, 10536, 7, 60, 2, 2, 10536, 10538, 5, 1436, 719, 2, 10537, 10534, 3, 2, 2, 2, 10537, 10535, 3, 2, 2, 2, 10538, 1477, 3, 2, 2, 2, 10539, 10540, 5, 1584, 793, 2, 10540, 10541, 5, 1524, 763, 2, 10541, 1479, 3, 2, 2, 2, 10542, 10543, 5, 1584, 793, 2, 10543, 10544, 7, 496, 2, 2, 10544, 10545, 5, 1602, 802, 2, 10545, 10546, 5, 1524, 763, 2, 10546, 1481, 3, 2, 2, 2, 10547, 10548, 5, 1584, 793, 2, 10548, 10549, 7, 64, 2, 2, 10549, 10550, 5, 1484, 743, 2, 10550, 10551, 5, 1524, 763, 2, 10551, 1483, 3, 2, 2, 2, 10552, 10553, 5, 1494, 748, 2, 10553, 10569, 7, 70, 2, 2, 10554, 10555, 5, 946, 474, 2, 10555, 10556, 5, 1488, 745, 2, 10556, 10570, 3, 2, 2, 2, 10557, 10570, 5, 952, 477, 2, 10558, 10570, 5, 878, 440, 2, 10559, 10560, 7, 204, 2, 2, 10560, 10561, 5, 1152, 577, 2, 10561, 10562, 5, 1486, 744, 2, 10562, 10570, 3, 2, 2, 2, 10563, 10564, 5, 1490, 746, 2, 10564, 10565, 5, 1152, 577, 2, 10565, 10566, 7, 26, 2, 2, 10566, 10567, 5, 1152, 577, 2, 10567, 10568, 5, 1492, 747, 2, 10568, 10570, 3, 2, 2, 2, 10569, 10554, 3, 2, 2, 2, 10569, 10557, 3, 2, 2, 2, 10569, 10558, 3, 2, 2, 2, 10569, 10559, 3, 2, 2, 2, 10569, 10563, 3, 2, 2, 2, 10570, 1485, 3, 2, 2, 2, 10571, 10575, 3, 2, 2, 2, 10572, 10573, 7, 102, 2, 2, 10573, 10575, 5, 1268, 635, 2, 10574, 10571, 3, 2, 2, 2, 10574, 10572, 3, 2, 2, 2, 10575, 1487, 3, 2, 2, 2, 10576, 10589, 3, 2, 2, 2, 10577, 10578, 7, 4, 2, 2, 10578, 10583, 5, 1152, 577, 2, 10579, 10580, 7, 8, 2, 2, 10580, 10582, 5, 1152, 577, 2, 10581, 10579, 3, 2, 2, 2, 10582, 10585, 3, 2, 2, 2, 10583, 10581, 3, 2, 2, 2, 10583, 10584, 3, 2, 2, 2, 10584, 10586, 3, 2, 2, 2, 10585, 10583, 3, 2, 2, 2, 10586, 10587, 7, 5, 2, 2, 10587, 10589, 3, 2, 2, 2, 10588, 10576, 3, 2, 2, 2, 10588, 10577, 3, 2, 2, 2, 10589, 1489, 3, 2, 2, 2, 10590, 10593, 3, 2, 2, 2, 10591, 10593, 7, 497, 2, 2, 10592, 10590, 3, 2, 2, 2, 10592, 10591, 3, 2, 2, 2, 10593, 1491, 3, 2, 2, 2, 10594, 10598, 3, 2, 2, 2, 10595, 10596, 7, 149, 2, 2, 10596, 10598, 5, 1152, 577, 2, 10597, 10594, 3, 2, 2, 2, 10597, 10595, 3, 2, 2, 2, 10598, 1493, 3, 2, 2, 2, 10599, 10600, 5, 522, 262, 2, 10600, 1495, 3, 2, 2, 2, 10601, 10602, 5, 1584, 793, 2, 10602, 10603, 7, 498, 2, 2, 10603, 10604, 5, 1494, 748, 2, 10604, 10605, 5, 1498, 750, 2, 10605, 10606, 7, 70, 2, 2, 10606, 10607, 7, 37, 2, 2, 10607, 10608, 5, 1152, 577, 2, 10608, 10609, 5, 1524, 763, 2, 10609, 1497, 3, 2, 2, 2, 10610, 10614, 3, 2, 2, 2, 10611, 10612, 7, 499, 2, 2, 10612, 10614, 5, 1344, 673, 2, 10613, 10610, 3, 2, 2, 2, 10613, 10611, 3, 2, 2, 2, 10614, 1499, 3, 2, 2, 2, 10615, 10616, 5, 1502, 752, 2, 10616, 10618, 5, 1586, 794, 2, 10617, 10619, 5, 1588, 795, 2, 10618, 10617, 3, 2, 2, 2, 10618, 10619, 3, 2, 2, 2, 10619, 10620, 3, 2, 2, 2, 10620, 10621, 7, 9, 2, 2, 10621, 1501, 3, 2, 2, 2, 10622, 10623, 9, 68, 2, 2, 10623, 1503, 3, 2, 2, 2, 10624, 10636, 7, 501, 2, 2, 10625, 10626, 7, 261, 2, 2, 10626, 10637, 5, 1594, 798, 2, 10627, 10633, 7, 502, 2, 2, 10628, 10629, 7, 204, 2, 2, 10629, 10630, 5, 1152, 577, 2, 10630, 10631, 5, 1486, 744, 2, 10631, 10634, 3, 2, 2, 2, 10632, 10634, 5, 952, 477, 2, 10633, 10628, 3, 2, 2, 2, 10633, 10632, 3, 2, 2, 2, 10634, 10637, 3, 2, 2, 2, 10635, 10637, 5, 1506, 754, 2, 10636, 10625, 3, 2, 2, 2, 10636, 10627, 3, 2, 2, 2, 10636, 10635, 3, 2, 2, 2, 10637, 10638, 3, 2, 2, 2, 10638, 10639, 7, 9, 2, 2, 10639, 1505, 3, 2, 2, 2, 10640, 10643, 3, 2, 2, 2, 10641, 10643, 5, 1594, 798, 2, 10642, 10640, 3, 2, 2, 2, 10642, 10641, 3, 2, 2, 2, 10643, 1507, 3, 2, 2, 2, 10644, 10646, 7, 503, 2, 2, 10645, 10647, 5, 1510, 756, 2, 10646, 10645, 3, 2, 2, 2, 10646, 10647, 3, 2, 2, 2, 10647, 10648, 3, 2, 2, 2, 10648, 10649, 5, 1346, 674, 2, 10649, 10650, 5, 1512, 757, 2, 10650, 10651, 5, 1514, 758, 2, 10651, 10652, 7, 9, 2, 2, 10652, 10679, 3, 2, 2, 2, 10653, 10655, 7, 503, 2, 2, 10654, 10656, 5, 1510, 756, 2, 10655, 10654, 3, 2, 2, 2, 10655, 10656, 3, 2, 2, 2, 10656, 10657, 3, 2, 2, 2, 10657, 10658, 5, 1368, 685, 2, 10658, 10659, 5, 1514, 758, 2, 10659, 10660, 7, 9, 2, 2, 10660, 10679, 3, 2, 2, 2, 10661, 10663, 7, 503, 2, 2, 10662, 10664, 5, 1510, 756, 2, 10663, 10662, 3, 2, 2, 2, 10663, 10664, 3, 2, 2, 2, 10664, 10665, 3, 2, 2, 2, 10665, 10666, 7, 504, 2, 2, 10666, 10667, 5, 1346, 674, 2, 10667, 10668, 5, 1514, 758, 2, 10668, 10669, 7, 9, 2, 2, 10669, 10679, 3, 2, 2, 2, 10670, 10672, 7, 503, 2, 2, 10671, 10673, 5, 1510, 756, 2, 10672, 10671, 3, 2, 2, 2, 10672, 10673, 3, 2, 2, 2, 10673, 10674, 3, 2, 2, 2, 10674, 10675, 5, 1514, 758, 2, 10675, 10676, 7, 9, 2, 2, 10676, 10679, 3, 2, 2, 2, 10677, 10679, 7, 503, 2, 2, 10678, 10644, 3, 2, 2, 2, 10678, 10653, 3, 2, 2, 2, 10678, 10661, 3, 2, 2, 2, 10678, 10670, 3, 2, 2, 2, 10678, 10677, 3, 2, 2, 2, 10679, 1509, 3, 2, 2, 2, 10680, 10681, 9, 69, 2, 2, 10681, 1511, 3, 2, 2, 2, 10682, 10690, 3, 2, 2, 2, 10683, 10684, 7, 8, 2, 2, 10684, 10686, 5, 1152, 577, 2, 10685, 10683, 3, 2, 2, 2, 10686, 10687, 3, 2, 2, 2, 10687, 10685, 3, 2, 2, 2, 10687, 10688, 3, 2, 2, 2, 10688, 10690, 3, 2, 2, 2, 10689, 10682, 3, 2, 2, 2, 10689, 10685, 3, 2, 2, 2, 10690, 1513, 3, 2, 2, 2, 10691, 10695, 3, 2, 2, 2, 10692, 10693, 7, 102, 2, 2, 10693, 10695, 5, 1518, 760, 2, 10694, 10691, 3, 2, 2, 2, 10694, 10692, 3, 2, 2, 2, 10695, 1515, 3, 2, 2, 2, 10696, 10697, 5, 1368, 685, 2, 10697, 10698, 7, 12, 2, 2, 10698, 10699, 5, 1152, 577, 2, 10699, 1517, 3, 2, 2, 2, 10700, 10705, 5, 1516, 759, 2, 10701, 10702, 7, 8, 2, 2, 10702, 10704, 5, 1516, 759, 2, 10703, 10701, 3, 2, 2, 2, 10704, 10707, 3, 2, 2, 2, 10705, 10703, 3, 2, 2, 2, 10705, 10706, 3, 2, 2, 2, 10706, 1519, 3, 2, 2, 2, 10707, 10705, 3, 2, 2, 2, 10708, 10709, 7, 511, 2, 2, 10709, 10710, 5, 1594, 798, 2, 10710, 10711, 5, 1522, 762, 2, 10711, 10712, 7, 9, 2, 2, 10712, 1521, 3, 2, 2, 2, 10713, 10717, 3, 2, 2, 2, 10714, 10715, 7, 8, 2, 2, 10715, 10717, 5, 1594, 798, 2, 10716, 10713, 3, 2, 2, 2, 10716, 10714, 3, 2, 2, 2, 10717, 1523, 3, 2, 2, 2, 10718, 10719, 7, 512, 2, 2, 10719, 10720, 5, 1436, 719, 2, 10720, 10721, 7, 447, 2, 2, 10721, 10722, 7, 512, 2, 2, 10722, 10723, 5, 1586, 794, 2, 10723, 10724, 7, 9, 2, 2, 10724, 1525, 3, 2, 2, 2, 10725, 10726, 5, 1604, 803, 2, 10726, 10727, 7, 9, 2, 2, 10727, 1527, 3, 2, 2, 2, 10728, 10729, 7, 204, 2, 2, 10729, 10737, 5, 1152, 577, 2, 10730, 10731, 5, 1534, 768, 2, 10731, 10732, 5, 1530, 766, 2, 10732, 10738, 3, 2, 2, 2, 10733, 10734, 5, 1530, 766, 2, 10734, 10735, 5, 1534, 768, 2, 10735, 10738, 3, 2, 2, 2, 10736, 10738, 3, 2, 2, 2, 10737, 10730, 3, 2, 2, 2, 10737, 10733, 3, 2, 2, 2, 10737, 10736, 3, 2, 2, 2, 10738, 10739, 3, 2, 2, 2, 10739, 10740, 7, 9, 2, 2, 10740, 1529, 3, 2, 2, 2, 10741, 10745, 3, 2, 2, 2, 10742, 10743, 7, 102, 2, 2, 10743, 10745, 5, 1532, 767, 2, 10744, 10741, 3, 2, 2, 2, 10744, 10742, 3, 2, 2, 2, 10745, 1531, 3, 2, 2, 2, 10746, 10751, 5, 1152, 577, 2, 10747, 10748, 7, 8, 2, 2, 10748, 10750, 5, 1152, 577, 2, 10749, 10747, 3, 2, 2, 2, 10750, 10753, 3, 2, 2, 2, 10751, 10749, 3, 2, 2, 2, 10751, 10752, 3, 2, 2, 2, 10752, 1533, 3, 2, 2, 2, 10753, 10751, 3, 2, 2, 2, 10754, 10761, 3, 2, 2, 2, 10755, 10757, 7, 73, 2, 2, 10756, 10758, 7, 339, 2, 2, 10757, 10756, 3, 2, 2, 2, 10757, 10758, 3, 2, 2, 2, 10758, 10759, 3, 2, 2, 2, 10759, 10761, 5, 1550, 776, 2, 10760, 10754, 3, 2, 2, 2, 10760, 10755, 3, 2, 2, 2, 10761, 1535, 3, 2, 2, 2, 10762, 10780, 7, 513, 2, 2, 10763, 10764, 5, 1570, 786, 2, 10764, 10765, 5, 1544, 773, 2, 10765, 10771, 7, 64, 2, 2, 10766, 10772, 5, 952, 477, 2, 10767, 10768, 7, 204, 2, 2, 10768, 10769, 5, 1594, 798, 2, 10769, 10770, 5, 1542, 772, 2, 10770, 10772, 3, 2, 2, 2, 10771, 10766, 3, 2, 2, 2, 10771, 10767, 3, 2, 2, 2, 10772, 10781, 3, 2, 2, 2, 10773, 10778, 5, 1360, 681, 2, 10774, 10775, 7, 4, 2, 2, 10775, 10776, 5, 1540, 771, 2, 10776, 10777, 7, 5, 2, 2, 10777, 10779, 3, 2, 2, 2, 10778, 10774, 3, 2, 2, 2, 10778, 10779, 3, 2, 2, 2, 10779, 10781, 3, 2, 2, 2, 10780, 10763, 3, 2, 2, 2, 10780, 10773, 3, 2, 2, 2, 10781, 10782, 3, 2, 2, 2, 10782, 10783, 7, 9, 2, 2, 10783, 1537, 3, 2, 2, 2, 10784, 10785, 5, 1360, 681, 2, 10785, 10786, 7, 22, 2, 2, 10786, 10787, 5, 1152, 577, 2, 10787, 10790, 3, 2, 2, 2, 10788, 10790, 5, 1152, 577, 2, 10789, 10784, 3, 2, 2, 2, 10789, 10788, 3, 2, 2, 2, 10790, 1539, 3, 2, 2, 2, 10791, 10796, 5, 1538, 770, 2, 10792, 10793, 7, 8, 2, 2, 10793, 10795, 5, 1538, 770, 2, 10794, 10792, 3, 2, 2, 2, 10795, 10798, 3, 2, 2, 2, 10796, 10794, 3, 2, 2, 2, 10796, 10797, 3, 2, 2, 2, 10797, 1541, 3, 2, 2, 2, 10798, 10796, 3, 2, 2, 2, 10799, 10803, 3, 2, 2, 2, 10800, 10801, 7, 102, 2, 2, 10801, 10803, 5, 1268, 635, 2, 10802, 10799, 3, 2, 2, 2, 10802, 10800, 3, 2, 2, 2, 10803, 1543, 3, 2, 2, 2, 10804, 10809, 3, 2, 2, 2, 10805, 10806, 5, 1546, 774, 2, 10806, 10807, 7, 317, 2, 2, 10807, 10809, 3, 2, 2, 2, 10808, 10804, 3, 2, 2, 2, 10808, 10805, 3, 2, 2, 2, 10809, 1545, 3, 2, 2, 2, 10810, 10813, 3, 2, 2, 2, 10811, 10813, 7, 262, 2, 2, 10812, 10810, 3, 2, 2, 2, 10812, 10811, 3, 2, 2, 2, 10813, 1547, 3, 2, 2, 2, 10814, 10816, 7, 63, 2, 2, 10815, 10817, 5, 1554, 778, 2, 10816, 10815, 3, 2, 2, 2, 10816, 10817, 3, 2, 2, 2, 10817, 10818, 3, 2, 2, 2, 10818, 10819, 5, 1552, 777, 2, 10819, 10820, 5, 1570, 786, 2, 10820, 10821, 7, 73, 2, 2, 10821, 10822, 5, 1550, 776, 2, 10822, 10823, 7, 9, 2, 2, 10823, 1549, 3, 2, 2, 2, 10824, 10825, 5, 1268, 635, 2, 10825, 1551, 3, 2, 2, 2, 10826, 10830, 3, 2, 2, 2, 10827, 10830, 7, 66, 2, 2, 10828, 10830, 7, 70, 2, 2, 10829, 10826, 3, 2, 2, 2, 10829, 10827, 3, 2, 2, 2, 10829, 10828, 3, 2, 2, 2, 10830, 1553, 3, 2, 2, 2, 10831, 10847, 7, 261, 2, 2, 10832, 10847, 7, 286, 2, 2, 10833, 10847, 7, 209, 2, 2, 10834, 10847, 7, 242, 2, 2, 10835, 10836, 7, 132, 2, 2, 10836, 10847, 5, 1152, 577, 2, 10837, 10838, 7, 300, 2, 2, 10838, 10847, 5, 1152, 577, 2, 10839, 10847, 5, 1152, 577, 2, 10840, 10847, 7, 32, 2, 2, 10841, 10844, 9, 70, 2, 2, 10842, 10845, 5, 1152, 577, 2, 10843, 10845, 7, 32, 2, 2, 10844, 10842, 3, 2, 2, 2, 10844, 10843, 3, 2, 2, 2, 10844, 10845, 3, 2, 2, 2, 10845, 10847, 3, 2, 2, 2, 10846, 10831, 3, 2, 2, 2, 10846, 10832, 3, 2, 2, 2, 10846, 10833, 3, 2, 2, 2, 10846, 10834, 3, 2, 2, 2, 10846, 10835, 3, 2, 2, 2, 10846, 10837, 3, 2, 2, 2, 10846, 10839, 3, 2, 2, 2, 10846, 10840, 3, 2, 2, 2, 10846, 10841, 3, 2, 2, 2, 10847, 1555, 3, 2, 2, 2, 10848, 10850, 7, 258, 2, 2, 10849, 10851, 5, 1554, 778, 2, 10850, 10849, 3, 2, 2, 2, 10850, 10851, 3, 2, 2, 2, 10851, 10852, 3, 2, 2, 2, 10852, 10853, 5, 1570, 786, 2, 10853, 10854, 7, 9, 2, 2, 10854, 1557, 3, 2, 2, 2, 10855, 10856, 7, 159, 2, 2, 10856, 10857, 5, 1570, 786, 2, 10857, 10858, 7, 9, 2, 2, 10858, 1559, 3, 2, 2, 2, 10859, 10860, 7, 80, 2, 2, 10860, 10861, 7, 9, 2, 2, 10861, 1561, 3, 2, 2, 2, 10862, 10864, 7, 163, 2, 2, 10863, 10865, 5, 1566, 784, 2, 10864, 10863, 3, 2, 2, 2, 10864, 10865, 3, 2, 2, 2, 10865, 10866, 3, 2, 2, 2, 10866, 10867, 7, 9, 2, 2, 10867, 1563, 3, 2, 2, 2, 10868, 10870, 7, 312, 2, 2, 10869, 10871, 5, 1566, 784, 2, 10870, 10869, 3, 2, 2, 2, 10870, 10871, 3, 2, 2, 2, 10871, 10872, 3, 2, 2, 2, 10872, 10873, 7, 9, 2, 2, 10873, 1565, 3, 2, 2, 2, 10874, 10876, 7, 35, 2, 2, 10875, 10877, 7, 262, 2, 2, 10876, 10875, 3, 2, 2, 2, 10876, 10877, 3, 2, 2, 2, 10877, 10878, 3, 2, 2, 2, 10878, 10879, 7, 155, 2, 2, 10879, 1567, 3, 2, 2, 2, 10880, 10881, 7, 326, 2, 2, 10881, 10882, 5, 524, 263, 2, 10882, 10883, 7, 96, 2, 2, 10883, 10884, 7, 55, 2, 2, 10884, 10885, 7, 9, 2, 2, 10885, 10893, 3, 2, 2, 2, 10886, 10889, 7, 306, 2, 2, 10887, 10890, 5, 524, 263, 2, 10888, 10890, 7, 32, 2, 2, 10889, 10887, 3, 2, 2, 2, 10889, 10888, 3, 2, 2, 2, 10890, 10891, 3, 2, 2, 2, 10891, 10893, 7, 9, 2, 2, 10892, 10880, 3, 2, 2, 2, 10892, 10886, 3, 2, 2, 2, 10893, 1569, 3, 2, 2, 2, 10894, 10897, 5, 1360, 681, 2, 10895, 10897, 7, 30, 2, 2, 10896, 10894, 3, 2, 2, 2, 10896, 10895, 3, 2, 2, 2, 10897, 1571, 3, 2, 2, 2, 10898, 10902, 3, 2, 2, 2, 10899, 10900, 7, 510, 2, 2, 10900, 10902, 5, 1574, 788, 2, 10901, 10898, 3, 2, 2, 2, 10901, 10899, 3, 2, 2, 2, 10902, 1573, 3, 2, 2, 2, 10903, 10905, 5, 1576, 789, 2, 10904, 10903, 3, 2, 2, 2, 10905, 10906, 3, 2, 2, 2, 10906, 10904, 3, 2, 2, 2, 10906, 10907, 3, 2, 2, 2, 10907, 1575, 3, 2, 2, 2, 10908, 10909, 7, 104, 2, 2, 10909, 10910, 5, 1578, 790, 2, 10910, 10911, 7, 95, 2, 2, 10911, 10912, 5, 1436, 719, 2, 10912, 1577, 3, 2, 2, 2, 10913, 10918, 5, 1580, 791, 2, 10914, 10915, 7, 84, 2, 2, 10915, 10917, 5, 1580, 791, 2, 10916, 10914, 3, 2, 2, 2, 10917, 10920, 3, 2, 2, 2, 10918, 10916, 3, 2, 2, 2, 10918, 10919, 3, 2, 2, 2, 10919, 1579, 3, 2, 2, 2, 10920, 10918, 3, 2, 2, 2, 10921, 10925, 5, 1590, 796, 2, 10922, 10923, 7, 504, 2, 2, 10923, 10925, 5, 1346, 674, 2, 10924, 10921, 3, 2, 2, 2, 10924, 10922, 3, 2, 2, 2, 10925, 1581, 3, 2, 2, 2, 10926, 10929, 3, 2, 2, 2, 10927, 10929, 5, 1400, 701, 2, 10928, 10926, 3, 2, 2, 2, 10928, 10927, 3, 2, 2, 2, 10929, 1583, 3, 2, 2, 2, 10930, 10933, 3, 2, 2, 2, 10931, 10933, 5, 1400, 701, 2, 10932, 10930, 3, 2, 2, 2, 10932, 10931, 3, 2, 2, 2, 10933, 1585, 3, 2, 2, 2, 10934, 10937, 3, 2, 2, 2, 10935, 10937, 5, 1590, 796, 2, 10936, 10934, 3, 2, 2, 2, 10936, 10935, 3, 2, 2, 2, 10937, 1587, 3, 2, 2, 2, 10938, 10939, 7, 104, 2, 2, 10939, 10940, 5, 1598, 800, 2, 10940, 1589, 3, 2, 2, 2, 10941, 10944, 5, 1360, 681, 2, 10942, 10944, 5, 1592, 797, 2, 10943, 10941, 3, 2, 2, 2, 10943, 10942, 3, 2, 2, 2, 10944, 1591, 3, 2, 2, 2, 10945, 10946, 9, 71, 2, 2, 10946, 1593, 3, 2, 2, 2, 10947, 10949, 5, 1316, 659, 2, 10948, 10947, 3, 2, 2, 2, 10948, 10949, 3, 2, 2, 2, 10949, 10951, 3, 2, 2, 2, 10950, 10952, 5, 976, 489, 2, 10951, 10950, 3, 2, 2, 2, 10951, 10952, 3, 2, 2, 2, 10952, 10954, 3, 2, 2, 2, 10953, 10955, 5, 1048, 525, 2, 10954, 10953, 3, 2, 2, 2, 10954, 10955, 3, 2, 2, 2, 10955, 10957, 3, 2, 2, 2, 10956, 10958, 5, 1084, 543, 2, 10957, 10956, 3, 2, 2, 2, 10957, 10958, 3, 2, 2, 2, 10958, 10960, 3, 2, 2, 2, 10959, 10961, 5, 1018, 510, 2, 10960, 10959, 3, 2, 2, 2, 10960, 10961, 3, 2, 2, 2, 10961, 10963, 3, 2, 2, 2, 10962, 10964, 5, 1032, 517, 2, 10963, 10962, 3, 2, 2, 2, 10963, 10964, 3, 2, 2, 2, 10964, 10966, 3, 2, 2, 2, 10965, 10967, 5, 1228, 615, 2, 10966, 10965, 3, 2, 2, 2, 10966, 10967, 3, 2, 2, 2, 10967, 1595, 3, 2, 2, 2, 10968, 10969, 5, 1594, 798, 2, 10969, 1597, 3, 2, 2, 2, 10970, 10971, 5, 1594, 798, 2, 10971, 1599, 3, 2, 2, 2, 10972, 10973, 5, 1152, 577, 2, 10973, 1601, 3, 2, 2, 2, 10974, 10975, 5, 1152, 577, 2, 10975, 1603, 3, 2, 2, 2, 10976, 10978, 5, 8, 5, 2, 10977, 10979, 5, 1606, 804, 2, 10978, 10977, 3, 2, 2, 2, 10978, 10979, 3, 2, 2, 2, 10979, 1605, 3, 2, 2, 2, 10980, 10981, 7, 73, 2, 2, 10981, 10982, 5, 978, 490, 2, 10982, 10983, 5, 1550, 776, 2, 10983, 1607, 3, 2, 2, 2, 1068, 1614, 1618, 1745, 1749, 1758, 1767, 1773, 1779, 1794, 1806, 1812, 1820, 1828, 1833, 1843, 1851, 1869, 1872, 1877, 1886, 1895, 1899, 1911, 1931, 1944, 1951, 1959, 1964, 1971, 1977, 1984, 1995, 1999, 2003, 2016, 2020, 2025, 2030, 2042, 2051, 2064, 2069, 2080, 2086, 2092, 2097, 2108, 2114, 2120, 2129, 2139, 2154, 2160, 2167, 2172, 2179, 2190, 2214, 2221, 2230, 2239, 2247, 2257, 2266, 2275, 2283, 2291, 2300, 2309, 2313, 2320, 2328, 2338, 2344, 2348, 2352, 2356, 2360, 2365, 2368, 2372, 2393, 2399, 2494, 2501, 2517, 2531, 2541, 2543, 2548, 2552, 2555, 2561, 2563, 2591, 2601, 2614, 2621, 2627, 2631, 2637, 2642, 2645, 2647, 2652, 2656, 2660, 2664, 2668, 2671, 2675, 2683, 2687, 2691, 2700, 2707, 2712, 2719, 2724, 2731, 2736, 2754, 2759, 2771, 2776, 2785, 2792, 2799, 2805, 2810, 2814, 2817, 2820, 2823, 2826, 2829, 2834, 2837, 2840, 2843, 2846, 2849, 2855, 2859, 2862, 2865, 2868, 2871, 2873, 2882, 2895, 2903, 2909, 2913, 2918, 2925, 2932, 2943, 2950, 2953, 2958, 2961, 2968, 2977, 2984, 2989, 2992, 2995, 2997, 3002, 3009, 3019, 3029, 3042, 3045, 3048, 3055, 3063, 3066, 3069, 3076, 3080, 3086, 3089, 3092, 3095, 3107, 3110, 3113, 3117, 3131, 3149, 3160, 3175, 3191, 3212, 3217, 3220, 3224, 3227, 3233, 3236, 3238, 3247, 3256, 3275, 3279, 3290, 3299, 3305, 3311, 3315, 3318, 3321, 3324, 3327, 3333, 3337, 3344, 3350, 3354, 3357, 3360, 3363, 3371, 3375, 3379, 3385, 3389, 3395, 3409, 3418, 3435, 3440, 3443, 3445, 3455, 3462, 3467, 3470, 3473, 3480, 3483, 3485, 3491, 3500, 3510, 3515, 3524, 3533, 3537, 3544, 3554, 3565, 3675, 3683, 3686, 3696, 3701, 3711, 3722, 3734, 3747, 3757, 3770, 3773, 3780, 3789, 3792, 3799, 3801, 3809, 3819, 3821, 3829, 3833, 3838, 3849, 3853, 3858, 3868, 3874, 3887, 3893, 3895, 3902, 3910, 3915, 3930, 3943, 3945, 3949, 3969, 3986, 3989, 3992, 3995, 3998, 4006, 4009, 4012, 4058, 4061, 4064, 4082, 4089, 4098, 4104, 4111, 4121, 4129, 4134, 4146, 4163, 4169, 4176, 4184, 4198, 4226, 4233, 4247, 4262, 4275, 4284, 4309, 4320, 4387, 4398, 4404, 4412, 4423, 4437, 4446, 4456, 4468, 4483, 4494, 4502, 4512, 4519, 4522, 4528, 4531, 4546, 4559, 4588, 4595, 4610, 4619, 4630, 4632, 4641, 4652, 4654, 4661, 4676, 4682, 4690, 4696, 4704, 4714, 4720, 4728, 4734, 4742, 4749, 4758, 4760, 4785, 4792, 4803, 4809, 4818, 4823, 4829, 4836, 4841, 4845, 4848, 4854, 5003, 5007, 5012, 5023, 5034, 5045, 5056, 5067, 5078, 5089, 5101, 5112, 5120, 5127, 5133, 5141, 5146, 5151, 5156, 5162, 5169, 5175, 5181, 5186, 5192, 5199, 5204, 5210, 5217, 5220, 5233, 5242, 5254, 5256, 5273, 5280, 5285, 5289, 5293, 5297, 5299, 5359, 5366, 5372, 5383, 5386, 5393, 5396, 5406, 5409, 5411, 5430, 5442, 5451, 5460, 5472, 5474, 5480, 5484, 5487, 5492, 5498, 5501, 5504, 5507, 5511, 5515, 5524, 5530, 5533, 5536, 5539, 5541, 5557, 5561, 5564, 5567, 5570, 5573, 5578, 5581, 5583, 5596, 5608, 5622, 5626, 5638, 5640, 5649, 5658, 5666, 5675, 5677, 5681, 5690, 5695, 5701, 5706, 5710, 5715, 5733, 5738, 5753, 5762, 5773, 5779, 5818, 5828, 5835, 5846, 5860, 5868, 5873, 5881, 5889, 5895, 5903, 5909, 5917, 5919, 5925, 5933, 5935, 5941, 5949, 5951, 5975, 5982, 5992, 6004, 6009, 6022, 6034, 6046, 6048, 6054, 6059, 6067, 6074, 6119, 6124, 6131, 6136, 6143, 6153, 6163, 6167, 6178, 6195, 6266, 6461, 6474, 6485, 6498, 6510, 6524, 6556, 6570, 6682, 6684, 6695, 6706, 6717, 6730, 6742, 6753, 6760, 6981, 6996, 7007, 7014, 7068, 7209, 7215, 7218, 7228, 7257, 7267, 7274, 7297, 7306, 7318, 7324, 7332, 7334, 7338, 7348, 7352, 7362, 7365, 7369, 7373, 7381, 7392, 7404, 7408, 7411, 7415, 7418, 7423, 7427, 7430, 7434, 7437, 7441, 7444, 7455, 7462, 7475, 7489, 7493, 7498, 7505, 7512, 7515, 7520, 7523, 7532, 7534, 7539, 7543, 7555, 7558, 7565, 7569, 7574, 7584, 7593, 7596, 7601, 7612, 7616, 7622, 7629, 7649, 7670, 7674, 7679, 7762, 7768, 7781, 7785, 7789, 7793, 7799, 7806, 7809, 7812, 7815, 7818, 7825, 7827, 7831, 7834, 7841, 7843, 7850, 7857, 7861, 7865, 7881, 7888, 7898, 7911, 7922, 7929, 7934, 7938, 7942, 7947, 7960, 7965, 7969, 7977, 7980, 7984, 7995, 7998, 8000, 8016, 8019, 8026, 8029, 8034, 8049, 8055, 8064, 8073, 8080, 8083, 8089, 8094, 8100, 8106, 8109, 8112, 8119, 8123, 8126, 8141, 8144, 8151, 8154, 8161, 8164, 8167, 8174, 8187, 8197, 8215, 8217, 8225, 8229, 8239, 8243, 8247, 8251, 8253, 8258, 8262, 8266, 8268, 8270, 8274, 8278, 8281, 8284, 8289, 8292, 8295, 8298, 8301, 8304, 8307, 8316, 8318, 8323, 8327, 8333, 8337, 8341, 8350, 8355, 8359, 8368, 8377, 8381, 8384, 8388, 8393, 8399, 8411, 8426, 8433, 8435, 8438, 8442, 8446, 8448, 8456, 8465, 8471, 8473, 8475, 8482, 8486, 8495, 8499, 8514, 8522, 8550, 8557, 8561, 8564, 8569, 8573, 8576, 8592, 8603, 8608, 8611, 8615, 8619, 8623, 8628, 8632, 8636, 8638, 8647, 8652, 8658, 8662, 8664, 8671, 8676, 8682, 8684, 8688, 8695, 8702, 8705, 8711, 8715, 8724, 8728, 8736, 8738, 8745, 8750, 8753, 8761, 8770, 8778, 8780, 8784, 8791, 8810, 8819, 8825, 8844, 8853, 8859, 8863, 8868, 8878, 8885, 8894, 8897, 8906, 8908, 8914, 8918, 8923, 8933, 8939, 8941, 8947, 8951, 8954, 8967, 8973, 8977, 8981, 8984, 8992, 8996, 9000, 9008, 9015, 9022, 9026, 9032, 9034, 9043, 9046, 9056, 9072, 9078, 9083, 9090, 9099, 9106, 9114, 9122, 9127, 9131, 9134, 9140, 9145, 9161, 9164, 9166, 9178, 9180, 9184, 9192, 9194, 9198, 9200, 9208, 9212, 9221, 9229, 9235, 9238, 9247, 9252, 9259, 9269, 9295, 9306, 9308, 9310, 9318, 9341, 9349, 9359, 9362, 9367, 9372, 9376, 9382, 9385, 9388, 9391, 9395, 9409, 9416, 9423, 9430, 9448, 9456, 9468, 9474, 9487, 9526, 9528, 9548, 9558, 9569, 9581, 9588, 9600, 9612, 9618, 9626, 9643, 9668, 9678, 9682, 9685, 9688, 9691, 9704, 9709, 9714, 9716, 9724, 9733, 9742, 9747, 9756, 9761, 9775, 9785, 9793, 9807, 9814, 9822, 9830, 9837, 9843, 9852, 9867, 9878, 9911, 9920, 9927, 9931, 9935, 9942, 9956, 9961, 9966, 9970, 9972, 9975, 9982, 9987, 9997, 10005, 10008, 10015, 10020, 10027, 10040, 10052, 10057, 10065, 10072, 10077, 10089, 10097, 10102, 10112, 10119, 10126, 10133, 10139, 10145, 10153, 10157, 10164, 10221, 10234, 10257, 10265, 10269, 10281, 10283, 10290, 10299, 10317, 10325, 10334, 10341, 10351, 10357, 10364, 10369, 10375, 10379, 10386, 10416, 10436, 10440, 10456, 10463, 10476, 10484, 10504, 10510, 10522, 10527, 10537, 10569, 10574, 10583, 10588, 10592, 10597, 10613, 10618, 10633, 10636, 10642, 10646, 10655, 10663, 10672, 10678, 10687, 10689, 10694, 10705, 10716, 10737, 10744, 10751, 10757, 10760, 10771, 10778, 10780, 10789, 10796, 10802, 10808, 10812, 10816, 10829, 10844, 10846, 10850, 10864, 10870, 10876, 10889, 10892, 10896, 10901, 10906, 10918, 10924, 10928, 10932, 10936, 10943, 10948, 10951, 10954, 10957, 10960, 10963, 10966, 10978] \ No newline at end of file +[3, 51485, 51898, 1421, 44986, 20307, 1543, 60043, 49729, 3, 568, 11104, 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, 4, 806, 9, 806, 4, 807, 9, 807, 4, 808, 9, 808, 4, 809, 9, 809, 4, 810, 9, 810, 4, 811, 9, 811, 4, 812, 9, 812, 4, 813, 9, 813, 4, 814, 9, 814, 4, 815, 9, 815, 4, 816, 9, 816, 4, 817, 9, 817, 3, 2, 3, 2, 3, 3, 3, 3, 3, 4, 3, 4, 5, 4, 1641, 10, 4, 7, 4, 1643, 10, 4, 12, 4, 14, 4, 1646, 11, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 5, 5, 1772, 10, 5, 3, 6, 3, 6, 5, 6, 1776, 10, 6, 3, 7, 3, 7, 3, 7, 3, 8, 3, 8, 3, 8, 3, 8, 5, 8, 1785, 10, 8, 3, 8, 3, 8, 3, 9, 3, 9, 3, 10, 7, 10, 1792, 10, 10, 12, 10, 14, 10, 1795, 11, 10, 3, 11, 7, 11, 1798, 10, 11, 12, 11, 14, 11, 1801, 11, 11, 3, 12, 3, 12, 3, 12, 5, 12, 1806, 10, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 3, 12, 5, 12, 1825, 10, 12, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 3, 13, 5, 13, 1837, 10, 13, 3, 14, 3, 14, 3, 14, 3, 14, 5, 14, 1843, 10, 14, 3, 14, 3, 14, 3, 15, 3, 15, 3, 15, 3, 15, 5, 15, 1851, 10, 15, 3, 15, 3, 15, 3, 16, 3, 16, 3, 16, 3, 16, 5, 16, 1859, 10, 16, 3, 17, 3, 17, 3, 17, 3, 17, 5, 17, 1865, 10, 17, 3, 17, 3, 17, 3, 17, 3, 18, 3, 18, 3, 18, 3, 18, 5, 18, 1874, 10, 18, 3, 18, 3, 18, 3, 19, 3, 19, 3, 19, 3, 19, 5, 19, 1882, 10, 19, 3, 19, 3, 19, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 20, 3, 21, 3, 21, 3, 22, 3, 22, 3, 22, 3, 22, 3, 22, 5, 22, 1900, 10, 22, 3, 22, 5, 22, 1903, 10, 22, 3, 22, 3, 22, 3, 22, 5, 22, 1908, 10, 22, 3, 22, 3, 22, 3, 23, 3, 23, 3, 24, 7, 24, 1915, 10, 24, 12, 24, 14, 24, 1918, 11, 24, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 3, 25, 5, 25, 1926, 10, 25, 3, 26, 3, 26, 5, 26, 1930, 10, 26, 3, 26, 3, 26, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 3, 27, 5, 27, 1942, 10, 27, 3, 28, 3, 28, 3, 28, 3, 28, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 1962, 10, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 3, 29, 5, 29, 1975, 10, 29, 3, 30, 3, 30, 3, 30, 7, 30, 1980, 10, 30, 12, 30, 14, 30, 1983, 11, 30, 3, 31, 3, 31, 3, 31, 7, 31, 1988, 10, 31, 12, 31, 14, 31, 1991, 11, 31, 3, 32, 3, 32, 5, 32, 1995, 10, 32, 3, 33, 3, 33, 3, 33, 3, 33, 3, 33, 5, 33, 2002, 10, 33, 3, 34, 3, 34, 3, 34, 3, 34, 5, 34, 2008, 10, 34, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 2015, 10, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 3, 35, 5, 35, 2026, 10, 35, 3, 36, 3, 36, 5, 36, 2030, 10, 36, 3, 37, 3, 37, 5, 37, 2034, 10, 37, 3, 38, 3, 38, 3, 38, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 3, 39, 5, 39, 2047, 10, 39, 3, 40, 3, 40, 5, 40, 2051, 10, 40, 3, 41, 3, 41, 3, 41, 5, 41, 2056, 10, 41, 3, 42, 3, 42, 3, 42, 5, 42, 2061, 10, 42, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 3, 43, 5, 43, 2073, 10, 43, 3, 44, 3, 44, 3, 44, 3, 44, 3, 44, 3, 45, 3, 45, 5, 45, 2082, 10, 45, 3, 46, 3, 46, 3, 47, 3, 47, 3, 48, 3, 48, 3, 48, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2095, 10, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2100, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2111, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2117, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2123, 10, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2128, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2139, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2145, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2151, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2160, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2170, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2185, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2191, 10, 49, 3, 49, 3, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2198, 10, 49, 3, 49, 3, 49, 3, 49, 5, 49, 2203, 10, 49, 3, 50, 3, 50, 3, 50, 7, 50, 2208, 10, 50, 12, 50, 14, 50, 2211, 11, 50, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 3, 51, 5, 51, 2221, 10, 51, 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, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2245, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2252, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2261, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2270, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2278, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2288, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2297, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2306, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2314, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2322, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2331, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2340, 10, 53, 3, 53, 3, 53, 5, 53, 2344, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2351, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2359, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2369, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2375, 10, 53, 3, 53, 3, 53, 5, 53, 2379, 10, 53, 3, 53, 3, 53, 5, 53, 2383, 10, 53, 3, 53, 3, 53, 5, 53, 2387, 10, 53, 3, 53, 3, 53, 5, 53, 2391, 10, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2396, 10, 53, 3, 53, 5, 53, 2399, 10, 53, 3, 53, 3, 53, 5, 53, 2403, 10, 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, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2424, 10, 53, 3, 53, 3, 53, 3, 53, 3, 53, 5, 53, 2430, 10, 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, 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, 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, 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, 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, 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, 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, 53, 3, 53, 3, 53, 5, 53, 2525, 10, 53, 3, 54, 3, 54, 3, 54, 3, 54, 3, 54, 5, 54, 2532, 10, 54, 3, 55, 3, 55, 3, 56, 3, 56, 3, 56, 3, 57, 3, 57, 3, 57, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 3, 58, 5, 58, 2548, 10, 58, 3, 59, 3, 59, 3, 59, 3, 59, 3, 60, 3, 60, 3, 60, 3, 61, 3, 61, 3, 61, 7, 61, 2560, 10, 61, 12, 61, 14, 61, 2563, 11, 61, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 3, 62, 5, 62, 2572, 10, 62, 5, 62, 2574, 10, 62, 3, 63, 6, 63, 2577, 10, 63, 13, 63, 14, 63, 2578, 3, 64, 3, 64, 5, 64, 2583, 10, 64, 3, 64, 5, 64, 2586, 10, 64, 3, 64, 3, 64, 3, 64, 3, 64, 5, 64, 2592, 10, 64, 5, 64, 2594, 10, 64, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 3, 65, 5, 65, 2622, 10, 65, 3, 66, 3, 66, 3, 66, 3, 67, 3, 67, 3, 67, 7, 67, 2630, 10, 67, 12, 67, 14, 67, 2633, 11, 67, 3, 68, 3, 68, 3, 68, 3, 68, 3, 68, 3, 69, 3, 69, 3, 69, 7, 69, 2643, 10, 69, 12, 69, 14, 69, 2646, 11, 69, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2652, 10, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2658, 10, 70, 3, 70, 3, 70, 5, 70, 2662, 10, 70, 3, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2668, 10, 70, 3, 70, 3, 70, 3, 70, 5, 70, 2673, 10, 70, 3, 70, 5, 70, 2676, 10, 70, 5, 70, 2678, 10, 70, 3, 71, 3, 71, 3, 71, 5, 71, 2683, 10, 71, 3, 72, 3, 72, 5, 72, 2687, 10, 72, 3, 72, 3, 72, 5, 72, 2691, 10, 72, 3, 72, 3, 72, 5, 72, 2695, 10, 72, 3, 72, 3, 72, 5, 72, 2699, 10, 72, 3, 72, 5, 72, 2702, 10, 72, 3, 72, 3, 72, 5, 72, 2706, 10, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 3, 72, 5, 72, 2714, 10, 72, 3, 72, 3, 72, 5, 72, 2718, 10, 72, 3, 72, 3, 72, 5, 72, 2722, 10, 72, 3, 73, 3, 73, 3, 74, 3, 74, 3, 75, 3, 75, 3, 75, 5, 75, 2731, 10, 75, 3, 76, 3, 76, 3, 76, 3, 76, 3, 76, 5, 76, 2738, 10, 76, 3, 77, 7, 77, 2741, 10, 77, 12, 77, 14, 77, 2744, 11, 77, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2750, 10, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2755, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2762, 10, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2767, 10, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 3, 78, 5, 78, 2785, 10, 78, 3, 79, 3, 79, 3, 80, 5, 80, 2790, 10, 80, 3, 80, 3, 80, 3, 80, 3, 81, 3, 81, 3, 82, 3, 82, 3, 82, 7, 82, 2800, 10, 82, 12, 82, 14, 82, 2803, 11, 82, 3, 83, 3, 83, 5, 83, 2807, 10, 83, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 3, 84, 5, 84, 2816, 10, 84, 3, 85, 3, 85, 3, 85, 7, 85, 2821, 10, 85, 12, 85, 14, 85, 2824, 11, 85, 3, 86, 3, 86, 3, 87, 3, 87, 5, 87, 2830, 10, 87, 3, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2836, 10, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2841, 10, 87, 3, 87, 3, 87, 5, 87, 2845, 10, 87, 3, 87, 5, 87, 2848, 10, 87, 3, 87, 5, 87, 2851, 10, 87, 3, 87, 5, 87, 2854, 10, 87, 3, 87, 5, 87, 2857, 10, 87, 3, 87, 5, 87, 2860, 10, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2865, 10, 87, 3, 87, 5, 87, 2868, 10, 87, 3, 87, 5, 87, 2871, 10, 87, 3, 87, 5, 87, 2874, 10, 87, 3, 87, 5, 87, 2877, 10, 87, 3, 87, 5, 87, 2880, 10, 87, 3, 87, 3, 87, 3, 87, 3, 87, 5, 87, 2886, 10, 87, 3, 87, 3, 87, 5, 87, 2890, 10, 87, 3, 87, 5, 87, 2893, 10, 87, 3, 87, 5, 87, 2896, 10, 87, 3, 87, 5, 87, 2899, 10, 87, 3, 87, 5, 87, 2902, 10, 87, 5, 87, 2904, 10, 87, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 3, 88, 5, 88, 2913, 10, 88, 3, 89, 3, 89, 3, 90, 3, 90, 3, 91, 3, 91, 3, 91, 3, 91, 3, 92, 3, 92, 3, 92, 7, 92, 2926, 10, 92, 12, 92, 14, 92, 2929, 11, 92, 3, 93, 3, 93, 3, 93, 7, 93, 2934, 10, 93, 12, 93, 14, 93, 2937, 11, 93, 3, 94, 3, 94, 3, 94, 5, 94, 2942, 10, 94, 3, 95, 3, 95, 5, 95, 2946, 10, 95, 3, 96, 3, 96, 3, 96, 5, 96, 2951, 10, 96, 3, 96, 3, 96, 5, 96, 2955, 10, 96, 3, 96, 3, 96, 3, 97, 3, 97, 3, 97, 5, 97, 2962, 10, 97, 3, 97, 3, 97, 3, 98, 7, 98, 2967, 10, 98, 12, 98, 14, 98, 2970, 11, 98, 3, 99, 3, 99, 5, 99, 2974, 10, 99, 3, 99, 3, 99, 5, 99, 2978, 10, 99, 3, 99, 5, 99, 2981, 10, 99, 3, 99, 3, 99, 5, 99, 2985, 10, 99, 3, 99, 5, 99, 2988, 10, 99, 5, 99, 2990, 10, 99, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 5, 100, 2997, 10, 100, 3, 100, 5, 100, 3000, 10, 100, 3, 100, 3, 100, 3, 100, 5, 100, 3005, 10, 100, 3, 100, 5, 100, 3008, 10, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 5, 100, 3015, 10, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 5, 100, 3024, 10, 100, 3, 100, 3, 100, 3, 100, 3, 100, 3, 100, 5, 100, 3031, 10, 100, 3, 100, 3, 100, 3, 100, 5, 100, 3036, 10, 100, 3, 100, 5, 100, 3039, 10, 100, 3, 100, 5, 100, 3042, 10, 100, 5, 100, 3044, 10, 100, 3, 101, 3, 101, 3, 101, 5, 101, 3049, 10, 101, 3, 102, 3, 102, 3, 102, 5, 102, 3054, 10, 102, 3, 103, 3, 103, 3, 103, 3, 104, 3, 104, 3, 104, 3, 104, 3, 105, 3, 105, 7, 105, 3065, 10, 105, 12, 105, 14, 105, 3068, 11, 105, 3, 106, 3, 106, 3, 107, 3, 107, 3, 107, 3, 107, 3, 107, 5, 107, 3077, 10, 107, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 5, 108, 3090, 10, 108, 3, 108, 5, 108, 3093, 10, 108, 3, 108, 5, 108, 3096, 10, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 5, 108, 3103, 10, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 5, 108, 3111, 10, 108, 3, 108, 5, 108, 3114, 10, 108, 3, 108, 5, 108, 3117, 10, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 5, 108, 3124, 10, 108, 3, 108, 3, 108, 5, 108, 3128, 10, 108, 3, 108, 3, 108, 3, 108, 3, 108, 5, 108, 3134, 10, 108, 3, 108, 5, 108, 3137, 10, 108, 3, 108, 5, 108, 3140, 10, 108, 3, 108, 5, 108, 3143, 10, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 3, 108, 5, 108, 3155, 10, 108, 3, 108, 5, 108, 3158, 10, 108, 3, 108, 5, 108, 3161, 10, 108, 3, 108, 3, 108, 5, 108, 3165, 10, 108, 3, 109, 3, 109, 3, 109, 3, 110, 3, 110, 3, 110, 3, 110, 3, 111, 3, 111, 3, 111, 7, 111, 3177, 10, 111, 12, 111, 14, 111, 3180, 11, 111, 3, 112, 3, 112, 3, 113, 3, 113, 3, 113, 3, 113, 3, 113, 3, 114, 3, 114, 3, 114, 3, 115, 3, 115, 3, 115, 7, 115, 3195, 10, 115, 12, 115, 14, 115, 3198, 11, 115, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 3, 116, 5, 116, 3208, 10, 116, 3, 117, 3, 117, 3, 117, 3, 117, 3, 117, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 3, 118, 5, 118, 3223, 10, 118, 3, 119, 3, 119, 3, 119, 3, 119, 3, 120, 3, 120, 3, 120, 3, 120, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 3, 121, 5, 121, 3239, 10, 121, 3, 122, 3, 122, 3, 122, 3, 122, 3, 122, 3, 123, 3, 123, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 124, 3, 125, 3, 125, 3, 125, 7, 125, 3258, 10, 125, 12, 125, 14, 125, 3261, 11, 125, 3, 126, 3, 126, 5, 126, 3265, 10, 126, 3, 126, 5, 126, 3268, 10, 126, 3, 126, 3, 126, 5, 126, 3272, 10, 126, 3, 126, 5, 126, 3275, 10, 126, 3, 126, 3, 126, 3, 126, 3, 126, 5, 126, 3281, 10, 126, 3, 126, 5, 126, 3284, 10, 126, 5, 126, 3286, 10, 126, 3, 127, 3, 127, 3, 127, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 3, 128, 5, 128, 3297, 10, 128, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 3, 129, 5, 129, 3306, 10, 129, 3, 130, 3, 130, 3, 130, 3, 131, 3, 131, 3, 131, 3, 131, 3, 131, 3, 132, 3, 132, 3, 132, 3, 132, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 5, 133, 3325, 10, 133, 3, 133, 3, 133, 5, 133, 3329, 10, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 133, 3, 134, 3, 134, 3, 134, 3, 134, 5, 134, 3340, 10, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 134, 3, 135, 3, 135, 5, 135, 3349, 10, 135, 3, 135, 3, 135, 3, 135, 3, 135, 5, 135, 3355, 10, 135, 3, 135, 3, 135, 3, 135, 3, 135, 5, 135, 3361, 10, 135, 3, 136, 3, 136, 5, 136, 3365, 10, 136, 3, 136, 5, 136, 3368, 10, 136, 3, 136, 5, 136, 3371, 10, 136, 3, 136, 5, 136, 3374, 10, 136, 3, 136, 5, 136, 3377, 10, 136, 3, 137, 3, 137, 3, 137, 3, 137, 5, 137, 3383, 10, 137, 3, 138, 3, 138, 5, 138, 3387, 10, 138, 3, 138, 3, 138, 3, 138, 3, 138, 3, 138, 5, 138, 3394, 10, 138, 3, 138, 3, 138, 3, 138, 3, 138, 5, 138, 3400, 10, 138, 3, 139, 3, 139, 5, 139, 3404, 10, 139, 3, 139, 5, 139, 3407, 10, 139, 3, 139, 5, 139, 3410, 10, 139, 3, 139, 5, 139, 3413, 10, 139, 3, 140, 3, 140, 3, 141, 3, 141, 3, 141, 3, 141, 5, 141, 3421, 10, 141, 3, 141, 3, 141, 5, 141, 3425, 10, 141, 3, 142, 3, 142, 5, 142, 3429, 10, 142, 3, 142, 3, 142, 3, 142, 3, 142, 5, 142, 3435, 10, 142, 3, 142, 3, 142, 5, 142, 3439, 10, 142, 3, 143, 3, 143, 3, 143, 3, 143, 5, 143, 3445, 10, 143, 3, 143, 3, 143, 3, 143, 3, 144, 3, 144, 3, 145, 3, 145, 3, 145, 3, 145, 3, 146, 6, 146, 3457, 10, 146, 13, 146, 14, 146, 3458, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 5, 147, 3468, 10, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 3, 147, 5, 147, 3485, 10, 147, 3, 147, 3, 147, 3, 147, 5, 147, 3490, 10, 147, 3, 147, 5, 147, 3493, 10, 147, 5, 147, 3495, 10, 147, 3, 148, 3, 148, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 3, 149, 5, 149, 3505, 10, 149, 3, 150, 3, 150, 3, 150, 7, 150, 3510, 10, 150, 12, 150, 14, 150, 3513, 11, 150, 3, 151, 3, 151, 5, 151, 3517, 10, 151, 3, 151, 5, 151, 3520, 10, 151, 3, 151, 5, 151, 3523, 10, 151, 3, 151, 3, 151, 3, 151, 3, 151, 3, 151, 5, 151, 3530, 10, 151, 3, 151, 5, 151, 3533, 10, 151, 5, 151, 3535, 10, 151, 3, 152, 3, 152, 3, 153, 3, 153, 5, 153, 3541, 10, 153, 3, 154, 3, 154, 3, 154, 3, 155, 3, 155, 3, 155, 3, 155, 5, 155, 3550, 10, 155, 3, 156, 3, 156, 3, 157, 3, 157, 3, 158, 3, 158, 3, 158, 3, 158, 5, 158, 3560, 10, 158, 3, 158, 3, 158, 3, 158, 5, 158, 3565, 10, 158, 3, 159, 3, 159, 3, 159, 3, 160, 3, 160, 3, 160, 3, 160, 5, 160, 3574, 10, 160, 3, 160, 3, 160, 3, 161, 3, 161, 3, 161, 3, 161, 3, 161, 5, 161, 3583, 10, 161, 3, 161, 3, 161, 5, 161, 3587, 10, 161, 3, 161, 3, 161, 3, 162, 7, 162, 3592, 10, 162, 12, 162, 14, 162, 3595, 11, 162, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 3, 163, 5, 163, 3604, 10, 163, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 164, 3, 165, 7, 165, 3613, 10, 165, 12, 165, 14, 165, 3616, 11, 165, 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, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 3, 167, 5, 167, 3725, 10, 167, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 3, 168, 5, 168, 3733, 10, 168, 3, 168, 5, 168, 3736, 10, 168, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 3, 169, 5, 169, 3746, 10, 169, 3, 170, 6, 170, 3749, 10, 170, 13, 170, 14, 170, 3750, 3, 171, 3, 171, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 5, 172, 3761, 10, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 3, 172, 5, 172, 3772, 10, 172, 3, 173, 3, 173, 3, 173, 3, 173, 3, 173, 3, 174, 3, 174, 3, 174, 7, 174, 3782, 10, 174, 12, 174, 14, 174, 3785, 11, 174, 3, 175, 3, 175, 3, 175, 3, 175, 3, 175, 3, 176, 3, 176, 3, 176, 7, 176, 3795, 10, 176, 12, 176, 14, 176, 3798, 11, 176, 3, 177, 3, 177, 3, 177, 3, 177, 3, 177, 3, 177, 3, 177, 5, 177, 3807, 10, 177, 3, 178, 3, 178, 3, 178, 3, 179, 3, 179, 3, 180, 3, 180, 3, 181, 3, 181, 3, 181, 3, 181, 5, 181, 3820, 10, 181, 3, 181, 5, 181, 3823, 10, 181, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 5, 181, 3830, 10, 181, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 5, 181, 3839, 10, 181, 3, 181, 5, 181, 3842, 10, 181, 3, 181, 3, 181, 3, 181, 3, 181, 3, 181, 5, 181, 3849, 10, 181, 5, 181, 3851, 10, 181, 3, 182, 3, 182, 3, 182, 3, 183, 3, 183, 3, 183, 5, 183, 3859, 10, 183, 3, 184, 3, 184, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 3, 185, 5, 185, 3869, 10, 185, 5, 185, 3871, 10, 185, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 5, 186, 3879, 10, 186, 3, 186, 3, 186, 5, 186, 3883, 10, 186, 3, 186, 3, 186, 3, 186, 5, 186, 3888, 10, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 5, 186, 3899, 10, 186, 3, 186, 3, 186, 5, 186, 3903, 10, 186, 3, 186, 3, 186, 3, 186, 5, 186, 3908, 10, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 5, 186, 3918, 10, 186, 3, 186, 3, 186, 3, 186, 3, 186, 5, 186, 3924, 10, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 3, 186, 5, 186, 3937, 10, 186, 3, 186, 3, 186, 3, 186, 3, 186, 5, 186, 3943, 10, 186, 5, 186, 3945, 10, 186, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 5, 187, 3952, 10, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 3, 187, 5, 187, 3960, 10, 187, 3, 188, 3, 188, 3, 188, 5, 188, 3965, 10, 188, 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, 5, 190, 3980, 10, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 3, 190, 5, 190, 3993, 10, 190, 5, 190, 3995, 10, 190, 3, 191, 3, 191, 5, 191, 3999, 10, 191, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 3, 192, 5, 192, 4019, 10, 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, 5, 194, 4036, 10, 194, 3, 194, 5, 194, 4039, 10, 194, 3, 194, 5, 194, 4042, 10, 194, 3, 194, 5, 194, 4045, 10, 194, 3, 194, 5, 194, 4048, 10, 194, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 3, 195, 5, 195, 4056, 10, 195, 3, 195, 5, 195, 4059, 10, 195, 3, 195, 5, 195, 4062, 10, 195, 3, 196, 3, 196, 3, 196, 3, 196, 3, 196, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 197, 3, 198, 3, 198, 3, 198, 3, 199, 3, 199, 3, 199, 3, 200, 3, 200, 3, 200, 3, 201, 3, 201, 3, 201, 3, 202, 3, 202, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 203, 3, 204, 3, 204, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 5, 205, 4108, 10, 205, 3, 205, 5, 205, 4111, 10, 205, 3, 205, 5, 205, 4114, 10, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 5, 205, 4125, 10, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 5, 205, 4134, 10, 205, 3, 205, 3, 205, 5, 205, 4138, 10, 205, 3, 205, 5, 205, 4141, 10, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 3, 205, 5, 205, 4150, 10, 205, 3, 206, 3, 206, 3, 206, 3, 206, 5, 206, 4156, 10, 206, 3, 207, 3, 207, 5, 207, 4160, 10, 207, 3, 207, 3, 207, 3, 208, 3, 208, 3, 209, 3, 209, 3, 209, 7, 209, 4169, 10, 209, 12, 209, 14, 209, 4172, 11, 209, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 3, 210, 5, 210, 4181, 10, 210, 3, 211, 3, 211, 3, 211, 3, 212, 6, 212, 4187, 10, 212, 13, 212, 14, 212, 4188, 3, 213, 3, 213, 3, 213, 5, 213, 4194, 10, 213, 3, 213, 3, 213, 3, 214, 3, 214, 3, 215, 3, 215, 3, 216, 3, 216, 3, 217, 3, 217, 5, 217, 4206, 10, 217, 3, 217, 3, 217, 3, 218, 3, 218, 3, 219, 3, 219, 3, 220, 3, 220, 3, 220, 3, 220, 3, 220, 3, 221, 3, 221, 3, 222, 3, 222, 5, 222, 4223, 10, 222, 3, 222, 3, 222, 7, 222, 4227, 10, 222, 12, 222, 14, 222, 4230, 11, 222, 3, 223, 3, 223, 3, 223, 3, 223, 5, 223, 4236, 10, 223, 3, 224, 3, 224, 3, 224, 3, 225, 7, 225, 4242, 10, 225, 12, 225, 14, 225, 4245, 11, 225, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 3, 226, 5, 226, 4258, 10, 226, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 3, 227, 5, 227, 4286, 10, 227, 3, 228, 3, 228, 3, 228, 7, 228, 4291, 10, 228, 12, 228, 14, 228, 4294, 11, 228, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 229, 3, 230, 3, 230, 3, 230, 7, 230, 4305, 10, 230, 12, 230, 14, 230, 4308, 11, 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, 5, 232, 4322, 10, 232, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 233, 3, 234, 3, 234, 5, 234, 4335, 10, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 5, 234, 4344, 10, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 5, 234, 4369, 10, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 5, 234, 4380, 10, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 3, 234, 5, 234, 4447, 10, 234, 3, 235, 3, 235, 3, 235, 3, 235, 3, 236, 3, 236, 3, 236, 7, 236, 4456, 10, 236, 12, 236, 14, 236, 4459, 11, 236, 3, 237, 3, 237, 3, 237, 5, 237, 4464, 10, 237, 3, 238, 3, 238, 3, 238, 3, 238, 3, 238, 3, 238, 5, 238, 4472, 10, 238, 3, 239, 3, 239, 3, 239, 3, 239, 3, 240, 3, 240, 3, 240, 7, 240, 4481, 10, 240, 12, 240, 14, 240, 4484, 11, 240, 3, 241, 3, 241, 3, 241, 3, 241, 3, 242, 3, 242, 3, 243, 3, 243, 3, 243, 7, 243, 4495, 10, 243, 12, 243, 14, 243, 4498, 11, 243, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 5, 244, 4506, 10, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 5, 244, 4516, 10, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 5, 244, 4528, 10, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 3, 244, 5, 244, 4543, 10, 244, 3, 245, 3, 245, 3, 245, 3, 245, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 5, 246, 4554, 10, 246, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 3, 246, 5, 246, 4562, 10, 246, 3, 246, 3, 246, 3, 246, 3, 247, 3, 247, 3, 247, 7, 247, 4570, 10, 247, 12, 247, 14, 247, 4573, 11, 247, 3, 248, 3, 248, 3, 248, 3, 248, 5, 248, 4579, 10, 248, 3, 248, 5, 248, 4582, 10, 248, 3, 248, 3, 248, 3, 248, 3, 248, 5, 248, 4588, 10, 248, 3, 248, 5, 248, 4591, 10, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 3, 248, 5, 248, 4606, 10, 248, 3, 249, 3, 249, 3, 250, 3, 250, 3, 250, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 3, 251, 5, 251, 4619, 10, 251, 3, 252, 3, 252, 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, 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, 4648, 10, 254, 3, 255, 3, 255, 3, 255, 7, 255, 4653, 10, 255, 12, 255, 14, 255, 4656, 11, 255, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 3, 256, 5, 256, 4670, 10, 256, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4679, 10, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 3, 257, 5, 257, 4690, 10, 257, 5, 257, 4692, 10, 257, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 5, 258, 4701, 10, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 3, 258, 5, 258, 4712, 10, 258, 5, 258, 4714, 10, 258, 3, 259, 3, 259, 3, 259, 3, 259, 3, 259, 5, 259, 4721, 10, 259, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 3, 260, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4736, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4742, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4750, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4756, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4764, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4774, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4780, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4788, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4794, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4802, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4809, 10, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 3, 261, 5, 261, 4818, 10, 261, 5, 261, 4820, 10, 261, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 3, 262, 5, 262, 4845, 10, 262, 3, 263, 3, 263, 3, 263, 3, 263, 3, 263, 5, 263, 4852, 10, 263, 3, 264, 3, 264, 3, 264, 3, 264, 3, 264, 3, 264, 3, 264, 3, 264, 3, 264, 5, 264, 4863, 10, 264, 3, 264, 3, 264, 3, 264, 3, 264, 5, 264, 4869, 10, 264, 3, 265, 3, 265, 3, 266, 3, 266, 3, 266, 7, 266, 4876, 10, 266, 12, 266, 14, 266, 4879, 11, 266, 3, 267, 3, 267, 5, 267, 4883, 10, 267, 3, 268, 3, 268, 6, 268, 4887, 10, 268, 13, 268, 14, 268, 4888, 3, 269, 3, 269, 3, 269, 7, 269, 4894, 10, 269, 12, 269, 14, 269, 4897, 11, 269, 3, 270, 3, 270, 5, 270, 4901, 10, 270, 3, 270, 3, 270, 5, 270, 4905, 10, 270, 3, 270, 5, 270, 4908, 10, 270, 3, 271, 3, 271, 3, 271, 3, 271, 5, 271, 4914, 10, 271, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 3, 272, 5, 272, 5063, 10, 272, 3, 273, 3, 273, 5, 273, 5067, 10, 273, 3, 274, 3, 274, 3, 274, 5, 274, 5072, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5083, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5094, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5105, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5116, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5127, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5138, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5149, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5161, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5172, 10, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 3, 274, 5, 274, 5180, 10, 274, 3, 275, 3, 275, 3, 275, 3, 276, 3, 276, 5, 276, 5187, 10, 276, 3, 277, 3, 277, 3, 277, 3, 277, 5, 277, 5193, 10, 277, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5201, 10, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5206, 10, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5211, 10, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5216, 10, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5222, 10, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5229, 10, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5235, 10, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5241, 10, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5246, 10, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5252, 10, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5259, 10, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5264, 10, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5270, 10, 278, 3, 278, 3, 278, 3, 278, 3, 278, 3, 278, 5, 278, 5277, 10, 278, 3, 278, 5, 278, 5280, 10, 278, 3, 279, 3, 279, 3, 280, 3, 280, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 3, 281, 5, 281, 5293, 10, 281, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 5, 282, 5302, 10, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 3, 282, 5, 282, 5314, 10, 282, 5, 282, 5316, 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, 5, 283, 5334, 10, 283, 3, 284, 3, 284, 3, 284, 7, 284, 5339, 10, 284, 12, 284, 14, 284, 5342, 11, 284, 3, 285, 3, 285, 3, 286, 3, 286, 3, 286, 7, 286, 5349, 10, 286, 12, 286, 14, 286, 5352, 11, 286, 3, 287, 3, 287, 5, 287, 5356, 10, 287, 3, 287, 3, 287, 5, 287, 5360, 10, 287, 3, 287, 3, 287, 5, 287, 5364, 10, 287, 3, 287, 3, 287, 5, 287, 5368, 10, 287, 5, 287, 5370, 10, 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, 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, 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, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 3, 288, 5, 288, 5430, 10, 288, 3, 289, 3, 289, 3, 289, 7, 289, 5435, 10, 289, 12, 289, 14, 289, 5438, 11, 289, 3, 290, 3, 290, 3, 290, 5, 290, 5443, 10, 290, 3, 291, 3, 291, 3, 291, 3, 291, 3, 292, 3, 292, 3, 292, 3, 292, 3, 292, 5, 292, 5454, 10, 292, 3, 292, 5, 292, 5457, 10, 292, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 5, 293, 5464, 10, 293, 3, 293, 5, 293, 5467, 10, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 3, 293, 5, 293, 5477, 10, 293, 3, 293, 5, 293, 5480, 10, 293, 5, 293, 5482, 10, 293, 3, 294, 3, 294, 3, 294, 3, 294, 3, 295, 3, 295, 3, 295, 3, 295, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 296, 3, 297, 7, 297, 5499, 10, 297, 12, 297, 14, 297, 5502, 11, 297, 3, 298, 3, 298, 3, 298, 3, 298, 3, 298, 3, 298, 3, 298, 3, 298, 3, 298, 5, 298, 5513, 10, 298, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 5, 299, 5522, 10, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 5, 299, 5531, 10, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 3, 299, 5, 299, 5543, 10, 299, 5, 299, 5545, 10, 299, 3, 300, 3, 300, 3, 301, 3, 301, 5, 301, 5551, 10, 301, 3, 301, 3, 301, 5, 301, 5555, 10, 301, 3, 301, 5, 301, 5558, 10, 301, 3, 301, 3, 301, 3, 301, 5, 301, 5563, 10, 301, 3, 301, 3, 301, 3, 301, 3, 301, 5, 301, 5569, 10, 301, 3, 301, 5, 301, 5572, 10, 301, 3, 301, 5, 301, 5575, 10, 301, 3, 301, 5, 301, 5578, 10, 301, 3, 301, 3, 301, 5, 301, 5582, 10, 301, 3, 301, 3, 301, 5, 301, 5586, 10, 301, 3, 301, 3, 301, 3, 301, 3, 301, 3, 301, 3, 301, 3, 301, 5, 301, 5595, 10, 301, 3, 301, 3, 301, 3, 301, 3, 301, 5, 301, 5601, 10, 301, 3, 301, 5, 301, 5604, 10, 301, 3, 301, 5, 301, 5607, 10, 301, 3, 301, 5, 301, 5610, 10, 301, 5, 301, 5612, 10, 301, 3, 302, 3, 302, 3, 303, 3, 303, 3, 304, 3, 304, 3, 305, 3, 305, 3, 305, 3, 306, 3, 306, 3, 306, 7, 306, 5626, 10, 306, 12, 306, 14, 306, 5629, 11, 306, 3, 307, 5, 307, 5632, 10, 307, 3, 307, 5, 307, 5635, 10, 307, 3, 307, 5, 307, 5638, 10, 307, 3, 307, 5, 307, 5641, 10, 307, 3, 307, 5, 307, 5644, 10, 307, 3, 307, 3, 307, 3, 307, 5, 307, 5649, 10, 307, 3, 307, 5, 307, 5652, 10, 307, 5, 307, 5654, 10, 307, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 3, 308, 5, 308, 5667, 10, 308, 3, 309, 3, 309, 3, 309, 3, 309, 3, 309, 3, 310, 3, 310, 3, 310, 7, 310, 5677, 10, 310, 12, 310, 14, 310, 5680, 11, 310, 3, 311, 3, 311, 3, 311, 3, 312, 3, 312, 3, 313, 3, 313, 3, 314, 3, 314, 3, 314, 3, 314, 5, 314, 5693, 10, 314, 3, 315, 3, 315, 5, 315, 5697, 10, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 3, 315, 5, 315, 5709, 10, 315, 5, 315, 5711, 10, 315, 3, 315, 3, 315, 3, 315, 5, 315, 5716, 10, 315, 3, 316, 3, 316, 3, 316, 3, 316, 7, 316, 5722, 10, 316, 12, 316, 14, 316, 5725, 11, 316, 3, 316, 3, 316, 3, 317, 3, 317, 3, 317, 3, 318, 3, 318, 5, 318, 5734, 10, 318, 3, 318, 3, 318, 3, 319, 3, 319, 3, 319, 7, 319, 5741, 10, 319, 12, 319, 14, 319, 5744, 11, 319, 3, 320, 3, 320, 3, 320, 7, 320, 5749, 10, 320, 12, 320, 14, 320, 5752, 11, 320, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 3, 321, 5, 321, 5760, 10, 321, 5, 321, 5762, 10, 321, 3, 322, 3, 322, 5, 322, 5766, 10, 322, 3, 322, 3, 322, 3, 323, 3, 323, 3, 323, 7, 323, 5773, 10, 323, 12, 323, 14, 323, 5776, 11, 323, 3, 324, 3, 324, 5, 324, 5780, 10, 324, 3, 324, 3, 324, 3, 324, 3, 324, 5, 324, 5786, 10, 324, 3, 324, 3, 324, 3, 324, 5, 324, 5791, 10, 324, 3, 325, 3, 325, 5, 325, 5795, 10, 325, 3, 325, 3, 325, 3, 325, 5, 325, 5800, 10, 325, 3, 326, 3, 326, 3, 327, 3, 327, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 3, 328, 5, 328, 5818, 10, 328, 3, 329, 3, 329, 3, 329, 5, 329, 5823, 10, 329, 3, 330, 3, 330, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 3, 331, 5, 331, 5838, 10, 331, 3, 331, 3, 331, 3, 332, 3, 332, 3, 332, 7, 332, 5845, 10, 332, 12, 332, 14, 332, 5848, 11, 332, 3, 333, 3, 333, 3, 333, 3, 334, 3, 334, 3, 334, 7, 334, 5856, 10, 334, 12, 334, 14, 334, 5859, 11, 334, 3, 335, 6, 335, 5862, 10, 335, 13, 335, 14, 335, 5863, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 3, 336, 5, 336, 5901, 10, 336, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 3, 337, 5, 337, 5911, 10, 337, 3, 338, 3, 338, 3, 338, 3, 338, 3, 338, 5, 338, 5918, 10, 338, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 3, 339, 7, 339, 5927, 10, 339, 12, 339, 14, 339, 5930, 11, 339, 3, 340, 3, 340, 3, 340, 3, 341, 3, 341, 3, 341, 3, 342, 3, 342, 3, 342, 7, 342, 5941, 10, 342, 12, 342, 14, 342, 5944, 11, 342, 3, 343, 3, 343, 3, 343, 3, 343, 3, 343, 5, 343, 5951, 10, 343, 3, 344, 6, 344, 5954, 10, 344, 13, 344, 14, 344, 5955, 3, 345, 3, 345, 3, 346, 3, 346, 3, 346, 3, 346, 5, 346, 5964, 10, 346, 3, 346, 3, 346, 3, 346, 3, 346, 3, 346, 3, 346, 5, 346, 5972, 10, 346, 3, 346, 3, 346, 3, 346, 3, 346, 5, 346, 5978, 10, 346, 3, 346, 3, 346, 3, 346, 3, 346, 3, 346, 3, 346, 5, 346, 5986, 10, 346, 3, 346, 3, 346, 3, 346, 3, 346, 5, 346, 5992, 10, 346, 3, 346, 3, 346, 3, 346, 3, 346, 3, 346, 3, 346, 5, 346, 6000, 10, 346, 5, 346, 6002, 10, 346, 3, 347, 3, 347, 3, 347, 3, 347, 5, 347, 6008, 10, 347, 3, 347, 3, 347, 3, 347, 3, 347, 3, 347, 3, 347, 5, 347, 6016, 10, 347, 5, 347, 6018, 10, 347, 3, 348, 3, 348, 3, 348, 3, 348, 5, 348, 6024, 10, 348, 3, 348, 3, 348, 3, 348, 3, 348, 3, 348, 3, 348, 5, 348, 6032, 10, 348, 5, 348, 6034, 10, 348, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 3, 349, 5, 349, 6058, 10, 349, 3, 350, 3, 350, 3, 350, 7, 350, 6063, 10, 350, 12, 350, 14, 350, 6066, 11, 350, 3, 350, 3, 350, 3, 351, 3, 351, 3, 351, 7, 351, 6073, 10, 351, 12, 351, 14, 351, 6076, 11, 351, 3, 352, 3, 352, 3, 352, 3, 353, 3, 353, 3, 353, 3, 354, 6, 354, 6085, 10, 354, 13, 354, 14, 354, 6086, 3, 355, 3, 355, 3, 355, 5, 355, 6092, 10, 355, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 5, 356, 6105, 10, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 5, 356, 6117, 10, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 3, 356, 5, 356, 6129, 10, 356, 5, 356, 6131, 10, 356, 3, 357, 3, 357, 3, 357, 3, 357, 5, 357, 6137, 10, 357, 3, 358, 3, 358, 3, 358, 5, 358, 6142, 10, 358, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 3, 358, 5, 358, 6150, 10, 358, 3, 359, 3, 359, 3, 359, 3, 360, 3, 360, 5, 360, 6157, 10, 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, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 3, 361, 5, 361, 6202, 10, 361, 3, 362, 3, 362, 3, 362, 5, 362, 6207, 10, 362, 3, 362, 3, 362, 3, 362, 3, 362, 3, 362, 5, 362, 6214, 10, 362, 3, 363, 3, 363, 3, 363, 5, 363, 6219, 10, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 5, 363, 6226, 10, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 5, 363, 6236, 10, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 3, 363, 5, 363, 6246, 10, 363, 3, 363, 3, 363, 5, 363, 6250, 10, 363, 3, 364, 3, 364, 3, 365, 3, 365, 3, 366, 3, 366, 3, 366, 7, 366, 6259, 10, 366, 12, 366, 14, 366, 6262, 11, 366, 3, 367, 3, 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, 5, 368, 6278, 10, 368, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6349, 10, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6544, 10, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6557, 10, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6568, 10, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6581, 10, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6593, 10, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6607, 10, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6639, 10, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6653, 10, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 3, 369, 5, 369, 6765, 10, 369, 5, 369, 6767, 10, 369, 3, 370, 3, 370, 3, 371, 3, 371, 3, 371, 3, 372, 3, 372, 3, 372, 3, 372, 5, 372, 6778, 10, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 5, 372, 6789, 10, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 5, 372, 6800, 10, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 5, 372, 6813, 10, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 5, 372, 6825, 10, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 5, 372, 6836, 10, 372, 3, 372, 3, 372, 3, 372, 3, 372, 3, 372, 5, 372, 6843, 10, 372, 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, 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, 7064, 10, 374, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 375, 3, 376, 3, 376, 3, 376, 7, 376, 7077, 10, 376, 12, 376, 14, 376, 7080, 11, 376, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 3, 377, 5, 377, 7090, 10, 377, 3, 378, 3, 378, 3, 378, 3, 378, 3, 378, 5, 378, 7097, 10, 378, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 379, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 5, 380, 7151, 10, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 3, 380, 5, 380, 7292, 10, 380, 3, 381, 3, 381, 3, 381, 3, 381, 5, 381, 7298, 10, 381, 3, 381, 5, 381, 7301, 10, 381, 3, 382, 3, 382, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 3, 383, 5, 383, 7311, 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, 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, 5, 384, 7340, 10, 384, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 3, 385, 5, 385, 7350, 10, 385, 3, 386, 3, 386, 3, 386, 7, 386, 7355, 10, 386, 12, 386, 14, 386, 7358, 11, 386, 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, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 5, 388, 7380, 10, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 5, 388, 7389, 10, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 3, 388, 5, 388, 7401, 10, 388, 3, 389, 3, 389, 3, 389, 3, 389, 5, 389, 7407, 10, 389, 3, 389, 3, 389, 3, 389, 3, 389, 3, 389, 3, 389, 5, 389, 7415, 10, 389, 5, 389, 7417, 10, 389, 3, 390, 3, 390, 5, 390, 7421, 10, 390, 3, 390, 3, 390, 3, 390, 3, 390, 3, 390, 3, 390, 3, 390, 3, 390, 5, 390, 7431, 10, 390, 3, 390, 3, 390, 5, 390, 7435, 10, 390, 3, 390, 3, 390, 3, 391, 3, 391, 3, 391, 3, 391, 3, 391, 3, 391, 5, 391, 7445, 10, 391, 3, 392, 5, 392, 7448, 10, 392, 3, 392, 3, 392, 5, 392, 7452, 10, 392, 7, 392, 7454, 10, 392, 12, 392, 14, 392, 7457, 11, 392, 3, 393, 3, 393, 3, 393, 3, 393, 3, 393, 5, 393, 7464, 10, 393, 3, 394, 3, 394, 3, 395, 3, 395, 3, 396, 3, 396, 3, 397, 3, 397, 3, 397, 5, 397, 7475, 10, 397, 3, 398, 3, 398, 3, 398, 3, 399, 3, 399, 3, 399, 3, 400, 3, 400, 3, 400, 3, 400, 5, 400, 7487, 10, 400, 3, 401, 3, 401, 5, 401, 7491, 10, 401, 3, 401, 5, 401, 7494, 10, 401, 3, 401, 3, 401, 5, 401, 7498, 10, 401, 3, 401, 5, 401, 7501, 10, 401, 3, 401, 3, 401, 3, 401, 5, 401, 7506, 10, 401, 3, 401, 3, 401, 5, 401, 7510, 10, 401, 3, 401, 5, 401, 7513, 10, 401, 3, 401, 3, 401, 5, 401, 7517, 10, 401, 3, 401, 5, 401, 7520, 10, 401, 3, 401, 3, 401, 5, 401, 7524, 10, 401, 3, 401, 5, 401, 7527, 10, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 5, 401, 7538, 10, 401, 3, 401, 3, 401, 3, 401, 3, 401, 3, 401, 5, 401, 7545, 10, 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, 7558, 10, 401, 3, 402, 3, 402, 3, 403, 3, 403, 3, 403, 3, 403, 3, 403, 3, 403, 3, 403, 3, 403, 3, 403, 3, 403, 5, 403, 7572, 10, 403, 3, 404, 3, 404, 5, 404, 7576, 10, 404, 3, 404, 7, 404, 7579, 10, 404, 12, 404, 14, 404, 7582, 11, 404, 3, 405, 3, 405, 3, 406, 3, 406, 5, 406, 7588, 10, 406, 3, 406, 3, 406, 3, 407, 3, 407, 3, 407, 5, 407, 7595, 10, 407, 3, 407, 5, 407, 7598, 10, 407, 3, 407, 3, 407, 3, 407, 5, 407, 7603, 10, 407, 3, 407, 5, 407, 7606, 10, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 3, 407, 5, 407, 7615, 10, 407, 5, 407, 7617, 10, 407, 3, 407, 3, 407, 3, 407, 5, 407, 7622, 10, 407, 3, 408, 3, 408, 5, 408, 7626, 10, 408, 3, 408, 3, 408, 3, 408, 3, 409, 3, 409, 3, 409, 3, 410, 3, 410, 3, 410, 3, 410, 5, 410, 7638, 10, 410, 3, 410, 5, 410, 7641, 10, 410, 3, 411, 3, 411, 3, 412, 6, 412, 7646, 10, 412, 13, 412, 14, 412, 7647, 3, 413, 3, 413, 5, 413, 7652, 10, 413, 3, 413, 3, 413, 3, 413, 5, 413, 7657, 10, 413, 3, 414, 3, 414, 3, 414, 3, 414, 3, 414, 3, 414, 3, 414, 3, 414, 5, 414, 7667, 10, 414, 3, 415, 3, 415, 3, 416, 3, 416, 3, 416, 3, 416, 3, 416, 5, 416, 7676, 10, 416, 3, 416, 5, 416, 7679, 10, 416, 3, 416, 3, 416, 3, 416, 5, 416, 7684, 10, 416, 3, 417, 3, 417, 3, 417, 3, 417, 3, 417, 3, 418, 3, 418, 3, 418, 3, 418, 5, 418, 7695, 10, 418, 3, 418, 3, 418, 5, 418, 7699, 10, 418, 3, 418, 3, 418, 3, 418, 3, 418, 5, 418, 7705, 10, 418, 3, 419, 3, 419, 3, 419, 7, 419, 7710, 10, 419, 12, 419, 14, 419, 7713, 11, 419, 3, 420, 3, 420, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 421, 3, 422, 3, 422, 3, 422, 3, 422, 3, 422, 3, 423, 3, 423, 3, 423, 3, 423, 5, 423, 7732, 10, 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, 3, 424, 3, 424, 3, 424, 5, 424, 7753, 10, 424, 3, 424, 3, 424, 5, 424, 7757, 10, 424, 3, 424, 3, 424, 3, 424, 5, 424, 7762, 10, 424, 3, 425, 3, 425, 3, 426, 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, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 3, 427, 5, 427, 7845, 10, 427, 3, 428, 3, 428, 3, 429, 3, 429, 5, 429, 7851, 10, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 429, 3, 430, 3, 430, 5, 430, 7864, 10, 430, 3, 430, 3, 430, 5, 430, 7868, 10, 430, 3, 430, 3, 430, 5, 430, 7872, 10, 430, 3, 430, 3, 430, 5, 430, 7876, 10, 430, 3, 430, 3, 430, 3, 430, 3, 430, 5, 430, 7882, 10, 430, 3, 431, 3, 431, 3, 431, 3, 432, 3, 432, 5, 432, 7889, 10, 432, 3, 432, 5, 432, 7892, 10, 432, 3, 432, 5, 432, 7895, 10, 432, 3, 432, 5, 432, 7898, 10, 432, 3, 432, 5, 432, 7901, 10, 432, 3, 432, 3, 432, 3, 432, 3, 432, 3, 432, 5, 432, 7908, 10, 432, 5, 432, 7910, 10, 432, 3, 433, 3, 433, 5, 433, 7914, 10, 433, 3, 433, 5, 433, 7917, 10, 433, 3, 433, 3, 433, 3, 433, 3, 433, 3, 433, 5, 433, 7924, 10, 433, 5, 433, 7926, 10, 433, 3, 434, 3, 434, 3, 434, 7, 434, 7931, 10, 434, 12, 434, 14, 434, 7934, 11, 434, 3, 435, 3, 435, 3, 436, 3, 436, 5, 436, 7940, 10, 436, 3, 437, 3, 437, 5, 437, 7944, 10, 437, 3, 438, 3, 438, 5, 438, 7948, 10, 438, 3, 439, 3, 439, 3, 440, 3, 440, 3, 441, 3, 441, 3, 442, 3, 442, 3, 443, 3, 443, 3, 443, 3, 443, 3, 444, 3, 444, 5, 444, 7964, 10, 444, 3, 445, 3, 445, 3, 445, 7, 445, 7969, 10, 445, 12, 445, 14, 445, 7972, 11, 445, 3, 446, 3, 446, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 5, 447, 7981, 10, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 3, 447, 5, 447, 7994, 10, 447, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 3, 448, 5, 448, 8005, 10, 448, 3, 449, 3, 449, 3, 449, 7, 449, 8010, 10, 449, 12, 449, 14, 449, 8013, 11, 449, 3, 450, 3, 450, 5, 450, 8017, 10, 450, 3, 451, 3, 451, 5, 451, 8021, 10, 451, 3, 452, 3, 452, 5, 452, 8025, 10, 452, 3, 453, 3, 453, 3, 453, 5, 453, 8030, 10, 453, 3, 453, 3, 453, 3, 453, 3, 454, 3, 454, 3, 454, 3, 454, 3, 455, 3, 455, 3, 455, 3, 455, 5, 455, 8043, 10, 455, 3, 456, 3, 456, 3, 456, 5, 456, 8048, 10, 456, 3, 456, 3, 456, 5, 456, 8052, 10, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 5, 456, 8060, 10, 456, 3, 456, 5, 456, 8063, 10, 456, 3, 456, 3, 456, 5, 456, 8067, 10, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 3, 456, 5, 456, 8078, 10, 456, 3, 456, 5, 456, 8081, 10, 456, 5, 456, 8083, 10, 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, 458, 3, 458, 5, 458, 8099, 10, 458, 3, 459, 5, 459, 8102, 10, 459, 3, 459, 3, 459, 3, 459, 3, 459, 3, 459, 5, 459, 8109, 10, 459, 3, 459, 5, 459, 8112, 10, 459, 3, 460, 3, 460, 3, 460, 5, 460, 8117, 10, 460, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 3, 461, 5, 461, 8132, 10, 461, 3, 461, 3, 461, 3, 461, 3, 461, 5, 461, 8138, 10, 461, 3, 462, 3, 462, 3, 463, 3, 463, 3, 463, 7, 463, 8145, 10, 463, 12, 463, 14, 463, 8148, 11, 463, 3, 464, 3, 464, 3, 464, 3, 465, 3, 465, 3, 465, 5, 465, 8156, 10, 465, 3, 465, 3, 465, 3, 465, 3, 465, 3, 465, 5, 465, 8163, 10, 465, 3, 465, 5, 465, 8166, 10, 465, 3, 466, 3, 466, 3, 466, 3, 466, 5, 466, 8172, 10, 466, 3, 466, 3, 466, 3, 466, 5, 466, 8177, 10, 466, 3, 467, 3, 467, 3, 467, 3, 468, 5, 468, 8183, 10, 468, 3, 468, 3, 468, 3, 468, 3, 468, 5, 468, 8189, 10, 468, 3, 468, 5, 468, 8192, 10, 468, 3, 468, 5, 468, 8195, 10, 468, 3, 469, 3, 469, 3, 469, 3, 470, 3, 470, 5, 470, 8202, 10, 470, 3, 470, 3, 470, 5, 470, 8206, 10, 470, 3, 470, 5, 470, 8209, 10, 470, 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, 5, 472, 8224, 10, 472, 3, 472, 5, 472, 8227, 10, 472, 3, 473, 3, 473, 3, 474, 3, 474, 3, 474, 5, 474, 8234, 10, 474, 3, 475, 5, 475, 8237, 10, 475, 3, 475, 3, 475, 3, 475, 3, 475, 3, 475, 5, 475, 8244, 10, 475, 3, 475, 5, 475, 8247, 10, 475, 3, 475, 5, 475, 8250, 10, 475, 3, 476, 3, 476, 3, 476, 7, 476, 8255, 10, 476, 12, 476, 14, 476, 8258, 11, 476, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 3, 477, 5, 477, 8270, 10, 477, 3, 478, 3, 478, 3, 478, 3, 479, 3, 479, 3, 479, 7, 479, 8278, 10, 479, 12, 479, 14, 479, 8281, 11, 479, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 480, 3, 481, 3, 481, 3, 482, 3, 482, 3, 482, 3, 482, 3, 482, 7, 482, 8298, 10, 482, 12, 482, 14, 482, 8301, 11, 482, 3, 483, 3, 483, 3, 483, 3, 483, 3, 483, 5, 483, 8308, 10, 483, 3, 484, 3, 484, 5, 484, 8312, 10, 484, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 3, 485, 5, 485, 8322, 10, 485, 3, 486, 3, 486, 5, 486, 8326, 10, 486, 3, 486, 3, 486, 5, 486, 8330, 10, 486, 3, 486, 3, 486, 5, 486, 8334, 10, 486, 5, 486, 8336, 10, 486, 3, 486, 3, 486, 3, 486, 5, 486, 8341, 10, 486, 3, 486, 3, 486, 5, 486, 8345, 10, 486, 3, 486, 3, 486, 5, 486, 8349, 10, 486, 5, 486, 8351, 10, 486, 5, 486, 8353, 10, 486, 3, 487, 3, 487, 5, 487, 8357, 10, 487, 3, 488, 3, 488, 5, 488, 8361, 10, 488, 3, 488, 5, 488, 8364, 10, 488, 3, 488, 5, 488, 8367, 10, 488, 3, 488, 5, 488, 8370, 10, 488, 3, 488, 5, 488, 8373, 10, 488, 5, 488, 8375, 10, 488, 3, 488, 5, 488, 8378, 10, 488, 3, 488, 5, 488, 8381, 10, 488, 3, 488, 5, 488, 8384, 10, 488, 3, 488, 5, 488, 8387, 10, 488, 3, 488, 5, 488, 8390, 10, 488, 3, 488, 5, 488, 8393, 10, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 3, 488, 5, 488, 8402, 10, 488, 5, 488, 8404, 10, 488, 3, 488, 3, 488, 3, 488, 5, 488, 8409, 10, 488, 7, 488, 8411, 10, 488, 12, 488, 14, 488, 8414, 11, 488, 3, 489, 3, 489, 3, 489, 5, 489, 8419, 10, 489, 3, 490, 3, 490, 5, 490, 8423, 10, 490, 3, 491, 3, 491, 5, 491, 8427, 10, 491, 3, 491, 3, 491, 3, 492, 3, 492, 3, 492, 7, 492, 8434, 10, 492, 12, 492, 14, 492, 8437, 11, 492, 3, 493, 3, 493, 5, 493, 8441, 10, 493, 3, 493, 3, 493, 5, 493, 8445, 10, 493, 3, 493, 3, 493, 3, 493, 3, 493, 3, 494, 3, 494, 3, 494, 5, 494, 8454, 10, 494, 3, 495, 3, 495, 3, 496, 3, 496, 3, 496, 3, 496, 3, 496, 5, 496, 8463, 10, 496, 3, 497, 3, 497, 5, 497, 8467, 10, 497, 3, 498, 5, 498, 8470, 10, 498, 3, 498, 3, 498, 5, 498, 8474, 10, 498, 3, 498, 3, 498, 3, 498, 5, 498, 8479, 10, 498, 3, 498, 3, 498, 3, 498, 3, 498, 5, 498, 8485, 10, 498, 3, 499, 3, 499, 3, 500, 3, 500, 3, 501, 3, 501, 3, 501, 3, 501, 3, 501, 3, 501, 5, 501, 8497, 10, 501, 3, 502, 3, 502, 3, 503, 3, 503, 3, 504, 3, 504, 3, 504, 3, 504, 3, 505, 3, 505, 3, 505, 7, 505, 8510, 10, 505, 12, 505, 14, 505, 8513, 11, 505, 3, 506, 3, 506, 3, 506, 3, 506, 5, 506, 8519, 10, 506, 3, 506, 5, 506, 8522, 10, 506, 3, 507, 3, 507, 5, 507, 8526, 10, 507, 3, 507, 3, 507, 5, 507, 8530, 10, 507, 5, 507, 8532, 10, 507, 3, 508, 3, 508, 3, 509, 3, 509, 3, 509, 3, 509, 5, 509, 8540, 10, 509, 3, 509, 3, 509, 3, 509, 3, 509, 3, 509, 3, 509, 3, 509, 5, 509, 8549, 10, 509, 3, 509, 3, 509, 3, 509, 3, 509, 5, 509, 8555, 10, 509, 5, 509, 8557, 10, 509, 5, 509, 8559, 10, 509, 3, 510, 3, 510, 3, 510, 3, 510, 3, 510, 5, 510, 8566, 10, 510, 3, 511, 3, 511, 5, 511, 8570, 10, 511, 3, 512, 3, 512, 3, 513, 3, 513, 3, 513, 3, 513, 3, 513, 5, 513, 8579, 10, 513, 3, 514, 3, 514, 5, 514, 8583, 10, 514, 3, 515, 3, 515, 3, 516, 3, 516, 3, 517, 3, 517, 3, 517, 3, 517, 3, 518, 3, 518, 3, 518, 7, 518, 8596, 10, 518, 12, 518, 14, 518, 8599, 11, 518, 3, 519, 3, 519, 3, 519, 3, 519, 3, 519, 5, 519, 8606, 10, 519, 3, 520, 3, 520, 3, 520, 3, 521, 3, 521, 3, 521, 3, 521, 3, 521, 3, 522, 3, 522, 3, 522, 3, 522, 3, 522, 3, 523, 3, 523, 3, 523, 3, 523, 3, 523, 3, 523, 3, 524, 3, 524, 3, 524, 3, 525, 3, 525, 3, 525, 3, 525, 5, 525, 8634, 10, 525, 3, 526, 3, 526, 3, 527, 6, 527, 8639, 10, 527, 13, 527, 14, 527, 8640, 3, 528, 3, 528, 5, 528, 8645, 10, 528, 3, 528, 5, 528, 8648, 10, 528, 3, 529, 3, 529, 3, 529, 5, 529, 8653, 10, 529, 3, 529, 3, 529, 5, 529, 8657, 10, 529, 3, 529, 5, 529, 8660, 10, 529, 3, 530, 3, 530, 3, 530, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 3, 531, 7, 531, 8674, 10, 531, 12, 531, 14, 531, 8677, 11, 531, 3, 532, 3, 532, 3, 532, 3, 533, 3, 533, 3, 533, 7, 533, 8685, 10, 533, 12, 533, 14, 533, 8688, 11, 533, 3, 534, 3, 534, 5, 534, 8692, 10, 534, 3, 534, 5, 534, 8695, 10, 534, 3, 534, 3, 534, 5, 534, 8699, 10, 534, 3, 534, 3, 534, 5, 534, 8703, 10, 534, 3, 534, 3, 534, 5, 534, 8707, 10, 534, 3, 534, 3, 534, 3, 534, 5, 534, 8712, 10, 534, 3, 534, 3, 534, 5, 534, 8716, 10, 534, 3, 534, 3, 534, 5, 534, 8720, 10, 534, 5, 534, 8722, 10, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 5, 534, 8731, 10, 534, 3, 534, 3, 534, 3, 534, 5, 534, 8736, 10, 534, 3, 534, 3, 534, 3, 534, 3, 534, 5, 534, 8742, 10, 534, 3, 534, 3, 534, 5, 534, 8746, 10, 534, 5, 534, 8748, 10, 534, 3, 534, 3, 534, 3, 534, 3, 534, 3, 534, 5, 534, 8755, 10, 534, 3, 534, 3, 534, 3, 534, 5, 534, 8760, 10, 534, 3, 534, 3, 534, 3, 534, 3, 534, 7, 534, 8766, 10, 534, 12, 534, 14, 534, 8769, 11, 534, 3, 535, 5, 535, 8772, 10, 535, 3, 535, 3, 535, 3, 535, 3, 535, 3, 535, 5, 535, 8779, 10, 535, 3, 536, 3, 536, 3, 537, 3, 537, 3, 537, 5, 537, 8786, 10, 537, 3, 537, 5, 537, 8789, 10, 537, 3, 537, 3, 537, 3, 537, 3, 537, 5, 537, 8795, 10, 537, 3, 538, 3, 538, 5, 538, 8799, 10, 538, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 3, 539, 5, 539, 8808, 10, 539, 3, 540, 5, 540, 8811, 10, 540, 3, 540, 3, 540, 5, 540, 8815, 10, 540, 3, 540, 3, 540, 3, 540, 3, 540, 3, 540, 3, 540, 5, 540, 8823, 10, 540, 5, 540, 8825, 10, 540, 3, 541, 3, 541, 3, 541, 7, 541, 8830, 10, 541, 12, 541, 14, 541, 8833, 11, 541, 3, 542, 3, 542, 5, 542, 8837, 10, 542, 3, 542, 5, 542, 8840, 10, 542, 3, 543, 3, 543, 3, 543, 3, 543, 3, 543, 3, 543, 5, 543, 8848, 10, 543, 3, 544, 3, 544, 3, 544, 3, 544, 3, 544, 3, 545, 3, 545, 5, 545, 8857, 10, 545, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 3, 545, 5, 545, 8865, 10, 545, 5, 545, 8867, 10, 545, 3, 546, 3, 546, 5, 546, 8871, 10, 546, 3, 547, 3, 547, 3, 547, 7, 547, 8876, 10, 547, 12, 547, 14, 547, 8879, 11, 547, 3, 548, 3, 548, 3, 548, 3, 548, 3, 548, 3, 549, 3, 549, 3, 549, 3, 550, 3, 550, 3, 550, 3, 551, 3, 551, 3, 551, 3, 551, 3, 551, 5, 551, 8897, 10, 551, 3, 552, 3, 552, 3, 553, 3, 553, 3, 553, 7, 553, 8904, 10, 553, 12, 553, 14, 553, 8907, 11, 553, 3, 554, 3, 554, 3, 554, 5, 554, 8912, 10, 554, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 3, 555, 5, 555, 8931, 10, 555, 3, 555, 3, 555, 3, 556, 3, 556, 3, 556, 7, 556, 8938, 10, 556, 12, 556, 14, 556, 8941, 11, 556, 3, 557, 3, 557, 3, 557, 5, 557, 8946, 10, 557, 3, 557, 3, 557, 5, 557, 8950, 10, 557, 3, 558, 6, 558, 8953, 10, 558, 13, 558, 14, 558, 8954, 3, 559, 3, 559, 3, 559, 3, 559, 3, 559, 3, 559, 3, 559, 3, 559, 5, 559, 8965, 10, 559, 3, 560, 3, 560, 3, 560, 7, 560, 8970, 10, 560, 12, 560, 14, 560, 8973, 11, 560, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 3, 561, 5, 561, 8981, 10, 561, 3, 562, 5, 562, 8984, 10, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 3, 562, 5, 562, 8993, 10, 562, 5, 562, 8995, 10, 562, 3, 562, 3, 562, 3, 562, 3, 562, 5, 562, 9001, 10, 562, 3, 563, 3, 563, 5, 563, 9005, 10, 563, 3, 563, 7, 563, 9008, 10, 563, 12, 563, 14, 563, 9011, 11, 563, 3, 564, 3, 564, 3, 564, 3, 564, 3, 564, 3, 564, 3, 564, 5, 564, 9020, 10, 564, 3, 564, 3, 564, 3, 564, 3, 564, 5, 564, 9026, 10, 564, 5, 564, 9028, 10, 564, 3, 565, 3, 565, 3, 565, 3, 565, 5, 565, 9034, 10, 565, 3, 566, 3, 566, 5, 566, 9038, 10, 566, 3, 566, 5, 566, 9041, 10, 566, 3, 567, 3, 567, 3, 567, 3, 567, 3, 568, 3, 568, 3, 568, 3, 568, 3, 568, 3, 568, 3, 568, 5, 568, 9054, 10, 568, 3, 568, 3, 568, 3, 568, 3, 568, 5, 568, 9060, 10, 568, 3, 568, 3, 568, 5, 568, 9064, 10, 568, 3, 568, 3, 568, 5, 568, 9068, 10, 568, 3, 568, 5, 568, 9071, 10, 568, 3, 569, 3, 569, 3, 569, 3, 569, 3, 570, 3, 570, 5, 570, 9079, 10, 570, 3, 571, 3, 571, 5, 571, 9083, 10, 571, 3, 572, 3, 572, 5, 572, 9087, 10, 572, 3, 572, 3, 572, 3, 572, 3, 572, 3, 573, 3, 573, 5, 573, 9095, 10, 573, 3, 574, 3, 574, 3, 574, 3, 574, 3, 574, 5, 574, 9102, 10, 574, 3, 575, 3, 575, 3, 575, 3, 575, 3, 575, 5, 575, 9109, 10, 575, 3, 576, 3, 576, 5, 576, 9113, 10, 576, 3, 576, 3, 576, 3, 576, 3, 576, 5, 576, 9119, 10, 576, 5, 576, 9121, 10, 576, 3, 577, 3, 577, 3, 578, 3, 578, 3, 578, 3, 578, 3, 578, 5, 578, 9130, 10, 578, 3, 578, 5, 578, 9133, 10, 578, 3, 579, 3, 579, 3, 580, 3, 580, 3, 580, 3, 580, 3, 580, 3, 580, 5, 580, 9143, 10, 580, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 3, 581, 5, 581, 9159, 10, 581, 3, 581, 3, 581, 3, 581, 3, 581, 5, 581, 9165, 10, 581, 3, 581, 3, 581, 3, 581, 5, 581, 9170, 10, 581, 3, 582, 3, 582, 3, 582, 3, 582, 3, 582, 5, 582, 9177, 10, 582, 3, 583, 3, 583, 3, 583, 3, 584, 3, 584, 3, 585, 3, 585, 5, 585, 9186, 10, 585, 3, 586, 3, 586, 3, 586, 7, 586, 9191, 10, 586, 12, 586, 14, 586, 9194, 11, 586, 3, 587, 3, 587, 3, 587, 7, 587, 9199, 10, 587, 12, 587, 14, 587, 9202, 11, 587, 3, 588, 3, 588, 3, 588, 7, 588, 9207, 10, 588, 12, 588, 14, 588, 9210, 11, 588, 3, 589, 3, 589, 5, 589, 9214, 10, 589, 3, 589, 3, 589, 5, 589, 9218, 10, 589, 3, 590, 5, 590, 9221, 10, 590, 3, 590, 3, 590, 3, 591, 3, 591, 5, 591, 9227, 10, 591, 3, 592, 3, 592, 3, 592, 5, 592, 9232, 10, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 3, 592, 5, 592, 9248, 10, 592, 3, 592, 5, 592, 9251, 10, 592, 5, 592, 9253, 10, 592, 3, 593, 3, 593, 3, 593, 3, 593, 3, 593, 3, 593, 3, 593, 3, 593, 3, 593, 3, 593, 5, 593, 9265, 10, 593, 5, 593, 9267, 10, 593, 3, 594, 3, 594, 5, 594, 9271, 10, 594, 3, 594, 3, 594, 3, 594, 3, 594, 3, 594, 3, 594, 5, 594, 9279, 10, 594, 5, 594, 9281, 10, 594, 3, 594, 3, 594, 5, 594, 9285, 10, 594, 5, 594, 9287, 10, 594, 3, 595, 3, 595, 3, 595, 3, 595, 7, 595, 9293, 10, 595, 12, 595, 14, 595, 9296, 11, 595, 3, 596, 5, 596, 9299, 10, 596, 3, 596, 3, 596, 3, 597, 3, 597, 3, 597, 7, 597, 9306, 10, 597, 12, 597, 14, 597, 9309, 11, 597, 3, 598, 3, 598, 3, 598, 7, 598, 9314, 10, 598, 12, 598, 14, 598, 9317, 11, 598, 3, 599, 3, 599, 3, 599, 5, 599, 9322, 10, 599, 3, 600, 5, 600, 9325, 10, 600, 3, 600, 3, 600, 3, 601, 3, 601, 3, 601, 3, 601, 3, 601, 5, 601, 9334, 10, 601, 3, 602, 3, 602, 3, 602, 5, 602, 9339, 10, 602, 3, 603, 3, 603, 3, 603, 7, 603, 9344, 10, 603, 12, 603, 14, 603, 9347, 11, 603, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9356, 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, 5, 604, 9382, 10, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 3, 604, 5, 604, 9393, 10, 604, 7, 604, 9395, 10, 604, 12, 604, 14, 604, 9398, 11, 604, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 5, 605, 9405, 10, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 5, 605, 9428, 10, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 3, 605, 5, 605, 9436, 10, 605, 3, 606, 3, 606, 3, 607, 3, 607, 3, 607, 3, 607, 3, 607, 3, 607, 5, 607, 9446, 10, 607, 3, 607, 5, 607, 9449, 10, 607, 3, 607, 3, 607, 3, 607, 5, 607, 9454, 10, 607, 3, 607, 3, 607, 3, 607, 5, 607, 9459, 10, 607, 3, 607, 3, 607, 5, 607, 9463, 10, 607, 3, 607, 3, 607, 3, 608, 3, 608, 5, 608, 9469, 10, 608, 3, 608, 5, 608, 9472, 10, 608, 3, 608, 5, 608, 9475, 10, 608, 3, 608, 5, 608, 9478, 10, 608, 3, 609, 3, 609, 5, 609, 9482, 10, 609, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9496, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9503, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9510, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9517, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9535, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9543, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9555, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9561, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9574, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9613, 10, 610, 5, 610, 9615, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9635, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9645, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9656, 10, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 3, 610, 5, 610, 9668, 10, 610, 3, 611, 3, 611, 3, 611, 3, 611, 3, 611, 5, 611, 9675, 10, 611, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 3, 612, 5, 612, 9687, 10, 612, 3, 613, 3, 613, 3, 613, 3, 613, 3, 613, 3, 614, 3, 614, 3, 614, 7, 614, 9697, 10, 614, 12, 614, 14, 614, 9700, 11, 614, 3, 615, 3, 615, 3, 615, 5, 615, 9705, 10, 615, 3, 616, 3, 616, 3, 617, 3, 617, 3, 617, 3, 617, 5, 617, 9713, 10, 617, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 3, 618, 5, 618, 9730, 10, 618, 3, 619, 3, 619, 3, 619, 3, 620, 3, 620, 3, 620, 3, 620, 3, 620, 3, 620, 3, 621, 3, 621, 3, 621, 3, 621, 3, 621, 3, 621, 3, 622, 3, 622, 3, 622, 3, 623, 3, 623, 3, 623, 7, 623, 9753, 10, 623, 12, 623, 14, 623, 9756, 11, 623, 3, 624, 3, 624, 3, 624, 3, 624, 3, 625, 3, 625, 3, 625, 5, 625, 9765, 10, 625, 3, 626, 3, 626, 5, 626, 9769, 10, 626, 3, 626, 5, 626, 9772, 10, 626, 3, 626, 5, 626, 9775, 10, 626, 3, 626, 5, 626, 9778, 10, 626, 3, 626, 3, 626, 3, 627, 3, 627, 3, 628, 3, 628, 3, 628, 3, 628, 3, 629, 3, 629, 3, 629, 5, 629, 9791, 10, 629, 3, 629, 3, 629, 3, 629, 5, 629, 9796, 10, 629, 3, 629, 3, 629, 3, 629, 5, 629, 9801, 10, 629, 5, 629, 9803, 10, 629, 3, 630, 3, 630, 3, 630, 3, 630, 3, 630, 3, 630, 5, 630, 9811, 10, 630, 3, 631, 3, 631, 3, 631, 3, 631, 3, 631, 3, 631, 3, 631, 5, 631, 9820, 10, 631, 3, 632, 3, 632, 3, 632, 3, 632, 3, 632, 3, 632, 3, 632, 5, 632, 9829, 10, 632, 3, 633, 3, 633, 3, 633, 5, 633, 9834, 10, 633, 3, 633, 3, 633, 3, 633, 3, 633, 3, 633, 3, 633, 3, 633, 5, 633, 9843, 10, 633, 3, 634, 3, 634, 3, 634, 5, 634, 9848, 10, 634, 3, 634, 3, 634, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 3, 635, 3, 636, 3, 636, 3, 637, 3, 637, 5, 637, 9862, 10, 637, 3, 638, 3, 638, 3, 639, 3, 639, 3, 639, 3, 639, 3, 639, 3, 639, 5, 639, 9872, 10, 639, 3, 640, 3, 640, 3, 640, 3, 640, 3, 640, 3, 640, 5, 640, 9880, 10, 640, 3, 641, 3, 641, 3, 641, 3, 641, 3, 641, 3, 641, 3, 641, 3, 641, 3, 641, 3, 641, 3, 641, 3, 641, 5, 641, 9894, 10, 641, 3, 642, 3, 642, 3, 642, 7, 642, 9899, 10, 642, 12, 642, 14, 642, 9902, 11, 642, 3, 643, 3, 643, 3, 643, 7, 643, 9907, 10, 643, 12, 643, 14, 643, 9910, 11, 643, 3, 644, 3, 644, 3, 644, 3, 644, 3, 644, 5, 644, 9917, 10, 644, 3, 645, 3, 645, 3, 645, 7, 645, 9922, 10, 645, 12, 645, 14, 645, 9925, 11, 645, 3, 646, 3, 646, 3, 646, 5, 646, 9930, 10, 646, 3, 646, 3, 646, 3, 647, 3, 647, 3, 647, 7, 647, 9937, 10, 647, 12, 647, 14, 647, 9940, 11, 647, 3, 648, 3, 648, 3, 648, 3, 648, 3, 649, 3, 649, 3, 649, 3, 649, 3, 649, 3, 649, 3, 649, 3, 649, 5, 649, 9954, 10, 649, 3, 650, 3, 650, 3, 651, 3, 651, 3, 651, 3, 651, 3, 651, 3, 651, 3, 651, 5, 651, 9965, 10, 651, 3, 652, 3, 652, 3, 652, 3, 652, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 3, 653, 5, 653, 9998, 10, 653, 3, 654, 3, 654, 3, 654, 3, 654, 3, 654, 3, 654, 3, 654, 5, 654, 10007, 10, 654, 3, 655, 3, 655, 3, 655, 3, 655, 3, 655, 5, 655, 10014, 10, 655, 3, 656, 3, 656, 5, 656, 10018, 10, 656, 3, 656, 3, 656, 5, 656, 10022, 10, 656, 3, 656, 3, 656, 3, 657, 6, 657, 10027, 10, 657, 13, 657, 14, 657, 10028, 3, 658, 3, 658, 3, 658, 3, 658, 3, 658, 3, 659, 3, 659, 3, 659, 3, 660, 3, 660, 3, 661, 3, 661, 5, 661, 10043, 10, 661, 3, 662, 3, 662, 3, 662, 5, 662, 10048, 10, 662, 3, 662, 3, 662, 3, 662, 5, 662, 10053, 10, 662, 3, 662, 3, 662, 5, 662, 10057, 10, 662, 5, 662, 10059, 10, 662, 3, 662, 5, 662, 10062, 10, 662, 3, 663, 3, 663, 3, 664, 6, 664, 10067, 10, 664, 13, 664, 14, 664, 10068, 3, 665, 7, 665, 10072, 10, 665, 12, 665, 14, 665, 10075, 11, 665, 3, 666, 3, 666, 3, 667, 3, 667, 3, 667, 7, 667, 10082, 10, 667, 12, 667, 14, 667, 10085, 11, 667, 3, 668, 3, 668, 3, 668, 3, 668, 3, 668, 5, 668, 10092, 10, 668, 3, 668, 5, 668, 10095, 10, 668, 3, 669, 3, 669, 3, 669, 7, 669, 10100, 10, 669, 12, 669, 14, 669, 10103, 11, 669, 3, 670, 3, 670, 5, 670, 10107, 10, 670, 3, 671, 3, 671, 5, 671, 10111, 10, 671, 3, 672, 3, 672, 3, 672, 7, 672, 10116, 10, 672, 12, 672, 14, 672, 10119, 11, 672, 3, 673, 3, 673, 3, 674, 3, 674, 3, 675, 3, 675, 3, 676, 3, 676, 3, 676, 3, 676, 5, 676, 10131, 10, 676, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 5, 677, 10143, 10, 677, 3, 677, 3, 677, 3, 677, 5, 677, 10148, 10, 677, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 5, 677, 10156, 10, 677, 3, 677, 3, 677, 3, 677, 3, 677, 3, 677, 5, 677, 10163, 10, 677, 3, 677, 3, 677, 3, 677, 5, 677, 10168, 10, 677, 3, 678, 3, 678, 3, 679, 3, 679, 3, 680, 3, 680, 3, 681, 3, 681, 3, 682, 3, 682, 5, 682, 10180, 10, 682, 3, 683, 3, 683, 3, 683, 3, 683, 7, 683, 10186, 10, 683, 12, 683, 14, 683, 10189, 11, 683, 3, 683, 3, 683, 5, 683, 10193, 10, 683, 3, 684, 3, 684, 3, 684, 3, 685, 3, 685, 3, 685, 3, 685, 3, 685, 5, 685, 10203, 10, 685, 3, 686, 3, 686, 3, 687, 3, 687, 3, 688, 3, 688, 3, 688, 3, 688, 5, 688, 10213, 10, 688, 3, 689, 3, 689, 3, 689, 7, 689, 10218, 10, 689, 12, 689, 14, 689, 10221, 11, 689, 3, 690, 3, 690, 3, 690, 3, 690, 5, 690, 10227, 10, 690, 3, 691, 3, 691, 3, 692, 3, 692, 3, 692, 3, 692, 3, 692, 3, 692, 3, 692, 5, 692, 10238, 10, 692, 3, 692, 5, 692, 10241, 10, 692, 5, 692, 10243, 10, 692, 3, 693, 3, 693, 5, 693, 10247, 10, 693, 3, 693, 5, 693, 10250, 10, 693, 3, 694, 3, 694, 3, 694, 3, 695, 3, 695, 3, 695, 3, 695, 5, 695, 10259, 10, 695, 3, 696, 3, 696, 3, 696, 3, 696, 5, 696, 10265, 10, 696, 3, 697, 3, 697, 3, 697, 3, 697, 3, 697, 3, 697, 5, 697, 10273, 10, 697, 3, 698, 3, 698, 5, 698, 10277, 10, 698, 3, 698, 3, 698, 3, 698, 3, 698, 3, 698, 5, 698, 10284, 10, 698, 3, 699, 3, 699, 3, 700, 3, 700, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 3, 701, 5, 701, 10341, 10, 701, 3, 702, 3, 702, 3, 703, 3, 703, 3, 704, 3, 704, 3, 704, 3, 704, 3, 705, 7, 705, 10352, 10, 705, 12, 705, 14, 705, 10355, 11, 705, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 3, 706, 5, 706, 10377, 10, 706, 3, 707, 3, 707, 3, 708, 3, 708, 3, 708, 3, 708, 5, 708, 10385, 10, 708, 3, 709, 3, 709, 5, 709, 10389, 10, 709, 3, 710, 3, 710, 3, 710, 3, 710, 3, 710, 3, 710, 3, 710, 3, 711, 3, 711, 3, 711, 5, 711, 10401, 10, 711, 5, 711, 10403, 10, 711, 3, 712, 3, 712, 3, 713, 6, 713, 10408, 10, 713, 13, 713, 14, 713, 10409, 3, 714, 3, 714, 3, 714, 3, 714, 3, 715, 3, 715, 3, 715, 5, 715, 10419, 10, 715, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 3, 716, 5, 716, 10437, 10, 716, 3, 716, 3, 716, 3, 717, 3, 717, 3, 717, 3, 717, 5, 717, 10445, 10, 717, 3, 718, 3, 718, 3, 719, 3, 719, 3, 719, 3, 719, 3, 719, 5, 719, 10454, 10, 719, 3, 720, 3, 720, 3, 720, 7, 720, 10459, 10, 720, 12, 720, 14, 720, 10462, 11, 720, 3, 721, 3, 721, 3, 721, 3, 722, 3, 722, 3, 723, 3, 723, 5, 723, 10471, 10, 723, 3, 724, 3, 724, 3, 725, 3, 725, 5, 725, 10477, 10, 725, 3, 726, 3, 726, 3, 727, 3, 727, 3, 727, 5, 727, 10484, 10, 727, 3, 728, 3, 728, 3, 728, 5, 728, 10489, 10, 728, 3, 729, 3, 729, 3, 729, 3, 729, 5, 729, 10495, 10, 729, 3, 730, 3, 730, 5, 730, 10499, 10, 730, 3, 731, 3, 731, 3, 732, 7, 732, 10504, 10, 732, 12, 732, 14, 732, 10507, 11, 732, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 3, 733, 5, 733, 10536, 10, 733, 3, 734, 3, 734, 3, 734, 3, 734, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 3, 735, 5, 735, 10556, 10, 735, 3, 736, 3, 736, 5, 736, 10560, 10, 736, 3, 737, 3, 737, 3, 737, 3, 737, 3, 737, 3, 738, 3, 738, 3, 738, 3, 738, 3, 738, 3, 738, 3, 739, 3, 739, 3, 739, 5, 739, 10576, 10, 739, 3, 740, 3, 740, 3, 740, 7, 740, 10581, 10, 740, 12, 740, 14, 740, 10584, 11, 740, 3, 741, 3, 741, 3, 741, 3, 741, 3, 742, 3, 742, 3, 743, 3, 743, 3, 744, 3, 744, 5, 744, 10596, 10, 744, 3, 744, 3, 744, 3, 744, 3, 744, 7, 744, 10602, 10, 744, 12, 744, 14, 744, 10605, 11, 744, 3, 745, 3, 745, 3, 745, 3, 745, 3, 745, 3, 745, 3, 745, 3, 745, 3, 745, 3, 745, 3, 746, 3, 746, 3, 746, 3, 746, 3, 746, 7, 746, 10622, 10, 746, 12, 746, 14, 746, 10625, 11, 746, 3, 747, 3, 747, 3, 747, 5, 747, 10630, 10, 747, 3, 748, 3, 748, 3, 748, 3, 748, 3, 748, 3, 748, 3, 748, 3, 748, 3, 749, 3, 749, 5, 749, 10642, 10, 749, 3, 750, 6, 750, 10645, 10, 750, 13, 750, 14, 750, 10646, 3, 751, 3, 751, 3, 751, 3, 751, 3, 751, 3, 752, 3, 752, 3, 752, 5, 752, 10657, 10, 752, 3, 753, 3, 753, 3, 753, 3, 754, 3, 754, 3, 754, 3, 754, 3, 754, 3, 755, 3, 755, 3, 755, 3, 755, 3, 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, 5, 756, 10689, 10, 756, 3, 757, 3, 757, 3, 757, 5, 757, 10694, 10, 757, 3, 758, 3, 758, 3, 758, 3, 758, 3, 758, 7, 758, 10701, 10, 758, 12, 758, 14, 758, 10704, 11, 758, 3, 758, 3, 758, 5, 758, 10708, 10, 758, 3, 759, 3, 759, 5, 759, 10712, 10, 759, 3, 760, 3, 760, 3, 760, 5, 760, 10717, 10, 760, 3, 761, 3, 761, 3, 762, 3, 762, 3, 762, 3, 762, 3, 762, 3, 762, 3, 762, 3, 762, 3, 762, 3, 763, 3, 763, 3, 763, 5, 763, 10733, 10, 763, 3, 764, 3, 764, 3, 764, 5, 764, 10738, 10, 764, 3, 764, 3, 764, 3, 765, 3, 765, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 3, 766, 5, 766, 10753, 10, 766, 3, 766, 5, 766, 10756, 10, 766, 3, 766, 3, 766, 3, 767, 3, 767, 5, 767, 10762, 10, 767, 3, 768, 3, 768, 5, 768, 10766, 10, 768, 3, 768, 3, 768, 3, 768, 3, 768, 3, 768, 3, 768, 3, 768, 5, 768, 10775, 10, 768, 3, 768, 3, 768, 3, 768, 3, 768, 3, 768, 3, 768, 5, 768, 10783, 10, 768, 3, 768, 3, 768, 3, 768, 3, 768, 3, 768, 3, 768, 3, 768, 5, 768, 10792, 10, 768, 3, 768, 3, 768, 3, 768, 3, 768, 5, 768, 10798, 10, 768, 3, 769, 3, 769, 3, 770, 3, 770, 3, 770, 6, 770, 10805, 10, 770, 13, 770, 14, 770, 10806, 5, 770, 10809, 10, 770, 3, 771, 3, 771, 3, 771, 5, 771, 10814, 10, 771, 3, 772, 3, 772, 3, 772, 3, 772, 3, 773, 3, 773, 3, 773, 7, 773, 10823, 10, 773, 12, 773, 14, 773, 10826, 11, 773, 3, 774, 3, 774, 3, 774, 3, 774, 3, 774, 3, 775, 3, 775, 3, 775, 5, 775, 10836, 10, 775, 3, 776, 3, 776, 3, 776, 3, 776, 3, 776, 3, 776, 3, 776, 3, 777, 3, 777, 3, 777, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 3, 778, 5, 778, 10857, 10, 778, 3, 778, 3, 778, 3, 779, 3, 779, 3, 779, 5, 779, 10864, 10, 779, 3, 780, 3, 780, 3, 780, 7, 780, 10869, 10, 780, 12, 780, 14, 780, 10872, 11, 780, 3, 781, 3, 781, 3, 781, 5, 781, 10877, 10, 781, 3, 781, 5, 781, 10880, 10, 781, 3, 782, 3, 782, 3, 782, 3, 782, 3, 782, 3, 782, 3, 782, 3, 782, 3, 782, 5, 782, 10891, 10, 782, 3, 782, 3, 782, 3, 782, 3, 782, 3, 782, 5, 782, 10898, 10, 782, 5, 782, 10900, 10, 782, 3, 782, 3, 782, 3, 783, 3, 783, 3, 783, 3, 783, 3, 783, 5, 783, 10909, 10, 783, 3, 784, 3, 784, 3, 784, 7, 784, 10914, 10, 784, 12, 784, 14, 784, 10917, 11, 784, 3, 785, 3, 785, 3, 785, 5, 785, 10922, 10, 785, 3, 786, 3, 786, 3, 786, 3, 786, 5, 786, 10928, 10, 786, 3, 787, 3, 787, 5, 787, 10932, 10, 787, 3, 788, 3, 788, 5, 788, 10936, 10, 788, 3, 788, 3, 788, 3, 788, 3, 788, 3, 788, 3, 788, 3, 789, 3, 789, 3, 790, 3, 790, 3, 790, 5, 790, 10949, 10, 790, 3, 791, 3, 791, 3, 791, 3, 791, 3, 791, 3, 791, 3, 791, 3, 791, 3, 791, 3, 791, 3, 791, 3, 791, 3, 791, 5, 791, 10964, 10, 791, 5, 791, 10966, 10, 791, 3, 792, 3, 792, 5, 792, 10970, 10, 792, 3, 792, 3, 792, 3, 792, 3, 793, 3, 793, 3, 793, 3, 793, 3, 794, 3, 794, 3, 794, 3, 795, 3, 795, 5, 795, 10984, 10, 795, 3, 795, 3, 795, 3, 796, 3, 796, 5, 796, 10990, 10, 796, 3, 796, 3, 796, 3, 797, 3, 797, 5, 797, 10996, 10, 797, 3, 797, 3, 797, 3, 798, 3, 798, 3, 798, 3, 798, 3, 798, 3, 798, 3, 798, 3, 798, 3, 798, 5, 798, 11009, 10, 798, 3, 798, 5, 798, 11012, 10, 798, 3, 799, 3, 799, 5, 799, 11016, 10, 799, 3, 800, 3, 800, 3, 800, 5, 800, 11021, 10, 800, 3, 801, 6, 801, 11024, 10, 801, 13, 801, 14, 801, 11025, 3, 802, 3, 802, 3, 802, 3, 802, 3, 802, 3, 803, 3, 803, 3, 803, 7, 803, 11036, 10, 803, 12, 803, 14, 803, 11039, 11, 803, 3, 804, 3, 804, 3, 804, 5, 804, 11044, 10, 804, 3, 805, 3, 805, 5, 805, 11048, 10, 805, 3, 806, 3, 806, 5, 806, 11052, 10, 806, 3, 807, 3, 807, 5, 807, 11056, 10, 807, 3, 808, 3, 808, 3, 808, 3, 809, 3, 809, 5, 809, 11063, 10, 809, 3, 810, 3, 810, 3, 811, 5, 811, 11068, 10, 811, 3, 811, 5, 811, 11071, 10, 811, 3, 811, 5, 811, 11074, 10, 811, 3, 811, 5, 811, 11077, 10, 811, 3, 811, 5, 811, 11080, 10, 811, 3, 811, 5, 811, 11083, 10, 811, 3, 811, 5, 811, 11086, 10, 811, 3, 812, 3, 812, 3, 813, 3, 813, 3, 814, 3, 814, 3, 815, 3, 815, 3, 816, 3, 816, 5, 816, 11098, 10, 816, 3, 817, 3, 817, 3, 817, 3, 817, 3, 817, 2, 2, 3, 1206, 818, 2, 2, 4, 2, 6, 2, 8, 2, 10, 2, 12, 2, 14, 2, 16, 2, 18, 2, 20, 2, 22, 2, 24, 2, 26, 2, 28, 2, 30, 2, 32, 2, 34, 2, 36, 2, 38, 2, 40, 2, 42, 2, 44, 2, 46, 2, 48, 2, 50, 2, 52, 2, 54, 2, 56, 2, 58, 2, 60, 2, 62, 2, 64, 2, 66, 2, 68, 2, 70, 2, 72, 2, 74, 2, 76, 2, 78, 2, 80, 2, 82, 2, 84, 2, 86, 2, 88, 2, 90, 2, 92, 2, 94, 2, 96, 2, 98, 2, 100, 2, 102, 2, 104, 2, 106, 2, 108, 2, 110, 2, 112, 2, 114, 2, 116, 2, 118, 2, 120, 2, 122, 2, 124, 2, 126, 2, 128, 2, 130, 2, 132, 2, 134, 2, 136, 2, 138, 2, 140, 2, 142, 2, 144, 2, 146, 2, 148, 2, 150, 2, 152, 2, 154, 2, 156, 2, 158, 2, 160, 2, 162, 2, 164, 2, 166, 2, 168, 2, 170, 2, 172, 2, 174, 2, 176, 2, 178, 2, 180, 2, 182, 2, 184, 2, 186, 2, 188, 2, 190, 2, 192, 2, 194, 2, 196, 2, 198, 2, 200, 2, 202, 2, 204, 2, 206, 2, 208, 2, 210, 2, 212, 2, 214, 2, 216, 2, 218, 2, 220, 2, 222, 2, 224, 2, 226, 2, 228, 2, 230, 2, 232, 2, 234, 2, 236, 2, 238, 2, 240, 2, 242, 2, 244, 2, 246, 2, 248, 2, 250, 2, 252, 2, 254, 2, 256, 2, 258, 2, 260, 2, 262, 2, 264, 2, 266, 2, 268, 2, 270, 2, 272, 2, 274, 2, 276, 2, 278, 2, 280, 2, 282, 2, 284, 2, 286, 2, 288, 2, 290, 2, 292, 2, 294, 2, 296, 2, 298, 2, 300, 2, 302, 2, 304, 2, 306, 2, 308, 2, 310, 2, 312, 2, 314, 2, 316, 2, 318, 2, 320, 2, 322, 2, 324, 2, 326, 2, 328, 2, 330, 2, 332, 2, 334, 2, 336, 2, 338, 2, 340, 2, 342, 2, 344, 2, 346, 2, 348, 2, 350, 2, 352, 2, 354, 2, 356, 2, 358, 2, 360, 2, 362, 2, 364, 2, 366, 2, 368, 2, 370, 2, 372, 2, 374, 2, 376, 2, 378, 2, 380, 2, 382, 2, 384, 2, 386, 2, 388, 2, 390, 2, 392, 2, 394, 2, 396, 2, 398, 2, 400, 2, 402, 2, 404, 2, 406, 2, 408, 2, 410, 2, 412, 2, 414, 2, 416, 2, 418, 2, 420, 2, 422, 2, 424, 2, 426, 2, 428, 2, 430, 2, 432, 2, 434, 2, 436, 2, 438, 2, 440, 2, 442, 2, 444, 2, 446, 2, 448, 2, 450, 2, 452, 2, 454, 2, 456, 2, 458, 2, 460, 2, 462, 2, 464, 2, 466, 2, 468, 2, 470, 2, 472, 2, 474, 2, 476, 2, 478, 2, 480, 2, 482, 2, 484, 2, 486, 2, 488, 2, 490, 2, 492, 2, 494, 2, 496, 2, 498, 2, 500, 2, 502, 2, 504, 2, 506, 2, 508, 2, 510, 2, 512, 2, 514, 2, 516, 2, 518, 2, 520, 2, 522, 2, 524, 2, 526, 2, 528, 2, 530, 2, 532, 2, 534, 2, 536, 2, 538, 2, 540, 2, 542, 2, 544, 2, 546, 2, 548, 2, 550, 2, 552, 2, 554, 2, 556, 2, 558, 2, 560, 2, 562, 2, 564, 2, 566, 2, 568, 2, 570, 2, 572, 2, 574, 2, 576, 2, 578, 2, 580, 2, 582, 2, 584, 2, 586, 2, 588, 2, 590, 2, 592, 2, 594, 2, 596, 2, 598, 2, 600, 2, 602, 2, 604, 2, 606, 2, 608, 2, 610, 2, 612, 2, 614, 2, 616, 2, 618, 2, 620, 2, 622, 2, 624, 2, 626, 2, 628, 2, 630, 2, 632, 2, 634, 2, 636, 2, 638, 2, 640, 2, 642, 2, 644, 2, 646, 2, 648, 2, 650, 2, 652, 2, 654, 2, 656, 2, 658, 2, 660, 2, 662, 2, 664, 2, 666, 2, 668, 2, 670, 2, 672, 2, 674, 2, 676, 2, 678, 2, 680, 2, 682, 2, 684, 2, 686, 2, 688, 2, 690, 2, 692, 2, 694, 2, 696, 2, 698, 2, 700, 2, 702, 2, 704, 2, 706, 2, 708, 2, 710, 2, 712, 2, 714, 2, 716, 2, 718, 2, 720, 2, 722, 2, 724, 2, 726, 2, 728, 2, 730, 2, 732, 2, 734, 2, 736, 2, 738, 2, 740, 2, 742, 2, 744, 2, 746, 2, 748, 2, 750, 2, 752, 2, 754, 2, 756, 2, 758, 2, 760, 2, 762, 2, 764, 2, 766, 2, 768, 2, 770, 2, 772, 2, 774, 2, 776, 2, 778, 2, 780, 2, 782, 2, 784, 2, 786, 2, 788, 2, 790, 2, 792, 2, 794, 2, 796, 2, 798, 2, 800, 2, 802, 2, 804, 2, 806, 2, 808, 2, 810, 2, 812, 2, 814, 2, 816, 2, 818, 2, 820, 2, 822, 2, 824, 2, 826, 2, 828, 2, 830, 2, 832, 2, 834, 2, 836, 2, 838, 2, 840, 2, 842, 2, 844, 2, 846, 2, 848, 2, 850, 2, 852, 2, 854, 2, 856, 2, 858, 2, 860, 2, 862, 2, 864, 2, 866, 2, 868, 2, 870, 2, 872, 2, 874, 2, 876, 2, 878, 2, 880, 2, 882, 2, 884, 2, 886, 2, 888, 2, 890, 2, 892, 2, 894, 2, 896, 2, 898, 2, 900, 2, 902, 2, 904, 2, 906, 2, 908, 2, 910, 2, 912, 2, 914, 2, 916, 2, 918, 2, 920, 2, 922, 2, 924, 2, 926, 2, 928, 2, 930, 2, 932, 2, 934, 2, 936, 2, 938, 2, 940, 2, 942, 2, 944, 2, 946, 2, 948, 2, 950, 2, 952, 2, 954, 2, 956, 2, 958, 2, 960, 2, 962, 2, 964, 2, 966, 2, 968, 2, 970, 2, 972, 2, 974, 2, 976, 2, 978, 2, 980, 2, 982, 2, 984, 2, 986, 2, 988, 2, 990, 2, 992, 2, 994, 2, 996, 2, 998, 2, 1000, 2, 1002, 2, 1004, 2, 1006, 2, 1008, 2, 1010, 2, 1012, 2, 1014, 2, 1016, 2, 1018, 2, 1020, 2, 1022, 2, 1024, 2, 1026, 2, 1028, 2, 1030, 2, 1032, 2, 1034, 2, 1036, 2, 1038, 2, 1040, 2, 1042, 2, 1044, 2, 1046, 2, 1048, 2, 1050, 2, 1052, 2, 1054, 2, 1056, 2, 1058, 2, 1060, 2, 1062, 2, 1064, 2, 1066, 2, 1068, 2, 1070, 2, 1072, 2, 1074, 2, 1076, 2, 1078, 2, 1080, 2, 1082, 2, 1084, 2, 1086, 2, 1088, 2, 1090, 2, 1092, 2, 1094, 2, 1096, 2, 1098, 2, 1100, 2, 1102, 2, 1104, 2, 1106, 2, 1108, 2, 1110, 2, 1112, 2, 1114, 2, 1116, 2, 1118, 2, 1120, 2, 1122, 2, 1124, 2, 1126, 2, 1128, 2, 1130, 2, 1132, 2, 1134, 2, 1136, 2, 1138, 2, 1140, 2, 1142, 2, 1144, 2, 1146, 2, 1148, 2, 1150, 2, 1152, 2, 1154, 2, 1156, 2, 1158, 2, 1160, 2, 1162, 2, 1164, 2, 1166, 2, 1168, 2, 1170, 2, 1172, 2, 1174, 2, 1176, 2, 1178, 2, 1180, 2, 1182, 2, 1184, 2, 1186, 2, 1188, 2, 1190, 2, 1192, 2, 1194, 2, 1196, 2, 1198, 2, 1200, 2, 1202, 2, 1204, 2, 1206, 2, 1208, 2, 1210, 2, 1212, 2, 1214, 2, 1216, 2, 1218, 2, 1220, 2, 1222, 2, 1224, 2, 1226, 2, 1228, 2, 1230, 2, 1232, 2, 1234, 2, 1236, 2, 1238, 2, 1240, 2, 1242, 2, 1244, 2, 1246, 2, 1248, 2, 1250, 2, 1252, 2, 1254, 2, 1256, 2, 1258, 2, 1260, 2, 1262, 2, 1264, 2, 1266, 2, 1268, 2, 1270, 2, 1272, 2, 1274, 2, 1276, 2, 1278, 2, 1280, 2, 1282, 2, 1284, 2, 1286, 2, 1288, 2, 1290, 2, 1292, 2, 1294, 2, 1296, 2, 1298, 2, 1300, 2, 1302, 2, 1304, 2, 1306, 2, 1308, 2, 1310, 2, 1312, 2, 1314, 2, 1316, 2, 1318, 2, 1320, 2, 1322, 2, 1324, 2, 1326, 2, 1328, 2, 1330, 2, 1332, 2, 1334, 2, 1336, 2, 1338, 2, 1340, 2, 1342, 2, 1344, 2, 1346, 2, 1348, 2, 1350, 2, 1352, 2, 1354, 2, 1356, 2, 1358, 2, 1360, 2, 1362, 2, 1364, 2, 1366, 2, 1368, 2, 1370, 2, 1372, 2, 1374, 2, 1376, 2, 1378, 2, 1380, 2, 1382, 2, 1384, 2, 1386, 2, 1388, 2, 1390, 2, 1392, 2, 1394, 2, 1396, 2, 1398, 2, 1400, 2, 1402, 2, 1404, 2, 1406, 2, 1408, 2, 1410, 2, 1412, 2, 1414, 2, 1416, 2, 1418, 2, 1420, 2, 1422, 2, 1424, 2, 1426, 2, 1428, 2, 1430, 2, 1432, 2, 1434, 2, 1436, 2, 1438, 2, 1440, 2, 1442, 2, 1444, 2, 1446, 2, 1448, 2, 1450, 2, 1452, 2, 1454, 2, 1456, 2, 1458, 2, 1460, 2, 1462, 2, 1464, 2, 1466, 2, 1468, 2, 1470, 2, 1472, 2, 1474, 2, 1476, 2, 1478, 2, 1480, 2, 1482, 2, 1484, 2, 1486, 2, 1488, 2, 1490, 2, 1492, 2, 1494, 2, 1496, 2, 1498, 2, 1500, 2, 1502, 2, 1504, 2, 1506, 2, 1508, 2, 1510, 2, 1512, 2, 1514, 2, 1516, 2, 1518, 2, 1520, 2, 1522, 2, 1524, 2, 1526, 2, 1528, 2, 1530, 2, 1532, 2, 1534, 2, 1536, 2, 1538, 2, 1540, 2, 1542, 2, 1544, 2, 1546, 2, 1548, 2, 1550, 2, 1552, 2, 1554, 2, 1556, 2, 1558, 2, 1560, 2, 1562, 2, 1564, 2, 1566, 2, 1568, 2, 1570, 2, 1572, 2, 1574, 2, 1576, 2, 1578, 2, 1580, 2, 1582, 2, 1584, 2, 1586, 2, 1588, 2, 1590, 2, 1592, 2, 1594, 2, 1596, 2, 1598, 2, 1600, 2, 1602, 2, 1604, 2, 1606, 2, 1608, 2, 1610, 2, 1612, 2, 1614, 2, 1616, 2, 1618, 2, 1620, 2, 1622, 2, 1624, 2, 1626, 2, 1628, 2, 1630, 2, 1632, 2, 2, 78, 4, 2, 197, 197, 366, 366, 3, 2, 230, 231, 3, 2, 238, 239, 3, 2, 236, 237, 3, 2, 234, 235, 3, 2, 232, 233, 4, 2, 68, 68, 320, 320, 4, 2, 101, 101, 320, 320, 5, 2, 68, 68, 101, 101, 320, 320, 4, 2, 135, 135, 193, 193, 4, 2, 256, 256, 334, 334, 4, 2, 12, 12, 96, 96, 4, 2, 164, 164, 365, 365, 4, 2, 182, 182, 223, 223, 7, 2, 32, 32, 290, 290, 331, 331, 354, 354, 356, 356, 4, 2, 152, 152, 317, 317, 4, 2, 66, 66, 96, 96, 4, 2, 354, 354, 356, 356, 4, 2, 202, 202, 226, 226, 11, 2, 32, 32, 162, 162, 167, 167, 181, 181, 221, 221, 229, 229, 344, 344, 347, 347, 440, 440, 5, 2, 115, 115, 286, 286, 338, 338, 4, 2, 55, 55, 80, 80, 5, 2, 175, 175, 262, 262, 264, 264, 7, 2, 32, 32, 90, 90, 184, 184, 243, 243, 371, 371, 4, 2, 94, 94, 228, 228, 4, 2, 343, 343, 416, 416, 3, 2, 450, 451, 4, 2, 94, 94, 416, 416, 4, 2, 213, 213, 298, 298, 5, 2, 323, 323, 359, 359, 447, 447, 4, 2, 66, 66, 70, 70, 12, 2, 48, 48, 90, 90, 184, 184, 204, 204, 243, 243, 354, 354, 356, 356, 359, 360, 371, 371, 523, 525, 7, 2, 214, 214, 331, 331, 352, 352, 363, 363, 457, 458, 4, 2, 39, 39, 57, 57, 4, 2, 12, 12, 55, 55, 5, 2, 213, 213, 298, 298, 444, 444, 5, 2, 177, 177, 325, 325, 351, 351, 6, 2, 90, 90, 184, 184, 243, 243, 371, 371, 4, 2, 139, 139, 244, 244, 4, 2, 358, 358, 382, 382, 4, 2, 153, 153, 256, 256, 4, 2, 315, 315, 335, 335, 3, 2, 33, 34, 4, 2, 101, 101, 351, 351, 4, 2, 203, 203, 336, 336, 4, 2, 215, 215, 256, 256, 4, 2, 32, 32, 58, 58, 4, 2, 322, 322, 416, 416, 4, 2, 209, 209, 270, 270, 6, 2, 115, 115, 117, 117, 121, 121, 128, 128, 4, 2, 362, 362, 479, 479, 4, 2, 393, 394, 408, 408, 3, 2, 393, 394, 3, 2, 420, 421, 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, 5, 2, 41, 41, 75, 75, 97, 97, 4, 2, 168, 168, 190, 190, 4, 2, 306, 306, 452, 452, 4, 2, 210, 210, 291, 291, 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, 485, 488, 11, 2, 126, 126, 131, 230, 240, 388, 435, 454, 457, 471, 473, 473, 475, 475, 477, 477, 480, 490, 5, 2, 108, 125, 127, 130, 474, 474, 6, 2, 32, 54, 56, 72, 74, 107, 456, 456, 4, 2, 64, 64, 118, 118, 4, 2, 12, 12, 22, 22, 4, 2, 169, 169, 509, 509, 3, 2, 514, 519, 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, 243, 243, 251, 251, 267, 267, 270, 271, 281, 281, 295, 295, 309, 309, 315, 315, 321, 321, 325, 326, 335, 335, 362, 362, 435, 436, 479, 479, 492, 504, 506, 506, 508, 520, 522, 522, 2, 12263, 2, 1634, 3, 2, 2, 2, 4, 1636, 3, 2, 2, 2, 6, 1644, 3, 2, 2, 2, 8, 1771, 3, 2, 2, 2, 10, 1773, 3, 2, 2, 2, 12, 1777, 3, 2, 2, 2, 14, 1780, 3, 2, 2, 2, 16, 1788, 3, 2, 2, 2, 18, 1793, 3, 2, 2, 2, 20, 1799, 3, 2, 2, 2, 22, 1824, 3, 2, 2, 2, 24, 1836, 3, 2, 2, 2, 26, 1838, 3, 2, 2, 2, 28, 1846, 3, 2, 2, 2, 30, 1858, 3, 2, 2, 2, 32, 1860, 3, 2, 2, 2, 34, 1869, 3, 2, 2, 2, 36, 1877, 3, 2, 2, 2, 38, 1885, 3, 2, 2, 2, 40, 1892, 3, 2, 2, 2, 42, 1894, 3, 2, 2, 2, 44, 1911, 3, 2, 2, 2, 46, 1916, 3, 2, 2, 2, 48, 1925, 3, 2, 2, 2, 50, 1927, 3, 2, 2, 2, 52, 1941, 3, 2, 2, 2, 54, 1943, 3, 2, 2, 2, 56, 1974, 3, 2, 2, 2, 58, 1976, 3, 2, 2, 2, 60, 1984, 3, 2, 2, 2, 62, 1994, 3, 2, 2, 2, 64, 2001, 3, 2, 2, 2, 66, 2007, 3, 2, 2, 2, 68, 2025, 3, 2, 2, 2, 70, 2029, 3, 2, 2, 2, 72, 2033, 3, 2, 2, 2, 74, 2035, 3, 2, 2, 2, 76, 2046, 3, 2, 2, 2, 78, 2050, 3, 2, 2, 2, 80, 2055, 3, 2, 2, 2, 82, 2060, 3, 2, 2, 2, 84, 2062, 3, 2, 2, 2, 86, 2074, 3, 2, 2, 2, 88, 2081, 3, 2, 2, 2, 90, 2083, 3, 2, 2, 2, 92, 2085, 3, 2, 2, 2, 94, 2087, 3, 2, 2, 2, 96, 2202, 3, 2, 2, 2, 98, 2204, 3, 2, 2, 2, 100, 2220, 3, 2, 2, 2, 102, 2222, 3, 2, 2, 2, 104, 2524, 3, 2, 2, 2, 106, 2531, 3, 2, 2, 2, 108, 2533, 3, 2, 2, 2, 110, 2535, 3, 2, 2, 2, 112, 2538, 3, 2, 2, 2, 114, 2547, 3, 2, 2, 2, 116, 2549, 3, 2, 2, 2, 118, 2553, 3, 2, 2, 2, 120, 2556, 3, 2, 2, 2, 122, 2564, 3, 2, 2, 2, 124, 2576, 3, 2, 2, 2, 126, 2593, 3, 2, 2, 2, 128, 2621, 3, 2, 2, 2, 130, 2623, 3, 2, 2, 2, 132, 2626, 3, 2, 2, 2, 134, 2634, 3, 2, 2, 2, 136, 2639, 3, 2, 2, 2, 138, 2677, 3, 2, 2, 2, 140, 2679, 3, 2, 2, 2, 142, 2721, 3, 2, 2, 2, 144, 2723, 3, 2, 2, 2, 146, 2725, 3, 2, 2, 2, 148, 2730, 3, 2, 2, 2, 150, 2737, 3, 2, 2, 2, 152, 2742, 3, 2, 2, 2, 154, 2784, 3, 2, 2, 2, 156, 2786, 3, 2, 2, 2, 158, 2789, 3, 2, 2, 2, 160, 2794, 3, 2, 2, 2, 162, 2796, 3, 2, 2, 2, 164, 2804, 3, 2, 2, 2, 166, 2815, 3, 2, 2, 2, 168, 2817, 3, 2, 2, 2, 170, 2825, 3, 2, 2, 2, 172, 2827, 3, 2, 2, 2, 174, 2912, 3, 2, 2, 2, 176, 2914, 3, 2, 2, 2, 178, 2916, 3, 2, 2, 2, 180, 2918, 3, 2, 2, 2, 182, 2922, 3, 2, 2, 2, 184, 2930, 3, 2, 2, 2, 186, 2941, 3, 2, 2, 2, 188, 2945, 3, 2, 2, 2, 190, 2947, 3, 2, 2, 2, 192, 2958, 3, 2, 2, 2, 194, 2968, 3, 2, 2, 2, 196, 2989, 3, 2, 2, 2, 198, 3043, 3, 2, 2, 2, 200, 3048, 3, 2, 2, 2, 202, 3053, 3, 2, 2, 2, 204, 3055, 3, 2, 2, 2, 206, 3058, 3, 2, 2, 2, 208, 3066, 3, 2, 2, 2, 210, 3069, 3, 2, 2, 2, 212, 3076, 3, 2, 2, 2, 214, 3164, 3, 2, 2, 2, 216, 3166, 3, 2, 2, 2, 218, 3169, 3, 2, 2, 2, 220, 3173, 3, 2, 2, 2, 222, 3181, 3, 2, 2, 2, 224, 3183, 3, 2, 2, 2, 226, 3188, 3, 2, 2, 2, 228, 3191, 3, 2, 2, 2, 230, 3199, 3, 2, 2, 2, 232, 3209, 3, 2, 2, 2, 234, 3222, 3, 2, 2, 2, 236, 3224, 3, 2, 2, 2, 238, 3228, 3, 2, 2, 2, 240, 3238, 3, 2, 2, 2, 242, 3240, 3, 2, 2, 2, 244, 3245, 3, 2, 2, 2, 246, 3247, 3, 2, 2, 2, 248, 3254, 3, 2, 2, 2, 250, 3285, 3, 2, 2, 2, 252, 3287, 3, 2, 2, 2, 254, 3296, 3, 2, 2, 2, 256, 3298, 3, 2, 2, 2, 258, 3307, 3, 2, 2, 2, 260, 3310, 3, 2, 2, 2, 262, 3315, 3, 2, 2, 2, 264, 3319, 3, 2, 2, 2, 266, 3335, 3, 2, 2, 2, 268, 3346, 3, 2, 2, 2, 270, 3362, 3, 2, 2, 2, 272, 3378, 3, 2, 2, 2, 274, 3384, 3, 2, 2, 2, 276, 3401, 3, 2, 2, 2, 278, 3414, 3, 2, 2, 2, 280, 3416, 3, 2, 2, 2, 282, 3426, 3, 2, 2, 2, 284, 3440, 3, 2, 2, 2, 286, 3449, 3, 2, 2, 2, 288, 3451, 3, 2, 2, 2, 290, 3456, 3, 2, 2, 2, 292, 3494, 3, 2, 2, 2, 294, 3496, 3, 2, 2, 2, 296, 3504, 3, 2, 2, 2, 298, 3506, 3, 2, 2, 2, 300, 3514, 3, 2, 2, 2, 302, 3536, 3, 2, 2, 2, 304, 3538, 3, 2, 2, 2, 306, 3542, 3, 2, 2, 2, 308, 3549, 3, 2, 2, 2, 310, 3551, 3, 2, 2, 2, 312, 3553, 3, 2, 2, 2, 314, 3555, 3, 2, 2, 2, 316, 3566, 3, 2, 2, 2, 318, 3569, 3, 2, 2, 2, 320, 3577, 3, 2, 2, 2, 322, 3593, 3, 2, 2, 2, 324, 3603, 3, 2, 2, 2, 326, 3605, 3, 2, 2, 2, 328, 3614, 3, 2, 2, 2, 330, 3617, 3, 2, 2, 2, 332, 3724, 3, 2, 2, 2, 334, 3726, 3, 2, 2, 2, 336, 3745, 3, 2, 2, 2, 338, 3748, 3, 2, 2, 2, 340, 3752, 3, 2, 2, 2, 342, 3771, 3, 2, 2, 2, 344, 3773, 3, 2, 2, 2, 346, 3778, 3, 2, 2, 2, 348, 3786, 3, 2, 2, 2, 350, 3791, 3, 2, 2, 2, 352, 3806, 3, 2, 2, 2, 354, 3808, 3, 2, 2, 2, 356, 3811, 3, 2, 2, 2, 358, 3813, 3, 2, 2, 2, 360, 3850, 3, 2, 2, 2, 362, 3852, 3, 2, 2, 2, 364, 3855, 3, 2, 2, 2, 366, 3860, 3, 2, 2, 2, 368, 3862, 3, 2, 2, 2, 370, 3944, 3, 2, 2, 2, 372, 3946, 3, 2, 2, 2, 374, 3964, 3, 2, 2, 2, 376, 3966, 3, 2, 2, 2, 378, 3994, 3, 2, 2, 2, 380, 3998, 3, 2, 2, 2, 382, 4018, 3, 2, 2, 2, 384, 4020, 3, 2, 2, 2, 386, 4029, 3, 2, 2, 2, 388, 4049, 3, 2, 2, 2, 390, 4063, 3, 2, 2, 2, 392, 4068, 3, 2, 2, 2, 394, 4074, 3, 2, 2, 2, 396, 4077, 3, 2, 2, 2, 398, 4080, 3, 2, 2, 2, 400, 4083, 3, 2, 2, 2, 402, 4086, 3, 2, 2, 2, 404, 4088, 3, 2, 2, 2, 406, 4097, 3, 2, 2, 2, 408, 4149, 3, 2, 2, 2, 410, 4155, 3, 2, 2, 2, 412, 4157, 3, 2, 2, 2, 414, 4163, 3, 2, 2, 2, 416, 4165, 3, 2, 2, 2, 418, 4180, 3, 2, 2, 2, 420, 4182, 3, 2, 2, 2, 422, 4186, 3, 2, 2, 2, 424, 4190, 3, 2, 2, 2, 426, 4197, 3, 2, 2, 2, 428, 4199, 3, 2, 2, 2, 430, 4201, 3, 2, 2, 2, 432, 4203, 3, 2, 2, 2, 434, 4209, 3, 2, 2, 2, 436, 4211, 3, 2, 2, 2, 438, 4213, 3, 2, 2, 2, 440, 4218, 3, 2, 2, 2, 442, 4222, 3, 2, 2, 2, 444, 4235, 3, 2, 2, 2, 446, 4237, 3, 2, 2, 2, 448, 4243, 3, 2, 2, 2, 450, 4257, 3, 2, 2, 2, 452, 4285, 3, 2, 2, 2, 454, 4287, 3, 2, 2, 2, 456, 4295, 3, 2, 2, 2, 458, 4301, 3, 2, 2, 2, 460, 4309, 3, 2, 2, 2, 462, 4321, 3, 2, 2, 2, 464, 4323, 3, 2, 2, 2, 466, 4446, 3, 2, 2, 2, 468, 4448, 3, 2, 2, 2, 470, 4452, 3, 2, 2, 2, 472, 4460, 3, 2, 2, 2, 474, 4471, 3, 2, 2, 2, 476, 4473, 3, 2, 2, 2, 478, 4477, 3, 2, 2, 2, 480, 4485, 3, 2, 2, 2, 482, 4489, 3, 2, 2, 2, 484, 4491, 3, 2, 2, 2, 486, 4542, 3, 2, 2, 2, 488, 4544, 3, 2, 2, 2, 490, 4548, 3, 2, 2, 2, 492, 4566, 3, 2, 2, 2, 494, 4605, 3, 2, 2, 2, 496, 4607, 3, 2, 2, 2, 498, 4609, 3, 2, 2, 2, 500, 4618, 3, 2, 2, 2, 502, 4620, 3, 2, 2, 2, 504, 4622, 3, 2, 2, 2, 506, 4647, 3, 2, 2, 2, 508, 4649, 3, 2, 2, 2, 510, 4669, 3, 2, 2, 2, 512, 4691, 3, 2, 2, 2, 514, 4713, 3, 2, 2, 2, 516, 4715, 3, 2, 2, 2, 518, 4722, 3, 2, 2, 2, 520, 4819, 3, 2, 2, 2, 522, 4844, 3, 2, 2, 2, 524, 4851, 3, 2, 2, 2, 526, 4868, 3, 2, 2, 2, 528, 4870, 3, 2, 2, 2, 530, 4872, 3, 2, 2, 2, 532, 4880, 3, 2, 2, 2, 534, 4886, 3, 2, 2, 2, 536, 4890, 3, 2, 2, 2, 538, 4898, 3, 2, 2, 2, 540, 4913, 3, 2, 2, 2, 542, 5062, 3, 2, 2, 2, 544, 5066, 3, 2, 2, 2, 546, 5179, 3, 2, 2, 2, 548, 5181, 3, 2, 2, 2, 550, 5186, 3, 2, 2, 2, 552, 5192, 3, 2, 2, 2, 554, 5279, 3, 2, 2, 2, 556, 5281, 3, 2, 2, 2, 558, 5283, 3, 2, 2, 2, 560, 5285, 3, 2, 2, 2, 562, 5315, 3, 2, 2, 2, 564, 5333, 3, 2, 2, 2, 566, 5335, 3, 2, 2, 2, 568, 5343, 3, 2, 2, 2, 570, 5345, 3, 2, 2, 2, 572, 5369, 3, 2, 2, 2, 574, 5429, 3, 2, 2, 2, 576, 5431, 3, 2, 2, 2, 578, 5442, 3, 2, 2, 2, 580, 5444, 3, 2, 2, 2, 582, 5448, 3, 2, 2, 2, 584, 5481, 3, 2, 2, 2, 586, 5483, 3, 2, 2, 2, 588, 5487, 3, 2, 2, 2, 590, 5491, 3, 2, 2, 2, 592, 5500, 3, 2, 2, 2, 594, 5512, 3, 2, 2, 2, 596, 5544, 3, 2, 2, 2, 598, 5546, 3, 2, 2, 2, 600, 5611, 3, 2, 2, 2, 602, 5613, 3, 2, 2, 2, 604, 5615, 3, 2, 2, 2, 606, 5617, 3, 2, 2, 2, 608, 5619, 3, 2, 2, 2, 610, 5622, 3, 2, 2, 2, 612, 5653, 3, 2, 2, 2, 614, 5666, 3, 2, 2, 2, 616, 5668, 3, 2, 2, 2, 618, 5673, 3, 2, 2, 2, 620, 5681, 3, 2, 2, 2, 622, 5684, 3, 2, 2, 2, 624, 5686, 3, 2, 2, 2, 626, 5692, 3, 2, 2, 2, 628, 5694, 3, 2, 2, 2, 630, 5717, 3, 2, 2, 2, 632, 5728, 3, 2, 2, 2, 634, 5731, 3, 2, 2, 2, 636, 5737, 3, 2, 2, 2, 638, 5745, 3, 2, 2, 2, 640, 5761, 3, 2, 2, 2, 642, 5763, 3, 2, 2, 2, 644, 5769, 3, 2, 2, 2, 646, 5790, 3, 2, 2, 2, 648, 5799, 3, 2, 2, 2, 650, 5801, 3, 2, 2, 2, 652, 5803, 3, 2, 2, 2, 654, 5817, 3, 2, 2, 2, 656, 5819, 3, 2, 2, 2, 658, 5824, 3, 2, 2, 2, 660, 5826, 3, 2, 2, 2, 662, 5841, 3, 2, 2, 2, 664, 5849, 3, 2, 2, 2, 666, 5852, 3, 2, 2, 2, 668, 5861, 3, 2, 2, 2, 670, 5900, 3, 2, 2, 2, 672, 5910, 3, 2, 2, 2, 674, 5917, 3, 2, 2, 2, 676, 5919, 3, 2, 2, 2, 678, 5931, 3, 2, 2, 2, 680, 5934, 3, 2, 2, 2, 682, 5937, 3, 2, 2, 2, 684, 5945, 3, 2, 2, 2, 686, 5953, 3, 2, 2, 2, 688, 5957, 3, 2, 2, 2, 690, 6001, 3, 2, 2, 2, 692, 6017, 3, 2, 2, 2, 694, 6033, 3, 2, 2, 2, 696, 6057, 3, 2, 2, 2, 698, 6064, 3, 2, 2, 2, 700, 6069, 3, 2, 2, 2, 702, 6077, 3, 2, 2, 2, 704, 6080, 3, 2, 2, 2, 706, 6084, 3, 2, 2, 2, 708, 6091, 3, 2, 2, 2, 710, 6130, 3, 2, 2, 2, 712, 6136, 3, 2, 2, 2, 714, 6138, 3, 2, 2, 2, 716, 6151, 3, 2, 2, 2, 718, 6154, 3, 2, 2, 2, 720, 6201, 3, 2, 2, 2, 722, 6203, 3, 2, 2, 2, 724, 6249, 3, 2, 2, 2, 726, 6251, 3, 2, 2, 2, 728, 6253, 3, 2, 2, 2, 730, 6255, 3, 2, 2, 2, 732, 6263, 3, 2, 2, 2, 734, 6277, 3, 2, 2, 2, 736, 6766, 3, 2, 2, 2, 738, 6768, 3, 2, 2, 2, 740, 6770, 3, 2, 2, 2, 742, 6842, 3, 2, 2, 2, 744, 6844, 3, 2, 2, 2, 746, 7063, 3, 2, 2, 2, 748, 7065, 3, 2, 2, 2, 750, 7073, 3, 2, 2, 2, 752, 7089, 3, 2, 2, 2, 754, 7096, 3, 2, 2, 2, 756, 7098, 3, 2, 2, 2, 758, 7291, 3, 2, 2, 2, 760, 7293, 3, 2, 2, 2, 762, 7302, 3, 2, 2, 2, 764, 7310, 3, 2, 2, 2, 766, 7339, 3, 2, 2, 2, 768, 7341, 3, 2, 2, 2, 770, 7351, 3, 2, 2, 2, 772, 7359, 3, 2, 2, 2, 774, 7400, 3, 2, 2, 2, 776, 7416, 3, 2, 2, 2, 778, 7418, 3, 2, 2, 2, 780, 7444, 3, 2, 2, 2, 782, 7447, 3, 2, 2, 2, 784, 7463, 3, 2, 2, 2, 786, 7465, 3, 2, 2, 2, 788, 7467, 3, 2, 2, 2, 790, 7469, 3, 2, 2, 2, 792, 7471, 3, 2, 2, 2, 794, 7476, 3, 2, 2, 2, 796, 7479, 3, 2, 2, 2, 798, 7486, 3, 2, 2, 2, 800, 7557, 3, 2, 2, 2, 802, 7559, 3, 2, 2, 2, 804, 7571, 3, 2, 2, 2, 806, 7573, 3, 2, 2, 2, 808, 7583, 3, 2, 2, 2, 810, 7585, 3, 2, 2, 2, 812, 7591, 3, 2, 2, 2, 814, 7623, 3, 2, 2, 2, 816, 7630, 3, 2, 2, 2, 818, 7633, 3, 2, 2, 2, 820, 7642, 3, 2, 2, 2, 822, 7645, 3, 2, 2, 2, 824, 7649, 3, 2, 2, 2, 826, 7666, 3, 2, 2, 2, 828, 7668, 3, 2, 2, 2, 830, 7670, 3, 2, 2, 2, 832, 7685, 3, 2, 2, 2, 834, 7690, 3, 2, 2, 2, 836, 7706, 3, 2, 2, 2, 838, 7714, 3, 2, 2, 2, 840, 7716, 3, 2, 2, 2, 842, 7722, 3, 2, 2, 2, 844, 7727, 3, 2, 2, 2, 846, 7736, 3, 2, 2, 2, 848, 7763, 3, 2, 2, 2, 850, 7765, 3, 2, 2, 2, 852, 7844, 3, 2, 2, 2, 854, 7846, 3, 2, 2, 2, 856, 7848, 3, 2, 2, 2, 858, 7881, 3, 2, 2, 2, 860, 7883, 3, 2, 2, 2, 862, 7909, 3, 2, 2, 2, 864, 7925, 3, 2, 2, 2, 866, 7927, 3, 2, 2, 2, 868, 7935, 3, 2, 2, 2, 870, 7937, 3, 2, 2, 2, 872, 7943, 3, 2, 2, 2, 874, 7947, 3, 2, 2, 2, 876, 7949, 3, 2, 2, 2, 878, 7951, 3, 2, 2, 2, 880, 7953, 3, 2, 2, 2, 882, 7955, 3, 2, 2, 2, 884, 7957, 3, 2, 2, 2, 886, 7961, 3, 2, 2, 2, 888, 7965, 3, 2, 2, 2, 890, 7973, 3, 2, 2, 2, 892, 7993, 3, 2, 2, 2, 894, 8004, 3, 2, 2, 2, 896, 8006, 3, 2, 2, 2, 898, 8014, 3, 2, 2, 2, 900, 8020, 3, 2, 2, 2, 902, 8024, 3, 2, 2, 2, 904, 8026, 3, 2, 2, 2, 906, 8034, 3, 2, 2, 2, 908, 8042, 3, 2, 2, 2, 910, 8082, 3, 2, 2, 2, 912, 8084, 3, 2, 2, 2, 914, 8098, 3, 2, 2, 2, 916, 8101, 3, 2, 2, 2, 918, 8113, 3, 2, 2, 2, 920, 8137, 3, 2, 2, 2, 922, 8139, 3, 2, 2, 2, 924, 8141, 3, 2, 2, 2, 926, 8149, 3, 2, 2, 2, 928, 8152, 3, 2, 2, 2, 930, 8176, 3, 2, 2, 2, 932, 8178, 3, 2, 2, 2, 934, 8182, 3, 2, 2, 2, 936, 8196, 3, 2, 2, 2, 938, 8199, 3, 2, 2, 2, 940, 8210, 3, 2, 2, 2, 942, 8226, 3, 2, 2, 2, 944, 8228, 3, 2, 2, 2, 946, 8233, 3, 2, 2, 2, 948, 8236, 3, 2, 2, 2, 950, 8251, 3, 2, 2, 2, 952, 8269, 3, 2, 2, 2, 954, 8271, 3, 2, 2, 2, 956, 8274, 3, 2, 2, 2, 958, 8282, 3, 2, 2, 2, 960, 8290, 3, 2, 2, 2, 962, 8299, 3, 2, 2, 2, 964, 8307, 3, 2, 2, 2, 966, 8311, 3, 2, 2, 2, 968, 8321, 3, 2, 2, 2, 970, 8352, 3, 2, 2, 2, 972, 8356, 3, 2, 2, 2, 974, 8403, 3, 2, 2, 2, 976, 8418, 3, 2, 2, 2, 978, 8420, 3, 2, 2, 2, 980, 8424, 3, 2, 2, 2, 982, 8430, 3, 2, 2, 2, 984, 8438, 3, 2, 2, 2, 986, 8453, 3, 2, 2, 2, 988, 8455, 3, 2, 2, 2, 990, 8457, 3, 2, 2, 2, 992, 8466, 3, 2, 2, 2, 994, 8484, 3, 2, 2, 2, 996, 8486, 3, 2, 2, 2, 998, 8488, 3, 2, 2, 2, 1000, 8490, 3, 2, 2, 2, 1002, 8498, 3, 2, 2, 2, 1004, 8500, 3, 2, 2, 2, 1006, 8502, 3, 2, 2, 2, 1008, 8506, 3, 2, 2, 2, 1010, 8514, 3, 2, 2, 2, 1012, 8531, 3, 2, 2, 2, 1014, 8533, 3, 2, 2, 2, 1016, 8558, 3, 2, 2, 2, 1018, 8560, 3, 2, 2, 2, 1020, 8569, 3, 2, 2, 2, 1022, 8571, 3, 2, 2, 2, 1024, 8578, 3, 2, 2, 2, 1026, 8582, 3, 2, 2, 2, 1028, 8584, 3, 2, 2, 2, 1030, 8586, 3, 2, 2, 2, 1032, 8588, 3, 2, 2, 2, 1034, 8592, 3, 2, 2, 2, 1036, 8605, 3, 2, 2, 2, 1038, 8607, 3, 2, 2, 2, 1040, 8610, 3, 2, 2, 2, 1042, 8615, 3, 2, 2, 2, 1044, 8620, 3, 2, 2, 2, 1046, 8626, 3, 2, 2, 2, 1048, 8633, 3, 2, 2, 2, 1050, 8635, 3, 2, 2, 2, 1052, 8638, 3, 2, 2, 2, 1054, 8642, 3, 2, 2, 2, 1056, 8649, 3, 2, 2, 2, 1058, 8661, 3, 2, 2, 2, 1060, 8664, 3, 2, 2, 2, 1062, 8678, 3, 2, 2, 2, 1064, 8681, 3, 2, 2, 2, 1066, 8747, 3, 2, 2, 2, 1068, 8771, 3, 2, 2, 2, 1070, 8780, 3, 2, 2, 2, 1072, 8794, 3, 2, 2, 2, 1074, 8796, 3, 2, 2, 2, 1076, 8807, 3, 2, 2, 2, 1078, 8824, 3, 2, 2, 2, 1080, 8826, 3, 2, 2, 2, 1082, 8834, 3, 2, 2, 2, 1084, 8841, 3, 2, 2, 2, 1086, 8849, 3, 2, 2, 2, 1088, 8866, 3, 2, 2, 2, 1090, 8868, 3, 2, 2, 2, 1092, 8872, 3, 2, 2, 2, 1094, 8880, 3, 2, 2, 2, 1096, 8885, 3, 2, 2, 2, 1098, 8888, 3, 2, 2, 2, 1100, 8891, 3, 2, 2, 2, 1102, 8898, 3, 2, 2, 2, 1104, 8900, 3, 2, 2, 2, 1106, 8908, 3, 2, 2, 2, 1108, 8913, 3, 2, 2, 2, 1110, 8934, 3, 2, 2, 2, 1112, 8942, 3, 2, 2, 2, 1114, 8952, 3, 2, 2, 2, 1116, 8964, 3, 2, 2, 2, 1118, 8966, 3, 2, 2, 2, 1120, 8980, 3, 2, 2, 2, 1122, 9000, 3, 2, 2, 2, 1124, 9009, 3, 2, 2, 2, 1126, 9027, 3, 2, 2, 2, 1128, 9033, 3, 2, 2, 2, 1130, 9035, 3, 2, 2, 2, 1132, 9042, 3, 2, 2, 2, 1134, 9070, 3, 2, 2, 2, 1136, 9072, 3, 2, 2, 2, 1138, 9078, 3, 2, 2, 2, 1140, 9082, 3, 2, 2, 2, 1142, 9084, 3, 2, 2, 2, 1144, 9092, 3, 2, 2, 2, 1146, 9096, 3, 2, 2, 2, 1148, 9103, 3, 2, 2, 2, 1150, 9120, 3, 2, 2, 2, 1152, 9122, 3, 2, 2, 2, 1154, 9124, 3, 2, 2, 2, 1156, 9134, 3, 2, 2, 2, 1158, 9142, 3, 2, 2, 2, 1160, 9169, 3, 2, 2, 2, 1162, 9171, 3, 2, 2, 2, 1164, 9178, 3, 2, 2, 2, 1166, 9181, 3, 2, 2, 2, 1168, 9183, 3, 2, 2, 2, 1170, 9187, 3, 2, 2, 2, 1172, 9195, 3, 2, 2, 2, 1174, 9203, 3, 2, 2, 2, 1176, 9211, 3, 2, 2, 2, 1178, 9220, 3, 2, 2, 2, 1180, 9224, 3, 2, 2, 2, 1182, 9228, 3, 2, 2, 2, 1184, 9254, 3, 2, 2, 2, 1186, 9268, 3, 2, 2, 2, 1188, 9288, 3, 2, 2, 2, 1190, 9298, 3, 2, 2, 2, 1192, 9302, 3, 2, 2, 2, 1194, 9310, 3, 2, 2, 2, 1196, 9318, 3, 2, 2, 2, 1198, 9324, 3, 2, 2, 2, 1200, 9328, 3, 2, 2, 2, 1202, 9335, 3, 2, 2, 2, 1204, 9340, 3, 2, 2, 2, 1206, 9355, 3, 2, 2, 2, 1208, 9435, 3, 2, 2, 2, 1210, 9437, 3, 2, 2, 2, 1212, 9439, 3, 2, 2, 2, 1214, 9477, 3, 2, 2, 2, 1216, 9481, 3, 2, 2, 2, 1218, 9667, 3, 2, 2, 2, 1220, 9674, 3, 2, 2, 2, 1222, 9686, 3, 2, 2, 2, 1224, 9688, 3, 2, 2, 2, 1226, 9693, 3, 2, 2, 2, 1228, 9701, 3, 2, 2, 2, 1230, 9706, 3, 2, 2, 2, 1232, 9712, 3, 2, 2, 2, 1234, 9729, 3, 2, 2, 2, 1236, 9731, 3, 2, 2, 2, 1238, 9734, 3, 2, 2, 2, 1240, 9740, 3, 2, 2, 2, 1242, 9746, 3, 2, 2, 2, 1244, 9749, 3, 2, 2, 2, 1246, 9757, 3, 2, 2, 2, 1248, 9761, 3, 2, 2, 2, 1250, 9766, 3, 2, 2, 2, 1252, 9781, 3, 2, 2, 2, 1254, 9783, 3, 2, 2, 2, 1256, 9802, 3, 2, 2, 2, 1258, 9810, 3, 2, 2, 2, 1260, 9819, 3, 2, 2, 2, 1262, 9821, 3, 2, 2, 2, 1264, 9842, 3, 2, 2, 2, 1266, 9844, 3, 2, 2, 2, 1268, 9851, 3, 2, 2, 2, 1270, 9857, 3, 2, 2, 2, 1272, 9861, 3, 2, 2, 2, 1274, 9863, 3, 2, 2, 2, 1276, 9871, 3, 2, 2, 2, 1278, 9879, 3, 2, 2, 2, 1280, 9893, 3, 2, 2, 2, 1282, 9895, 3, 2, 2, 2, 1284, 9903, 3, 2, 2, 2, 1286, 9916, 3, 2, 2, 2, 1288, 9918, 3, 2, 2, 2, 1290, 9926, 3, 2, 2, 2, 1292, 9933, 3, 2, 2, 2, 1294, 9941, 3, 2, 2, 2, 1296, 9953, 3, 2, 2, 2, 1298, 9955, 3, 2, 2, 2, 1300, 9957, 3, 2, 2, 2, 1302, 9966, 3, 2, 2, 2, 1304, 9997, 3, 2, 2, 2, 1306, 10006, 3, 2, 2, 2, 1308, 10013, 3, 2, 2, 2, 1310, 10015, 3, 2, 2, 2, 1312, 10026, 3, 2, 2, 2, 1314, 10030, 3, 2, 2, 2, 1316, 10035, 3, 2, 2, 2, 1318, 10038, 3, 2, 2, 2, 1320, 10040, 3, 2, 2, 2, 1322, 10061, 3, 2, 2, 2, 1324, 10063, 3, 2, 2, 2, 1326, 10066, 3, 2, 2, 2, 1328, 10073, 3, 2, 2, 2, 1330, 10076, 3, 2, 2, 2, 1332, 10078, 3, 2, 2, 2, 1334, 10094, 3, 2, 2, 2, 1336, 10096, 3, 2, 2, 2, 1338, 10104, 3, 2, 2, 2, 1340, 10108, 3, 2, 2, 2, 1342, 10112, 3, 2, 2, 2, 1344, 10120, 3, 2, 2, 2, 1346, 10122, 3, 2, 2, 2, 1348, 10124, 3, 2, 2, 2, 1350, 10130, 3, 2, 2, 2, 1352, 10167, 3, 2, 2, 2, 1354, 10169, 3, 2, 2, 2, 1356, 10171, 3, 2, 2, 2, 1358, 10173, 3, 2, 2, 2, 1360, 10175, 3, 2, 2, 2, 1362, 10177, 3, 2, 2, 2, 1364, 10192, 3, 2, 2, 2, 1366, 10194, 3, 2, 2, 2, 1368, 10202, 3, 2, 2, 2, 1370, 10204, 3, 2, 2, 2, 1372, 10206, 3, 2, 2, 2, 1374, 10212, 3, 2, 2, 2, 1376, 10214, 3, 2, 2, 2, 1378, 10226, 3, 2, 2, 2, 1380, 10228, 3, 2, 2, 2, 1382, 10242, 3, 2, 2, 2, 1384, 10246, 3, 2, 2, 2, 1386, 10251, 3, 2, 2, 2, 1388, 10258, 3, 2, 2, 2, 1390, 10264, 3, 2, 2, 2, 1392, 10272, 3, 2, 2, 2, 1394, 10283, 3, 2, 2, 2, 1396, 10285, 3, 2, 2, 2, 1398, 10287, 3, 2, 2, 2, 1400, 10340, 3, 2, 2, 2, 1402, 10342, 3, 2, 2, 2, 1404, 10344, 3, 2, 2, 2, 1406, 10346, 3, 2, 2, 2, 1408, 10353, 3, 2, 2, 2, 1410, 10376, 3, 2, 2, 2, 1412, 10378, 3, 2, 2, 2, 1414, 10384, 3, 2, 2, 2, 1416, 10388, 3, 2, 2, 2, 1418, 10390, 3, 2, 2, 2, 1420, 10397, 3, 2, 2, 2, 1422, 10404, 3, 2, 2, 2, 1424, 10407, 3, 2, 2, 2, 1426, 10411, 3, 2, 2, 2, 1428, 10418, 3, 2, 2, 2, 1430, 10420, 3, 2, 2, 2, 1432, 10444, 3, 2, 2, 2, 1434, 10446, 3, 2, 2, 2, 1436, 10453, 3, 2, 2, 2, 1438, 10455, 3, 2, 2, 2, 1440, 10463, 3, 2, 2, 2, 1442, 10466, 3, 2, 2, 2, 1444, 10470, 3, 2, 2, 2, 1446, 10472, 3, 2, 2, 2, 1448, 10476, 3, 2, 2, 2, 1450, 10478, 3, 2, 2, 2, 1452, 10483, 3, 2, 2, 2, 1454, 10488, 3, 2, 2, 2, 1456, 10494, 3, 2, 2, 2, 1458, 10498, 3, 2, 2, 2, 1460, 10500, 3, 2, 2, 2, 1462, 10505, 3, 2, 2, 2, 1464, 10535, 3, 2, 2, 2, 1466, 10537, 3, 2, 2, 2, 1468, 10555, 3, 2, 2, 2, 1470, 10559, 3, 2, 2, 2, 1472, 10561, 3, 2, 2, 2, 1474, 10566, 3, 2, 2, 2, 1476, 10575, 3, 2, 2, 2, 1478, 10577, 3, 2, 2, 2, 1480, 10585, 3, 2, 2, 2, 1482, 10589, 3, 2, 2, 2, 1484, 10591, 3, 2, 2, 2, 1486, 10595, 3, 2, 2, 2, 1488, 10606, 3, 2, 2, 2, 1490, 10623, 3, 2, 2, 2, 1492, 10629, 3, 2, 2, 2, 1494, 10631, 3, 2, 2, 2, 1496, 10641, 3, 2, 2, 2, 1498, 10644, 3, 2, 2, 2, 1500, 10648, 3, 2, 2, 2, 1502, 10656, 3, 2, 2, 2, 1504, 10658, 3, 2, 2, 2, 1506, 10661, 3, 2, 2, 2, 1508, 10666, 3, 2, 2, 2, 1510, 10671, 3, 2, 2, 2, 1512, 10693, 3, 2, 2, 2, 1514, 10707, 3, 2, 2, 2, 1516, 10711, 3, 2, 2, 2, 1518, 10716, 3, 2, 2, 2, 1520, 10718, 3, 2, 2, 2, 1522, 10720, 3, 2, 2, 2, 1524, 10732, 3, 2, 2, 2, 1526, 10734, 3, 2, 2, 2, 1528, 10741, 3, 2, 2, 2, 1530, 10743, 3, 2, 2, 2, 1532, 10761, 3, 2, 2, 2, 1534, 10797, 3, 2, 2, 2, 1536, 10799, 3, 2, 2, 2, 1538, 10808, 3, 2, 2, 2, 1540, 10813, 3, 2, 2, 2, 1542, 10815, 3, 2, 2, 2, 1544, 10819, 3, 2, 2, 2, 1546, 10827, 3, 2, 2, 2, 1548, 10835, 3, 2, 2, 2, 1550, 10837, 3, 2, 2, 2, 1552, 10844, 3, 2, 2, 2, 1554, 10847, 3, 2, 2, 2, 1556, 10863, 3, 2, 2, 2, 1558, 10865, 3, 2, 2, 2, 1560, 10879, 3, 2, 2, 2, 1562, 10881, 3, 2, 2, 2, 1564, 10908, 3, 2, 2, 2, 1566, 10910, 3, 2, 2, 2, 1568, 10921, 3, 2, 2, 2, 1570, 10927, 3, 2, 2, 2, 1572, 10931, 3, 2, 2, 2, 1574, 10933, 3, 2, 2, 2, 1576, 10943, 3, 2, 2, 2, 1578, 10948, 3, 2, 2, 2, 1580, 10965, 3, 2, 2, 2, 1582, 10967, 3, 2, 2, 2, 1584, 10974, 3, 2, 2, 2, 1586, 10978, 3, 2, 2, 2, 1588, 10981, 3, 2, 2, 2, 1590, 10987, 3, 2, 2, 2, 1592, 10993, 3, 2, 2, 2, 1594, 11011, 3, 2, 2, 2, 1596, 11015, 3, 2, 2, 2, 1598, 11020, 3, 2, 2, 2, 1600, 11023, 3, 2, 2, 2, 1602, 11027, 3, 2, 2, 2, 1604, 11032, 3, 2, 2, 2, 1606, 11043, 3, 2, 2, 2, 1608, 11047, 3, 2, 2, 2, 1610, 11051, 3, 2, 2, 2, 1612, 11055, 3, 2, 2, 2, 1614, 11057, 3, 2, 2, 2, 1616, 11062, 3, 2, 2, 2, 1618, 11064, 3, 2, 2, 2, 1620, 11067, 3, 2, 2, 2, 1622, 11087, 3, 2, 2, 2, 1624, 11089, 3, 2, 2, 2, 1626, 11091, 3, 2, 2, 2, 1628, 11093, 3, 2, 2, 2, 1630, 11095, 3, 2, 2, 2, 1632, 11099, 3, 2, 2, 2, 1634, 1635, 5, 6, 4, 2, 1635, 3, 3, 2, 2, 2, 1636, 1637, 5, 1406, 704, 2, 1637, 5, 3, 2, 2, 2, 1638, 1640, 5, 8, 5, 2, 1639, 1641, 7, 9, 2, 2, 1640, 1639, 3, 2, 2, 2, 1640, 1641, 3, 2, 2, 2, 1641, 1643, 3, 2, 2, 2, 1642, 1638, 3, 2, 2, 2, 1643, 1646, 3, 2, 2, 2, 1644, 1642, 3, 2, 2, 2, 1644, 1645, 3, 2, 2, 2, 1645, 7, 3, 2, 2, 2, 1646, 1644, 3, 2, 2, 2, 1647, 1772, 5, 460, 231, 2, 1648, 1772, 5, 840, 421, 2, 1649, 1772, 5, 830, 416, 2, 1650, 1772, 5, 832, 417, 2, 1651, 1772, 5, 590, 296, 2, 1652, 1772, 5, 846, 424, 2, 1653, 1772, 5, 486, 244, 2, 1654, 1772, 5, 326, 164, 2, 1655, 1772, 5, 332, 167, 2, 1656, 1772, 5, 342, 172, 2, 1657, 1772, 5, 368, 185, 2, 1658, 1772, 5, 684, 343, 2, 1659, 1772, 5, 38, 20, 2, 1660, 1772, 5, 742, 372, 2, 1661, 1772, 5, 746, 374, 2, 1662, 1772, 5, 758, 380, 2, 1663, 1772, 5, 748, 375, 2, 1664, 1772, 5, 756, 379, 2, 1665, 1772, 5, 388, 195, 2, 1666, 1772, 5, 284, 143, 2, 1667, 1772, 5, 842, 422, 2, 1668, 1772, 5, 96, 49, 2, 1669, 1772, 5, 734, 368, 2, 1670, 1772, 5, 134, 68, 2, 1671, 1772, 5, 766, 384, 2, 1672, 1772, 5, 32, 17, 2, 1673, 1772, 5, 28, 15, 2, 1674, 1772, 5, 774, 388, 2, 1675, 1772, 5, 266, 134, 2, 1676, 1772, 5, 852, 427, 2, 1677, 1772, 5, 850, 426, 2, 1678, 1772, 5, 384, 193, 2, 1679, 1772, 5, 864, 433, 2, 1680, 1772, 5, 12, 7, 2, 1681, 1772, 5, 92, 47, 2, 1682, 1772, 5, 140, 71, 2, 1683, 1772, 5, 858, 430, 2, 1684, 1772, 5, 542, 272, 2, 1685, 1772, 5, 86, 44, 2, 1686, 1772, 5, 142, 72, 2, 1687, 1772, 5, 404, 203, 2, 1688, 1772, 5, 268, 135, 2, 1689, 1772, 5, 464, 233, 2, 1690, 1772, 5, 710, 356, 2, 1691, 1772, 5, 856, 429, 2, 1692, 1772, 5, 844, 423, 2, 1693, 1772, 5, 320, 161, 2, 1694, 1772, 5, 334, 168, 2, 1695, 1772, 5, 360, 181, 2, 1696, 1772, 5, 370, 186, 2, 1697, 1772, 5, 628, 315, 2, 1698, 1772, 5, 36, 19, 2, 1699, 1772, 5, 274, 138, 2, 1700, 1772, 5, 490, 246, 2, 1701, 1772, 5, 504, 253, 2, 1702, 1772, 5, 760, 381, 2, 1703, 1772, 5, 506, 254, 2, 1704, 1772, 5, 386, 194, 2, 1705, 1772, 5, 300, 151, 2, 1706, 1772, 5, 42, 22, 2, 1707, 1772, 5, 282, 142, 2, 1708, 1772, 5, 172, 87, 2, 1709, 1772, 5, 768, 385, 2, 1710, 1772, 5, 264, 133, 2, 1711, 1772, 5, 314, 158, 2, 1712, 1772, 5, 718, 360, 2, 1713, 1772, 5, 408, 205, 2, 1714, 1772, 5, 452, 227, 2, 1715, 1772, 5, 14, 8, 2, 1716, 1772, 5, 26, 14, 2, 1717, 1772, 5, 378, 190, 2, 1718, 1772, 5, 818, 410, 2, 1719, 1772, 5, 914, 458, 2, 1720, 1772, 5, 958, 480, 2, 1721, 1772, 5, 466, 234, 2, 1722, 1772, 5, 934, 468, 2, 1723, 1772, 5, 94, 48, 2, 1724, 1772, 5, 704, 353, 2, 1725, 1772, 5, 714, 358, 2, 1726, 1772, 5, 512, 257, 2, 1727, 1772, 5, 514, 258, 2, 1728, 1772, 5, 516, 259, 2, 1729, 1772, 5, 520, 261, 2, 1730, 1772, 5, 776, 389, 2, 1731, 1772, 5, 318, 160, 2, 1732, 1772, 5, 722, 362, 2, 1733, 1772, 5, 34, 18, 2, 1734, 1772, 5, 382, 192, 2, 1735, 1772, 5, 834, 418, 2, 1736, 1772, 5, 910, 456, 2, 1737, 1772, 5, 892, 447, 2, 1738, 1772, 5, 552, 277, 2, 1739, 1772, 5, 560, 281, 2, 1740, 1772, 5, 582, 292, 2, 1741, 1772, 5, 372, 187, 2, 1742, 1772, 5, 600, 301, 2, 1743, 1772, 5, 916, 459, 2, 1744, 1772, 5, 796, 399, 2, 1745, 1772, 5, 280, 141, 2, 1746, 1772, 5, 816, 409, 2, 1747, 1772, 5, 938, 470, 2, 1748, 1772, 5, 792, 397, 2, 1749, 1772, 5, 904, 453, 2, 1750, 1772, 5, 518, 260, 2, 1751, 1772, 5, 724, 363, 2, 1752, 1772, 5, 692, 347, 2, 1753, 1772, 5, 690, 346, 2, 1754, 1772, 5, 694, 348, 2, 1755, 1772, 5, 736, 369, 2, 1756, 1772, 5, 562, 282, 2, 1757, 1772, 5, 584, 293, 2, 1758, 1772, 5, 778, 390, 2, 1759, 1772, 5, 546, 274, 2, 1760, 1772, 5, 966, 484, 2, 1761, 1772, 5, 800, 401, 2, 1762, 1772, 5, 538, 270, 2, 1763, 1772, 5, 798, 400, 2, 1764, 1772, 5, 948, 475, 2, 1765, 1772, 5, 862, 432, 2, 1766, 1772, 5, 74, 38, 2, 1767, 1772, 5, 50, 26, 2, 1768, 1772, 5, 84, 43, 2, 1769, 1772, 5, 812, 407, 2, 1770, 1772, 5, 10, 6, 2, 1771, 1647, 3, 2, 2, 2, 1771, 1648, 3, 2, 2, 2, 1771, 1649, 3, 2, 2, 2, 1771, 1650, 3, 2, 2, 2, 1771, 1651, 3, 2, 2, 2, 1771, 1652, 3, 2, 2, 2, 1771, 1653, 3, 2, 2, 2, 1771, 1654, 3, 2, 2, 2, 1771, 1655, 3, 2, 2, 2, 1771, 1656, 3, 2, 2, 2, 1771, 1657, 3, 2, 2, 2, 1771, 1658, 3, 2, 2, 2, 1771, 1659, 3, 2, 2, 2, 1771, 1660, 3, 2, 2, 2, 1771, 1661, 3, 2, 2, 2, 1771, 1662, 3, 2, 2, 2, 1771, 1663, 3, 2, 2, 2, 1771, 1664, 3, 2, 2, 2, 1771, 1665, 3, 2, 2, 2, 1771, 1666, 3, 2, 2, 2, 1771, 1667, 3, 2, 2, 2, 1771, 1668, 3, 2, 2, 2, 1771, 1669, 3, 2, 2, 2, 1771, 1670, 3, 2, 2, 2, 1771, 1671, 3, 2, 2, 2, 1771, 1672, 3, 2, 2, 2, 1771, 1673, 3, 2, 2, 2, 1771, 1674, 3, 2, 2, 2, 1771, 1675, 3, 2, 2, 2, 1771, 1676, 3, 2, 2, 2, 1771, 1677, 3, 2, 2, 2, 1771, 1678, 3, 2, 2, 2, 1771, 1679, 3, 2, 2, 2, 1771, 1680, 3, 2, 2, 2, 1771, 1681, 3, 2, 2, 2, 1771, 1682, 3, 2, 2, 2, 1771, 1683, 3, 2, 2, 2, 1771, 1684, 3, 2, 2, 2, 1771, 1685, 3, 2, 2, 2, 1771, 1686, 3, 2, 2, 2, 1771, 1687, 3, 2, 2, 2, 1771, 1688, 3, 2, 2, 2, 1771, 1689, 3, 2, 2, 2, 1771, 1690, 3, 2, 2, 2, 1771, 1691, 3, 2, 2, 2, 1771, 1692, 3, 2, 2, 2, 1771, 1693, 3, 2, 2, 2, 1771, 1694, 3, 2, 2, 2, 1771, 1695, 3, 2, 2, 2, 1771, 1696, 3, 2, 2, 2, 1771, 1697, 3, 2, 2, 2, 1771, 1698, 3, 2, 2, 2, 1771, 1699, 3, 2, 2, 2, 1771, 1700, 3, 2, 2, 2, 1771, 1701, 3, 2, 2, 2, 1771, 1702, 3, 2, 2, 2, 1771, 1703, 3, 2, 2, 2, 1771, 1704, 3, 2, 2, 2, 1771, 1705, 3, 2, 2, 2, 1771, 1706, 3, 2, 2, 2, 1771, 1707, 3, 2, 2, 2, 1771, 1708, 3, 2, 2, 2, 1771, 1709, 3, 2, 2, 2, 1771, 1710, 3, 2, 2, 2, 1771, 1711, 3, 2, 2, 2, 1771, 1712, 3, 2, 2, 2, 1771, 1713, 3, 2, 2, 2, 1771, 1714, 3, 2, 2, 2, 1771, 1715, 3, 2, 2, 2, 1771, 1716, 3, 2, 2, 2, 1771, 1717, 3, 2, 2, 2, 1771, 1718, 3, 2, 2, 2, 1771, 1719, 3, 2, 2, 2, 1771, 1720, 3, 2, 2, 2, 1771, 1721, 3, 2, 2, 2, 1771, 1722, 3, 2, 2, 2, 1771, 1723, 3, 2, 2, 2, 1771, 1724, 3, 2, 2, 2, 1771, 1725, 3, 2, 2, 2, 1771, 1726, 3, 2, 2, 2, 1771, 1727, 3, 2, 2, 2, 1771, 1728, 3, 2, 2, 2, 1771, 1729, 3, 2, 2, 2, 1771, 1730, 3, 2, 2, 2, 1771, 1731, 3, 2, 2, 2, 1771, 1732, 3, 2, 2, 2, 1771, 1733, 3, 2, 2, 2, 1771, 1734, 3, 2, 2, 2, 1771, 1735, 3, 2, 2, 2, 1771, 1736, 3, 2, 2, 2, 1771, 1737, 3, 2, 2, 2, 1771, 1738, 3, 2, 2, 2, 1771, 1739, 3, 2, 2, 2, 1771, 1740, 3, 2, 2, 2, 1771, 1741, 3, 2, 2, 2, 1771, 1742, 3, 2, 2, 2, 1771, 1743, 3, 2, 2, 2, 1771, 1744, 3, 2, 2, 2, 1771, 1745, 3, 2, 2, 2, 1771, 1746, 3, 2, 2, 2, 1771, 1747, 3, 2, 2, 2, 1771, 1748, 3, 2, 2, 2, 1771, 1749, 3, 2, 2, 2, 1771, 1750, 3, 2, 2, 2, 1771, 1751, 3, 2, 2, 2, 1771, 1752, 3, 2, 2, 2, 1771, 1753, 3, 2, 2, 2, 1771, 1754, 3, 2, 2, 2, 1771, 1755, 3, 2, 2, 2, 1771, 1756, 3, 2, 2, 2, 1771, 1757, 3, 2, 2, 2, 1771, 1758, 3, 2, 2, 2, 1771, 1759, 3, 2, 2, 2, 1771, 1760, 3, 2, 2, 2, 1771, 1761, 3, 2, 2, 2, 1771, 1762, 3, 2, 2, 2, 1771, 1763, 3, 2, 2, 2, 1771, 1764, 3, 2, 2, 2, 1771, 1765, 3, 2, 2, 2, 1771, 1766, 3, 2, 2, 2, 1771, 1767, 3, 2, 2, 2, 1771, 1768, 3, 2, 2, 2, 1771, 1769, 3, 2, 2, 2, 1771, 1770, 3, 2, 2, 2, 1772, 9, 3, 2, 2, 2, 1773, 1775, 7, 559, 2, 2, 1774, 1776, 7, 560, 2, 2, 1775, 1774, 3, 2, 2, 2, 1775, 1776, 3, 2, 2, 2, 1776, 11, 3, 2, 2, 2, 1777, 1778, 7, 435, 2, 2, 1778, 1779, 5, 1212, 607, 2, 1779, 13, 3, 2, 2, 2, 1780, 1781, 7, 48, 2, 2, 1781, 1782, 7, 320, 2, 2, 1782, 1784, 5, 1372, 687, 2, 1783, 1785, 5, 16, 9, 2, 1784, 1783, 3, 2, 2, 2, 1784, 1785, 3, 2, 2, 2, 1785, 1786, 3, 2, 2, 2, 1786, 1787, 5, 18, 10, 2, 1787, 15, 3, 2, 2, 2, 1788, 1789, 7, 107, 2, 2, 1789, 17, 3, 2, 2, 2, 1790, 1792, 5, 24, 13, 2, 1791, 1790, 3, 2, 2, 2, 1792, 1795, 3, 2, 2, 2, 1793, 1791, 3, 2, 2, 2, 1793, 1794, 3, 2, 2, 2, 1794, 19, 3, 2, 2, 2, 1795, 1793, 3, 2, 2, 2, 1796, 1798, 5, 22, 12, 2, 1797, 1796, 3, 2, 2, 2, 1798, 1801, 3, 2, 2, 2, 1799, 1797, 3, 2, 2, 2, 1799, 1800, 3, 2, 2, 2, 1800, 21, 3, 2, 2, 2, 1801, 1799, 3, 2, 2, 2, 1802, 1805, 7, 289, 2, 2, 1803, 1806, 5, 1362, 682, 2, 1804, 1806, 7, 80, 2, 2, 1805, 1803, 3, 2, 2, 2, 1805, 1804, 3, 2, 2, 2, 1806, 1825, 3, 2, 2, 2, 1807, 1808, 9, 2, 2, 2, 1808, 1809, 7, 289, 2, 2, 1809, 1825, 5, 1362, 682, 2, 1810, 1825, 9, 3, 2, 2, 1811, 1825, 9, 4, 2, 2, 1812, 1825, 9, 5, 2, 2, 1813, 1825, 9, 6, 2, 2, 1814, 1825, 9, 7, 2, 2, 1815, 1816, 7, 166, 2, 2, 1816, 1817, 7, 76, 2, 2, 1817, 1825, 5, 1368, 685, 2, 1818, 1819, 7, 373, 2, 2, 1819, 1820, 7, 370, 2, 2, 1820, 1825, 5, 1362, 682, 2, 1821, 1822, 7, 101, 2, 2, 1822, 1825, 5, 1376, 689, 2, 1823, 1825, 5, 1394, 698, 2, 1824, 1802, 3, 2, 2, 2, 1824, 1807, 3, 2, 2, 2, 1824, 1810, 3, 2, 2, 2, 1824, 1811, 3, 2, 2, 2, 1824, 1812, 3, 2, 2, 2, 1824, 1813, 3, 2, 2, 2, 1824, 1814, 3, 2, 2, 2, 1824, 1815, 3, 2, 2, 2, 1824, 1818, 3, 2, 2, 2, 1824, 1821, 3, 2, 2, 2, 1824, 1823, 3, 2, 2, 2, 1825, 23, 3, 2, 2, 2, 1826, 1837, 5, 22, 12, 2, 1827, 1828, 7, 350, 2, 2, 1828, 1837, 5, 1360, 681, 2, 1829, 1830, 7, 136, 2, 2, 1830, 1837, 5, 1376, 689, 2, 1831, 1832, 7, 320, 2, 2, 1832, 1837, 5, 1376, 689, 2, 1833, 1834, 7, 70, 2, 2, 1834, 1835, 9, 8, 2, 2, 1835, 1837, 5, 1376, 689, 2, 1836, 1826, 3, 2, 2, 2, 1836, 1827, 3, 2, 2, 2, 1836, 1829, 3, 2, 2, 2, 1836, 1831, 3, 2, 2, 2, 1836, 1833, 3, 2, 2, 2, 1837, 25, 3, 2, 2, 2, 1838, 1839, 7, 48, 2, 2, 1839, 1840, 7, 101, 2, 2, 1840, 1842, 5, 1372, 687, 2, 1841, 1843, 5, 16, 9, 2, 1842, 1841, 3, 2, 2, 2, 1842, 1843, 3, 2, 2, 2, 1843, 1844, 3, 2, 2, 2, 1844, 1845, 5, 18, 10, 2, 1845, 27, 3, 2, 2, 2, 1846, 1847, 7, 140, 2, 2, 1847, 1848, 9, 9, 2, 2, 1848, 1850, 5, 1374, 688, 2, 1849, 1851, 5, 16, 9, 2, 1850, 1849, 3, 2, 2, 2, 1850, 1851, 3, 2, 2, 2, 1851, 1852, 3, 2, 2, 2, 1852, 1853, 5, 20, 11, 2, 1853, 29, 3, 2, 2, 2, 1854, 1859, 3, 2, 2, 2, 1855, 1856, 7, 70, 2, 2, 1856, 1857, 7, 177, 2, 2, 1857, 1859, 5, 1344, 673, 2, 1858, 1854, 3, 2, 2, 2, 1858, 1855, 3, 2, 2, 2, 1859, 31, 3, 2, 2, 2, 1860, 1861, 7, 140, 2, 2, 1861, 1864, 9, 9, 2, 2, 1862, 1865, 7, 32, 2, 2, 1863, 1865, 5, 1374, 688, 2, 1864, 1862, 3, 2, 2, 2, 1864, 1863, 3, 2, 2, 2, 1865, 1866, 3, 2, 2, 2, 1866, 1867, 5, 30, 16, 2, 1867, 1868, 5, 80, 41, 2, 1868, 33, 3, 2, 2, 2, 1869, 1870, 7, 193, 2, 2, 1870, 1873, 9, 10, 2, 2, 1871, 1872, 7, 222, 2, 2, 1872, 1874, 7, 398, 2, 2, 1873, 1871, 3, 2, 2, 2, 1873, 1874, 3, 2, 2, 2, 1874, 1875, 3, 2, 2, 2, 1875, 1876, 5, 1376, 689, 2, 1876, 35, 3, 2, 2, 2, 1877, 1878, 7, 48, 2, 2, 1878, 1879, 7, 68, 2, 2, 1879, 1881, 5, 1370, 686, 2, 1880, 1882, 5, 16, 9, 2, 1881, 1880, 3, 2, 2, 2, 1881, 1882, 3, 2, 2, 2, 1882, 1883, 3, 2, 2, 2, 1883, 1884, 5, 18, 10, 2, 1884, 37, 3, 2, 2, 2, 1885, 1886, 7, 140, 2, 2, 1886, 1887, 7, 68, 2, 2, 1887, 1888, 5, 1374, 688, 2, 1888, 1889, 5, 40, 21, 2, 1889, 1890, 7, 101, 2, 2, 1890, 1891, 5, 1376, 689, 2, 1891, 39, 3, 2, 2, 2, 1892, 1893, 9, 11, 2, 2, 1893, 41, 3, 2, 2, 2, 1894, 1895, 7, 48, 2, 2, 1895, 1899, 7, 325, 2, 2, 1896, 1897, 7, 222, 2, 2, 1897, 1898, 7, 79, 2, 2, 1898, 1900, 7, 398, 2, 2, 1899, 1896, 3, 2, 2, 2, 1899, 1900, 3, 2, 2, 2, 1900, 1907, 3, 2, 2, 2, 1901, 1903, 5, 44, 23, 2, 1902, 1901, 3, 2, 2, 2, 1902, 1903, 3, 2, 2, 2, 1903, 1904, 3, 2, 2, 2, 1904, 1905, 7, 108, 2, 2, 1905, 1908, 5, 1374, 688, 2, 1906, 1908, 5, 1378, 690, 2, 1907, 1902, 3, 2, 2, 2, 1907, 1906, 3, 2, 2, 2, 1908, 1909, 3, 2, 2, 2, 1909, 1910, 5, 46, 24, 2, 1910, 43, 3, 2, 2, 2, 1911, 1912, 5, 1378, 690, 2, 1912, 45, 3, 2, 2, 2, 1913, 1915, 5, 48, 25, 2, 1914, 1913, 3, 2, 2, 2, 1915, 1918, 3, 2, 2, 2, 1916, 1914, 3, 2, 2, 2, 1916, 1917, 3, 2, 2, 2, 1917, 47, 3, 2, 2, 2, 1918, 1916, 3, 2, 2, 2, 1919, 1926, 5, 172, 87, 2, 1920, 1926, 5, 600, 301, 2, 1921, 1926, 5, 282, 142, 2, 1922, 1926, 5, 408, 205, 2, 1923, 1926, 5, 560, 281, 2, 1924, 1926, 5, 812, 407, 2, 1925, 1919, 3, 2, 2, 2, 1925, 1920, 3, 2, 2, 2, 1925, 1921, 3, 2, 2, 2, 1925, 1922, 3, 2, 2, 2, 1925, 1923, 3, 2, 2, 2, 1925, 1924, 3, 2, 2, 2, 1926, 49, 3, 2, 2, 2, 1927, 1929, 7, 335, 2, 2, 1928, 1930, 9, 12, 2, 2, 1929, 1928, 3, 2, 2, 2, 1929, 1930, 3, 2, 2, 2, 1930, 1931, 3, 2, 2, 2, 1931, 1932, 5, 52, 27, 2, 1932, 51, 3, 2, 2, 2, 1933, 1934, 7, 358, 2, 2, 1934, 1942, 5, 806, 404, 2, 1935, 1936, 7, 334, 2, 2, 1936, 1937, 7, 156, 2, 2, 1937, 1938, 7, 38, 2, 2, 1938, 1939, 7, 358, 2, 2, 1939, 1942, 5, 806, 404, 2, 1940, 1942, 5, 56, 29, 2, 1941, 1933, 3, 2, 2, 2, 1941, 1935, 3, 2, 2, 2, 1941, 1940, 3, 2, 2, 2, 1942, 53, 3, 2, 2, 2, 1943, 1944, 5, 58, 30, 2, 1944, 1945, 9, 13, 2, 2, 1945, 1946, 5, 60, 31, 2, 1946, 55, 3, 2, 2, 2, 1947, 1975, 5, 54, 28, 2, 1948, 1949, 5, 58, 30, 2, 1949, 1950, 7, 66, 2, 2, 1950, 1951, 7, 436, 2, 2, 1951, 1975, 3, 2, 2, 2, 1952, 1953, 7, 420, 2, 2, 1953, 1954, 7, 388, 2, 2, 1954, 1975, 5, 68, 35, 2, 1955, 1956, 7, 154, 2, 2, 1956, 1975, 5, 1362, 682, 2, 1957, 1958, 7, 325, 2, 2, 1958, 1975, 5, 1362, 682, 2, 1959, 1961, 7, 269, 2, 2, 1960, 1962, 5, 70, 36, 2, 1961, 1960, 3, 2, 2, 2, 1961, 1962, 3, 2, 2, 2, 1962, 1975, 3, 2, 2, 2, 1963, 1964, 7, 320, 2, 2, 1964, 1975, 5, 72, 37, 2, 1965, 1966, 7, 334, 2, 2, 1966, 1967, 7, 108, 2, 2, 1967, 1975, 5, 72, 37, 2, 1968, 1969, 7, 385, 2, 2, 1969, 1970, 7, 281, 2, 2, 1970, 1975, 5, 1230, 616, 2, 1971, 1972, 7, 358, 2, 2, 1972, 1973, 7, 339, 2, 2, 1973, 1975, 5, 1362, 682, 2, 1974, 1947, 3, 2, 2, 2, 1974, 1948, 3, 2, 2, 2, 1974, 1952, 3, 2, 2, 2, 1974, 1955, 3, 2, 2, 2, 1974, 1957, 3, 2, 2, 2, 1974, 1959, 3, 2, 2, 2, 1974, 1963, 3, 2, 2, 2, 1974, 1965, 3, 2, 2, 2, 1974, 1968, 3, 2, 2, 2, 1974, 1971, 3, 2, 2, 2, 1975, 57, 3, 2, 2, 2, 1976, 1981, 5, 1378, 690, 2, 1977, 1978, 7, 13, 2, 2, 1978, 1980, 5, 1378, 690, 2, 1979, 1977, 3, 2, 2, 2, 1980, 1983, 3, 2, 2, 2, 1981, 1979, 3, 2, 2, 2, 1981, 1982, 3, 2, 2, 2, 1982, 59, 3, 2, 2, 2, 1983, 1981, 3, 2, 2, 2, 1984, 1989, 5, 62, 32, 2, 1985, 1986, 7, 8, 2, 2, 1986, 1988, 5, 62, 32, 2, 1987, 1985, 3, 2, 2, 2, 1988, 1991, 3, 2, 2, 2, 1989, 1987, 3, 2, 2, 2, 1989, 1990, 3, 2, 2, 2, 1990, 61, 3, 2, 2, 2, 1991, 1989, 3, 2, 2, 2, 1992, 1995, 5, 66, 34, 2, 1993, 1995, 5, 296, 149, 2, 1994, 1992, 3, 2, 2, 2, 1994, 1993, 3, 2, 2, 2, 1995, 63, 3, 2, 2, 2, 1996, 1997, 7, 302, 2, 2, 1997, 2002, 9, 14, 2, 2, 1998, 1999, 7, 312, 2, 2, 1999, 2002, 7, 302, 2, 2, 2000, 2002, 7, 332, 2, 2, 2001, 1996, 3, 2, 2, 2, 2001, 1998, 3, 2, 2, 2, 2001, 2000, 3, 2, 2, 2, 2002, 65, 3, 2, 2, 2, 2003, 2008, 7, 98, 2, 2, 2004, 2008, 7, 62, 2, 2, 2005, 2008, 7, 82, 2, 2, 2006, 2008, 5, 72, 37, 2, 2007, 2003, 3, 2, 2, 2, 2007, 2004, 3, 2, 2, 2, 2007, 2005, 3, 2, 2, 2, 2007, 2006, 3, 2, 2, 2, 2008, 67, 3, 2, 2, 2, 2009, 2026, 5, 1362, 682, 2, 2010, 2026, 5, 1394, 698, 2, 2011, 2012, 5, 1156, 579, 2, 2012, 2014, 5, 1362, 682, 2, 2013, 2015, 5, 1160, 581, 2, 2014, 2013, 3, 2, 2, 2, 2014, 2015, 3, 2, 2, 2, 2015, 2026, 3, 2, 2, 2, 2016, 2017, 5, 1156, 579, 2, 2017, 2018, 7, 4, 2, 2, 2018, 2019, 5, 1360, 681, 2, 2019, 2020, 7, 5, 2, 2, 2020, 2021, 5, 1362, 682, 2, 2021, 2026, 3, 2, 2, 2, 2022, 2026, 5, 296, 149, 2, 2023, 2026, 7, 55, 2, 2, 2024, 2026, 7, 256, 2, 2, 2025, 2009, 3, 2, 2, 2, 2025, 2010, 3, 2, 2, 2, 2025, 2011, 3, 2, 2, 2, 2025, 2016, 3, 2, 2, 2, 2025, 2022, 3, 2, 2, 2, 2025, 2023, 3, 2, 2, 2, 2025, 2024, 3, 2, 2, 2, 2026, 69, 3, 2, 2, 2, 2027, 2030, 5, 1362, 682, 2, 2028, 2030, 7, 55, 2, 2, 2029, 2027, 3, 2, 2, 2, 2029, 2028, 3, 2, 2, 2, 2030, 71, 3, 2, 2, 2, 2031, 2034, 5, 1390, 696, 2, 2032, 2034, 5, 1362, 682, 2, 2033, 2031, 3, 2, 2, 2, 2033, 2032, 3, 2, 2, 2, 2034, 73, 3, 2, 2, 2, 2035, 2036, 7, 315, 2, 2, 2036, 2037, 5, 76, 39, 2, 2037, 75, 3, 2, 2, 2, 2038, 2047, 5, 78, 40, 2, 2039, 2040, 7, 420, 2, 2, 2040, 2047, 7, 388, 2, 2, 2041, 2042, 7, 358, 2, 2, 2042, 2043, 7, 246, 2, 2, 2043, 2047, 7, 253, 2, 2, 2044, 2045, 7, 334, 2, 2, 2045, 2047, 7, 108, 2, 2, 2046, 2038, 3, 2, 2, 2, 2046, 2039, 3, 2, 2, 2, 2046, 2041, 3, 2, 2, 2, 2046, 2044, 3, 2, 2, 2, 2047, 77, 3, 2, 2, 2, 2048, 2051, 5, 58, 30, 2, 2049, 2051, 7, 32, 2, 2, 2050, 2048, 3, 2, 2, 2, 2050, 2049, 3, 2, 2, 2, 2051, 79, 3, 2, 2, 2, 2052, 2053, 7, 335, 2, 2, 2053, 2056, 5, 52, 27, 2, 2054, 2056, 5, 74, 38, 2, 2055, 2052, 3, 2, 2, 2, 2055, 2054, 3, 2, 2, 2, 2056, 81, 3, 2, 2, 2, 2057, 2058, 7, 335, 2, 2, 2058, 2061, 5, 56, 29, 2, 2059, 2061, 5, 74, 38, 2, 2060, 2057, 3, 2, 2, 2, 2060, 2059, 3, 2, 2, 2, 2061, 83, 3, 2, 2, 2, 2062, 2072, 7, 337, 2, 2, 2063, 2073, 5, 58, 30, 2, 2064, 2065, 7, 420, 2, 2, 2065, 2073, 7, 388, 2, 2, 2066, 2067, 7, 358, 2, 2, 2067, 2068, 7, 246, 2, 2, 2068, 2073, 7, 253, 2, 2, 2069, 2070, 7, 334, 2, 2, 2070, 2073, 7, 108, 2, 2, 2071, 2073, 7, 32, 2, 2, 2072, 2063, 3, 2, 2, 2, 2072, 2064, 3, 2, 2, 2, 2072, 2066, 3, 2, 2, 2, 2072, 2069, 3, 2, 2, 2, 2072, 2071, 3, 2, 2, 2, 2073, 85, 3, 2, 2, 2, 2074, 2075, 7, 335, 2, 2, 2075, 2076, 7, 167, 2, 2, 2076, 2077, 5, 88, 45, 2, 2077, 2078, 5, 90, 46, 2, 2078, 87, 3, 2, 2, 2, 2079, 2082, 7, 32, 2, 2, 2080, 2082, 5, 1336, 669, 2, 2081, 2079, 3, 2, 2, 2, 2081, 2080, 3, 2, 2, 2, 2082, 89, 3, 2, 2, 2, 2083, 2084, 9, 15, 2, 2, 2084, 91, 3, 2, 2, 2, 2085, 2086, 7, 157, 2, 2, 2086, 93, 3, 2, 2, 2, 2087, 2088, 7, 189, 2, 2, 2088, 2089, 9, 16, 2, 2, 2089, 95, 3, 2, 2, 2, 2090, 2091, 7, 140, 2, 2, 2091, 2094, 7, 94, 2, 2, 2092, 2093, 7, 222, 2, 2, 2093, 2095, 7, 398, 2, 2, 2094, 2092, 3, 2, 2, 2, 2094, 2095, 3, 2, 2, 2, 2095, 2096, 3, 2, 2, 2, 2096, 2099, 5, 1078, 540, 2, 2097, 2100, 5, 98, 50, 2, 2098, 2100, 5, 100, 51, 2, 2099, 2097, 3, 2, 2, 2, 2099, 2098, 3, 2, 2, 2, 2100, 2203, 3, 2, 2, 2, 2101, 2102, 7, 140, 2, 2, 2102, 2103, 7, 94, 2, 2, 2103, 2104, 7, 32, 2, 2, 2104, 2105, 7, 70, 2, 2, 2105, 2106, 7, 353, 2, 2, 2106, 2110, 5, 1344, 673, 2, 2107, 2108, 7, 283, 2, 2, 2108, 2109, 7, 149, 2, 2, 2109, 2111, 5, 1376, 689, 2, 2110, 2107, 3, 2, 2, 2, 2110, 2111, 3, 2, 2, 2, 2111, 2112, 3, 2, 2, 2, 2112, 2113, 7, 335, 2, 2, 2113, 2114, 7, 353, 2, 2, 2114, 2116, 5, 1344, 673, 2, 2115, 2117, 5, 944, 473, 2, 2116, 2115, 3, 2, 2, 2, 2116, 2117, 3, 2, 2, 2, 2117, 2203, 3, 2, 2, 2, 2118, 2119, 7, 140, 2, 2, 2119, 2122, 7, 228, 2, 2, 2120, 2121, 7, 222, 2, 2, 2121, 2123, 7, 398, 2, 2, 2122, 2120, 3, 2, 2, 2, 2122, 2123, 3, 2, 2, 2, 2123, 2124, 3, 2, 2, 2, 2124, 2127, 5, 1340, 671, 2, 2125, 2128, 5, 98, 50, 2, 2126, 2128, 5, 102, 52, 2, 2127, 2125, 3, 2, 2, 2, 2127, 2126, 3, 2, 2, 2, 2128, 2203, 3, 2, 2, 2, 2129, 2130, 7, 140, 2, 2, 2130, 2131, 7, 228, 2, 2, 2131, 2132, 7, 32, 2, 2, 2132, 2133, 7, 70, 2, 2, 2133, 2134, 7, 353, 2, 2, 2134, 2138, 5, 1344, 673, 2, 2135, 2136, 7, 283, 2, 2, 2136, 2137, 7, 149, 2, 2, 2137, 2139, 5, 1376, 689, 2, 2138, 2135, 3, 2, 2, 2, 2138, 2139, 3, 2, 2, 2, 2139, 2140, 3, 2, 2, 2, 2140, 2141, 7, 335, 2, 2, 2141, 2142, 7, 353, 2, 2, 2142, 2144, 5, 1344, 673, 2, 2143, 2145, 5, 944, 473, 2, 2144, 2143, 3, 2, 2, 2, 2144, 2145, 3, 2, 2, 2, 2145, 2203, 3, 2, 2, 2, 2146, 2147, 7, 140, 2, 2, 2147, 2150, 7, 330, 2, 2, 2148, 2149, 7, 222, 2, 2, 2149, 2151, 7, 398, 2, 2, 2150, 2148, 3, 2, 2, 2, 2150, 2151, 3, 2, 2, 2, 2151, 2152, 3, 2, 2, 2, 2152, 2153, 5, 1340, 671, 2, 2153, 2154, 5, 98, 50, 2, 2154, 2203, 3, 2, 2, 2, 2155, 2156, 7, 140, 2, 2, 2156, 2159, 7, 378, 2, 2, 2157, 2158, 7, 222, 2, 2, 2158, 2160, 7, 398, 2, 2, 2159, 2157, 3, 2, 2, 2, 2159, 2160, 3, 2, 2, 2, 2160, 2161, 3, 2, 2, 2, 2161, 2162, 5, 1340, 671, 2, 2162, 2163, 5, 98, 50, 2, 2163, 2203, 3, 2, 2, 2, 2164, 2165, 7, 140, 2, 2, 2165, 2166, 7, 261, 2, 2, 2166, 2169, 7, 378, 2, 2, 2167, 2168, 7, 222, 2, 2, 2168, 2170, 7, 398, 2, 2, 2169, 2167, 3, 2, 2, 2, 2169, 2170, 3, 2, 2, 2, 2170, 2171, 3, 2, 2, 2, 2171, 2172, 5, 1340, 671, 2, 2172, 2173, 5, 98, 50, 2, 2173, 2203, 3, 2, 2, 2, 2174, 2175, 7, 140, 2, 2, 2175, 2176, 7, 261, 2, 2, 2176, 2177, 7, 378, 2, 2, 2177, 2178, 7, 32, 2, 2, 2178, 2179, 7, 70, 2, 2, 2179, 2180, 7, 353, 2, 2, 2180, 2184, 5, 1344, 673, 2, 2181, 2182, 7, 283, 2, 2, 2182, 2183, 7, 149, 2, 2, 2183, 2185, 5, 1376, 689, 2, 2184, 2181, 3, 2, 2, 2, 2184, 2185, 3, 2, 2, 2, 2185, 2186, 3, 2, 2, 2, 2186, 2187, 7, 335, 2, 2, 2187, 2188, 7, 353, 2, 2, 2188, 2190, 5, 1344, 673, 2, 2189, 2191, 5, 944, 473, 2, 2190, 2189, 3, 2, 2, 2, 2190, 2191, 3, 2, 2, 2, 2191, 2203, 3, 2, 2, 2, 2192, 2193, 7, 140, 2, 2, 2193, 2194, 7, 65, 2, 2, 2194, 2197, 7, 94, 2, 2, 2195, 2196, 7, 222, 2, 2, 2196, 2198, 7, 398, 2, 2, 2197, 2195, 3, 2, 2, 2, 2197, 2198, 3, 2, 2, 2, 2198, 2199, 3, 2, 2, 2, 2199, 2200, 5, 1078, 540, 2, 2200, 2201, 5, 98, 50, 2, 2201, 2203, 3, 2, 2, 2, 2202, 2090, 3, 2, 2, 2, 2202, 2101, 3, 2, 2, 2, 2202, 2118, 3, 2, 2, 2, 2202, 2129, 3, 2, 2, 2, 2202, 2146, 3, 2, 2, 2, 2202, 2155, 3, 2, 2, 2, 2202, 2164, 3, 2, 2, 2, 2202, 2174, 3, 2, 2, 2, 2202, 2192, 3, 2, 2, 2, 2203, 97, 3, 2, 2, 2, 2204, 2209, 5, 104, 53, 2, 2205, 2206, 7, 8, 2, 2, 2206, 2208, 5, 104, 53, 2, 2207, 2205, 3, 2, 2, 2, 2208, 2211, 3, 2, 2, 2, 2209, 2207, 3, 2, 2, 2, 2209, 2210, 3, 2, 2, 2, 2210, 99, 3, 2, 2, 2, 2211, 2209, 3, 2, 2, 2, 2212, 2213, 7, 437, 2, 2, 2213, 2214, 7, 287, 2, 2, 2214, 2215, 5, 1340, 671, 2, 2215, 2216, 5, 128, 65, 2, 2216, 2221, 3, 2, 2, 2, 2217, 2218, 7, 438, 2, 2, 2218, 2219, 7, 287, 2, 2, 2219, 2221, 5, 1340, 671, 2, 2220, 2212, 3, 2, 2, 2, 2220, 2217, 3, 2, 2, 2, 2221, 101, 3, 2, 2, 2, 2222, 2223, 7, 437, 2, 2, 2223, 2224, 7, 287, 2, 2, 2224, 2225, 5, 1340, 671, 2, 2225, 103, 3, 2, 2, 2, 2226, 2227, 7, 135, 2, 2, 2227, 2525, 5, 190, 96, 2, 2228, 2229, 7, 135, 2, 2, 2229, 2230, 7, 222, 2, 2, 2230, 2231, 7, 79, 2, 2, 2231, 2232, 7, 398, 2, 2, 2232, 2525, 5, 190, 96, 2, 2233, 2234, 7, 135, 2, 2, 2234, 2235, 7, 46, 2, 2, 2235, 2525, 5, 190, 96, 2, 2236, 2237, 7, 135, 2, 2, 2237, 2238, 7, 46, 2, 2, 2238, 2239, 7, 222, 2, 2, 2239, 2240, 7, 79, 2, 2, 2240, 2241, 7, 398, 2, 2, 2241, 2525, 5, 190, 96, 2, 2242, 2244, 7, 140, 2, 2, 2243, 2245, 5, 738, 370, 2, 2244, 2243, 3, 2, 2, 2, 2244, 2245, 3, 2, 2, 2, 2245, 2246, 3, 2, 2, 2, 2246, 2247, 5, 1378, 690, 2, 2247, 2248, 5, 106, 54, 2, 2248, 2525, 3, 2, 2, 2, 2249, 2251, 7, 140, 2, 2, 2250, 2252, 5, 738, 370, 2, 2251, 2250, 3, 2, 2, 2, 2251, 2252, 3, 2, 2, 2, 2252, 2253, 3, 2, 2, 2, 2253, 2254, 5, 1378, 690, 2, 2254, 2255, 7, 193, 2, 2, 2255, 2256, 7, 79, 2, 2, 2256, 2257, 7, 80, 2, 2, 2257, 2525, 3, 2, 2, 2, 2258, 2260, 7, 140, 2, 2, 2259, 2261, 5, 738, 370, 2, 2260, 2259, 3, 2, 2, 2, 2260, 2261, 3, 2, 2, 2, 2261, 2262, 3, 2, 2, 2, 2262, 2263, 5, 1378, 690, 2, 2263, 2264, 7, 335, 2, 2, 2264, 2265, 7, 79, 2, 2, 2265, 2266, 7, 80, 2, 2, 2266, 2525, 3, 2, 2, 2, 2267, 2269, 7, 140, 2, 2, 2268, 2270, 5, 738, 370, 2, 2269, 2268, 3, 2, 2, 2, 2269, 2270, 3, 2, 2, 2, 2270, 2271, 3, 2, 2, 2, 2271, 2272, 5, 1378, 690, 2, 2272, 2273, 7, 193, 2, 2, 2273, 2274, 7, 439, 2, 2, 2274, 2525, 3, 2, 2, 2, 2275, 2277, 7, 140, 2, 2, 2276, 2278, 5, 738, 370, 2, 2277, 2276, 3, 2, 2, 2, 2277, 2278, 3, 2, 2, 2, 2278, 2279, 3, 2, 2, 2, 2279, 2280, 5, 1378, 690, 2, 2280, 2281, 7, 193, 2, 2, 2281, 2282, 7, 439, 2, 2, 2282, 2283, 7, 222, 2, 2, 2283, 2284, 7, 398, 2, 2, 2284, 2525, 3, 2, 2, 2, 2285, 2287, 7, 140, 2, 2, 2286, 2288, 5, 738, 370, 2, 2287, 2286, 3, 2, 2, 2, 2287, 2288, 3, 2, 2, 2, 2288, 2289, 3, 2, 2, 2, 2289, 2290, 5, 1378, 690, 2, 2290, 2291, 7, 335, 2, 2, 2291, 2292, 7, 344, 2, 2, 2292, 2293, 5, 1368, 685, 2, 2293, 2525, 3, 2, 2, 2, 2294, 2296, 7, 140, 2, 2, 2295, 2297, 5, 738, 370, 2, 2296, 2295, 3, 2, 2, 2, 2296, 2297, 3, 2, 2, 2, 2297, 2298, 3, 2, 2, 2, 2298, 2299, 5, 1360, 681, 2, 2299, 2300, 7, 335, 2, 2, 2300, 2301, 7, 344, 2, 2, 2301, 2302, 5, 1368, 685, 2, 2302, 2525, 3, 2, 2, 2, 2303, 2305, 7, 140, 2, 2, 2304, 2306, 5, 738, 370, 2, 2305, 2304, 3, 2, 2, 2, 2305, 2306, 3, 2, 2, 2, 2306, 2307, 3, 2, 2, 2, 2307, 2308, 5, 1378, 690, 2, 2308, 2309, 7, 335, 2, 2, 2309, 2310, 5, 116, 59, 2, 2310, 2525, 3, 2, 2, 2, 2311, 2313, 7, 140, 2, 2, 2312, 2314, 5, 738, 370, 2, 2313, 2312, 3, 2, 2, 2, 2313, 2314, 3, 2, 2, 2, 2314, 2315, 3, 2, 2, 2, 2315, 2316, 5, 1378, 690, 2, 2316, 2317, 7, 315, 2, 2, 2317, 2318, 5, 116, 59, 2, 2318, 2525, 3, 2, 2, 2, 2319, 2321, 7, 140, 2, 2, 2320, 2322, 5, 738, 370, 2, 2321, 2320, 3, 2, 2, 2, 2321, 2322, 3, 2, 2, 2, 2322, 2323, 3, 2, 2, 2, 2323, 2324, 5, 1378, 690, 2, 2324, 2325, 7, 335, 2, 2, 2325, 2326, 7, 347, 2, 2, 2326, 2327, 5, 1378, 690, 2, 2327, 2525, 3, 2, 2, 2, 2328, 2330, 7, 140, 2, 2, 2329, 2331, 5, 738, 370, 2, 2330, 2329, 3, 2, 2, 2, 2330, 2331, 3, 2, 2, 2, 2331, 2332, 3, 2, 2, 2, 2332, 2333, 5, 1378, 690, 2, 2333, 2334, 7, 135, 2, 2, 2334, 2335, 7, 440, 2, 2, 2335, 2336, 5, 200, 101, 2, 2336, 2337, 7, 38, 2, 2, 2337, 2339, 7, 221, 2, 2, 2338, 2340, 5, 288, 145, 2, 2339, 2338, 3, 2, 2, 2, 2339, 2340, 3, 2, 2, 2, 2340, 2525, 3, 2, 2, 2, 2341, 2343, 7, 140, 2, 2, 2342, 2344, 5, 738, 370, 2, 2343, 2342, 3, 2, 2, 2, 2343, 2344, 3, 2, 2, 2, 2344, 2345, 3, 2, 2, 2, 2345, 2346, 5, 1378, 690, 2, 2346, 2347, 5, 124, 63, 2, 2347, 2525, 3, 2, 2, 2, 2348, 2350, 7, 140, 2, 2, 2349, 2351, 5, 738, 370, 2, 2350, 2349, 3, 2, 2, 2, 2350, 2351, 3, 2, 2, 2, 2351, 2352, 3, 2, 2, 2, 2352, 2353, 5, 1378, 690, 2, 2353, 2354, 7, 193, 2, 2, 2354, 2355, 7, 221, 2, 2, 2355, 2525, 3, 2, 2, 2, 2356, 2358, 7, 140, 2, 2, 2357, 2359, 5, 738, 370, 2, 2358, 2357, 3, 2, 2, 2, 2358, 2359, 3, 2, 2, 2, 2359, 2360, 3, 2, 2, 2, 2360, 2361, 5, 1378, 690, 2, 2361, 2362, 7, 193, 2, 2, 2362, 2363, 7, 221, 2, 2, 2363, 2364, 7, 222, 2, 2, 2364, 2365, 7, 398, 2, 2, 2365, 2525, 3, 2, 2, 2, 2366, 2368, 7, 193, 2, 2, 2367, 2369, 5, 738, 370, 2, 2368, 2367, 3, 2, 2, 2, 2368, 2369, 3, 2, 2, 2, 2369, 2370, 3, 2, 2, 2, 2370, 2371, 7, 222, 2, 2, 2371, 2372, 7, 398, 2, 2, 2372, 2374, 5, 1378, 690, 2, 2373, 2375, 5, 108, 55, 2, 2374, 2373, 3, 2, 2, 2, 2374, 2375, 3, 2, 2, 2, 2375, 2525, 3, 2, 2, 2, 2376, 2378, 7, 193, 2, 2, 2377, 2379, 5, 738, 370, 2, 2378, 2377, 3, 2, 2, 2, 2378, 2379, 3, 2, 2, 2, 2379, 2380, 3, 2, 2, 2, 2380, 2382, 5, 1378, 690, 2, 2381, 2383, 5, 108, 55, 2, 2382, 2381, 3, 2, 2, 2, 2382, 2383, 3, 2, 2, 2, 2383, 2525, 3, 2, 2, 2, 2384, 2386, 7, 140, 2, 2, 2385, 2387, 5, 738, 370, 2, 2386, 2385, 3, 2, 2, 2, 2386, 2387, 3, 2, 2, 2, 2387, 2388, 3, 2, 2, 2, 2388, 2390, 5, 1378, 690, 2, 2389, 2391, 5, 740, 371, 2, 2390, 2389, 3, 2, 2, 2, 2390, 2391, 3, 2, 2, 2, 2391, 2392, 3, 2, 2, 2, 2392, 2393, 7, 362, 2, 2, 2393, 2395, 5, 1122, 562, 2, 2394, 2396, 5, 110, 56, 2, 2395, 2394, 3, 2, 2, 2, 2395, 2396, 3, 2, 2, 2, 2396, 2398, 3, 2, 2, 2, 2397, 2399, 5, 112, 57, 2, 2398, 2397, 3, 2, 2, 2, 2398, 2399, 3, 2, 2, 2, 2399, 2525, 3, 2, 2, 2, 2400, 2402, 7, 140, 2, 2, 2401, 2403, 5, 738, 370, 2, 2402, 2401, 3, 2, 2, 2, 2402, 2403, 3, 2, 2, 2, 2403, 2404, 3, 2, 2, 2, 2404, 2405, 5, 1378, 690, 2, 2405, 2406, 5, 348, 175, 2, 2406, 2525, 3, 2, 2, 2, 2407, 2408, 7, 135, 2, 2, 2408, 2525, 5, 212, 107, 2, 2409, 2410, 7, 140, 2, 2, 2410, 2411, 7, 47, 2, 2, 2411, 2412, 5, 1344, 673, 2, 2412, 2413, 5, 448, 225, 2, 2413, 2525, 3, 2, 2, 2, 2414, 2415, 7, 374, 2, 2, 2415, 2416, 7, 47, 2, 2, 2416, 2525, 5, 1344, 673, 2, 2417, 2418, 7, 193, 2, 2, 2418, 2419, 7, 47, 2, 2, 2419, 2420, 7, 222, 2, 2, 2420, 2421, 7, 398, 2, 2, 2421, 2423, 5, 1344, 673, 2, 2422, 2424, 5, 108, 55, 2, 2423, 2422, 3, 2, 2, 2, 2423, 2424, 3, 2, 2, 2, 2424, 2525, 3, 2, 2, 2, 2425, 2426, 7, 193, 2, 2, 2426, 2427, 7, 47, 2, 2, 2427, 2429, 5, 1344, 673, 2, 2428, 2430, 5, 108, 55, 2, 2429, 2428, 3, 2, 2, 2, 2429, 2430, 3, 2, 2, 2, 2430, 2525, 3, 2, 2, 2, 2431, 2432, 7, 335, 2, 2, 2432, 2433, 7, 381, 2, 2, 2433, 2525, 7, 279, 2, 2, 2434, 2435, 7, 160, 2, 2, 2435, 2436, 7, 82, 2, 2, 2436, 2525, 5, 1344, 673, 2, 2437, 2438, 7, 335, 2, 2, 2438, 2439, 7, 381, 2, 2, 2439, 2525, 7, 160, 2, 2, 2440, 2441, 7, 335, 2, 2, 2441, 2525, 7, 441, 2, 2, 2442, 2443, 7, 335, 2, 2, 2443, 2525, 7, 369, 2, 2, 2444, 2445, 7, 195, 2, 2, 2445, 2446, 7, 359, 2, 2, 2446, 2525, 5, 1344, 673, 2, 2447, 2448, 7, 195, 2, 2, 2448, 2449, 7, 141, 2, 2, 2449, 2450, 7, 359, 2, 2, 2450, 2525, 5, 1344, 673, 2, 2451, 2452, 7, 195, 2, 2, 2452, 2453, 7, 314, 2, 2, 2453, 2454, 7, 359, 2, 2, 2454, 2525, 5, 1344, 673, 2, 2455, 2456, 7, 195, 2, 2, 2456, 2457, 7, 359, 2, 2, 2457, 2525, 7, 32, 2, 2, 2458, 2459, 7, 195, 2, 2, 2459, 2460, 7, 359, 2, 2, 2460, 2525, 7, 101, 2, 2, 2461, 2462, 7, 188, 2, 2, 2462, 2463, 7, 359, 2, 2, 2463, 2525, 5, 1344, 673, 2, 2464, 2465, 7, 188, 2, 2, 2465, 2466, 7, 359, 2, 2, 2466, 2525, 7, 32, 2, 2, 2467, 2468, 7, 188, 2, 2, 2468, 2469, 7, 359, 2, 2, 2469, 2525, 7, 101, 2, 2, 2470, 2471, 7, 195, 2, 2, 2471, 2472, 7, 323, 2, 2, 2472, 2525, 5, 1344, 673, 2, 2473, 2474, 7, 195, 2, 2, 2474, 2475, 7, 141, 2, 2, 2475, 2476, 7, 323, 2, 2, 2476, 2525, 5, 1344, 673, 2, 2477, 2478, 7, 195, 2, 2, 2478, 2479, 7, 314, 2, 2, 2479, 2480, 7, 323, 2, 2, 2480, 2525, 5, 1344, 673, 2, 2481, 2482, 7, 188, 2, 2, 2482, 2483, 7, 323, 2, 2, 2483, 2525, 5, 1344, 673, 2, 2484, 2485, 7, 230, 2, 2, 2485, 2525, 5, 1340, 671, 2, 2486, 2487, 7, 271, 2, 2, 2487, 2488, 7, 230, 2, 2, 2488, 2525, 5, 1340, 671, 2, 2489, 2490, 7, 277, 2, 2, 2490, 2525, 5, 532, 267, 2, 2491, 2492, 7, 79, 2, 2, 2492, 2525, 7, 277, 2, 2, 2493, 2494, 7, 284, 2, 2, 2494, 2495, 7, 96, 2, 2, 2495, 2525, 5, 1374, 688, 2, 2496, 2497, 7, 335, 2, 2, 2497, 2498, 7, 353, 2, 2, 2498, 2525, 5, 1344, 673, 2, 2499, 2500, 7, 335, 2, 2, 2500, 2525, 5, 116, 59, 2, 2501, 2502, 7, 315, 2, 2, 2502, 2525, 5, 116, 59, 2, 2503, 2504, 7, 314, 2, 2, 2504, 2505, 7, 221, 2, 2, 2505, 2525, 5, 114, 58, 2, 2506, 2507, 7, 195, 2, 2, 2507, 2508, 7, 416, 2, 2, 2508, 2509, 7, 253, 2, 2, 2509, 2525, 7, 329, 2, 2, 2510, 2511, 7, 188, 2, 2, 2511, 2512, 7, 416, 2, 2, 2512, 2513, 7, 253, 2, 2, 2513, 2525, 7, 329, 2, 2, 2514, 2515, 7, 211, 2, 2, 2515, 2516, 7, 416, 2, 2, 2516, 2517, 7, 253, 2, 2, 2517, 2525, 7, 329, 2, 2, 2518, 2519, 7, 271, 2, 2, 2519, 2520, 7, 211, 2, 2, 2520, 2521, 7, 416, 2, 2, 2521, 2522, 7, 253, 2, 2, 2522, 2525, 7, 329, 2, 2, 2523, 2525, 5, 348, 175, 2, 2524, 2226, 3, 2, 2, 2, 2524, 2228, 3, 2, 2, 2, 2524, 2233, 3, 2, 2, 2, 2524, 2236, 3, 2, 2, 2, 2524, 2242, 3, 2, 2, 2, 2524, 2249, 3, 2, 2, 2, 2524, 2258, 3, 2, 2, 2, 2524, 2267, 3, 2, 2, 2, 2524, 2275, 3, 2, 2, 2, 2524, 2285, 3, 2, 2, 2, 2524, 2294, 3, 2, 2, 2, 2524, 2303, 3, 2, 2, 2, 2524, 2311, 3, 2, 2, 2, 2524, 2319, 3, 2, 2, 2, 2524, 2328, 3, 2, 2, 2, 2524, 2341, 3, 2, 2, 2, 2524, 2348, 3, 2, 2, 2, 2524, 2356, 3, 2, 2, 2, 2524, 2366, 3, 2, 2, 2, 2524, 2376, 3, 2, 2, 2, 2524, 2384, 3, 2, 2, 2, 2524, 2400, 3, 2, 2, 2, 2524, 2407, 3, 2, 2, 2, 2524, 2409, 3, 2, 2, 2, 2524, 2414, 3, 2, 2, 2, 2524, 2417, 3, 2, 2, 2, 2524, 2425, 3, 2, 2, 2, 2524, 2431, 3, 2, 2, 2, 2524, 2434, 3, 2, 2, 2, 2524, 2437, 3, 2, 2, 2, 2524, 2440, 3, 2, 2, 2, 2524, 2442, 3, 2, 2, 2, 2524, 2444, 3, 2, 2, 2, 2524, 2447, 3, 2, 2, 2, 2524, 2451, 3, 2, 2, 2, 2524, 2455, 3, 2, 2, 2, 2524, 2458, 3, 2, 2, 2, 2524, 2461, 3, 2, 2, 2, 2524, 2464, 3, 2, 2, 2, 2524, 2467, 3, 2, 2, 2, 2524, 2470, 3, 2, 2, 2, 2524, 2473, 3, 2, 2, 2, 2524, 2477, 3, 2, 2, 2, 2524, 2481, 3, 2, 2, 2, 2524, 2484, 3, 2, 2, 2, 2524, 2486, 3, 2, 2, 2, 2524, 2489, 3, 2, 2, 2, 2524, 2491, 3, 2, 2, 2, 2524, 2493, 3, 2, 2, 2, 2524, 2496, 3, 2, 2, 2, 2524, 2499, 3, 2, 2, 2, 2524, 2501, 3, 2, 2, 2, 2524, 2503, 3, 2, 2, 2, 2524, 2506, 3, 2, 2, 2, 2524, 2510, 3, 2, 2, 2, 2524, 2514, 3, 2, 2, 2, 2524, 2518, 3, 2, 2, 2, 2524, 2523, 3, 2, 2, 2, 2525, 105, 3, 2, 2, 2, 2526, 2527, 7, 335, 2, 2, 2527, 2528, 7, 55, 2, 2, 2528, 2532, 5, 1166, 584, 2, 2529, 2530, 7, 193, 2, 2, 2530, 2532, 7, 55, 2, 2, 2531, 2526, 3, 2, 2, 2, 2531, 2529, 3, 2, 2, 2, 2532, 107, 3, 2, 2, 2, 2533, 2534, 9, 17, 2, 2, 2534, 109, 3, 2, 2, 2, 2535, 2536, 7, 45, 2, 2, 2536, 2537, 5, 532, 267, 2, 2537, 111, 3, 2, 2, 2, 2538, 2539, 7, 102, 2, 2, 2539, 2540, 5, 1166, 584, 2, 2540, 113, 3, 2, 2, 2, 2541, 2548, 7, 272, 2, 2, 2542, 2548, 7, 115, 2, 2, 2543, 2548, 7, 55, 2, 2, 2544, 2545, 7, 102, 2, 2, 2545, 2546, 7, 228, 2, 2, 2546, 2548, 5, 1344, 673, 2, 2547, 2541, 3, 2, 2, 2, 2547, 2542, 3, 2, 2, 2, 2547, 2543, 3, 2, 2, 2, 2547, 2544, 3, 2, 2, 2, 2548, 115, 3, 2, 2, 2, 2549, 2550, 7, 4, 2, 2, 2550, 2551, 5, 120, 61, 2, 2551, 2552, 7, 5, 2, 2, 2552, 117, 3, 2, 2, 2, 2553, 2554, 7, 107, 2, 2, 2554, 2555, 5, 116, 59, 2, 2555, 119, 3, 2, 2, 2, 2556, 2561, 5, 122, 62, 2, 2557, 2558, 7, 8, 2, 2, 2558, 2560, 5, 122, 62, 2, 2559, 2557, 3, 2, 2, 2, 2560, 2563, 3, 2, 2, 2, 2561, 2559, 3, 2, 2, 2, 2561, 2562, 3, 2, 2, 2, 2562, 121, 3, 2, 2, 2, 2563, 2561, 3, 2, 2, 2, 2564, 2573, 5, 1392, 697, 2, 2565, 2566, 7, 12, 2, 2, 2566, 2574, 5, 474, 238, 2, 2567, 2568, 7, 13, 2, 2, 2568, 2571, 5, 1392, 697, 2, 2569, 2570, 7, 12, 2, 2, 2570, 2572, 5, 474, 238, 2, 2571, 2569, 3, 2, 2, 2, 2571, 2572, 3, 2, 2, 2, 2572, 2574, 3, 2, 2, 2, 2573, 2565, 3, 2, 2, 2, 2573, 2567, 3, 2, 2, 2, 2573, 2574, 3, 2, 2, 2, 2574, 123, 3, 2, 2, 2, 2575, 2577, 5, 126, 64, 2, 2576, 2575, 3, 2, 2, 2, 2577, 2578, 3, 2, 2, 2, 2578, 2576, 3, 2, 2, 2, 2578, 2579, 3, 2, 2, 2, 2579, 125, 3, 2, 2, 2, 2580, 2585, 7, 316, 2, 2, 2581, 2583, 5, 16, 9, 2, 2582, 2581, 3, 2, 2, 2, 2582, 2583, 3, 2, 2, 2, 2583, 2584, 3, 2, 2, 2, 2584, 2586, 5, 296, 149, 2, 2585, 2582, 3, 2, 2, 2, 2585, 2586, 3, 2, 2, 2, 2586, 2594, 3, 2, 2, 2, 2587, 2591, 7, 335, 2, 2, 2588, 2592, 5, 292, 147, 2, 2589, 2590, 7, 440, 2, 2, 2590, 2592, 5, 200, 101, 2, 2591, 2588, 3, 2, 2, 2, 2591, 2589, 3, 2, 2, 2, 2592, 2594, 3, 2, 2, 2, 2593, 2580, 3, 2, 2, 2, 2593, 2587, 3, 2, 2, 2, 2594, 127, 3, 2, 2, 2, 2595, 2596, 7, 64, 2, 2, 2596, 2597, 7, 424, 2, 2, 2597, 2598, 7, 107, 2, 2, 2598, 2599, 7, 4, 2, 2, 2599, 2600, 5, 132, 67, 2, 2600, 2601, 7, 5, 2, 2, 2601, 2622, 3, 2, 2, 2, 2602, 2603, 7, 64, 2, 2, 2603, 2604, 7, 424, 2, 2, 2604, 2605, 7, 70, 2, 2, 2605, 2606, 7, 4, 2, 2, 2606, 2607, 5, 1282, 642, 2, 2607, 2608, 7, 5, 2, 2, 2608, 2622, 3, 2, 2, 2, 2609, 2610, 7, 64, 2, 2, 2610, 2611, 7, 424, 2, 2, 2611, 2612, 7, 66, 2, 2, 2612, 2613, 7, 4, 2, 2, 2613, 2614, 5, 1282, 642, 2, 2614, 2615, 7, 5, 2, 2, 2615, 2616, 7, 96, 2, 2, 2616, 2617, 7, 4, 2, 2, 2617, 2618, 5, 1282, 642, 2, 2618, 2619, 7, 5, 2, 2, 2619, 2622, 3, 2, 2, 2, 2620, 2622, 7, 55, 2, 2, 2621, 2595, 3, 2, 2, 2, 2621, 2602, 3, 2, 2, 2, 2621, 2609, 3, 2, 2, 2, 2621, 2620, 3, 2, 2, 2, 2622, 129, 3, 2, 2, 2, 2623, 2624, 5, 1390, 696, 2, 2624, 2625, 5, 1360, 681, 2, 2625, 131, 3, 2, 2, 2, 2626, 2631, 5, 130, 66, 2, 2627, 2628, 7, 8, 2, 2, 2628, 2630, 5, 130, 66, 2, 2629, 2627, 3, 2, 2, 2, 2630, 2633, 3, 2, 2, 2, 2631, 2629, 3, 2, 2, 2, 2631, 2632, 3, 2, 2, 2, 2632, 133, 3, 2, 2, 2, 2633, 2631, 3, 2, 2, 2, 2634, 2635, 7, 140, 2, 2, 2635, 2636, 7, 362, 2, 2, 2636, 2637, 5, 532, 267, 2, 2637, 2638, 5, 136, 69, 2, 2638, 135, 3, 2, 2, 2, 2639, 2644, 5, 138, 70, 2, 2640, 2641, 7, 8, 2, 2, 2641, 2643, 5, 138, 70, 2, 2642, 2640, 3, 2, 2, 2, 2643, 2646, 3, 2, 2, 2, 2644, 2642, 3, 2, 2, 2, 2644, 2645, 3, 2, 2, 2, 2645, 137, 3, 2, 2, 2, 2646, 2644, 3, 2, 2, 2, 2647, 2648, 7, 135, 2, 2, 2648, 2649, 7, 145, 2, 2, 2649, 2651, 5, 1106, 554, 2, 2650, 2652, 5, 108, 55, 2, 2651, 2650, 3, 2, 2, 2, 2651, 2652, 3, 2, 2, 2, 2652, 2678, 3, 2, 2, 2, 2653, 2654, 7, 193, 2, 2, 2654, 2657, 7, 145, 2, 2, 2655, 2656, 7, 222, 2, 2, 2656, 2658, 7, 398, 2, 2, 2657, 2655, 3, 2, 2, 2, 2657, 2658, 3, 2, 2, 2, 2658, 2659, 3, 2, 2, 2, 2659, 2661, 5, 1378, 690, 2, 2660, 2662, 5, 108, 55, 2, 2661, 2660, 3, 2, 2, 2, 2661, 2662, 3, 2, 2, 2, 2662, 2678, 3, 2, 2, 2, 2663, 2664, 7, 140, 2, 2, 2664, 2665, 7, 145, 2, 2, 2665, 2667, 5, 1378, 690, 2, 2666, 2668, 5, 740, 371, 2, 2667, 2666, 3, 2, 2, 2, 2667, 2668, 3, 2, 2, 2, 2668, 2669, 3, 2, 2, 2, 2669, 2670, 7, 362, 2, 2, 2670, 2672, 5, 1122, 562, 2, 2671, 2673, 5, 110, 56, 2, 2672, 2671, 3, 2, 2, 2, 2672, 2673, 3, 2, 2, 2, 2673, 2675, 3, 2, 2, 2, 2674, 2676, 5, 108, 55, 2, 2675, 2674, 3, 2, 2, 2, 2675, 2676, 3, 2, 2, 2, 2676, 2678, 3, 2, 2, 2, 2677, 2647, 3, 2, 2, 2, 2677, 2653, 3, 2, 2, 2, 2677, 2663, 3, 2, 2, 2, 2678, 139, 3, 2, 2, 2, 2679, 2682, 7, 159, 2, 2, 2680, 2683, 5, 960, 481, 2, 2681, 2683, 7, 32, 2, 2, 2682, 2680, 3, 2, 2, 2, 2682, 2681, 3, 2, 2, 2, 2683, 141, 3, 2, 2, 2, 2684, 2686, 7, 171, 2, 2, 2685, 2687, 5, 156, 79, 2, 2686, 2685, 3, 2, 2, 2, 2686, 2687, 3, 2, 2, 2, 2687, 2688, 3, 2, 2, 2, 2688, 2690, 5, 1340, 671, 2, 2689, 2691, 5, 218, 110, 2, 2690, 2689, 3, 2, 2, 2, 2690, 2691, 3, 2, 2, 2, 2691, 2692, 3, 2, 2, 2, 2692, 2694, 5, 144, 73, 2, 2693, 2695, 5, 146, 74, 2, 2694, 2693, 3, 2, 2, 2, 2694, 2695, 3, 2, 2, 2, 2695, 2696, 3, 2, 2, 2, 2696, 2698, 5, 148, 75, 2, 2697, 2699, 5, 158, 80, 2, 2698, 2697, 3, 2, 2, 2, 2698, 2699, 3, 2, 2, 2, 2699, 2701, 3, 2, 2, 2, 2700, 2702, 5, 16, 9, 2, 2701, 2700, 3, 2, 2, 2, 2701, 2702, 3, 2, 2, 2, 2702, 2703, 3, 2, 2, 2, 2703, 2705, 5, 150, 76, 2, 2704, 2706, 5, 1098, 550, 2, 2705, 2704, 3, 2, 2, 2, 2705, 2706, 3, 2, 2, 2, 2706, 2722, 3, 2, 2, 2, 2707, 2708, 7, 171, 2, 2, 2708, 2709, 7, 4, 2, 2, 2709, 2710, 5, 908, 455, 2, 2710, 2711, 7, 5, 2, 2, 2711, 2713, 7, 96, 2, 2, 2712, 2714, 5, 146, 74, 2, 2713, 2712, 3, 2, 2, 2, 2713, 2714, 3, 2, 2, 2, 2714, 2715, 3, 2, 2, 2, 2715, 2717, 5, 148, 75, 2, 2716, 2718, 5, 16, 9, 2, 2717, 2716, 3, 2, 2, 2, 2717, 2718, 3, 2, 2, 2, 2718, 2719, 3, 2, 2, 2, 2719, 2720, 5, 150, 76, 2, 2720, 2722, 3, 2, 2, 2, 2721, 2684, 3, 2, 2, 2, 2721, 2707, 3, 2, 2, 2, 2722, 143, 3, 2, 2, 2, 2723, 2724, 9, 18, 2, 2, 2724, 145, 3, 2, 2, 2, 2725, 2726, 7, 299, 2, 2, 2726, 147, 3, 2, 2, 2, 2727, 2731, 5, 1362, 682, 2, 2728, 2731, 7, 345, 2, 2, 2729, 2731, 7, 346, 2, 2, 2730, 2727, 3, 2, 2, 2, 2730, 2728, 3, 2, 2, 2, 2730, 2729, 3, 2, 2, 2, 2731, 149, 3, 2, 2, 2, 2732, 2738, 5, 152, 77, 2, 2733, 2734, 7, 4, 2, 2, 2734, 2735, 5, 162, 82, 2, 2735, 2736, 7, 5, 2, 2, 2736, 2738, 3, 2, 2, 2, 2737, 2732, 3, 2, 2, 2, 2737, 2733, 3, 2, 2, 2, 2738, 151, 3, 2, 2, 2, 2739, 2741, 5, 154, 78, 2, 2740, 2739, 3, 2, 2, 2, 2741, 2744, 3, 2, 2, 2, 2742, 2740, 3, 2, 2, 2, 2742, 2743, 3, 2, 2, 2, 2743, 153, 3, 2, 2, 2, 2744, 2742, 3, 2, 2, 2, 2745, 2785, 7, 109, 2, 2, 2746, 2785, 7, 114, 2, 2, 2747, 2749, 7, 185, 2, 2, 2748, 2750, 5, 848, 425, 2, 2749, 2748, 3, 2, 2, 2, 2749, 2750, 3, 2, 2, 2, 2750, 2751, 3, 2, 2, 2, 2751, 2785, 5, 1362, 682, 2, 2752, 2754, 7, 80, 2, 2, 2753, 2755, 5, 848, 425, 2, 2754, 2753, 3, 2, 2, 2, 2754, 2755, 3, 2, 2, 2, 2755, 2756, 3, 2, 2, 2, 2756, 2785, 5, 1362, 682, 2, 2757, 2785, 7, 173, 2, 2, 2758, 2785, 7, 218, 2, 2, 2759, 2761, 7, 300, 2, 2, 2760, 2762, 5, 848, 425, 2, 2761, 2760, 3, 2, 2, 2, 2761, 2762, 3, 2, 2, 2, 2762, 2763, 3, 2, 2, 2, 2763, 2785, 5, 1362, 682, 2, 2764, 2766, 7, 199, 2, 2, 2765, 2767, 5, 848, 425, 2, 2766, 2765, 3, 2, 2, 2, 2766, 2767, 3, 2, 2, 2, 2767, 2768, 3, 2, 2, 2, 2768, 2785, 5, 1362, 682, 2, 2769, 2770, 7, 211, 2, 2, 2770, 2771, 7, 300, 2, 2, 2771, 2785, 5, 220, 111, 2, 2772, 2773, 7, 211, 2, 2, 2773, 2774, 7, 300, 2, 2, 2774, 2785, 7, 11, 2, 2, 2775, 2776, 7, 211, 2, 2, 2776, 2777, 7, 79, 2, 2, 2777, 2778, 7, 80, 2, 2, 2778, 2785, 5, 220, 111, 2, 2779, 2780, 7, 211, 2, 2, 2780, 2781, 7, 80, 2, 2, 2781, 2785, 5, 220, 111, 2, 2782, 2783, 7, 196, 2, 2, 2783, 2785, 5, 1362, 682, 2, 2784, 2745, 3, 2, 2, 2, 2784, 2746, 3, 2, 2, 2, 2784, 2747, 3, 2, 2, 2, 2784, 2752, 3, 2, 2, 2, 2784, 2757, 3, 2, 2, 2, 2784, 2758, 3, 2, 2, 2, 2784, 2759, 3, 2, 2, 2, 2784, 2764, 3, 2, 2, 2, 2784, 2769, 3, 2, 2, 2, 2784, 2772, 3, 2, 2, 2, 2784, 2775, 3, 2, 2, 2, 2784, 2779, 3, 2, 2, 2, 2784, 2782, 3, 2, 2, 2, 2785, 155, 3, 2, 2, 2, 2786, 2787, 7, 109, 2, 2, 2787, 157, 3, 2, 2, 2, 2788, 2790, 5, 160, 81, 2, 2789, 2788, 3, 2, 2, 2, 2789, 2790, 3, 2, 2, 2, 2790, 2791, 3, 2, 2, 2, 2791, 2792, 7, 186, 2, 2, 2792, 2793, 5, 1362, 682, 2, 2793, 159, 3, 2, 2, 2, 2794, 2795, 7, 102, 2, 2, 2795, 161, 3, 2, 2, 2, 2796, 2801, 5, 164, 83, 2, 2797, 2798, 7, 8, 2, 2, 2798, 2800, 5, 164, 83, 2, 2799, 2797, 3, 2, 2, 2, 2800, 2803, 3, 2, 2, 2, 2801, 2799, 3, 2, 2, 2, 2801, 2802, 3, 2, 2, 2, 2802, 163, 3, 2, 2, 2, 2803, 2801, 3, 2, 2, 2, 2804, 2806, 5, 1392, 697, 2, 2805, 2807, 5, 166, 84, 2, 2806, 2805, 3, 2, 2, 2, 2806, 2807, 3, 2, 2, 2, 2807, 165, 3, 2, 2, 2, 2808, 2816, 5, 66, 34, 2, 2809, 2816, 5, 296, 149, 2, 2810, 2816, 7, 11, 2, 2, 2811, 2812, 7, 4, 2, 2, 2812, 2813, 5, 168, 85, 2, 2813, 2814, 7, 5, 2, 2, 2814, 2816, 3, 2, 2, 2, 2815, 2808, 3, 2, 2, 2, 2815, 2809, 3, 2, 2, 2, 2815, 2810, 3, 2, 2, 2, 2815, 2811, 3, 2, 2, 2, 2816, 167, 3, 2, 2, 2, 2817, 2822, 5, 170, 86, 2, 2818, 2819, 7, 8, 2, 2, 2819, 2821, 5, 170, 86, 2, 2820, 2818, 3, 2, 2, 2, 2821, 2824, 3, 2, 2, 2, 2822, 2820, 3, 2, 2, 2, 2822, 2823, 3, 2, 2, 2, 2823, 169, 3, 2, 2, 2, 2824, 2822, 3, 2, 2, 2, 2825, 2826, 5, 66, 34, 2, 2826, 171, 3, 2, 2, 2, 2827, 2829, 7, 48, 2, 2, 2828, 2830, 5, 174, 88, 2, 2829, 2828, 3, 2, 2, 2, 2829, 2830, 3, 2, 2, 2, 2830, 2831, 3, 2, 2, 2, 2831, 2835, 7, 94, 2, 2, 2832, 2833, 7, 222, 2, 2, 2833, 2834, 7, 79, 2, 2, 2834, 2836, 7, 398, 2, 2, 2835, 2832, 3, 2, 2, 2, 2835, 2836, 3, 2, 2, 2, 2836, 2837, 3, 2, 2, 2, 2837, 2903, 5, 1338, 670, 2, 2838, 2840, 7, 4, 2, 2, 2839, 2841, 5, 176, 89, 2, 2840, 2839, 3, 2, 2, 2, 2840, 2841, 3, 2, 2, 2, 2841, 2842, 3, 2, 2, 2, 2842, 2844, 7, 5, 2, 2, 2843, 2845, 5, 242, 122, 2, 2844, 2843, 3, 2, 2, 2, 2844, 2845, 3, 2, 2, 2, 2845, 2847, 3, 2, 2, 2, 2846, 2848, 5, 244, 123, 2, 2847, 2846, 3, 2, 2, 2, 2847, 2848, 3, 2, 2, 2, 2848, 2850, 3, 2, 2, 2, 2849, 2851, 5, 252, 127, 2, 2850, 2849, 3, 2, 2, 2, 2850, 2851, 3, 2, 2, 2, 2851, 2853, 3, 2, 2, 2, 2852, 2854, 5, 254, 128, 2, 2853, 2852, 3, 2, 2, 2, 2853, 2854, 3, 2, 2, 2, 2854, 2856, 3, 2, 2, 2, 2855, 2857, 5, 256, 129, 2, 2856, 2855, 3, 2, 2, 2, 2856, 2857, 3, 2, 2, 2, 2857, 2859, 3, 2, 2, 2, 2858, 2860, 5, 258, 130, 2, 2859, 2858, 3, 2, 2, 2, 2859, 2860, 3, 2, 2, 2, 2860, 2904, 3, 2, 2, 2, 2861, 2862, 7, 277, 2, 2, 2862, 2864, 5, 532, 267, 2, 2863, 2865, 5, 180, 91, 2, 2864, 2863, 3, 2, 2, 2, 2864, 2865, 3, 2, 2, 2, 2865, 2867, 3, 2, 2, 2, 2866, 2868, 5, 244, 123, 2, 2867, 2866, 3, 2, 2, 2, 2867, 2868, 3, 2, 2, 2, 2868, 2870, 3, 2, 2, 2, 2869, 2871, 5, 252, 127, 2, 2870, 2869, 3, 2, 2, 2, 2870, 2871, 3, 2, 2, 2, 2871, 2873, 3, 2, 2, 2, 2872, 2874, 5, 254, 128, 2, 2873, 2872, 3, 2, 2, 2, 2873, 2874, 3, 2, 2, 2, 2874, 2876, 3, 2, 2, 2, 2875, 2877, 5, 256, 129, 2, 2876, 2875, 3, 2, 2, 2, 2876, 2877, 3, 2, 2, 2, 2877, 2879, 3, 2, 2, 2, 2878, 2880, 5, 258, 130, 2, 2879, 2878, 3, 2, 2, 2, 2879, 2880, 3, 2, 2, 2, 2880, 2904, 3, 2, 2, 2, 2881, 2882, 7, 287, 2, 2, 2882, 2883, 7, 277, 2, 2, 2883, 2885, 5, 1340, 671, 2, 2884, 2886, 5, 180, 91, 2, 2885, 2884, 3, 2, 2, 2, 2885, 2886, 3, 2, 2, 2, 2886, 2887, 3, 2, 2, 2, 2887, 2889, 5, 128, 65, 2, 2888, 2890, 5, 244, 123, 2, 2889, 2888, 3, 2, 2, 2, 2889, 2890, 3, 2, 2, 2, 2890, 2892, 3, 2, 2, 2, 2891, 2893, 5, 252, 127, 2, 2892, 2891, 3, 2, 2, 2, 2892, 2893, 3, 2, 2, 2, 2893, 2895, 3, 2, 2, 2, 2894, 2896, 5, 254, 128, 2, 2895, 2894, 3, 2, 2, 2, 2895, 2896, 3, 2, 2, 2, 2896, 2898, 3, 2, 2, 2, 2897, 2899, 5, 256, 129, 2, 2898, 2897, 3, 2, 2, 2, 2898, 2899, 3, 2, 2, 2, 2899, 2901, 3, 2, 2, 2, 2900, 2902, 5, 258, 130, 2, 2901, 2900, 3, 2, 2, 2, 2901, 2902, 3, 2, 2, 2, 2902, 2904, 3, 2, 2, 2, 2903, 2838, 3, 2, 2, 2, 2903, 2861, 3, 2, 2, 2, 2903, 2881, 3, 2, 2, 2, 2904, 173, 3, 2, 2, 2, 2905, 2913, 7, 356, 2, 2, 2906, 2913, 7, 354, 2, 2, 2907, 2908, 7, 256, 2, 2, 2908, 2913, 9, 19, 2, 2, 2909, 2910, 7, 215, 2, 2, 2910, 2913, 9, 19, 2, 2, 2911, 2913, 7, 369, 2, 2, 2912, 2905, 3, 2, 2, 2, 2912, 2906, 3, 2, 2, 2, 2912, 2907, 3, 2, 2, 2, 2912, 2909, 3, 2, 2, 2, 2912, 2911, 3, 2, 2, 2, 2913, 175, 3, 2, 2, 2, 2914, 2915, 5, 182, 92, 2, 2915, 177, 3, 2, 2, 2, 2916, 2917, 5, 182, 92, 2, 2917, 179, 3, 2, 2, 2, 2918, 2919, 7, 4, 2, 2, 2919, 2920, 5, 184, 93, 2, 2920, 2921, 7, 5, 2, 2, 2921, 181, 3, 2, 2, 2, 2922, 2927, 5, 186, 94, 2, 2923, 2924, 7, 8, 2, 2, 2924, 2926, 5, 186, 94, 2, 2925, 2923, 3, 2, 2, 2, 2926, 2929, 3, 2, 2, 2, 2927, 2925, 3, 2, 2, 2, 2927, 2928, 3, 2, 2, 2, 2928, 183, 3, 2, 2, 2, 2929, 2927, 3, 2, 2, 2, 2930, 2935, 5, 188, 95, 2, 2931, 2932, 7, 8, 2, 2, 2932, 2934, 5, 188, 95, 2, 2933, 2931, 3, 2, 2, 2, 2934, 2937, 3, 2, 2, 2, 2935, 2933, 3, 2, 2, 2, 2935, 2936, 3, 2, 2, 2, 2936, 185, 3, 2, 2, 2, 2937, 2935, 3, 2, 2, 2, 2938, 2942, 5, 190, 96, 2, 2939, 2942, 5, 206, 104, 2, 2940, 2942, 5, 212, 107, 2, 2941, 2938, 3, 2, 2, 2, 2941, 2939, 3, 2, 2, 2, 2941, 2940, 3, 2, 2, 2, 2942, 187, 3, 2, 2, 2, 2943, 2946, 5, 192, 97, 2, 2944, 2946, 5, 212, 107, 2, 2945, 2943, 3, 2, 2, 2, 2945, 2944, 3, 2, 2, 2, 2946, 189, 3, 2, 2, 2, 2947, 2948, 5, 1378, 690, 2, 2948, 2950, 5, 1122, 562, 2, 2949, 2951, 5, 344, 173, 2, 2950, 2949, 3, 2, 2, 2, 2950, 2951, 3, 2, 2, 2, 2951, 2954, 3, 2, 2, 2, 2952, 2953, 7, 45, 2, 2, 2953, 2955, 5, 532, 267, 2, 2954, 2952, 3, 2, 2, 2, 2954, 2955, 3, 2, 2, 2, 2955, 2956, 3, 2, 2, 2, 2956, 2957, 5, 194, 98, 2, 2957, 191, 3, 2, 2, 2, 2958, 2961, 5, 1378, 690, 2, 2959, 2960, 7, 107, 2, 2, 2960, 2962, 7, 282, 2, 2, 2961, 2959, 3, 2, 2, 2, 2961, 2962, 3, 2, 2, 2, 2962, 2963, 3, 2, 2, 2, 2963, 2964, 5, 194, 98, 2, 2964, 193, 3, 2, 2, 2, 2965, 2967, 5, 196, 99, 2, 2966, 2965, 3, 2, 2, 2, 2967, 2970, 3, 2, 2, 2, 2968, 2966, 3, 2, 2, 2, 2968, 2969, 3, 2, 2, 2, 2969, 195, 3, 2, 2, 2, 2970, 2968, 3, 2, 2, 2, 2971, 2972, 7, 47, 2, 2, 2972, 2974, 5, 1344, 673, 2, 2973, 2971, 3, 2, 2, 2, 2973, 2974, 3, 2, 2, 2, 2974, 2975, 3, 2, 2, 2, 2975, 2977, 5, 198, 100, 2, 2976, 2978, 5, 202, 102, 2, 2977, 2976, 3, 2, 2, 2, 2977, 2978, 3, 2, 2, 2, 2978, 2980, 3, 2, 2, 2, 2979, 2981, 5, 204, 103, 2, 2980, 2979, 3, 2, 2, 2, 2980, 2981, 3, 2, 2, 2, 2981, 2990, 3, 2, 2, 2, 2982, 2984, 5, 198, 100, 2, 2983, 2985, 5, 202, 102, 2, 2984, 2983, 3, 2, 2, 2, 2984, 2985, 3, 2, 2, 2, 2985, 2987, 3, 2, 2, 2, 2986, 2988, 5, 204, 103, 2, 2987, 2986, 3, 2, 2, 2, 2987, 2988, 3, 2, 2, 2, 2988, 2990, 3, 2, 2, 2, 2989, 2973, 3, 2, 2, 2, 2989, 2982, 3, 2, 2, 2, 2990, 197, 3, 2, 2, 2, 2991, 2992, 7, 79, 2, 2, 2992, 3044, 7, 80, 2, 2, 2993, 3044, 7, 80, 2, 2, 2994, 2996, 7, 100, 2, 2, 2995, 2997, 5, 678, 340, 2, 2996, 2995, 3, 2, 2, 2, 2996, 2997, 3, 2, 2, 2, 2997, 2999, 3, 2, 2, 2, 2998, 3000, 5, 260, 131, 2, 2999, 2998, 3, 2, 2, 2, 2999, 3000, 3, 2, 2, 2, 3000, 3044, 3, 2, 2, 2, 3001, 3002, 7, 87, 2, 2, 3002, 3004, 7, 247, 2, 2, 3003, 3005, 5, 678, 340, 2, 3004, 3003, 3, 2, 2, 2, 3004, 3005, 3, 2, 2, 2, 3005, 3007, 3, 2, 2, 2, 3006, 3008, 5, 260, 131, 2, 3007, 3006, 3, 2, 2, 2, 3007, 3008, 3, 2, 2, 2, 3008, 3044, 3, 2, 2, 2, 3009, 3010, 7, 44, 2, 2, 3010, 3011, 7, 4, 2, 2, 3011, 3012, 5, 1166, 584, 2, 3012, 3014, 7, 5, 2, 2, 3013, 3015, 5, 216, 109, 2, 3014, 3013, 3, 2, 2, 2, 3014, 3015, 3, 2, 2, 2, 3015, 3044, 3, 2, 2, 2, 3016, 3017, 7, 55, 2, 2, 3017, 3044, 5, 1206, 604, 2, 3018, 3019, 7, 440, 2, 2, 3019, 3020, 5, 200, 101, 2, 3020, 3030, 7, 38, 2, 2, 3021, 3023, 7, 221, 2, 2, 3022, 3024, 5, 288, 145, 2, 3023, 3022, 3, 2, 2, 2, 3023, 3024, 3, 2, 2, 2, 3024, 3031, 3, 2, 2, 2, 3025, 3026, 7, 4, 2, 2, 3026, 3027, 5, 1166, 584, 2, 3027, 3028, 7, 5, 2, 2, 3028, 3029, 7, 442, 2, 2, 3029, 3031, 3, 2, 2, 2, 3030, 3021, 3, 2, 2, 2, 3030, 3025, 3, 2, 2, 2, 3031, 3044, 3, 2, 2, 2, 3032, 3033, 7, 88, 2, 2, 3033, 3035, 5, 1340, 671, 2, 3034, 3036, 5, 218, 110, 2, 3035, 3034, 3, 2, 2, 2, 3035, 3036, 3, 2, 2, 2, 3036, 3038, 3, 2, 2, 2, 3037, 3039, 5, 226, 114, 2, 3038, 3037, 3, 2, 2, 2, 3038, 3039, 3, 2, 2, 2, 3039, 3041, 3, 2, 2, 2, 3040, 3042, 5, 234, 118, 2, 3041, 3040, 3, 2, 2, 2, 3041, 3042, 3, 2, 2, 2, 3042, 3044, 3, 2, 2, 2, 3043, 2991, 3, 2, 2, 2, 3043, 2993, 3, 2, 2, 2, 3043, 2994, 3, 2, 2, 2, 3043, 3001, 3, 2, 2, 2, 3043, 3009, 3, 2, 2, 2, 3043, 3016, 3, 2, 2, 2, 3043, 3018, 3, 2, 2, 2, 3043, 3032, 3, 2, 2, 2, 3044, 199, 3, 2, 2, 2, 3045, 3049, 7, 141, 2, 2, 3046, 3047, 7, 149, 2, 2, 3047, 3049, 7, 55, 2, 2, 3048, 3045, 3, 2, 2, 2, 3048, 3046, 3, 2, 2, 2, 3049, 201, 3, 2, 2, 2, 3050, 3054, 7, 56, 2, 2, 3051, 3052, 7, 79, 2, 2, 3052, 3054, 7, 56, 2, 2, 3053, 3050, 3, 2, 2, 2, 3053, 3051, 3, 2, 2, 2, 3054, 203, 3, 2, 2, 2, 3055, 3056, 7, 71, 2, 2, 3056, 3057, 9, 15, 2, 2, 3057, 205, 3, 2, 2, 2, 3058, 3059, 7, 122, 2, 2, 3059, 3060, 5, 1340, 671, 2, 3060, 3061, 5, 208, 105, 2, 3061, 207, 3, 2, 2, 2, 3062, 3063, 9, 20, 2, 2, 3063, 3065, 5, 210, 106, 2, 3064, 3062, 3, 2, 2, 2, 3065, 3068, 3, 2, 2, 2, 3066, 3064, 3, 2, 2, 2, 3066, 3067, 3, 2, 2, 2, 3067, 209, 3, 2, 2, 2, 3068, 3066, 3, 2, 2, 2, 3069, 3070, 9, 21, 2, 2, 3070, 211, 3, 2, 2, 2, 3071, 3072, 7, 47, 2, 2, 3072, 3073, 5, 1344, 673, 2, 3073, 3074, 5, 214, 108, 2, 3074, 3077, 3, 2, 2, 2, 3075, 3077, 5, 214, 108, 2, 3076, 3071, 3, 2, 2, 2, 3076, 3075, 3, 2, 2, 2, 3077, 213, 3, 2, 2, 2, 3078, 3079, 7, 44, 2, 2, 3079, 3080, 7, 4, 2, 2, 3080, 3081, 5, 1166, 584, 2, 3081, 3082, 7, 5, 2, 2, 3082, 3083, 5, 448, 225, 2, 3083, 3165, 3, 2, 2, 2, 3084, 3102, 7, 100, 2, 2, 3085, 3086, 7, 4, 2, 2, 3086, 3087, 5, 220, 111, 2, 3087, 3089, 7, 5, 2, 2, 3088, 3090, 5, 224, 113, 2, 3089, 3088, 3, 2, 2, 2, 3089, 3090, 3, 2, 2, 2, 3090, 3092, 3, 2, 2, 2, 3091, 3093, 5, 678, 340, 2, 3092, 3091, 3, 2, 2, 2, 3092, 3093, 3, 2, 2, 2, 3093, 3095, 3, 2, 2, 2, 3094, 3096, 5, 260, 131, 2, 3095, 3094, 3, 2, 2, 2, 3095, 3096, 3, 2, 2, 2, 3096, 3097, 3, 2, 2, 2, 3097, 3098, 5, 448, 225, 2, 3098, 3103, 3, 2, 2, 2, 3099, 3100, 5, 262, 132, 2, 3100, 3101, 5, 448, 225, 2, 3101, 3103, 3, 2, 2, 2, 3102, 3085, 3, 2, 2, 2, 3102, 3099, 3, 2, 2, 2, 3103, 3165, 3, 2, 2, 2, 3104, 3105, 7, 87, 2, 2, 3105, 3123, 7, 247, 2, 2, 3106, 3107, 7, 4, 2, 2, 3107, 3108, 5, 220, 111, 2, 3108, 3110, 7, 5, 2, 2, 3109, 3111, 5, 224, 113, 2, 3110, 3109, 3, 2, 2, 2, 3110, 3111, 3, 2, 2, 2, 3111, 3113, 3, 2, 2, 2, 3112, 3114, 5, 678, 340, 2, 3113, 3112, 3, 2, 2, 2, 3113, 3114, 3, 2, 2, 2, 3114, 3116, 3, 2, 2, 2, 3115, 3117, 5, 260, 131, 2, 3116, 3115, 3, 2, 2, 2, 3116, 3117, 3, 2, 2, 2, 3117, 3118, 3, 2, 2, 2, 3118, 3119, 5, 448, 225, 2, 3119, 3124, 3, 2, 2, 2, 3120, 3121, 5, 262, 132, 2, 3121, 3122, 5, 448, 225, 2, 3122, 3124, 3, 2, 2, 2, 3123, 3106, 3, 2, 2, 2, 3123, 3120, 3, 2, 2, 2, 3124, 3165, 3, 2, 2, 2, 3125, 3127, 7, 201, 2, 2, 3126, 3128, 5, 608, 305, 2, 3127, 3126, 3, 2, 2, 2, 3127, 3128, 3, 2, 2, 2, 3128, 3129, 3, 2, 2, 2, 3129, 3130, 7, 4, 2, 2, 3130, 3131, 5, 228, 115, 2, 3131, 3133, 7, 5, 2, 2, 3132, 3134, 5, 224, 113, 2, 3133, 3132, 3, 2, 2, 2, 3133, 3134, 3, 2, 2, 2, 3134, 3136, 3, 2, 2, 2, 3135, 3137, 5, 678, 340, 2, 3136, 3135, 3, 2, 2, 2, 3136, 3137, 3, 2, 2, 2, 3137, 3139, 3, 2, 2, 2, 3138, 3140, 5, 260, 131, 2, 3139, 3138, 3, 2, 2, 2, 3139, 3140, 3, 2, 2, 2, 3140, 3142, 3, 2, 2, 2, 3141, 3143, 5, 232, 117, 2, 3142, 3141, 3, 2, 2, 2, 3142, 3143, 3, 2, 2, 2, 3143, 3144, 3, 2, 2, 2, 3144, 3145, 5, 448, 225, 2, 3145, 3165, 3, 2, 2, 2, 3146, 3147, 7, 65, 2, 2, 3147, 3148, 7, 247, 2, 2, 3148, 3149, 7, 4, 2, 2, 3149, 3150, 5, 220, 111, 2, 3150, 3151, 7, 5, 2, 2, 3151, 3152, 7, 88, 2, 2, 3152, 3154, 5, 1340, 671, 2, 3153, 3155, 5, 218, 110, 2, 3154, 3153, 3, 2, 2, 2, 3154, 3155, 3, 2, 2, 2, 3155, 3157, 3, 2, 2, 2, 3156, 3158, 5, 226, 114, 2, 3157, 3156, 3, 2, 2, 2, 3157, 3158, 3, 2, 2, 2, 3158, 3160, 3, 2, 2, 2, 3159, 3161, 5, 234, 118, 2, 3160, 3159, 3, 2, 2, 2, 3160, 3161, 3, 2, 2, 2, 3161, 3162, 3, 2, 2, 2, 3162, 3163, 5, 448, 225, 2, 3163, 3165, 3, 2, 2, 2, 3164, 3078, 3, 2, 2, 2, 3164, 3084, 3, 2, 2, 2, 3164, 3104, 3, 2, 2, 2, 3164, 3125, 3, 2, 2, 2, 3164, 3146, 3, 2, 2, 2, 3165, 215, 3, 2, 2, 2, 3166, 3167, 7, 271, 2, 2, 3167, 3168, 7, 230, 2, 2, 3168, 217, 3, 2, 2, 2, 3169, 3170, 7, 4, 2, 2, 3170, 3171, 5, 220, 111, 2, 3171, 3172, 7, 5, 2, 2, 3172, 219, 3, 2, 2, 2, 3173, 3178, 5, 222, 112, 2, 3174, 3175, 7, 8, 2, 2, 3175, 3177, 5, 222, 112, 2, 3176, 3174, 3, 2, 2, 2, 3177, 3180, 3, 2, 2, 2, 3178, 3176, 3, 2, 2, 2, 3178, 3179, 3, 2, 2, 2, 3179, 221, 3, 2, 2, 2, 3180, 3178, 3, 2, 2, 2, 3181, 3182, 5, 1378, 690, 2, 3182, 223, 3, 2, 2, 2, 3183, 3184, 7, 443, 2, 2, 3184, 3185, 7, 4, 2, 2, 3185, 3186, 5, 220, 111, 2, 3186, 3187, 7, 5, 2, 2, 3187, 225, 3, 2, 2, 2, 3188, 3189, 7, 260, 2, 2, 3189, 3190, 9, 22, 2, 2, 3190, 227, 3, 2, 2, 2, 3191, 3196, 5, 230, 116, 2, 3192, 3193, 7, 8, 2, 2, 3193, 3195, 5, 230, 116, 2, 3194, 3192, 3, 2, 2, 2, 3195, 3198, 3, 2, 2, 2, 3196, 3194, 3, 2, 2, 2, 3196, 3197, 3, 2, 2, 2, 3197, 229, 3, 2, 2, 2, 3198, 3196, 3, 2, 2, 2, 3199, 3200, 5, 614, 308, 2, 3200, 3207, 7, 107, 2, 2, 3201, 3208, 5, 698, 350, 2, 3202, 3203, 7, 280, 2, 2, 3203, 3204, 7, 4, 2, 2, 3204, 3205, 5, 698, 350, 2, 3205, 3206, 7, 5, 2, 2, 3206, 3208, 3, 2, 2, 2, 3207, 3201, 3, 2, 2, 2, 3207, 3202, 3, 2, 2, 2, 3208, 231, 3, 2, 2, 2, 3209, 3210, 7, 105, 2, 2, 3210, 3211, 7, 4, 2, 2, 3211, 3212, 5, 1166, 584, 2, 3212, 3213, 7, 5, 2, 2, 3213, 233, 3, 2, 2, 2, 3214, 3223, 5, 236, 119, 2, 3215, 3223, 5, 238, 120, 2, 3216, 3217, 5, 236, 119, 2, 3217, 3218, 5, 238, 120, 2, 3218, 3223, 3, 2, 2, 2, 3219, 3220, 5, 238, 120, 2, 3220, 3221, 5, 236, 119, 2, 3221, 3223, 3, 2, 2, 2, 3222, 3214, 3, 2, 2, 2, 3222, 3215, 3, 2, 2, 2, 3222, 3216, 3, 2, 2, 2, 3222, 3219, 3, 2, 2, 2, 3223, 235, 3, 2, 2, 2, 3224, 3225, 7, 82, 2, 2, 3225, 3226, 7, 371, 2, 2, 3226, 3227, 5, 240, 121, 2, 3227, 237, 3, 2, 2, 2, 3228, 3229, 7, 82, 2, 2, 3229, 3230, 7, 184, 2, 2, 3230, 3231, 5, 240, 121, 2, 3231, 239, 3, 2, 2, 2, 3232, 3233, 7, 271, 2, 2, 3233, 3239, 7, 134, 2, 2, 3234, 3239, 7, 317, 2, 2, 3235, 3239, 7, 152, 2, 2, 3236, 3237, 7, 335, 2, 2, 3237, 3239, 9, 23, 2, 2, 3238, 3232, 3, 2, 2, 2, 3238, 3234, 3, 2, 2, 2, 3238, 3235, 3, 2, 2, 2, 3238, 3236, 3, 2, 2, 2, 3239, 241, 3, 2, 2, 2, 3240, 3241, 7, 240, 2, 2, 3241, 3242, 7, 4, 2, 2, 3242, 3243, 5, 1336, 669, 2, 3243, 3244, 7, 5, 2, 2, 3244, 243, 3, 2, 2, 2, 3245, 3246, 5, 246, 124, 2, 3246, 245, 3, 2, 2, 2, 3247, 3248, 7, 287, 2, 2, 3248, 3249, 7, 149, 2, 2, 3249, 3250, 5, 1378, 690, 2, 3250, 3251, 7, 4, 2, 2, 3251, 3252, 5, 248, 125, 2, 3252, 3253, 7, 5, 2, 2, 3253, 247, 3, 2, 2, 2, 3254, 3259, 5, 250, 126, 2, 3255, 3256, 7, 8, 2, 2, 3256, 3258, 5, 250, 126, 2, 3257, 3255, 3, 2, 2, 2, 3258, 3261, 3, 2, 2, 2, 3259, 3257, 3, 2, 2, 2, 3259, 3260, 3, 2, 2, 2, 3260, 249, 3, 2, 2, 2, 3261, 3259, 3, 2, 2, 2, 3262, 3264, 5, 1378, 690, 2, 3263, 3265, 5, 620, 311, 2, 3264, 3263, 3, 2, 2, 2, 3264, 3265, 3, 2, 2, 2, 3265, 3267, 3, 2, 2, 2, 3266, 3268, 5, 622, 312, 2, 3267, 3266, 3, 2, 2, 2, 3267, 3268, 3, 2, 2, 2, 3268, 3286, 3, 2, 2, 2, 3269, 3271, 5, 1216, 609, 2, 3270, 3272, 5, 620, 311, 2, 3271, 3270, 3, 2, 2, 2, 3271, 3272, 3, 2, 2, 2, 3272, 3274, 3, 2, 2, 2, 3273, 3275, 5, 622, 312, 2, 3274, 3273, 3, 2, 2, 2, 3274, 3275, 3, 2, 2, 2, 3275, 3286, 3, 2, 2, 2, 3276, 3277, 7, 4, 2, 2, 3277, 3278, 5, 1166, 584, 2, 3278, 3280, 7, 5, 2, 2, 3279, 3281, 5, 620, 311, 2, 3280, 3279, 3, 2, 2, 2, 3280, 3281, 3, 2, 2, 2, 3281, 3283, 3, 2, 2, 2, 3282, 3284, 5, 622, 312, 2, 3283, 3282, 3, 2, 2, 2, 3283, 3284, 3, 2, 2, 2, 3284, 3286, 3, 2, 2, 2, 3285, 3262, 3, 2, 2, 2, 3285, 3269, 3, 2, 2, 2, 3285, 3276, 3, 2, 2, 2, 3286, 251, 3, 2, 2, 2, 3287, 3288, 7, 102, 2, 2, 3288, 3289, 5, 1344, 673, 2, 3289, 253, 3, 2, 2, 2, 3290, 3291, 7, 107, 2, 2, 3291, 3297, 5, 116, 59, 2, 3292, 3293, 7, 381, 2, 2, 3293, 3297, 7, 279, 2, 2, 3294, 3295, 7, 107, 2, 2, 3295, 3297, 7, 279, 2, 2, 3296, 3290, 3, 2, 2, 2, 3296, 3292, 3, 2, 2, 2, 3296, 3294, 3, 2, 2, 2, 3297, 255, 3, 2, 2, 2, 3298, 3299, 7, 82, 2, 2, 3299, 3305, 7, 163, 2, 2, 3300, 3306, 7, 193, 2, 2, 3301, 3302, 7, 184, 2, 2, 3302, 3306, 7, 322, 2, 2, 3303, 3304, 7, 294, 2, 2, 3304, 3306, 7, 322, 2, 2, 3305, 3300, 3, 2, 2, 2, 3305, 3301, 3, 2, 2, 2, 3305, 3303, 3, 2, 2, 2, 3306, 257, 3, 2, 2, 2, 3307, 3308, 7, 353, 2, 2, 3308, 3309, 5, 1344, 673, 2, 3309, 259, 3, 2, 2, 2, 3310, 3311, 7, 102, 2, 2, 3311, 3312, 7, 228, 2, 2, 3312, 3313, 7, 353, 2, 2, 3313, 3314, 5, 1344, 673, 2, 3314, 261, 3, 2, 2, 2, 3315, 3316, 7, 102, 2, 2, 3316, 3317, 7, 228, 2, 2, 3317, 3318, 5, 1344, 673, 2, 3318, 263, 3, 2, 2, 2, 3319, 3320, 7, 48, 2, 2, 3320, 3324, 7, 344, 2, 2, 3321, 3322, 7, 222, 2, 2, 3322, 3323, 7, 79, 2, 2, 3323, 3325, 7, 398, 2, 2, 3324, 3321, 3, 2, 2, 2, 3324, 3325, 3, 2, 2, 2, 3325, 3326, 3, 2, 2, 2, 3326, 3328, 5, 532, 267, 2, 3327, 3329, 5, 884, 443, 2, 3328, 3327, 3, 2, 2, 2, 3328, 3329, 3, 2, 2, 2, 3329, 3330, 3, 2, 2, 2, 3330, 3331, 7, 82, 2, 2, 3331, 3332, 5, 1282, 642, 2, 3332, 3333, 7, 66, 2, 2, 3333, 3334, 5, 1064, 533, 2, 3334, 265, 3, 2, 2, 2, 3335, 3336, 7, 140, 2, 2, 3336, 3339, 7, 344, 2, 2, 3337, 3338, 7, 222, 2, 2, 3338, 3340, 7, 398, 2, 2, 3339, 3337, 3, 2, 2, 2, 3339, 3340, 3, 2, 2, 2, 3340, 3341, 3, 2, 2, 2, 3341, 3342, 5, 532, 267, 2, 3342, 3343, 7, 335, 2, 2, 3343, 3344, 7, 344, 2, 2, 3344, 3345, 5, 1368, 685, 2, 3345, 267, 3, 2, 2, 2, 3346, 3348, 7, 48, 2, 2, 3347, 3349, 5, 174, 88, 2, 3348, 3347, 3, 2, 2, 2, 3348, 3349, 3, 2, 2, 2, 3349, 3350, 3, 2, 2, 2, 3350, 3354, 7, 94, 2, 2, 3351, 3352, 7, 222, 2, 2, 3352, 3353, 7, 79, 2, 2, 3353, 3355, 7, 398, 2, 2, 3354, 3351, 3, 2, 2, 2, 3354, 3355, 3, 2, 2, 2, 3355, 3356, 3, 2, 2, 2, 3356, 3357, 5, 270, 136, 2, 3357, 3358, 7, 38, 2, 2, 3358, 3360, 5, 966, 484, 2, 3359, 3361, 5, 272, 137, 2, 3360, 3359, 3, 2, 2, 2, 3360, 3361, 3, 2, 2, 2, 3361, 269, 3, 2, 2, 2, 3362, 3364, 5, 1340, 671, 2, 3363, 3365, 5, 218, 110, 2, 3364, 3363, 3, 2, 2, 2, 3364, 3365, 3, 2, 2, 2, 3365, 3367, 3, 2, 2, 2, 3366, 3368, 5, 252, 127, 2, 3367, 3366, 3, 2, 2, 2, 3367, 3368, 3, 2, 2, 2, 3368, 3370, 3, 2, 2, 2, 3369, 3371, 5, 254, 128, 2, 3370, 3369, 3, 2, 2, 2, 3370, 3371, 3, 2, 2, 2, 3371, 3373, 3, 2, 2, 2, 3372, 3374, 5, 256, 129, 2, 3373, 3372, 3, 2, 2, 2, 3373, 3374, 3, 2, 2, 2, 3374, 3376, 3, 2, 2, 2, 3375, 3377, 5, 258, 130, 2, 3376, 3375, 3, 2, 2, 2, 3376, 3377, 3, 2, 2, 2, 3377, 271, 3, 2, 2, 2, 3378, 3382, 7, 107, 2, 2, 3379, 3383, 7, 176, 2, 2, 3380, 3381, 7, 271, 2, 2, 3381, 3383, 7, 176, 2, 2, 3382, 3379, 3, 2, 2, 2, 3382, 3380, 3, 2, 2, 2, 3383, 273, 3, 2, 2, 2, 3384, 3386, 7, 48, 2, 2, 3385, 3387, 5, 278, 140, 2, 3386, 3385, 3, 2, 2, 2, 3386, 3387, 3, 2, 2, 2, 3387, 3388, 3, 2, 2, 2, 3388, 3389, 7, 261, 2, 2, 3389, 3393, 7, 378, 2, 2, 3390, 3391, 7, 222, 2, 2, 3391, 3392, 7, 79, 2, 2, 3392, 3394, 7, 398, 2, 2, 3393, 3390, 3, 2, 2, 2, 3393, 3394, 3, 2, 2, 2, 3394, 3395, 3, 2, 2, 2, 3395, 3396, 5, 276, 139, 2, 3396, 3397, 7, 38, 2, 2, 3397, 3399, 5, 966, 484, 2, 3398, 3400, 5, 272, 137, 2, 3399, 3398, 3, 2, 2, 2, 3399, 3400, 3, 2, 2, 2, 3400, 275, 3, 2, 2, 2, 3401, 3403, 5, 1340, 671, 2, 3402, 3404, 5, 218, 110, 2, 3403, 3402, 3, 2, 2, 2, 3403, 3404, 3, 2, 2, 2, 3404, 3406, 3, 2, 2, 2, 3405, 3407, 5, 252, 127, 2, 3406, 3405, 3, 2, 2, 2, 3406, 3407, 3, 2, 2, 2, 3407, 3409, 3, 2, 2, 2, 3408, 3410, 5, 118, 60, 2, 3409, 3408, 3, 2, 2, 2, 3409, 3410, 3, 2, 2, 2, 3410, 3412, 3, 2, 2, 2, 3411, 3413, 5, 258, 130, 2, 3412, 3411, 3, 2, 2, 2, 3412, 3413, 3, 2, 2, 2, 3413, 277, 3, 2, 2, 2, 3414, 3415, 7, 369, 2, 2, 3415, 279, 3, 2, 2, 2, 3416, 3417, 7, 307, 2, 2, 3417, 3418, 7, 261, 2, 2, 3418, 3420, 7, 378, 2, 2, 3419, 3421, 5, 604, 303, 2, 3420, 3419, 3, 2, 2, 2, 3420, 3421, 3, 2, 2, 2, 3421, 3422, 3, 2, 2, 2, 3422, 3424, 5, 1340, 671, 2, 3423, 3425, 5, 272, 137, 2, 3424, 3423, 3, 2, 2, 2, 3424, 3425, 3, 2, 2, 2, 3425, 281, 3, 2, 2, 2, 3426, 3428, 7, 48, 2, 2, 3427, 3429, 5, 174, 88, 2, 3428, 3427, 3, 2, 2, 2, 3428, 3429, 3, 2, 2, 2, 3429, 3430, 3, 2, 2, 2, 3430, 3434, 7, 330, 2, 2, 3431, 3432, 7, 222, 2, 2, 3432, 3433, 7, 79, 2, 2, 3433, 3435, 7, 398, 2, 2, 3434, 3431, 3, 2, 2, 2, 3434, 3435, 3, 2, 2, 2, 3435, 3436, 3, 2, 2, 2, 3436, 3438, 5, 1340, 671, 2, 3437, 3439, 5, 286, 144, 2, 3438, 3437, 3, 2, 2, 2, 3438, 3439, 3, 2, 2, 2, 3439, 283, 3, 2, 2, 2, 3440, 3441, 7, 140, 2, 2, 3441, 3444, 7, 330, 2, 2, 3442, 3443, 7, 222, 2, 2, 3443, 3445, 7, 398, 2, 2, 3444, 3442, 3, 2, 2, 2, 3444, 3445, 3, 2, 2, 2, 3445, 3446, 3, 2, 2, 2, 3446, 3447, 5, 1340, 671, 2, 3447, 3448, 5, 290, 146, 2, 3448, 285, 3, 2, 2, 2, 3449, 3450, 5, 290, 146, 2, 3450, 287, 3, 2, 2, 2, 3451, 3452, 7, 4, 2, 2, 3452, 3453, 5, 290, 146, 2, 3453, 3454, 7, 5, 2, 2, 3454, 289, 3, 2, 2, 2, 3455, 3457, 5, 292, 147, 2, 3456, 3455, 3, 2, 2, 2, 3457, 3458, 3, 2, 2, 2, 3458, 3456, 3, 2, 2, 2, 3458, 3459, 3, 2, 2, 2, 3459, 291, 3, 2, 2, 2, 3460, 3461, 7, 38, 2, 2, 3461, 3495, 5, 1126, 564, 2, 3462, 3463, 7, 150, 2, 2, 3463, 3495, 5, 296, 149, 2, 3464, 3495, 7, 175, 2, 2, 3465, 3467, 7, 227, 2, 2, 3466, 3468, 5, 294, 148, 2, 3467, 3466, 3, 2, 2, 2, 3467, 3468, 3, 2, 2, 2, 3468, 3469, 3, 2, 2, 2, 3469, 3495, 5, 296, 149, 2, 3470, 3471, 7, 262, 2, 2, 3471, 3495, 5, 296, 149, 2, 3472, 3473, 7, 264, 2, 2, 3473, 3495, 5, 296, 149, 2, 3474, 3475, 7, 271, 2, 2, 3475, 3495, 9, 24, 2, 2, 3476, 3477, 7, 283, 2, 2, 3477, 3478, 7, 149, 2, 2, 3478, 3495, 5, 532, 267, 2, 3479, 3480, 7, 330, 2, 2, 3480, 3481, 7, 268, 2, 2, 3481, 3495, 5, 532, 267, 2, 3482, 3484, 7, 342, 2, 2, 3483, 3485, 5, 16, 9, 2, 3484, 3483, 3, 2, 2, 2, 3484, 3485, 3, 2, 2, 2, 3485, 3486, 3, 2, 2, 2, 3486, 3495, 5, 296, 149, 2, 3487, 3489, 7, 316, 2, 2, 3488, 3490, 5, 16, 9, 2, 3489, 3488, 3, 2, 2, 2, 3489, 3490, 3, 2, 2, 2, 3490, 3492, 3, 2, 2, 2, 3491, 3493, 5, 296, 149, 2, 3492, 3491, 3, 2, 2, 2, 3492, 3493, 3, 2, 2, 2, 3493, 3495, 3, 2, 2, 2, 3494, 3460, 3, 2, 2, 2, 3494, 3462, 3, 2, 2, 2, 3494, 3464, 3, 2, 2, 2, 3494, 3465, 3, 2, 2, 2, 3494, 3470, 3, 2, 2, 2, 3494, 3472, 3, 2, 2, 2, 3494, 3474, 3, 2, 2, 2, 3494, 3476, 3, 2, 2, 2, 3494, 3479, 3, 2, 2, 2, 3494, 3482, 3, 2, 2, 2, 3494, 3487, 3, 2, 2, 2, 3495, 293, 3, 2, 2, 2, 3496, 3497, 7, 149, 2, 2, 3497, 295, 3, 2, 2, 2, 3498, 3505, 5, 1358, 680, 2, 3499, 3500, 7, 14, 2, 2, 3500, 3505, 5, 1358, 680, 2, 3501, 3502, 7, 15, 2, 2, 3502, 3505, 5, 1358, 680, 2, 3503, 3505, 5, 1368, 685, 2, 3504, 3498, 3, 2, 2, 2, 3504, 3499, 3, 2, 2, 2, 3504, 3501, 3, 2, 2, 2, 3504, 3503, 3, 2, 2, 2, 3505, 297, 3, 2, 2, 2, 3506, 3511, 5, 296, 149, 2, 3507, 3508, 7, 8, 2, 2, 3508, 3510, 5, 296, 149, 2, 3509, 3507, 3, 2, 2, 2, 3510, 3513, 3, 2, 2, 2, 3511, 3509, 3, 2, 2, 2, 3511, 3512, 3, 2, 2, 2, 3512, 299, 3, 2, 2, 2, 3513, 3511, 3, 2, 2, 2, 3514, 3516, 7, 48, 2, 2, 3515, 3517, 5, 632, 317, 2, 3516, 3515, 3, 2, 2, 2, 3516, 3517, 3, 2, 2, 2, 3517, 3519, 3, 2, 2, 2, 3518, 3520, 5, 302, 152, 2, 3519, 3518, 3, 2, 2, 2, 3519, 3520, 3, 2, 2, 2, 3520, 3522, 3, 2, 2, 2, 3521, 3523, 5, 312, 157, 2, 3522, 3521, 3, 2, 2, 2, 3522, 3523, 3, 2, 2, 2, 3523, 3524, 3, 2, 2, 2, 3524, 3525, 7, 249, 2, 2, 3525, 3534, 5, 1344, 673, 2, 3526, 3527, 7, 217, 2, 2, 3527, 3529, 5, 304, 153, 2, 3528, 3530, 5, 306, 154, 2, 3529, 3528, 3, 2, 2, 2, 3529, 3530, 3, 2, 2, 2, 3530, 3532, 3, 2, 2, 2, 3531, 3533, 5, 310, 156, 2, 3532, 3531, 3, 2, 2, 2, 3532, 3533, 3, 2, 2, 2, 3533, 3535, 3, 2, 2, 2, 3534, 3526, 3, 2, 2, 2, 3534, 3535, 3, 2, 2, 2, 3535, 301, 3, 2, 2, 2, 3536, 3537, 7, 361, 2, 2, 3537, 303, 3, 2, 2, 2, 3538, 3540, 5, 1344, 673, 2, 3539, 3541, 5, 534, 268, 2, 3540, 3539, 3, 2, 2, 2, 3540, 3541, 3, 2, 2, 2, 3541, 305, 3, 2, 2, 2, 3542, 3543, 7, 241, 2, 2, 3543, 3544, 5, 304, 153, 2, 3544, 307, 3, 2, 2, 2, 3545, 3546, 7, 375, 2, 2, 3546, 3550, 5, 304, 153, 2, 3547, 3548, 7, 271, 2, 2, 3548, 3550, 7, 375, 2, 2, 3549, 3545, 3, 2, 2, 2, 3549, 3547, 3, 2, 2, 2, 3550, 309, 3, 2, 2, 2, 3551, 3552, 5, 308, 155, 2, 3552, 311, 3, 2, 2, 2, 3553, 3554, 7, 297, 2, 2, 3554, 313, 3, 2, 2, 2, 3555, 3556, 7, 48, 2, 2, 3556, 3557, 7, 353, 2, 2, 3557, 3559, 5, 1344, 673, 2, 3558, 3560, 5, 316, 159, 2, 3559, 3558, 3, 2, 2, 2, 3559, 3560, 3, 2, 2, 2, 3560, 3561, 3, 2, 2, 2, 3561, 3562, 7, 257, 2, 2, 3562, 3564, 5, 1362, 682, 2, 3563, 3565, 5, 118, 60, 2, 3564, 3563, 3, 2, 2, 2, 3564, 3565, 3, 2, 2, 2, 3565, 315, 3, 2, 2, 2, 3566, 3567, 7, 284, 2, 2, 3567, 3568, 5, 1374, 688, 2, 3568, 317, 3, 2, 2, 2, 3569, 3570, 7, 193, 2, 2, 3570, 3573, 7, 353, 2, 2, 3571, 3572, 7, 222, 2, 2, 3572, 3574, 7, 398, 2, 2, 3573, 3571, 3, 2, 2, 2, 3573, 3574, 3, 2, 2, 2, 3574, 3575, 3, 2, 2, 2, 3575, 3576, 5, 1344, 673, 2, 3576, 319, 3, 2, 2, 2, 3577, 3578, 7, 48, 2, 2, 3578, 3582, 7, 206, 2, 2, 3579, 3580, 7, 222, 2, 2, 3580, 3581, 7, 79, 2, 2, 3581, 3583, 7, 398, 2, 2, 3582, 3579, 3, 2, 2, 2, 3582, 3583, 3, 2, 2, 2, 3583, 3584, 3, 2, 2, 2, 3584, 3586, 5, 1344, 673, 2, 3585, 3587, 5, 16, 9, 2, 3586, 3585, 3, 2, 2, 2, 3586, 3587, 3, 2, 2, 2, 3587, 3588, 3, 2, 2, 2, 3588, 3589, 5, 322, 162, 2, 3589, 321, 3, 2, 2, 2, 3590, 3592, 5, 324, 163, 2, 3591, 3590, 3, 2, 2, 2, 3592, 3595, 3, 2, 2, 2, 3593, 3591, 3, 2, 2, 2, 3593, 3594, 3, 2, 2, 2, 3594, 323, 3, 2, 2, 2, 3595, 3593, 3, 2, 2, 2, 3596, 3597, 7, 325, 2, 2, 3597, 3604, 5, 1344, 673, 2, 3598, 3599, 7, 377, 2, 2, 3599, 3604, 5, 72, 37, 2, 3600, 3601, 7, 66, 2, 2, 3601, 3604, 5, 72, 37, 2, 3602, 3604, 7, 152, 2, 2, 3603, 3596, 3, 2, 2, 2, 3603, 3598, 3, 2, 2, 2, 3603, 3600, 3, 2, 2, 2, 3603, 3602, 3, 2, 2, 2, 3604, 325, 3, 2, 2, 2, 3605, 3606, 7, 140, 2, 2, 3606, 3607, 7, 206, 2, 2, 3607, 3608, 5, 1344, 673, 2, 3608, 3609, 7, 371, 2, 2, 3609, 3610, 5, 328, 165, 2, 3610, 327, 3, 2, 2, 2, 3611, 3613, 5, 330, 166, 2, 3612, 3611, 3, 2, 2, 2, 3613, 3616, 3, 2, 2, 2, 3614, 3612, 3, 2, 2, 2, 3614, 3615, 3, 2, 2, 2, 3615, 329, 3, 2, 2, 2, 3616, 3614, 3, 2, 2, 2, 3617, 3618, 7, 96, 2, 2, 3618, 3619, 5, 72, 37, 2, 3619, 331, 3, 2, 2, 2, 3620, 3621, 7, 140, 2, 2, 3621, 3622, 7, 206, 2, 2, 3622, 3623, 5, 1344, 673, 2, 3623, 3624, 5, 40, 21, 2, 3624, 3625, 5, 524, 263, 2, 3625, 3626, 5, 1344, 673, 2, 3626, 3725, 3, 2, 2, 2, 3627, 3628, 7, 140, 2, 2, 3628, 3629, 7, 206, 2, 2, 3629, 3630, 5, 1344, 673, 2, 3630, 3631, 5, 40, 21, 2, 3631, 3632, 5, 522, 262, 2, 3632, 3633, 5, 532, 267, 2, 3633, 3725, 3, 2, 2, 2, 3634, 3635, 7, 140, 2, 2, 3635, 3636, 7, 206, 2, 2, 3636, 3637, 5, 1344, 673, 2, 3637, 3638, 5, 40, 21, 2, 3638, 3639, 7, 138, 2, 2, 3639, 3640, 5, 664, 333, 2, 3640, 3725, 3, 2, 2, 2, 3641, 3642, 7, 140, 2, 2, 3642, 3643, 7, 206, 2, 2, 3643, 3644, 5, 1344, 673, 2, 3644, 3645, 5, 40, 21, 2, 3645, 3646, 7, 43, 2, 2, 3646, 3647, 7, 4, 2, 2, 3647, 3648, 5, 1122, 562, 2, 3648, 3649, 7, 38, 2, 2, 3649, 3650, 5, 1122, 562, 2, 3650, 3651, 7, 5, 2, 2, 3651, 3725, 3, 2, 2, 2, 3652, 3653, 7, 140, 2, 2, 3653, 3654, 7, 206, 2, 2, 3654, 3655, 5, 1344, 673, 2, 3655, 3656, 5, 40, 21, 2, 3656, 3657, 7, 191, 2, 2, 3657, 3658, 5, 1122, 562, 2, 3658, 3725, 3, 2, 2, 2, 3659, 3660, 7, 140, 2, 2, 3660, 3661, 7, 206, 2, 2, 3661, 3662, 5, 1344, 673, 2, 3662, 3663, 5, 40, 21, 2, 3663, 3664, 7, 213, 2, 2, 3664, 3665, 5, 640, 321, 2, 3665, 3725, 3, 2, 2, 2, 3666, 3667, 7, 140, 2, 2, 3667, 3668, 7, 206, 2, 2, 3668, 3669, 5, 1344, 673, 2, 3669, 3670, 5, 40, 21, 2, 3670, 3671, 7, 280, 2, 2, 3671, 3672, 5, 702, 352, 2, 3672, 3725, 3, 2, 2, 2, 3673, 3674, 7, 140, 2, 2, 3674, 3675, 7, 206, 2, 2, 3675, 3676, 5, 1344, 673, 2, 3676, 3677, 5, 40, 21, 2, 3677, 3678, 7, 280, 2, 2, 3678, 3679, 7, 158, 2, 2, 3679, 3680, 5, 532, 267, 2, 3680, 3681, 7, 102, 2, 2, 3681, 3682, 5, 1344, 673, 2, 3682, 3725, 3, 2, 2, 2, 3683, 3684, 7, 140, 2, 2, 3684, 3685, 7, 206, 2, 2, 3685, 3686, 5, 1344, 673, 2, 3686, 3687, 5, 40, 21, 2, 3687, 3688, 7, 280, 2, 2, 3688, 3689, 7, 208, 2, 2, 3689, 3690, 5, 532, 267, 2, 3690, 3691, 7, 102, 2, 2, 3691, 3692, 5, 1344, 673, 2, 3692, 3725, 3, 2, 2, 2, 3693, 3694, 7, 140, 2, 2, 3694, 3695, 7, 206, 2, 2, 3695, 3696, 5, 1344, 673, 2, 3696, 3697, 5, 40, 21, 2, 3697, 3698, 7, 298, 2, 2, 3698, 3699, 5, 640, 321, 2, 3699, 3725, 3, 2, 2, 2, 3700, 3701, 7, 140, 2, 2, 3701, 3702, 7, 206, 2, 2, 3702, 3703, 5, 1344, 673, 2, 3703, 3704, 5, 40, 21, 2, 3704, 3705, 7, 444, 2, 2, 3705, 3706, 5, 640, 321, 2, 3706, 3725, 3, 2, 2, 2, 3707, 3708, 7, 140, 2, 2, 3708, 3709, 7, 206, 2, 2, 3709, 3710, 5, 1344, 673, 2, 3710, 3711, 5, 40, 21, 2, 3711, 3712, 7, 445, 2, 2, 3712, 3713, 7, 64, 2, 2, 3713, 3714, 5, 1122, 562, 2, 3714, 3715, 7, 249, 2, 2, 3715, 3716, 5, 1344, 673, 2, 3716, 3725, 3, 2, 2, 2, 3717, 3718, 7, 140, 2, 2, 3718, 3719, 7, 206, 2, 2, 3719, 3720, 5, 1344, 673, 2, 3720, 3721, 5, 40, 21, 2, 3721, 3722, 7, 362, 2, 2, 3722, 3723, 5, 1122, 562, 2, 3723, 3725, 3, 2, 2, 2, 3724, 3620, 3, 2, 2, 2, 3724, 3627, 3, 2, 2, 2, 3724, 3634, 3, 2, 2, 2, 3724, 3641, 3, 2, 2, 2, 3724, 3652, 3, 2, 2, 2, 3724, 3659, 3, 2, 2, 2, 3724, 3666, 3, 2, 2, 2, 3724, 3673, 3, 2, 2, 2, 3724, 3683, 3, 2, 2, 2, 3724, 3693, 3, 2, 2, 2, 3724, 3700, 3, 2, 2, 2, 3724, 3707, 3, 2, 2, 2, 3724, 3717, 3, 2, 2, 2, 3725, 333, 3, 2, 2, 2, 3726, 3727, 7, 48, 2, 2, 3727, 3728, 7, 65, 2, 2, 3728, 3729, 7, 176, 2, 2, 3729, 3730, 7, 383, 2, 2, 3730, 3732, 5, 1344, 673, 2, 3731, 3733, 5, 340, 171, 2, 3732, 3731, 3, 2, 2, 2, 3732, 3733, 3, 2, 2, 2, 3733, 3735, 3, 2, 2, 2, 3734, 3736, 5, 344, 173, 2, 3735, 3734, 3, 2, 2, 2, 3735, 3736, 3, 2, 2, 2, 3736, 335, 3, 2, 2, 2, 3737, 3738, 7, 217, 2, 2, 3738, 3746, 5, 304, 153, 2, 3739, 3740, 7, 271, 2, 2, 3740, 3746, 7, 217, 2, 2, 3741, 3742, 7, 375, 2, 2, 3742, 3746, 5, 304, 153, 2, 3743, 3744, 7, 271, 2, 2, 3744, 3746, 7, 375, 2, 2, 3745, 3737, 3, 2, 2, 2, 3745, 3739, 3, 2, 2, 2, 3745, 3741, 3, 2, 2, 2, 3745, 3743, 3, 2, 2, 2, 3746, 337, 3, 2, 2, 2, 3747, 3749, 5, 336, 169, 2, 3748, 3747, 3, 2, 2, 2, 3749, 3750, 3, 2, 2, 2, 3750, 3748, 3, 2, 2, 2, 3750, 3751, 3, 2, 2, 2, 3751, 339, 3, 2, 2, 2, 3752, 3753, 5, 338, 170, 2, 3753, 341, 3, 2, 2, 2, 3754, 3755, 7, 140, 2, 2, 3755, 3756, 7, 65, 2, 2, 3756, 3757, 7, 176, 2, 2, 3757, 3758, 7, 383, 2, 2, 3758, 3760, 5, 1344, 673, 2, 3759, 3761, 5, 340, 171, 2, 3760, 3759, 3, 2, 2, 2, 3760, 3761, 3, 2, 2, 2, 3761, 3762, 3, 2, 2, 2, 3762, 3763, 5, 348, 175, 2, 3763, 3772, 3, 2, 2, 2, 3764, 3765, 7, 140, 2, 2, 3765, 3766, 7, 65, 2, 2, 3766, 3767, 7, 176, 2, 2, 3767, 3768, 7, 383, 2, 2, 3768, 3769, 5, 1344, 673, 2, 3769, 3770, 5, 338, 170, 2, 3770, 3772, 3, 2, 2, 2, 3771, 3754, 3, 2, 2, 2, 3771, 3764, 3, 2, 2, 2, 3772, 343, 3, 2, 2, 2, 3773, 3774, 7, 282, 2, 2, 3774, 3775, 7, 4, 2, 2, 3775, 3776, 5, 346, 174, 2, 3776, 3777, 7, 5, 2, 2, 3777, 345, 3, 2, 2, 2, 3778, 3783, 5, 354, 178, 2, 3779, 3780, 7, 8, 2, 2, 3780, 3782, 5, 354, 178, 2, 3781, 3779, 3, 2, 2, 2, 3782, 3785, 3, 2, 2, 2, 3783, 3781, 3, 2, 2, 2, 3783, 3784, 3, 2, 2, 2, 3784, 347, 3, 2, 2, 2, 3785, 3783, 3, 2, 2, 2, 3786, 3787, 7, 282, 2, 2, 3787, 3788, 7, 4, 2, 2, 3788, 3789, 5, 350, 176, 2, 3789, 3790, 7, 5, 2, 2, 3790, 349, 3, 2, 2, 2, 3791, 3796, 5, 352, 177, 2, 3792, 3793, 7, 8, 2, 2, 3793, 3795, 5, 352, 177, 2, 3794, 3792, 3, 2, 2, 2, 3795, 3798, 3, 2, 2, 2, 3796, 3794, 3, 2, 2, 2, 3796, 3797, 3, 2, 2, 2, 3797, 351, 3, 2, 2, 2, 3798, 3796, 3, 2, 2, 2, 3799, 3807, 5, 354, 178, 2, 3800, 3801, 7, 335, 2, 2, 3801, 3807, 5, 354, 178, 2, 3802, 3803, 7, 135, 2, 2, 3803, 3807, 5, 354, 178, 2, 3804, 3805, 7, 193, 2, 2, 3805, 3807, 5, 354, 178, 2, 3806, 3799, 3, 2, 2, 2, 3806, 3800, 3, 2, 2, 2, 3806, 3802, 3, 2, 2, 2, 3806, 3804, 3, 2, 2, 2, 3807, 353, 3, 2, 2, 2, 3808, 3809, 5, 356, 179, 2, 3809, 3810, 5, 358, 180, 2, 3810, 355, 3, 2, 2, 2, 3811, 3812, 5, 1392, 697, 2, 3812, 357, 3, 2, 2, 2, 3813, 3814, 5, 1362, 682, 2, 3814, 359, 3, 2, 2, 2, 3815, 3816, 7, 48, 2, 2, 3816, 3817, 7, 333, 2, 2, 3817, 3819, 5, 1344, 673, 2, 3818, 3820, 5, 362, 182, 2, 3819, 3818, 3, 2, 2, 2, 3819, 3820, 3, 2, 2, 2, 3820, 3822, 3, 2, 2, 2, 3821, 3823, 5, 366, 184, 2, 3822, 3821, 3, 2, 2, 2, 3822, 3823, 3, 2, 2, 2, 3823, 3824, 3, 2, 2, 2, 3824, 3825, 7, 65, 2, 2, 3825, 3826, 7, 176, 2, 2, 3826, 3827, 7, 383, 2, 2, 3827, 3829, 5, 1344, 673, 2, 3828, 3830, 5, 344, 173, 2, 3829, 3828, 3, 2, 2, 2, 3829, 3830, 3, 2, 2, 2, 3830, 3851, 3, 2, 2, 2, 3831, 3832, 7, 48, 2, 2, 3832, 3833, 7, 333, 2, 2, 3833, 3834, 7, 222, 2, 2, 3834, 3835, 7, 79, 2, 2, 3835, 3836, 7, 398, 2, 2, 3836, 3838, 5, 1344, 673, 2, 3837, 3839, 5, 362, 182, 2, 3838, 3837, 3, 2, 2, 2, 3838, 3839, 3, 2, 2, 2, 3839, 3841, 3, 2, 2, 2, 3840, 3842, 5, 366, 184, 2, 3841, 3840, 3, 2, 2, 2, 3841, 3842, 3, 2, 2, 2, 3842, 3843, 3, 2, 2, 2, 3843, 3844, 7, 65, 2, 2, 3844, 3845, 7, 176, 2, 2, 3845, 3846, 7, 383, 2, 2, 3846, 3848, 5, 1344, 673, 2, 3847, 3849, 5, 344, 173, 2, 3848, 3847, 3, 2, 2, 2, 3848, 3849, 3, 2, 2, 2, 3849, 3851, 3, 2, 2, 2, 3850, 3815, 3, 2, 2, 2, 3850, 3831, 3, 2, 2, 2, 3851, 361, 3, 2, 2, 2, 3852, 3853, 7, 362, 2, 2, 3853, 3854, 5, 1362, 682, 2, 3854, 363, 3, 2, 2, 2, 3855, 3858, 7, 377, 2, 2, 3856, 3859, 5, 1362, 682, 2, 3857, 3859, 7, 80, 2, 2, 3858, 3856, 3, 2, 2, 2, 3858, 3857, 3, 2, 2, 2, 3859, 365, 3, 2, 2, 2, 3860, 3861, 5, 364, 183, 2, 3861, 367, 3, 2, 2, 2, 3862, 3863, 7, 140, 2, 2, 3863, 3864, 7, 333, 2, 2, 3864, 3870, 5, 1344, 673, 2, 3865, 3871, 5, 348, 175, 2, 3866, 3868, 5, 364, 183, 2, 3867, 3869, 5, 348, 175, 2, 3868, 3867, 3, 2, 2, 2, 3868, 3869, 3, 2, 2, 2, 3869, 3871, 3, 2, 2, 2, 3870, 3865, 3, 2, 2, 2, 3870, 3866, 3, 2, 2, 2, 3871, 369, 3, 2, 2, 2, 3872, 3873, 7, 48, 2, 2, 3873, 3874, 7, 65, 2, 2, 3874, 3875, 7, 94, 2, 2, 3875, 3876, 5, 1340, 671, 2, 3876, 3878, 7, 4, 2, 2, 3877, 3879, 5, 178, 90, 2, 3878, 3877, 3, 2, 2, 2, 3878, 3879, 3, 2, 2, 2, 3879, 3880, 3, 2, 2, 2, 3880, 3882, 7, 5, 2, 2, 3881, 3883, 5, 242, 122, 2, 3882, 3881, 3, 2, 2, 2, 3882, 3883, 3, 2, 2, 2, 3883, 3884, 3, 2, 2, 2, 3884, 3885, 7, 333, 2, 2, 3885, 3887, 5, 1344, 673, 2, 3886, 3888, 5, 344, 173, 2, 3887, 3886, 3, 2, 2, 2, 3887, 3888, 3, 2, 2, 2, 3888, 3945, 3, 2, 2, 2, 3889, 3890, 7, 48, 2, 2, 3890, 3891, 7, 65, 2, 2, 3891, 3892, 7, 94, 2, 2, 3892, 3893, 7, 222, 2, 2, 3893, 3894, 7, 79, 2, 2, 3894, 3895, 7, 398, 2, 2, 3895, 3896, 5, 1340, 671, 2, 3896, 3898, 7, 4, 2, 2, 3897, 3899, 5, 178, 90, 2, 3898, 3897, 3, 2, 2, 2, 3898, 3899, 3, 2, 2, 2, 3899, 3900, 3, 2, 2, 2, 3900, 3902, 7, 5, 2, 2, 3901, 3903, 5, 242, 122, 2, 3902, 3901, 3, 2, 2, 2, 3902, 3903, 3, 2, 2, 2, 3903, 3904, 3, 2, 2, 2, 3904, 3905, 7, 333, 2, 2, 3905, 3907, 5, 1344, 673, 2, 3906, 3908, 5, 344, 173, 2, 3907, 3906, 3, 2, 2, 2, 3907, 3908, 3, 2, 2, 2, 3908, 3945, 3, 2, 2, 2, 3909, 3910, 7, 48, 2, 2, 3910, 3911, 7, 65, 2, 2, 3911, 3912, 7, 94, 2, 2, 3912, 3913, 5, 1340, 671, 2, 3913, 3914, 7, 287, 2, 2, 3914, 3915, 7, 277, 2, 2, 3915, 3917, 5, 1340, 671, 2, 3916, 3918, 5, 180, 91, 2, 3917, 3916, 3, 2, 2, 2, 3917, 3918, 3, 2, 2, 2, 3918, 3919, 3, 2, 2, 2, 3919, 3920, 5, 128, 65, 2, 3920, 3921, 7, 333, 2, 2, 3921, 3923, 5, 1344, 673, 2, 3922, 3924, 5, 344, 173, 2, 3923, 3922, 3, 2, 2, 2, 3923, 3924, 3, 2, 2, 2, 3924, 3945, 3, 2, 2, 2, 3925, 3926, 7, 48, 2, 2, 3926, 3927, 7, 65, 2, 2, 3927, 3928, 7, 94, 2, 2, 3928, 3929, 7, 222, 2, 2, 3929, 3930, 7, 79, 2, 2, 3930, 3931, 7, 398, 2, 2, 3931, 3932, 5, 1340, 671, 2, 3932, 3933, 7, 287, 2, 2, 3933, 3934, 7, 277, 2, 2, 3934, 3936, 5, 1340, 671, 2, 3935, 3937, 5, 180, 91, 2, 3936, 3935, 3, 2, 2, 2, 3936, 3937, 3, 2, 2, 2, 3937, 3938, 3, 2, 2, 2, 3938, 3939, 5, 128, 65, 2, 3939, 3940, 7, 333, 2, 2, 3940, 3942, 5, 1344, 673, 2, 3941, 3943, 5, 344, 173, 2, 3942, 3941, 3, 2, 2, 2, 3942, 3943, 3, 2, 2, 2, 3943, 3945, 3, 2, 2, 2, 3944, 3872, 3, 2, 2, 2, 3944, 3889, 3, 2, 2, 2, 3944, 3909, 3, 2, 2, 2, 3944, 3925, 3, 2, 2, 2, 3945, 371, 3, 2, 2, 2, 3946, 3947, 7, 446, 2, 2, 3947, 3948, 7, 65, 2, 2, 3948, 3949, 7, 325, 2, 2, 3949, 3951, 5, 1344, 673, 2, 3950, 3952, 5, 376, 189, 2, 3951, 3950, 3, 2, 2, 2, 3951, 3952, 3, 2, 2, 2, 3952, 3953, 3, 2, 2, 2, 3953, 3954, 7, 66, 2, 2, 3954, 3955, 7, 333, 2, 2, 3955, 3956, 5, 1344, 673, 2, 3956, 3957, 7, 73, 2, 2, 3957, 3959, 5, 1344, 673, 2, 3958, 3960, 5, 344, 173, 2, 3959, 3958, 3, 2, 2, 2, 3959, 3960, 3, 2, 2, 2, 3960, 373, 3, 2, 2, 2, 3961, 3962, 7, 76, 2, 2, 3962, 3965, 7, 96, 2, 2, 3963, 3965, 7, 61, 2, 2, 3964, 3961, 3, 2, 2, 2, 3964, 3963, 3, 2, 2, 2, 3965, 375, 3, 2, 2, 2, 3966, 3967, 5, 374, 188, 2, 3967, 3968, 7, 4, 2, 2, 3968, 3969, 5, 1080, 541, 2, 3969, 3970, 7, 5, 2, 2, 3970, 377, 3, 2, 2, 2, 3971, 3972, 7, 48, 2, 2, 3972, 3973, 7, 101, 2, 2, 3973, 3974, 7, 259, 2, 2, 3974, 3975, 7, 64, 2, 2, 3975, 3976, 5, 380, 191, 2, 3976, 3977, 7, 333, 2, 2, 3977, 3979, 5, 1344, 673, 2, 3978, 3980, 5, 344, 173, 2, 3979, 3978, 3, 2, 2, 2, 3979, 3980, 3, 2, 2, 2, 3980, 3995, 3, 2, 2, 2, 3981, 3982, 7, 48, 2, 2, 3982, 3983, 7, 101, 2, 2, 3983, 3984, 7, 259, 2, 2, 3984, 3985, 7, 222, 2, 2, 3985, 3986, 7, 79, 2, 2, 3986, 3987, 7, 398, 2, 2, 3987, 3988, 7, 64, 2, 2, 3988, 3989, 5, 380, 191, 2, 3989, 3990, 7, 333, 2, 2, 3990, 3992, 5, 1344, 673, 2, 3991, 3993, 5, 344, 173, 2, 3992, 3991, 3, 2, 2, 2, 3992, 3993, 3, 2, 2, 2, 3993, 3995, 3, 2, 2, 2, 3994, 3971, 3, 2, 2, 2, 3994, 3981, 3, 2, 2, 2, 3995, 379, 3, 2, 2, 2, 3996, 3999, 5, 1374, 688, 2, 3997, 3999, 7, 101, 2, 2, 3998, 3996, 3, 2, 2, 2, 3998, 3997, 3, 2, 2, 2, 3999, 381, 3, 2, 2, 2, 4000, 4001, 7, 193, 2, 2, 4001, 4002, 7, 101, 2, 2, 4002, 4003, 7, 259, 2, 2, 4003, 4004, 7, 64, 2, 2, 4004, 4005, 5, 380, 191, 2, 4005, 4006, 7, 333, 2, 2, 4006, 4007, 5, 1344, 673, 2, 4007, 4019, 3, 2, 2, 2, 4008, 4009, 7, 193, 2, 2, 4009, 4010, 7, 101, 2, 2, 4010, 4011, 7, 259, 2, 2, 4011, 4012, 7, 222, 2, 2, 4012, 4013, 7, 398, 2, 2, 4013, 4014, 7, 64, 2, 2, 4014, 4015, 5, 380, 191, 2, 4015, 4016, 7, 333, 2, 2, 4016, 4017, 5, 1344, 673, 2, 4017, 4019, 3, 2, 2, 2, 4018, 4000, 3, 2, 2, 2, 4018, 4008, 3, 2, 2, 2, 4019, 383, 3, 2, 2, 2, 4020, 4021, 7, 140, 2, 2, 4021, 4022, 7, 101, 2, 2, 4022, 4023, 7, 259, 2, 2, 4023, 4024, 7, 64, 2, 2, 4024, 4025, 5, 380, 191, 2, 4025, 4026, 7, 333, 2, 2, 4026, 4027, 5, 1344, 673, 2, 4027, 4028, 5, 348, 175, 2, 4028, 385, 3, 2, 2, 2, 4029, 4030, 7, 48, 2, 2, 4030, 4031, 7, 447, 2, 2, 4031, 4032, 5, 1344, 673, 2, 4032, 4033, 7, 82, 2, 2, 4033, 4035, 5, 1340, 671, 2, 4034, 4036, 5, 398, 200, 2, 4035, 4034, 3, 2, 2, 2, 4035, 4036, 3, 2, 2, 2, 4036, 4038, 3, 2, 2, 2, 4037, 4039, 5, 400, 201, 2, 4038, 4037, 3, 2, 2, 2, 4038, 4039, 3, 2, 2, 2, 4039, 4041, 3, 2, 2, 2, 4040, 4042, 5, 394, 198, 2, 4041, 4040, 3, 2, 2, 2, 4041, 4042, 3, 2, 2, 2, 4042, 4044, 3, 2, 2, 2, 4043, 4045, 5, 390, 196, 2, 4044, 4043, 3, 2, 2, 2, 4044, 4045, 3, 2, 2, 2, 4045, 4047, 3, 2, 2, 2, 4046, 4048, 5, 392, 197, 2, 4047, 4046, 3, 2, 2, 2, 4047, 4048, 3, 2, 2, 2, 4048, 387, 3, 2, 2, 2, 4049, 4050, 7, 140, 2, 2, 4050, 4051, 7, 447, 2, 2, 4051, 4052, 5, 1344, 673, 2, 4052, 4053, 7, 82, 2, 2, 4053, 4055, 5, 1340, 671, 2, 4054, 4056, 5, 396, 199, 2, 4055, 4054, 3, 2, 2, 2, 4055, 4056, 3, 2, 2, 2, 4056, 4058, 3, 2, 2, 2, 4057, 4059, 5, 390, 196, 2, 4058, 4057, 3, 2, 2, 2, 4058, 4059, 3, 2, 2, 2, 4059, 4061, 3, 2, 2, 2, 4060, 4062, 5, 392, 197, 2, 4061, 4060, 3, 2, 2, 2, 4061, 4062, 3, 2, 2, 2, 4062, 389, 3, 2, 2, 2, 4063, 4064, 7, 102, 2, 2, 4064, 4065, 7, 4, 2, 2, 4065, 4066, 5, 1166, 584, 2, 4066, 4067, 7, 5, 2, 2, 4067, 391, 3, 2, 2, 2, 4068, 4069, 7, 107, 2, 2, 4069, 4070, 7, 44, 2, 2, 4070, 4071, 7, 4, 2, 2, 4071, 4072, 5, 1166, 584, 2, 4072, 4073, 7, 5, 2, 2, 4073, 393, 3, 2, 2, 2, 4074, 4075, 7, 96, 2, 2, 4075, 4076, 5, 1376, 689, 2, 4076, 395, 3, 2, 2, 2, 4077, 4078, 7, 96, 2, 2, 4078, 4079, 5, 1376, 689, 2, 4079, 397, 3, 2, 2, 2, 4080, 4081, 7, 38, 2, 2, 4081, 4082, 5, 1394, 698, 2, 4082, 399, 3, 2, 2, 2, 4083, 4084, 7, 64, 2, 2, 4084, 4085, 5, 402, 202, 2, 4085, 401, 3, 2, 2, 2, 4086, 4087, 9, 25, 2, 2, 4087, 403, 3, 2, 2, 2, 4088, 4089, 7, 48, 2, 2, 4089, 4090, 7, 133, 2, 2, 4090, 4091, 7, 448, 2, 2, 4091, 4092, 5, 1344, 673, 2, 4092, 4093, 7, 362, 2, 2, 4093, 4094, 5, 406, 204, 2, 4094, 4095, 7, 217, 2, 2, 4095, 4096, 5, 304, 153, 2, 4096, 405, 3, 2, 2, 2, 4097, 4098, 9, 26, 2, 2, 4098, 407, 3, 2, 2, 2, 4099, 4100, 7, 48, 2, 2, 4100, 4101, 7, 359, 2, 2, 4101, 4102, 5, 1344, 673, 2, 4102, 4103, 5, 410, 206, 2, 4103, 4104, 5, 416, 209, 2, 4104, 4105, 7, 82, 2, 2, 4105, 4107, 5, 1340, 671, 2, 4106, 4108, 5, 420, 211, 2, 4107, 4106, 3, 2, 2, 2, 4107, 4108, 3, 2, 2, 2, 4108, 4110, 3, 2, 2, 2, 4109, 4111, 5, 432, 217, 2, 4110, 4109, 3, 2, 2, 2, 4110, 4111, 3, 2, 2, 2, 4111, 4113, 3, 2, 2, 2, 4112, 4114, 5, 438, 220, 2, 4113, 4112, 3, 2, 2, 2, 4113, 4114, 3, 2, 2, 2, 4114, 4115, 3, 2, 2, 2, 4115, 4116, 7, 204, 2, 2, 4116, 4117, 5, 440, 221, 2, 4117, 4118, 5, 1350, 676, 2, 4118, 4119, 7, 4, 2, 2, 4119, 4120, 5, 442, 222, 2, 4120, 4121, 7, 5, 2, 2, 4121, 4150, 3, 2, 2, 2, 4122, 4124, 7, 48, 2, 2, 4123, 4125, 7, 47, 2, 2, 4124, 4123, 3, 2, 2, 2, 4124, 4125, 3, 2, 2, 2, 4125, 4126, 3, 2, 2, 2, 4126, 4127, 7, 359, 2, 2, 4127, 4128, 5, 1344, 673, 2, 4128, 4129, 5, 410, 206, 2, 4129, 4130, 5, 416, 209, 2, 4130, 4131, 7, 82, 2, 2, 4131, 4133, 5, 1340, 671, 2, 4132, 4134, 5, 446, 224, 2, 4133, 4132, 3, 2, 2, 2, 4133, 4134, 3, 2, 2, 2, 4134, 4135, 3, 2, 2, 2, 4135, 4137, 5, 448, 225, 2, 4136, 4138, 5, 412, 207, 2, 4137, 4136, 3, 2, 2, 2, 4137, 4138, 3, 2, 2, 2, 4138, 4140, 3, 2, 2, 2, 4139, 4141, 5, 438, 220, 2, 4140, 4139, 3, 2, 2, 2, 4140, 4141, 3, 2, 2, 2, 4141, 4142, 3, 2, 2, 2, 4142, 4143, 7, 204, 2, 2, 4143, 4144, 5, 440, 221, 2, 4144, 4145, 5, 1350, 676, 2, 4145, 4146, 7, 4, 2, 2, 4146, 4147, 5, 442, 222, 2, 4147, 4148, 7, 5, 2, 2, 4148, 4150, 3, 2, 2, 2, 4149, 4099, 3, 2, 2, 2, 4149, 4122, 3, 2, 2, 2, 4150, 409, 3, 2, 2, 2, 4151, 4156, 7, 147, 2, 2, 4152, 4156, 7, 137, 2, 2, 4153, 4154, 7, 244, 2, 2, 4154, 4156, 7, 277, 2, 2, 4155, 4151, 3, 2, 2, 2, 4155, 4152, 3, 2, 2, 2, 4155, 4153, 3, 2, 2, 2, 4156, 411, 3, 2, 2, 2, 4157, 4159, 7, 64, 2, 2, 4158, 4160, 7, 194, 2, 2, 4159, 4158, 3, 2, 2, 2, 4159, 4160, 3, 2, 2, 2, 4160, 4161, 3, 2, 2, 2, 4161, 4162, 5, 414, 208, 2, 4162, 413, 3, 2, 2, 2, 4163, 4164, 9, 27, 2, 2, 4164, 415, 3, 2, 2, 2, 4165, 4170, 5, 418, 210, 2, 4166, 4167, 7, 84, 2, 2, 4167, 4169, 5, 418, 210, 2, 4168, 4166, 3, 2, 2, 2, 4169, 4172, 3, 2, 2, 2, 4170, 4168, 3, 2, 2, 2, 4170, 4171, 3, 2, 2, 2, 4171, 417, 3, 2, 2, 2, 4172, 4170, 3, 2, 2, 2, 4173, 4181, 7, 243, 2, 2, 4174, 4181, 7, 184, 2, 2, 4175, 4181, 7, 371, 2, 2, 4176, 4177, 7, 371, 2, 2, 4177, 4178, 7, 277, 2, 2, 4178, 4181, 5, 220, 111, 2, 4179, 4181, 7, 360, 2, 2, 4180, 4173, 3, 2, 2, 2, 4180, 4174, 3, 2, 2, 2, 4180, 4175, 3, 2, 2, 2, 4180, 4176, 3, 2, 2, 2, 4180, 4179, 3, 2, 2, 2, 4181, 419, 3, 2, 2, 2, 4182, 4183, 7, 449, 2, 2, 4183, 4184, 5, 422, 212, 2, 4184, 421, 3, 2, 2, 2, 4185, 4187, 5, 424, 213, 2, 4186, 4185, 3, 2, 2, 2, 4187, 4188, 3, 2, 2, 2, 4188, 4186, 3, 2, 2, 2, 4188, 4189, 3, 2, 2, 2, 4189, 423, 3, 2, 2, 2, 4190, 4191, 5, 426, 214, 2, 4191, 4193, 5, 428, 215, 2, 4192, 4194, 5, 848, 425, 2, 4193, 4192, 3, 2, 2, 2, 4193, 4194, 3, 2, 2, 2, 4194, 4195, 3, 2, 2, 2, 4195, 4196, 5, 430, 216, 2, 4196, 425, 3, 2, 2, 2, 4197, 4198, 9, 28, 2, 2, 4198, 427, 3, 2, 2, 2, 4199, 4200, 9, 29, 2, 2, 4200, 429, 3, 2, 2, 2, 4201, 4202, 5, 1378, 690, 2, 4202, 431, 3, 2, 2, 2, 4203, 4205, 7, 64, 2, 2, 4204, 4206, 5, 434, 218, 2, 4205, 4204, 3, 2, 2, 2, 4205, 4206, 3, 2, 2, 2, 4206, 4207, 3, 2, 2, 2, 4207, 4208, 5, 436, 219, 2, 4208, 433, 3, 2, 2, 2, 4209, 4210, 7, 194, 2, 2, 4210, 435, 3, 2, 2, 2, 4211, 4212, 9, 27, 2, 2, 4212, 437, 3, 2, 2, 2, 4213, 4214, 7, 104, 2, 2, 4214, 4215, 7, 4, 2, 2, 4215, 4216, 5, 1166, 584, 2, 4216, 4217, 7, 5, 2, 2, 4217, 439, 3, 2, 2, 2, 4218, 4219, 9, 30, 2, 2, 4219, 441, 3, 2, 2, 2, 4220, 4223, 5, 444, 223, 2, 4221, 4223, 3, 2, 2, 2, 4222, 4220, 3, 2, 2, 2, 4222, 4221, 3, 2, 2, 2, 4223, 4228, 3, 2, 2, 2, 4224, 4225, 7, 8, 2, 2, 4225, 4227, 5, 444, 223, 2, 4226, 4224, 3, 2, 2, 2, 4227, 4230, 3, 2, 2, 2, 4228, 4226, 3, 2, 2, 2, 4228, 4229, 3, 2, 2, 2, 4229, 443, 3, 2, 2, 2, 4230, 4228, 3, 2, 2, 2, 4231, 4236, 5, 1360, 681, 2, 4232, 4236, 5, 1358, 680, 2, 4233, 4236, 5, 1362, 682, 2, 4234, 4236, 5, 1392, 697, 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, 445, 3, 2, 2, 2, 4237, 4238, 7, 66, 2, 2, 4238, 4239, 5, 1340, 671, 2, 4239, 447, 3, 2, 2, 2, 4240, 4242, 5, 450, 226, 2, 4241, 4240, 3, 2, 2, 2, 4242, 4245, 3, 2, 2, 2, 4243, 4241, 3, 2, 2, 2, 4243, 4244, 3, 2, 2, 2, 4244, 449, 3, 2, 2, 2, 4245, 4243, 3, 2, 2, 2, 4246, 4247, 7, 79, 2, 2, 4247, 4258, 7, 56, 2, 2, 4248, 4258, 7, 56, 2, 2, 4249, 4250, 7, 71, 2, 2, 4250, 4258, 7, 223, 2, 2, 4251, 4252, 7, 71, 2, 2, 4252, 4258, 7, 182, 2, 2, 4253, 4254, 7, 79, 2, 2, 4254, 4258, 7, 373, 2, 2, 4255, 4256, 7, 271, 2, 2, 4256, 4258, 7, 230, 2, 2, 4257, 4246, 3, 2, 2, 2, 4257, 4248, 3, 2, 2, 2, 4257, 4249, 3, 2, 2, 2, 4257, 4251, 3, 2, 2, 2, 4257, 4253, 3, 2, 2, 2, 4257, 4255, 3, 2, 2, 2, 4258, 451, 3, 2, 2, 2, 4259, 4260, 7, 48, 2, 2, 4260, 4261, 7, 200, 2, 2, 4261, 4262, 7, 359, 2, 2, 4262, 4263, 5, 1344, 673, 2, 4263, 4264, 7, 82, 2, 2, 4264, 4265, 5, 1392, 697, 2, 4265, 4266, 7, 204, 2, 2, 4266, 4267, 5, 440, 221, 2, 4267, 4268, 5, 1350, 676, 2, 4268, 4269, 7, 4, 2, 2, 4269, 4270, 7, 5, 2, 2, 4270, 4286, 3, 2, 2, 2, 4271, 4272, 7, 48, 2, 2, 4272, 4273, 7, 200, 2, 2, 4273, 4274, 7, 359, 2, 2, 4274, 4275, 5, 1344, 673, 2, 4275, 4276, 7, 82, 2, 2, 4276, 4277, 5, 1392, 697, 2, 4277, 4278, 7, 104, 2, 2, 4278, 4279, 5, 454, 228, 2, 4279, 4280, 7, 204, 2, 2, 4280, 4281, 5, 440, 221, 2, 4281, 4282, 5, 1350, 676, 2, 4282, 4283, 7, 4, 2, 2, 4283, 4284, 7, 5, 2, 2, 4284, 4286, 3, 2, 2, 2, 4285, 4259, 3, 2, 2, 2, 4285, 4271, 3, 2, 2, 2, 4286, 453, 3, 2, 2, 2, 4287, 4292, 5, 456, 229, 2, 4288, 4289, 7, 35, 2, 2, 4289, 4291, 5, 456, 229, 2, 4290, 4288, 3, 2, 2, 2, 4291, 4294, 3, 2, 2, 2, 4292, 4290, 3, 2, 2, 2, 4292, 4293, 3, 2, 2, 2, 4293, 455, 3, 2, 2, 2, 4294, 4292, 3, 2, 2, 2, 4295, 4296, 5, 1378, 690, 2, 4296, 4297, 7, 70, 2, 2, 4297, 4298, 7, 4, 2, 2, 4298, 4299, 5, 458, 230, 2, 4299, 4300, 7, 5, 2, 2, 4300, 457, 3, 2, 2, 2, 4301, 4306, 5, 1362, 682, 2, 4302, 4303, 7, 8, 2, 2, 4303, 4305, 5, 1362, 682, 2, 4304, 4302, 3, 2, 2, 2, 4305, 4308, 3, 2, 2, 2, 4306, 4304, 3, 2, 2, 2, 4306, 4307, 3, 2, 2, 2, 4307, 459, 3, 2, 2, 2, 4308, 4306, 3, 2, 2, 2, 4309, 4310, 7, 140, 2, 2, 4310, 4311, 7, 200, 2, 2, 4311, 4312, 7, 359, 2, 2, 4312, 4313, 5, 1344, 673, 2, 4313, 4314, 5, 462, 232, 2, 4314, 461, 3, 2, 2, 2, 4315, 4322, 7, 195, 2, 2, 4316, 4317, 7, 195, 2, 2, 4317, 4322, 7, 314, 2, 2, 4318, 4319, 7, 195, 2, 2, 4319, 4322, 7, 141, 2, 2, 4320, 4322, 7, 188, 2, 2, 4321, 4315, 3, 2, 2, 2, 4321, 4316, 3, 2, 2, 2, 4321, 4318, 3, 2, 2, 2, 4321, 4320, 3, 2, 2, 2, 4322, 463, 3, 2, 2, 2, 4323, 4324, 7, 48, 2, 2, 4324, 4325, 7, 142, 2, 2, 4325, 4326, 5, 532, 267, 2, 4326, 4327, 7, 44, 2, 2, 4327, 4328, 7, 4, 2, 2, 4328, 4329, 5, 1166, 584, 2, 4329, 4330, 7, 5, 2, 2, 4330, 4331, 5, 448, 225, 2, 4331, 465, 3, 2, 2, 2, 4332, 4334, 7, 48, 2, 2, 4333, 4335, 5, 632, 317, 2, 4334, 4333, 3, 2, 2, 2, 4334, 4335, 3, 2, 2, 2, 4335, 4336, 3, 2, 2, 2, 4336, 4337, 7, 138, 2, 2, 4337, 4338, 5, 1350, 676, 2, 4338, 4339, 5, 660, 331, 2, 4339, 4340, 5, 468, 235, 2, 4340, 4447, 3, 2, 2, 2, 4341, 4343, 7, 48, 2, 2, 4342, 4344, 5, 632, 317, 2, 4343, 4342, 3, 2, 2, 2, 4343, 4344, 3, 2, 2, 2, 4344, 4345, 3, 2, 2, 2, 4345, 4346, 7, 138, 2, 2, 4346, 4347, 5, 1350, 676, 2, 4347, 4348, 5, 476, 239, 2, 4348, 4447, 3, 2, 2, 2, 4349, 4350, 7, 48, 2, 2, 4350, 4351, 7, 280, 2, 2, 4351, 4352, 5, 698, 350, 2, 4352, 4353, 5, 468, 235, 2, 4353, 4447, 3, 2, 2, 2, 4354, 4355, 7, 48, 2, 2, 4355, 4356, 7, 362, 2, 2, 4356, 4357, 5, 532, 267, 2, 4357, 4358, 5, 468, 235, 2, 4358, 4447, 3, 2, 2, 2, 4359, 4360, 7, 48, 2, 2, 4360, 4361, 7, 362, 2, 2, 4361, 4447, 5, 532, 267, 2, 4362, 4363, 7, 48, 2, 2, 4363, 4364, 7, 362, 2, 2, 4364, 4365, 5, 532, 267, 2, 4365, 4366, 7, 38, 2, 2, 4366, 4368, 7, 4, 2, 2, 4367, 4369, 5, 1102, 552, 2, 4368, 4367, 3, 2, 2, 2, 4368, 4369, 3, 2, 2, 2, 4369, 4370, 3, 2, 2, 2, 4370, 4371, 7, 5, 2, 2, 4371, 4447, 3, 2, 2, 2, 4372, 4373, 7, 48, 2, 2, 4373, 4374, 7, 362, 2, 2, 4374, 4375, 5, 532, 267, 2, 4375, 4376, 7, 38, 2, 2, 4376, 4377, 7, 198, 2, 2, 4377, 4379, 7, 4, 2, 2, 4378, 4380, 5, 482, 242, 2, 4379, 4378, 3, 2, 2, 2, 4379, 4380, 3, 2, 2, 2, 4380, 4381, 3, 2, 2, 2, 4381, 4382, 7, 5, 2, 2, 4382, 4447, 3, 2, 2, 2, 4383, 4384, 7, 48, 2, 2, 4384, 4385, 7, 362, 2, 2, 4385, 4386, 5, 532, 267, 2, 4386, 4387, 7, 38, 2, 2, 4387, 4388, 7, 301, 2, 2, 4388, 4389, 5, 468, 235, 2, 4389, 4447, 3, 2, 2, 2, 4390, 4391, 7, 48, 2, 2, 4391, 4392, 7, 357, 2, 2, 4392, 4393, 7, 327, 2, 2, 4393, 4394, 7, 285, 2, 2, 4394, 4395, 5, 532, 267, 2, 4395, 4396, 5, 468, 235, 2, 4396, 4447, 3, 2, 2, 2, 4397, 4398, 7, 48, 2, 2, 4398, 4399, 7, 357, 2, 2, 4399, 4400, 7, 327, 2, 2, 4400, 4401, 7, 187, 2, 2, 4401, 4402, 5, 532, 267, 2, 4402, 4403, 5, 468, 235, 2, 4403, 4447, 3, 2, 2, 2, 4404, 4405, 7, 48, 2, 2, 4405, 4406, 7, 357, 2, 2, 4406, 4407, 7, 327, 2, 2, 4407, 4408, 7, 355, 2, 2, 4408, 4409, 5, 532, 267, 2, 4409, 4410, 5, 468, 235, 2, 4410, 4447, 3, 2, 2, 2, 4411, 4412, 7, 48, 2, 2, 4412, 4413, 7, 357, 2, 2, 4413, 4414, 7, 327, 2, 2, 4414, 4415, 7, 165, 2, 2, 4415, 4416, 5, 532, 267, 2, 4416, 4417, 5, 468, 235, 2, 4417, 4447, 3, 2, 2, 2, 4418, 4419, 7, 48, 2, 2, 4419, 4420, 7, 110, 2, 2, 4420, 4421, 5, 532, 267, 2, 4421, 4422, 5, 468, 235, 2, 4422, 4447, 3, 2, 2, 2, 4423, 4424, 7, 48, 2, 2, 4424, 4425, 7, 110, 2, 2, 4425, 4426, 7, 222, 2, 2, 4426, 4427, 7, 79, 2, 2, 4427, 4428, 7, 398, 2, 2, 4428, 4429, 5, 532, 267, 2, 4429, 4430, 5, 468, 235, 2, 4430, 4447, 3, 2, 2, 2, 4431, 4432, 7, 48, 2, 2, 4432, 4433, 7, 110, 2, 2, 4433, 4434, 5, 532, 267, 2, 4434, 4435, 7, 66, 2, 2, 4435, 4436, 5, 532, 267, 2, 4436, 4447, 3, 2, 2, 2, 4437, 4438, 7, 48, 2, 2, 4438, 4439, 7, 110, 2, 2, 4439, 4440, 7, 222, 2, 2, 4440, 4441, 7, 79, 2, 2, 4441, 4442, 7, 398, 2, 2, 4442, 4443, 5, 532, 267, 2, 4443, 4444, 7, 66, 2, 2, 4444, 4445, 5, 532, 267, 2, 4445, 4447, 3, 2, 2, 2, 4446, 4332, 3, 2, 2, 2, 4446, 4341, 3, 2, 2, 2, 4446, 4349, 3, 2, 2, 2, 4446, 4354, 3, 2, 2, 2, 4446, 4359, 3, 2, 2, 2, 4446, 4362, 3, 2, 2, 2, 4446, 4372, 3, 2, 2, 2, 4446, 4383, 3, 2, 2, 2, 4446, 4390, 3, 2, 2, 2, 4446, 4397, 3, 2, 2, 2, 4446, 4404, 3, 2, 2, 2, 4446, 4411, 3, 2, 2, 2, 4446, 4418, 3, 2, 2, 2, 4446, 4423, 3, 2, 2, 2, 4446, 4431, 3, 2, 2, 2, 4446, 4437, 3, 2, 2, 2, 4447, 467, 3, 2, 2, 2, 4448, 4449, 7, 4, 2, 2, 4449, 4450, 5, 470, 236, 2, 4450, 4451, 7, 5, 2, 2, 4451, 469, 3, 2, 2, 2, 4452, 4457, 5, 472, 237, 2, 4453, 4454, 7, 8, 2, 2, 4454, 4456, 5, 472, 237, 2, 4455, 4453, 3, 2, 2, 2, 4456, 4459, 3, 2, 2, 2, 4457, 4455, 3, 2, 2, 2, 4457, 4458, 3, 2, 2, 2, 4458, 471, 3, 2, 2, 2, 4459, 4457, 3, 2, 2, 2, 4460, 4463, 5, 1392, 697, 2, 4461, 4462, 7, 12, 2, 2, 4462, 4464, 5, 474, 238, 2, 4463, 4461, 3, 2, 2, 2, 4463, 4464, 3, 2, 2, 2, 4464, 473, 3, 2, 2, 2, 4465, 4472, 5, 654, 328, 2, 4466, 4472, 5, 1404, 703, 2, 4467, 4472, 5, 1278, 640, 2, 4468, 4472, 5, 296, 149, 2, 4469, 4472, 5, 1362, 682, 2, 4470, 4472, 7, 409, 2, 2, 4471, 4465, 3, 2, 2, 2, 4471, 4466, 3, 2, 2, 2, 4471, 4467, 3, 2, 2, 2, 4471, 4468, 3, 2, 2, 2, 4471, 4469, 3, 2, 2, 2, 4471, 4470, 3, 2, 2, 2, 4472, 475, 3, 2, 2, 2, 4473, 4474, 7, 4, 2, 2, 4474, 4475, 5, 478, 240, 2, 4475, 4476, 7, 5, 2, 2, 4476, 477, 3, 2, 2, 2, 4477, 4482, 5, 480, 241, 2, 4478, 4479, 7, 8, 2, 2, 4479, 4481, 5, 480, 241, 2, 4480, 4478, 3, 2, 2, 2, 4481, 4484, 3, 2, 2, 2, 4482, 4480, 3, 2, 2, 2, 4482, 4483, 3, 2, 2, 2, 4483, 479, 3, 2, 2, 2, 4484, 4482, 3, 2, 2, 2, 4485, 4486, 5, 1394, 698, 2, 4486, 4487, 7, 12, 2, 2, 4487, 4488, 5, 474, 238, 2, 4488, 481, 3, 2, 2, 2, 4489, 4490, 5, 484, 243, 2, 4490, 483, 3, 2, 2, 2, 4491, 4496, 5, 1362, 682, 2, 4492, 4493, 7, 8, 2, 2, 4493, 4495, 5, 1362, 682, 2, 4494, 4492, 3, 2, 2, 2, 4495, 4498, 3, 2, 2, 2, 4496, 4494, 3, 2, 2, 2, 4496, 4497, 3, 2, 2, 2, 4497, 485, 3, 2, 2, 2, 4498, 4496, 3, 2, 2, 2, 4499, 4500, 7, 140, 2, 2, 4500, 4501, 7, 362, 2, 2, 4501, 4502, 5, 532, 267, 2, 4502, 4503, 7, 135, 2, 2, 4503, 4505, 7, 452, 2, 2, 4504, 4506, 5, 488, 245, 2, 4505, 4504, 3, 2, 2, 2, 4505, 4506, 3, 2, 2, 2, 4506, 4507, 3, 2, 2, 2, 4507, 4508, 5, 1362, 682, 2, 4508, 4543, 3, 2, 2, 2, 4509, 4510, 7, 140, 2, 2, 4510, 4511, 7, 362, 2, 2, 4511, 4512, 5, 532, 267, 2, 4512, 4513, 7, 135, 2, 2, 4513, 4515, 7, 452, 2, 2, 4514, 4516, 5, 488, 245, 2, 4515, 4514, 3, 2, 2, 2, 4515, 4516, 3, 2, 2, 2, 4516, 4517, 3, 2, 2, 2, 4517, 4518, 5, 1362, 682, 2, 4518, 4519, 7, 147, 2, 2, 4519, 4520, 5, 1362, 682, 2, 4520, 4543, 3, 2, 2, 2, 4521, 4522, 7, 140, 2, 2, 4522, 4523, 7, 362, 2, 2, 4523, 4524, 5, 532, 267, 2, 4524, 4525, 7, 135, 2, 2, 4525, 4527, 7, 452, 2, 2, 4526, 4528, 5, 488, 245, 2, 4527, 4526, 3, 2, 2, 2, 4527, 4528, 3, 2, 2, 2, 4528, 4529, 3, 2, 2, 2, 4529, 4530, 5, 1362, 682, 2, 4530, 4531, 7, 137, 2, 2, 4531, 4532, 5, 1362, 682, 2, 4532, 4543, 3, 2, 2, 2, 4533, 4534, 7, 140, 2, 2, 4534, 4535, 7, 362, 2, 2, 4535, 4536, 5, 532, 267, 2, 4536, 4537, 7, 311, 2, 2, 4537, 4538, 7, 452, 2, 2, 4538, 4539, 5, 1362, 682, 2, 4539, 4540, 7, 96, 2, 2, 4540, 4541, 5, 1362, 682, 2, 4541, 4543, 3, 2, 2, 2, 4542, 4499, 3, 2, 2, 2, 4542, 4509, 3, 2, 2, 2, 4542, 4521, 3, 2, 2, 2, 4542, 4533, 3, 2, 2, 2, 4543, 487, 3, 2, 2, 2, 4544, 4545, 7, 222, 2, 2, 4545, 4546, 7, 79, 2, 2, 4546, 4547, 7, 398, 2, 2, 4547, 489, 3, 2, 2, 2, 4548, 4549, 7, 48, 2, 2, 4549, 4550, 7, 280, 2, 2, 4550, 4551, 7, 158, 2, 2, 4551, 4553, 5, 532, 267, 2, 4552, 4554, 5, 496, 249, 2, 4553, 4552, 3, 2, 2, 2, 4553, 4554, 3, 2, 2, 2, 4554, 4555, 3, 2, 2, 2, 4555, 4556, 7, 64, 2, 2, 4556, 4557, 7, 362, 2, 2, 4557, 4558, 5, 1122, 562, 2, 4558, 4559, 7, 102, 2, 2, 4559, 4561, 5, 1344, 673, 2, 4560, 4562, 5, 498, 250, 2, 4561, 4560, 3, 2, 2, 2, 4561, 4562, 3, 2, 2, 2, 4562, 4563, 3, 2, 2, 2, 4563, 4564, 7, 38, 2, 2, 4564, 4565, 5, 492, 247, 2, 4565, 491, 3, 2, 2, 2, 4566, 4571, 5, 494, 248, 2, 4567, 4568, 7, 8, 2, 2, 4568, 4570, 5, 494, 248, 2, 4569, 4567, 3, 2, 2, 2, 4570, 4573, 3, 2, 2, 2, 4571, 4569, 3, 2, 2, 2, 4571, 4572, 3, 2, 2, 2, 4572, 493, 3, 2, 2, 2, 4573, 4571, 3, 2, 2, 2, 4574, 4575, 7, 280, 2, 2, 4575, 4576, 5, 1360, 681, 2, 4576, 4578, 5, 698, 350, 2, 4577, 4579, 5, 500, 251, 2, 4578, 4577, 3, 2, 2, 2, 4578, 4579, 3, 2, 2, 2, 4579, 4581, 3, 2, 2, 2, 4580, 4582, 5, 502, 252, 2, 4581, 4580, 3, 2, 2, 2, 4581, 4582, 3, 2, 2, 2, 4582, 4606, 3, 2, 2, 2, 4583, 4584, 7, 280, 2, 2, 4584, 4585, 5, 1360, 681, 2, 4585, 4587, 5, 702, 352, 2, 4586, 4588, 5, 500, 251, 2, 4587, 4586, 3, 2, 2, 2, 4587, 4588, 3, 2, 2, 2, 4588, 4590, 3, 2, 2, 2, 4589, 4591, 5, 502, 252, 2, 4590, 4589, 3, 2, 2, 2, 4590, 4591, 3, 2, 2, 2, 4591, 4606, 3, 2, 2, 2, 4592, 4593, 7, 213, 2, 2, 4593, 4594, 5, 1360, 681, 2, 4594, 4595, 5, 640, 321, 2, 4595, 4606, 3, 2, 2, 2, 4596, 4597, 7, 213, 2, 2, 4597, 4598, 5, 1360, 681, 2, 4598, 4599, 7, 4, 2, 2, 4599, 4600, 5, 1288, 645, 2, 4600, 4601, 7, 5, 2, 2, 4601, 4602, 5, 640, 321, 2, 4602, 4606, 3, 2, 2, 2, 4603, 4604, 7, 347, 2, 2, 4604, 4606, 5, 1122, 562, 2, 4605, 4574, 3, 2, 2, 2, 4605, 4583, 3, 2, 2, 2, 4605, 4592, 3, 2, 2, 2, 4605, 4596, 3, 2, 2, 2, 4605, 4603, 3, 2, 2, 2, 4606, 495, 3, 2, 2, 2, 4607, 4608, 7, 55, 2, 2, 4608, 497, 3, 2, 2, 2, 4609, 4610, 7, 208, 2, 2, 4610, 4611, 5, 532, 267, 2, 4611, 499, 3, 2, 2, 2, 4612, 4613, 7, 64, 2, 2, 4613, 4619, 7, 327, 2, 2, 4614, 4615, 7, 64, 2, 2, 4615, 4616, 7, 85, 2, 2, 4616, 4617, 7, 149, 2, 2, 4617, 4619, 5, 532, 267, 2, 4618, 4612, 3, 2, 2, 2, 4618, 4614, 3, 2, 2, 2, 4619, 501, 3, 2, 2, 2, 4620, 4621, 7, 304, 2, 2, 4621, 503, 3, 2, 2, 2, 4622, 4623, 7, 48, 2, 2, 4623, 4624, 7, 280, 2, 2, 4624, 4625, 7, 208, 2, 2, 4625, 4626, 5, 532, 267, 2, 4626, 4627, 7, 102, 2, 2, 4627, 4628, 5, 1344, 673, 2, 4628, 505, 3, 2, 2, 2, 4629, 4630, 7, 140, 2, 2, 4630, 4631, 7, 280, 2, 2, 4631, 4632, 7, 208, 2, 2, 4632, 4633, 5, 532, 267, 2, 4633, 4634, 7, 102, 2, 2, 4634, 4635, 5, 1344, 673, 2, 4635, 4636, 7, 135, 2, 2, 4636, 4637, 5, 492, 247, 2, 4637, 4648, 3, 2, 2, 2, 4638, 4639, 7, 140, 2, 2, 4639, 4640, 7, 280, 2, 2, 4640, 4641, 7, 208, 2, 2, 4641, 4642, 5, 532, 267, 2, 4642, 4643, 7, 102, 2, 2, 4643, 4644, 5, 1344, 673, 2, 4644, 4645, 7, 193, 2, 2, 4645, 4646, 5, 508, 255, 2, 4646, 4648, 3, 2, 2, 2, 4647, 4629, 3, 2, 2, 2, 4647, 4638, 3, 2, 2, 2, 4648, 507, 3, 2, 2, 2, 4649, 4654, 5, 510, 256, 2, 4650, 4651, 7, 8, 2, 2, 4651, 4653, 5, 510, 256, 2, 4652, 4650, 3, 2, 2, 2, 4653, 4656, 3, 2, 2, 2, 4654, 4652, 3, 2, 2, 2, 4654, 4655, 3, 2, 2, 2, 4655, 509, 3, 2, 2, 2, 4656, 4654, 3, 2, 2, 2, 4657, 4658, 7, 280, 2, 2, 4658, 4659, 5, 1360, 681, 2, 4659, 4660, 7, 4, 2, 2, 4660, 4661, 5, 1288, 645, 2, 4661, 4662, 7, 5, 2, 2, 4662, 4670, 3, 2, 2, 2, 4663, 4664, 7, 213, 2, 2, 4664, 4665, 5, 1360, 681, 2, 4665, 4666, 7, 4, 2, 2, 4666, 4667, 5, 1288, 645, 2, 4667, 4668, 7, 5, 2, 2, 4668, 4670, 3, 2, 2, 2, 4669, 4657, 3, 2, 2, 2, 4669, 4663, 3, 2, 2, 2, 4670, 511, 3, 2, 2, 2, 4671, 4672, 7, 193, 2, 2, 4672, 4673, 7, 280, 2, 2, 4673, 4674, 7, 158, 2, 2, 4674, 4675, 5, 532, 267, 2, 4675, 4676, 7, 102, 2, 2, 4676, 4678, 5, 1344, 673, 2, 4677, 4679, 5, 108, 55, 2, 4678, 4677, 3, 2, 2, 2, 4678, 4679, 3, 2, 2, 2, 4679, 4692, 3, 2, 2, 2, 4680, 4681, 7, 193, 2, 2, 4681, 4682, 7, 280, 2, 2, 4682, 4683, 7, 158, 2, 2, 4683, 4684, 7, 222, 2, 2, 4684, 4685, 7, 398, 2, 2, 4685, 4686, 5, 532, 267, 2, 4686, 4687, 7, 102, 2, 2, 4687, 4689, 5, 1344, 673, 2, 4688, 4690, 5, 108, 55, 2, 4689, 4688, 3, 2, 2, 2, 4689, 4690, 3, 2, 2, 2, 4690, 4692, 3, 2, 2, 2, 4691, 4671, 3, 2, 2, 2, 4691, 4680, 3, 2, 2, 2, 4692, 513, 3, 2, 2, 2, 4693, 4694, 7, 193, 2, 2, 4694, 4695, 7, 280, 2, 2, 4695, 4696, 7, 208, 2, 2, 4696, 4697, 5, 532, 267, 2, 4697, 4698, 7, 102, 2, 2, 4698, 4700, 5, 1344, 673, 2, 4699, 4701, 5, 108, 55, 2, 4700, 4699, 3, 2, 2, 2, 4700, 4701, 3, 2, 2, 2, 4701, 4714, 3, 2, 2, 2, 4702, 4703, 7, 193, 2, 2, 4703, 4704, 7, 280, 2, 2, 4704, 4705, 7, 208, 2, 2, 4705, 4706, 7, 222, 2, 2, 4706, 4707, 7, 398, 2, 2, 4707, 4708, 5, 532, 267, 2, 4708, 4709, 7, 102, 2, 2, 4709, 4711, 5, 1344, 673, 2, 4710, 4712, 5, 108, 55, 2, 4711, 4710, 3, 2, 2, 2, 4711, 4712, 3, 2, 2, 2, 4712, 4714, 3, 2, 2, 2, 4713, 4693, 3, 2, 2, 2, 4713, 4702, 3, 2, 2, 2, 4714, 515, 3, 2, 2, 2, 4715, 4716, 7, 193, 2, 2, 4716, 4717, 7, 283, 2, 2, 4717, 4718, 7, 149, 2, 2, 4718, 4720, 5, 1376, 689, 2, 4719, 4721, 5, 108, 55, 2, 4720, 4719, 3, 2, 2, 2, 4720, 4721, 3, 2, 2, 2, 4721, 517, 3, 2, 2, 2, 4722, 4723, 7, 303, 2, 2, 4723, 4724, 7, 283, 2, 2, 4724, 4725, 7, 149, 2, 2, 4725, 4726, 5, 1376, 689, 2, 4726, 4727, 7, 96, 2, 2, 4727, 4728, 5, 1374, 688, 2, 4728, 519, 3, 2, 2, 2, 4729, 4730, 7, 193, 2, 2, 4730, 4731, 5, 522, 262, 2, 4731, 4732, 7, 222, 2, 2, 4732, 4733, 7, 398, 2, 2, 4733, 4735, 5, 530, 266, 2, 4734, 4736, 5, 108, 55, 2, 4735, 4734, 3, 2, 2, 2, 4735, 4736, 3, 2, 2, 2, 4736, 4820, 3, 2, 2, 2, 4737, 4738, 7, 193, 2, 2, 4738, 4739, 5, 522, 262, 2, 4739, 4741, 5, 530, 266, 2, 4740, 4742, 5, 108, 55, 2, 4741, 4740, 3, 2, 2, 2, 4741, 4742, 3, 2, 2, 2, 4742, 4820, 3, 2, 2, 2, 4743, 4744, 7, 193, 2, 2, 4744, 4745, 5, 526, 264, 2, 4745, 4746, 7, 222, 2, 2, 4746, 4747, 7, 398, 2, 2, 4747, 4749, 5, 1342, 672, 2, 4748, 4750, 5, 108, 55, 2, 4749, 4748, 3, 2, 2, 2, 4749, 4750, 3, 2, 2, 2, 4750, 4820, 3, 2, 2, 2, 4751, 4752, 7, 193, 2, 2, 4752, 4753, 5, 526, 264, 2, 4753, 4755, 5, 1342, 672, 2, 4754, 4756, 5, 108, 55, 2, 4755, 4754, 3, 2, 2, 2, 4755, 4756, 3, 2, 2, 2, 4756, 4820, 3, 2, 2, 2, 4757, 4758, 7, 193, 2, 2, 4758, 4759, 5, 528, 265, 2, 4759, 4760, 5, 1344, 673, 2, 4760, 4761, 7, 82, 2, 2, 4761, 4763, 5, 532, 267, 2, 4762, 4764, 5, 108, 55, 2, 4763, 4762, 3, 2, 2, 2, 4763, 4764, 3, 2, 2, 2, 4764, 4820, 3, 2, 2, 2, 4765, 4766, 7, 193, 2, 2, 4766, 4767, 5, 528, 265, 2, 4767, 4768, 7, 222, 2, 2, 4768, 4769, 7, 398, 2, 2, 4769, 4770, 5, 1344, 673, 2, 4770, 4771, 7, 82, 2, 2, 4771, 4773, 5, 532, 267, 2, 4772, 4774, 5, 108, 55, 2, 4773, 4772, 3, 2, 2, 2, 4773, 4774, 3, 2, 2, 2, 4774, 4820, 3, 2, 2, 2, 4775, 4776, 7, 193, 2, 2, 4776, 4777, 7, 362, 2, 2, 4777, 4779, 5, 536, 269, 2, 4778, 4780, 5, 108, 55, 2, 4779, 4778, 3, 2, 2, 2, 4779, 4780, 3, 2, 2, 2, 4780, 4820, 3, 2, 2, 2, 4781, 4782, 7, 193, 2, 2, 4782, 4783, 7, 362, 2, 2, 4783, 4784, 7, 222, 2, 2, 4784, 4785, 7, 398, 2, 2, 4785, 4787, 5, 536, 269, 2, 4786, 4788, 5, 108, 55, 2, 4787, 4786, 3, 2, 2, 2, 4787, 4788, 3, 2, 2, 2, 4788, 4820, 3, 2, 2, 2, 4789, 4790, 7, 193, 2, 2, 4790, 4791, 7, 191, 2, 2, 4791, 4793, 5, 536, 269, 2, 4792, 4794, 5, 108, 55, 2, 4793, 4792, 3, 2, 2, 2, 4793, 4794, 3, 2, 2, 2, 4794, 4820, 3, 2, 2, 2, 4795, 4796, 7, 193, 2, 2, 4796, 4797, 7, 191, 2, 2, 4797, 4798, 7, 222, 2, 2, 4798, 4799, 7, 398, 2, 2, 4799, 4801, 5, 536, 269, 2, 4800, 4802, 5, 108, 55, 2, 4801, 4800, 3, 2, 2, 2, 4801, 4802, 3, 2, 2, 2, 4802, 4820, 3, 2, 2, 2, 4803, 4804, 7, 193, 2, 2, 4804, 4805, 7, 228, 2, 2, 4805, 4806, 7, 111, 2, 2, 4806, 4808, 5, 530, 266, 2, 4807, 4809, 5, 108, 55, 2, 4808, 4807, 3, 2, 2, 2, 4808, 4809, 3, 2, 2, 2, 4809, 4820, 3, 2, 2, 2, 4810, 4811, 7, 193, 2, 2, 4811, 4812, 7, 228, 2, 2, 4812, 4813, 7, 111, 2, 2, 4813, 4814, 7, 222, 2, 2, 4814, 4815, 7, 398, 2, 2, 4815, 4817, 5, 530, 266, 2, 4816, 4818, 5, 108, 55, 2, 4817, 4816, 3, 2, 2, 2, 4817, 4818, 3, 2, 2, 2, 4818, 4820, 3, 2, 2, 2, 4819, 4729, 3, 2, 2, 2, 4819, 4737, 3, 2, 2, 2, 4819, 4743, 3, 2, 2, 2, 4819, 4751, 3, 2, 2, 2, 4819, 4757, 3, 2, 2, 2, 4819, 4765, 3, 2, 2, 2, 4819, 4775, 3, 2, 2, 2, 4819, 4781, 3, 2, 2, 2, 4819, 4789, 3, 2, 2, 2, 4819, 4795, 3, 2, 2, 2, 4819, 4803, 3, 2, 2, 2, 4819, 4810, 3, 2, 2, 2, 4820, 521, 3, 2, 2, 2, 4821, 4845, 7, 94, 2, 2, 4822, 4845, 7, 330, 2, 2, 4823, 4845, 7, 378, 2, 2, 4824, 4825, 7, 261, 2, 2, 4825, 4845, 7, 378, 2, 2, 4826, 4845, 7, 228, 2, 2, 4827, 4828, 7, 65, 2, 2, 4828, 4845, 7, 94, 2, 2, 4829, 4845, 7, 110, 2, 2, 4830, 4845, 7, 170, 2, 2, 4831, 4845, 7, 344, 2, 2, 4832, 4833, 7, 357, 2, 2, 4833, 4834, 7, 327, 2, 2, 4834, 4845, 7, 285, 2, 2, 4835, 4836, 7, 357, 2, 2, 4836, 4837, 7, 327, 2, 2, 4837, 4845, 7, 187, 2, 2, 4838, 4839, 7, 357, 2, 2, 4839, 4840, 7, 327, 2, 2, 4840, 4845, 7, 355, 2, 2, 4841, 4842, 7, 357, 2, 2, 4842, 4843, 7, 327, 2, 2, 4843, 4845, 7, 165, 2, 2, 4844, 4821, 3, 2, 2, 2, 4844, 4822, 3, 2, 2, 2, 4844, 4823, 3, 2, 2, 2, 4844, 4824, 3, 2, 2, 2, 4844, 4826, 3, 2, 2, 2, 4844, 4827, 3, 2, 2, 2, 4844, 4829, 3, 2, 2, 2, 4844, 4830, 3, 2, 2, 2, 4844, 4831, 3, 2, 2, 2, 4844, 4832, 3, 2, 2, 2, 4844, 4835, 3, 2, 2, 2, 4844, 4838, 3, 2, 2, 2, 4844, 4841, 3, 2, 2, 2, 4845, 523, 3, 2, 2, 2, 4846, 4852, 5, 526, 264, 2, 4847, 4852, 7, 177, 2, 2, 4848, 4852, 7, 320, 2, 2, 4849, 4852, 7, 453, 2, 2, 4850, 4852, 7, 353, 2, 2, 4851, 4846, 3, 2, 2, 2, 4851, 4847, 3, 2, 2, 2, 4851, 4848, 3, 2, 2, 2, 4851, 4849, 3, 2, 2, 2, 4851, 4850, 3, 2, 2, 2, 4852, 525, 3, 2, 2, 2, 4853, 4854, 7, 133, 2, 2, 4854, 4869, 7, 448, 2, 2, 4855, 4856, 7, 200, 2, 2, 4856, 4869, 7, 359, 2, 2, 4857, 4869, 7, 206, 2, 2, 4858, 4859, 7, 65, 2, 2, 4859, 4860, 7, 176, 2, 2, 4860, 4869, 7, 383, 2, 2, 4861, 4863, 5, 312, 157, 2, 4862, 4861, 3, 2, 2, 2, 4862, 4863, 3, 2, 2, 2, 4863, 4864, 3, 2, 2, 2, 4864, 4869, 7, 249, 2, 2, 4865, 4869, 7, 454, 2, 2, 4866, 4869, 7, 325, 2, 2, 4867, 4869, 7, 333, 2, 2, 4868, 4853, 3, 2, 2, 2, 4868, 4855, 3, 2, 2, 2, 4868, 4857, 3, 2, 2, 2, 4868, 4858, 3, 2, 2, 2, 4868, 4862, 3, 2, 2, 2, 4868, 4865, 3, 2, 2, 2, 4868, 4866, 3, 2, 2, 2, 4868, 4867, 3, 2, 2, 2, 4869, 527, 3, 2, 2, 2, 4870, 4871, 9, 31, 2, 2, 4871, 529, 3, 2, 2, 2, 4872, 4877, 5, 532, 267, 2, 4873, 4874, 7, 8, 2, 2, 4874, 4876, 5, 532, 267, 2, 4875, 4873, 3, 2, 2, 2, 4876, 4879, 3, 2, 2, 2, 4877, 4875, 3, 2, 2, 2, 4877, 4878, 3, 2, 2, 2, 4878, 531, 3, 2, 2, 2, 4879, 4877, 3, 2, 2, 2, 4880, 4882, 5, 1378, 690, 2, 4881, 4883, 5, 534, 268, 2, 4882, 4881, 3, 2, 2, 2, 4882, 4883, 3, 2, 2, 2, 4883, 533, 3, 2, 2, 2, 4884, 4885, 7, 13, 2, 2, 4885, 4887, 5, 1346, 674, 2, 4886, 4884, 3, 2, 2, 2, 4887, 4888, 3, 2, 2, 2, 4888, 4886, 3, 2, 2, 2, 4888, 4889, 3, 2, 2, 2, 4889, 535, 3, 2, 2, 2, 4890, 4895, 5, 1122, 562, 2, 4891, 4892, 7, 8, 2, 2, 4892, 4894, 5, 1122, 562, 2, 4893, 4891, 3, 2, 2, 2, 4894, 4897, 3, 2, 2, 2, 4895, 4893, 3, 2, 2, 2, 4895, 4896, 3, 2, 2, 2, 4896, 537, 3, 2, 2, 2, 4897, 4895, 3, 2, 2, 2, 4898, 4900, 7, 360, 2, 2, 4899, 4901, 5, 996, 499, 2, 4900, 4899, 3, 2, 2, 2, 4900, 4901, 3, 2, 2, 2, 4901, 4902, 3, 2, 2, 2, 4902, 4904, 5, 1080, 541, 2, 4903, 4905, 5, 540, 271, 2, 4904, 4903, 3, 2, 2, 2, 4904, 4905, 3, 2, 2, 2, 4905, 4907, 3, 2, 2, 2, 4906, 4908, 5, 108, 55, 2, 4907, 4906, 3, 2, 2, 2, 4907, 4908, 3, 2, 2, 2, 4908, 539, 3, 2, 2, 2, 4909, 4910, 7, 169, 2, 2, 4910, 4914, 7, 221, 2, 2, 4911, 4912, 7, 316, 2, 2, 4912, 4914, 7, 221, 2, 2, 4913, 4909, 3, 2, 2, 2, 4913, 4911, 3, 2, 2, 2, 4914, 541, 3, 2, 2, 2, 4915, 4916, 7, 161, 2, 2, 4916, 4917, 7, 82, 2, 2, 4917, 4918, 5, 522, 262, 2, 4918, 4919, 5, 532, 267, 2, 4919, 4920, 7, 118, 2, 2, 4920, 4921, 5, 544, 273, 2, 4921, 5063, 3, 2, 2, 2, 4922, 4923, 7, 161, 2, 2, 4923, 4924, 7, 82, 2, 2, 4924, 4925, 7, 46, 2, 2, 4925, 4926, 5, 532, 267, 2, 4926, 4927, 7, 118, 2, 2, 4927, 4928, 5, 544, 273, 2, 4928, 5063, 3, 2, 2, 2, 4929, 4930, 7, 161, 2, 2, 4930, 4931, 7, 82, 2, 2, 4931, 4932, 5, 524, 263, 2, 4932, 4933, 5, 1344, 673, 2, 4933, 4934, 7, 118, 2, 2, 4934, 4935, 5, 544, 273, 2, 4935, 5063, 3, 2, 2, 2, 4936, 4937, 7, 161, 2, 2, 4937, 4938, 7, 82, 2, 2, 4938, 4939, 7, 362, 2, 2, 4939, 4940, 5, 1122, 562, 2, 4940, 4941, 7, 118, 2, 2, 4941, 4942, 5, 544, 273, 2, 4942, 5063, 3, 2, 2, 2, 4943, 4944, 7, 161, 2, 2, 4944, 4945, 7, 82, 2, 2, 4945, 4946, 7, 191, 2, 2, 4946, 4947, 5, 1122, 562, 2, 4947, 4948, 7, 118, 2, 2, 4948, 4949, 5, 544, 273, 2, 4949, 5063, 3, 2, 2, 2, 4950, 4951, 7, 161, 2, 2, 4951, 4952, 7, 82, 2, 2, 4952, 4953, 7, 138, 2, 2, 4953, 4954, 5, 664, 333, 2, 4954, 4955, 7, 118, 2, 2, 4955, 4956, 5, 544, 273, 2, 4956, 5063, 3, 2, 2, 2, 4957, 4958, 7, 161, 2, 2, 4958, 4959, 7, 82, 2, 2, 4959, 4960, 7, 213, 2, 2, 4960, 4961, 5, 640, 321, 2, 4961, 4962, 7, 118, 2, 2, 4962, 4963, 5, 544, 273, 2, 4963, 5063, 3, 2, 2, 2, 4964, 4965, 7, 161, 2, 2, 4965, 4966, 7, 82, 2, 2, 4966, 4967, 7, 280, 2, 2, 4967, 4968, 5, 702, 352, 2, 4968, 4969, 7, 118, 2, 2, 4969, 4970, 5, 544, 273, 2, 4970, 5063, 3, 2, 2, 2, 4971, 4972, 7, 161, 2, 2, 4972, 4973, 7, 82, 2, 2, 4973, 4974, 7, 47, 2, 2, 4974, 4975, 5, 1344, 673, 2, 4975, 4976, 7, 82, 2, 2, 4976, 4977, 5, 532, 267, 2, 4977, 4978, 7, 118, 2, 2, 4978, 4979, 5, 544, 273, 2, 4979, 5063, 3, 2, 2, 2, 4980, 4981, 7, 161, 2, 2, 4981, 4982, 7, 82, 2, 2, 4982, 4983, 7, 47, 2, 2, 4983, 4984, 5, 1344, 673, 2, 4984, 4985, 7, 82, 2, 2, 4985, 4986, 7, 191, 2, 2, 4986, 4987, 5, 532, 267, 2, 4987, 4988, 7, 118, 2, 2, 4988, 4989, 5, 544, 273, 2, 4989, 5063, 3, 2, 2, 2, 4990, 4991, 7, 161, 2, 2, 4991, 4992, 7, 82, 2, 2, 4992, 4993, 5, 528, 265, 2, 4993, 4994, 5, 1344, 673, 2, 4994, 4995, 7, 82, 2, 2, 4995, 4996, 5, 532, 267, 2, 4996, 4997, 7, 118, 2, 2, 4997, 4998, 5, 544, 273, 2, 4998, 5063, 3, 2, 2, 2, 4999, 5000, 7, 161, 2, 2, 5000, 5001, 7, 82, 2, 2, 5001, 5002, 7, 298, 2, 2, 5002, 5003, 5, 640, 321, 2, 5003, 5004, 7, 118, 2, 2, 5004, 5005, 5, 544, 273, 2, 5005, 5063, 3, 2, 2, 2, 5006, 5007, 7, 161, 2, 2, 5007, 5008, 7, 82, 2, 2, 5008, 5009, 7, 444, 2, 2, 5009, 5010, 5, 640, 321, 2, 5010, 5011, 7, 118, 2, 2, 5011, 5012, 5, 544, 273, 2, 5012, 5063, 3, 2, 2, 2, 5013, 5014, 7, 161, 2, 2, 5014, 5015, 7, 82, 2, 2, 5015, 5016, 7, 445, 2, 2, 5016, 5017, 7, 64, 2, 2, 5017, 5018, 5, 1122, 562, 2, 5018, 5019, 7, 249, 2, 2, 5019, 5020, 5, 1344, 673, 2, 5020, 5021, 7, 118, 2, 2, 5021, 5022, 5, 544, 273, 2, 5022, 5063, 3, 2, 2, 2, 5023, 5024, 7, 161, 2, 2, 5024, 5025, 7, 82, 2, 2, 5025, 5026, 7, 280, 2, 2, 5026, 5027, 7, 158, 2, 2, 5027, 5028, 5, 532, 267, 2, 5028, 5029, 7, 102, 2, 2, 5029, 5030, 5, 1344, 673, 2, 5030, 5031, 7, 118, 2, 2, 5031, 5032, 5, 544, 273, 2, 5032, 5063, 3, 2, 2, 2, 5033, 5034, 7, 161, 2, 2, 5034, 5035, 7, 82, 2, 2, 5035, 5036, 7, 280, 2, 2, 5036, 5037, 7, 208, 2, 2, 5037, 5038, 5, 532, 267, 2, 5038, 5039, 7, 102, 2, 2, 5039, 5040, 5, 1344, 673, 2, 5040, 5041, 7, 118, 2, 2, 5041, 5042, 5, 544, 273, 2, 5042, 5063, 3, 2, 2, 2, 5043, 5044, 7, 161, 2, 2, 5044, 5045, 7, 82, 2, 2, 5045, 5046, 7, 250, 2, 2, 5046, 5047, 7, 276, 2, 2, 5047, 5048, 5, 296, 149, 2, 5048, 5049, 7, 118, 2, 2, 5049, 5050, 5, 544, 273, 2, 5050, 5063, 3, 2, 2, 2, 5051, 5052, 7, 161, 2, 2, 5052, 5053, 7, 82, 2, 2, 5053, 5054, 7, 43, 2, 2, 5054, 5055, 7, 4, 2, 2, 5055, 5056, 5, 1122, 562, 2, 5056, 5057, 7, 38, 2, 2, 5057, 5058, 5, 1122, 562, 2, 5058, 5059, 7, 5, 2, 2, 5059, 5060, 7, 118, 2, 2, 5060, 5061, 5, 544, 273, 2, 5061, 5063, 3, 2, 2, 2, 5062, 4915, 3, 2, 2, 2, 5062, 4922, 3, 2, 2, 2, 5062, 4929, 3, 2, 2, 2, 5062, 4936, 3, 2, 2, 2, 5062, 4943, 3, 2, 2, 2, 5062, 4950, 3, 2, 2, 2, 5062, 4957, 3, 2, 2, 2, 5062, 4964, 3, 2, 2, 2, 5062, 4971, 3, 2, 2, 2, 5062, 4980, 3, 2, 2, 2, 5062, 4990, 3, 2, 2, 2, 5062, 4999, 3, 2, 2, 2, 5062, 5006, 3, 2, 2, 2, 5062, 5013, 3, 2, 2, 2, 5062, 5023, 3, 2, 2, 2, 5062, 5033, 3, 2, 2, 2, 5062, 5043, 3, 2, 2, 2, 5062, 5051, 3, 2, 2, 2, 5063, 543, 3, 2, 2, 2, 5064, 5067, 5, 1362, 682, 2, 5065, 5067, 7, 80, 2, 2, 5066, 5064, 3, 2, 2, 2, 5066, 5065, 3, 2, 2, 2, 5067, 545, 3, 2, 2, 2, 5068, 5069, 7, 329, 2, 2, 5069, 5071, 7, 248, 2, 2, 5070, 5072, 5, 548, 275, 2, 5071, 5070, 3, 2, 2, 2, 5071, 5072, 3, 2, 2, 2, 5072, 5073, 3, 2, 2, 2, 5073, 5074, 7, 82, 2, 2, 5074, 5075, 5, 522, 262, 2, 5075, 5076, 5, 532, 267, 2, 5076, 5077, 7, 118, 2, 2, 5077, 5078, 5, 550, 276, 2, 5078, 5180, 3, 2, 2, 2, 5079, 5080, 7, 329, 2, 2, 5080, 5082, 7, 248, 2, 2, 5081, 5083, 5, 548, 275, 2, 5082, 5081, 3, 2, 2, 2, 5082, 5083, 3, 2, 2, 2, 5083, 5084, 3, 2, 2, 2, 5084, 5085, 7, 82, 2, 2, 5085, 5086, 7, 46, 2, 2, 5086, 5087, 5, 532, 267, 2, 5087, 5088, 7, 118, 2, 2, 5088, 5089, 5, 550, 276, 2, 5089, 5180, 3, 2, 2, 2, 5090, 5091, 7, 329, 2, 2, 5091, 5093, 7, 248, 2, 2, 5092, 5094, 5, 548, 275, 2, 5093, 5092, 3, 2, 2, 2, 5093, 5094, 3, 2, 2, 2, 5094, 5095, 3, 2, 2, 2, 5095, 5096, 7, 82, 2, 2, 5096, 5097, 5, 524, 263, 2, 5097, 5098, 5, 1344, 673, 2, 5098, 5099, 7, 118, 2, 2, 5099, 5100, 5, 550, 276, 2, 5100, 5180, 3, 2, 2, 2, 5101, 5102, 7, 329, 2, 2, 5102, 5104, 7, 248, 2, 2, 5103, 5105, 5, 548, 275, 2, 5104, 5103, 3, 2, 2, 2, 5104, 5105, 3, 2, 2, 2, 5105, 5106, 3, 2, 2, 2, 5106, 5107, 7, 82, 2, 2, 5107, 5108, 7, 362, 2, 2, 5108, 5109, 5, 1122, 562, 2, 5109, 5110, 7, 118, 2, 2, 5110, 5111, 5, 550, 276, 2, 5111, 5180, 3, 2, 2, 2, 5112, 5113, 7, 329, 2, 2, 5113, 5115, 7, 248, 2, 2, 5114, 5116, 5, 548, 275, 2, 5115, 5114, 3, 2, 2, 2, 5115, 5116, 3, 2, 2, 2, 5116, 5117, 3, 2, 2, 2, 5117, 5118, 7, 82, 2, 2, 5118, 5119, 7, 191, 2, 2, 5119, 5120, 5, 1122, 562, 2, 5120, 5121, 7, 118, 2, 2, 5121, 5122, 5, 550, 276, 2, 5122, 5180, 3, 2, 2, 2, 5123, 5124, 7, 329, 2, 2, 5124, 5126, 7, 248, 2, 2, 5125, 5127, 5, 548, 275, 2, 5126, 5125, 3, 2, 2, 2, 5126, 5127, 3, 2, 2, 2, 5127, 5128, 3, 2, 2, 2, 5128, 5129, 7, 82, 2, 2, 5129, 5130, 7, 138, 2, 2, 5130, 5131, 5, 664, 333, 2, 5131, 5132, 7, 118, 2, 2, 5132, 5133, 5, 550, 276, 2, 5133, 5180, 3, 2, 2, 2, 5134, 5135, 7, 329, 2, 2, 5135, 5137, 7, 248, 2, 2, 5136, 5138, 5, 548, 275, 2, 5137, 5136, 3, 2, 2, 2, 5137, 5138, 3, 2, 2, 2, 5138, 5139, 3, 2, 2, 2, 5139, 5140, 7, 82, 2, 2, 5140, 5141, 7, 213, 2, 2, 5141, 5142, 5, 640, 321, 2, 5142, 5143, 7, 118, 2, 2, 5143, 5144, 5, 550, 276, 2, 5144, 5180, 3, 2, 2, 2, 5145, 5146, 7, 329, 2, 2, 5146, 5148, 7, 248, 2, 2, 5147, 5149, 5, 548, 275, 2, 5148, 5147, 3, 2, 2, 2, 5148, 5149, 3, 2, 2, 2, 5149, 5150, 3, 2, 2, 2, 5150, 5151, 7, 82, 2, 2, 5151, 5152, 7, 250, 2, 2, 5152, 5153, 7, 276, 2, 2, 5153, 5154, 5, 296, 149, 2, 5154, 5155, 7, 118, 2, 2, 5155, 5156, 5, 550, 276, 2, 5156, 5180, 3, 2, 2, 2, 5157, 5158, 7, 329, 2, 2, 5158, 5160, 7, 248, 2, 2, 5159, 5161, 5, 548, 275, 2, 5160, 5159, 3, 2, 2, 2, 5160, 5161, 3, 2, 2, 2, 5161, 5162, 3, 2, 2, 2, 5162, 5163, 7, 82, 2, 2, 5163, 5164, 7, 298, 2, 2, 5164, 5165, 5, 640, 321, 2, 5165, 5166, 7, 118, 2, 2, 5166, 5167, 5, 550, 276, 2, 5167, 5180, 3, 2, 2, 2, 5168, 5169, 7, 329, 2, 2, 5169, 5171, 7, 248, 2, 2, 5170, 5172, 5, 548, 275, 2, 5171, 5170, 3, 2, 2, 2, 5171, 5172, 3, 2, 2, 2, 5172, 5173, 3, 2, 2, 2, 5173, 5174, 7, 82, 2, 2, 5174, 5175, 7, 444, 2, 2, 5175, 5176, 5, 640, 321, 2, 5176, 5177, 7, 118, 2, 2, 5177, 5178, 5, 550, 276, 2, 5178, 5180, 3, 2, 2, 2, 5179, 5068, 3, 2, 2, 2, 5179, 5079, 3, 2, 2, 2, 5179, 5090, 3, 2, 2, 2, 5179, 5101, 3, 2, 2, 2, 5179, 5112, 3, 2, 2, 2, 5179, 5123, 3, 2, 2, 2, 5179, 5134, 3, 2, 2, 2, 5179, 5145, 3, 2, 2, 2, 5179, 5157, 3, 2, 2, 2, 5179, 5168, 3, 2, 2, 2, 5180, 547, 3, 2, 2, 2, 5181, 5182, 7, 64, 2, 2, 5182, 5183, 5, 72, 37, 2, 5183, 549, 3, 2, 2, 2, 5184, 5187, 5, 1362, 682, 2, 5185, 5187, 7, 80, 2, 2, 5186, 5184, 3, 2, 2, 2, 5186, 5185, 3, 2, 2, 2, 5187, 551, 3, 2, 2, 2, 5188, 5189, 7, 63, 2, 2, 5189, 5193, 5, 554, 278, 2, 5190, 5191, 7, 267, 2, 2, 5191, 5193, 5, 554, 278, 2, 5192, 5188, 3, 2, 2, 2, 5192, 5190, 3, 2, 2, 2, 5193, 553, 3, 2, 2, 2, 5194, 5280, 5, 960, 481, 2, 5195, 5196, 5, 556, 279, 2, 5196, 5197, 5, 960, 481, 2, 5197, 5280, 3, 2, 2, 2, 5198, 5200, 7, 270, 2, 2, 5199, 5201, 5, 558, 280, 2, 5200, 5199, 3, 2, 2, 2, 5200, 5201, 3, 2, 2, 2, 5201, 5202, 3, 2, 2, 2, 5202, 5280, 5, 960, 481, 2, 5203, 5205, 7, 295, 2, 2, 5204, 5206, 5, 558, 280, 2, 5205, 5204, 3, 2, 2, 2, 5205, 5206, 3, 2, 2, 2, 5206, 5207, 3, 2, 2, 2, 5207, 5280, 5, 960, 481, 2, 5208, 5210, 7, 209, 2, 2, 5209, 5211, 5, 558, 280, 2, 5210, 5209, 3, 2, 2, 2, 5210, 5211, 3, 2, 2, 2, 5211, 5212, 3, 2, 2, 2, 5212, 5280, 5, 960, 481, 2, 5213, 5215, 7, 251, 2, 2, 5214, 5216, 5, 558, 280, 2, 5215, 5214, 3, 2, 2, 2, 5215, 5216, 3, 2, 2, 2, 5216, 5217, 3, 2, 2, 2, 5217, 5280, 5, 960, 481, 2, 5218, 5219, 7, 132, 2, 2, 5219, 5221, 5, 1368, 685, 2, 5220, 5222, 5, 558, 280, 2, 5221, 5220, 3, 2, 2, 2, 5221, 5222, 3, 2, 2, 2, 5222, 5223, 3, 2, 2, 2, 5223, 5224, 5, 960, 481, 2, 5224, 5280, 3, 2, 2, 2, 5225, 5226, 7, 309, 2, 2, 5226, 5228, 5, 1368, 685, 2, 5227, 5229, 5, 558, 280, 2, 5228, 5227, 3, 2, 2, 2, 5228, 5229, 3, 2, 2, 2, 5229, 5230, 3, 2, 2, 2, 5230, 5231, 5, 960, 481, 2, 5231, 5280, 3, 2, 2, 2, 5232, 5234, 5, 1368, 685, 2, 5233, 5235, 5, 558, 280, 2, 5234, 5233, 3, 2, 2, 2, 5234, 5235, 3, 2, 2, 2, 5235, 5236, 3, 2, 2, 2, 5236, 5237, 5, 960, 481, 2, 5237, 5280, 3, 2, 2, 2, 5238, 5240, 7, 32, 2, 2, 5239, 5241, 5, 558, 280, 2, 5240, 5239, 3, 2, 2, 2, 5240, 5241, 3, 2, 2, 2, 5241, 5242, 3, 2, 2, 2, 5242, 5280, 5, 960, 481, 2, 5243, 5245, 7, 212, 2, 2, 5244, 5246, 5, 558, 280, 2, 5245, 5244, 3, 2, 2, 2, 5245, 5246, 3, 2, 2, 2, 5246, 5247, 3, 2, 2, 2, 5247, 5280, 5, 960, 481, 2, 5248, 5249, 7, 212, 2, 2, 5249, 5251, 5, 1368, 685, 2, 5250, 5252, 5, 558, 280, 2, 5251, 5250, 3, 2, 2, 2, 5251, 5252, 3, 2, 2, 2, 5252, 5253, 3, 2, 2, 2, 5253, 5254, 5, 960, 481, 2, 5254, 5280, 3, 2, 2, 2, 5255, 5256, 7, 212, 2, 2, 5256, 5258, 7, 32, 2, 2, 5257, 5259, 5, 558, 280, 2, 5258, 5257, 3, 2, 2, 2, 5258, 5259, 3, 2, 2, 2, 5259, 5260, 3, 2, 2, 2, 5260, 5280, 5, 960, 481, 2, 5261, 5263, 7, 146, 2, 2, 5262, 5264, 5, 558, 280, 2, 5263, 5262, 3, 2, 2, 2, 5263, 5264, 3, 2, 2, 2, 5264, 5265, 3, 2, 2, 2, 5265, 5280, 5, 960, 481, 2, 5266, 5267, 7, 146, 2, 2, 5267, 5269, 5, 1368, 685, 2, 5268, 5270, 5, 558, 280, 2, 5269, 5268, 3, 2, 2, 2, 5269, 5270, 3, 2, 2, 2, 5270, 5271, 3, 2, 2, 2, 5271, 5272, 5, 960, 481, 2, 5272, 5280, 3, 2, 2, 2, 5273, 5274, 7, 146, 2, 2, 5274, 5276, 7, 32, 2, 2, 5275, 5277, 5, 558, 280, 2, 5276, 5275, 3, 2, 2, 2, 5276, 5277, 3, 2, 2, 2, 5277, 5278, 3, 2, 2, 2, 5278, 5280, 5, 960, 481, 2, 5279, 5194, 3, 2, 2, 2, 5279, 5195, 3, 2, 2, 2, 5279, 5198, 3, 2, 2, 2, 5279, 5203, 3, 2, 2, 2, 5279, 5208, 3, 2, 2, 2, 5279, 5213, 3, 2, 2, 2, 5279, 5218, 3, 2, 2, 2, 5279, 5225, 3, 2, 2, 2, 5279, 5232, 3, 2, 2, 2, 5279, 5238, 3, 2, 2, 2, 5279, 5243, 3, 2, 2, 2, 5279, 5248, 3, 2, 2, 2, 5279, 5255, 3, 2, 2, 2, 5279, 5261, 3, 2, 2, 2, 5279, 5266, 3, 2, 2, 2, 5279, 5273, 3, 2, 2, 2, 5280, 555, 3, 2, 2, 2, 5281, 5282, 9, 32, 2, 2, 5282, 557, 3, 2, 2, 2, 5283, 5284, 5, 556, 279, 2, 5284, 559, 3, 2, 2, 2, 5285, 5286, 7, 67, 2, 2, 5286, 5287, 5, 564, 283, 2, 5287, 5288, 7, 82, 2, 2, 5288, 5289, 5, 574, 288, 2, 5289, 5290, 7, 96, 2, 2, 5290, 5292, 5, 576, 289, 2, 5291, 5293, 5, 580, 291, 2, 5292, 5291, 3, 2, 2, 2, 5292, 5293, 3, 2, 2, 2, 5293, 561, 3, 2, 2, 2, 5294, 5295, 7, 319, 2, 2, 5295, 5296, 5, 564, 283, 2, 5296, 5297, 7, 82, 2, 2, 5297, 5298, 5, 574, 288, 2, 5298, 5299, 7, 66, 2, 2, 5299, 5301, 5, 576, 289, 2, 5300, 5302, 5, 108, 55, 2, 5301, 5300, 3, 2, 2, 2, 5301, 5302, 3, 2, 2, 2, 5302, 5316, 3, 2, 2, 2, 5303, 5304, 7, 319, 2, 2, 5304, 5305, 7, 67, 2, 2, 5305, 5306, 7, 281, 2, 2, 5306, 5307, 7, 64, 2, 2, 5307, 5308, 5, 564, 283, 2, 5308, 5309, 7, 82, 2, 2, 5309, 5310, 5, 574, 288, 2, 5310, 5311, 7, 66, 2, 2, 5311, 5313, 5, 576, 289, 2, 5312, 5314, 5, 108, 55, 2, 5313, 5312, 3, 2, 2, 2, 5313, 5314, 3, 2, 2, 2, 5314, 5316, 3, 2, 2, 2, 5315, 5294, 3, 2, 2, 2, 5315, 5303, 3, 2, 2, 2, 5316, 563, 3, 2, 2, 2, 5317, 5334, 5, 570, 286, 2, 5318, 5334, 7, 32, 2, 2, 5319, 5320, 7, 32, 2, 2, 5320, 5334, 7, 296, 2, 2, 5321, 5322, 7, 32, 2, 2, 5322, 5323, 7, 4, 2, 2, 5323, 5324, 5, 220, 111, 2, 5324, 5325, 7, 5, 2, 2, 5325, 5334, 3, 2, 2, 2, 5326, 5327, 7, 32, 2, 2, 5327, 5328, 7, 296, 2, 2, 5328, 5329, 7, 4, 2, 2, 5329, 5330, 5, 220, 111, 2, 5330, 5331, 7, 5, 2, 2, 5331, 5334, 3, 2, 2, 2, 5332, 5334, 5, 566, 284, 2, 5333, 5317, 3, 2, 2, 2, 5333, 5318, 3, 2, 2, 2, 5333, 5319, 3, 2, 2, 2, 5333, 5321, 3, 2, 2, 2, 5333, 5326, 3, 2, 2, 2, 5333, 5332, 3, 2, 2, 2, 5334, 565, 3, 2, 2, 2, 5335, 5340, 5, 568, 285, 2, 5336, 5337, 7, 8, 2, 2, 5337, 5339, 5, 568, 285, 2, 5338, 5336, 3, 2, 2, 2, 5339, 5342, 3, 2, 2, 2, 5340, 5338, 3, 2, 2, 2, 5340, 5341, 3, 2, 2, 2, 5341, 567, 3, 2, 2, 2, 5342, 5340, 3, 2, 2, 2, 5343, 5344, 9, 33, 2, 2, 5344, 569, 3, 2, 2, 2, 5345, 5350, 5, 572, 287, 2, 5346, 5347, 7, 8, 2, 2, 5347, 5349, 5, 572, 287, 2, 5348, 5346, 3, 2, 2, 2, 5349, 5352, 3, 2, 2, 2, 5350, 5348, 3, 2, 2, 2, 5350, 5351, 3, 2, 2, 2, 5351, 571, 3, 2, 2, 2, 5352, 5350, 3, 2, 2, 2, 5353, 5355, 7, 90, 2, 2, 5354, 5356, 5, 218, 110, 2, 5355, 5354, 3, 2, 2, 2, 5355, 5356, 3, 2, 2, 2, 5356, 5370, 3, 2, 2, 2, 5357, 5359, 7, 88, 2, 2, 5358, 5360, 5, 218, 110, 2, 5359, 5358, 3, 2, 2, 2, 5359, 5360, 3, 2, 2, 2, 5360, 5370, 3, 2, 2, 2, 5361, 5363, 7, 48, 2, 2, 5362, 5364, 5, 218, 110, 2, 5363, 5362, 3, 2, 2, 2, 5363, 5364, 3, 2, 2, 2, 5364, 5370, 3, 2, 2, 2, 5365, 5367, 5, 1378, 690, 2, 5366, 5368, 5, 218, 110, 2, 5367, 5366, 3, 2, 2, 2, 5367, 5368, 3, 2, 2, 2, 5368, 5370, 3, 2, 2, 2, 5369, 5353, 3, 2, 2, 2, 5369, 5357, 3, 2, 2, 2, 5369, 5361, 3, 2, 2, 2, 5369, 5365, 3, 2, 2, 2, 5370, 573, 3, 2, 2, 2, 5371, 5430, 5, 1336, 669, 2, 5372, 5373, 7, 94, 2, 2, 5373, 5430, 5, 1336, 669, 2, 5374, 5375, 7, 330, 2, 2, 5375, 5430, 5, 1336, 669, 2, 5376, 5377, 7, 65, 2, 2, 5377, 5378, 7, 176, 2, 2, 5378, 5379, 7, 383, 2, 2, 5379, 5430, 5, 1342, 672, 2, 5380, 5381, 7, 65, 2, 2, 5381, 5382, 7, 333, 2, 2, 5382, 5430, 5, 1342, 672, 2, 5383, 5384, 7, 213, 2, 2, 5384, 5430, 5, 638, 320, 2, 5385, 5386, 7, 298, 2, 2, 5386, 5430, 5, 638, 320, 2, 5387, 5388, 7, 444, 2, 2, 5388, 5430, 5, 638, 320, 2, 5389, 5390, 7, 177, 2, 2, 5390, 5430, 5, 1342, 672, 2, 5391, 5392, 7, 191, 2, 2, 5392, 5430, 5, 530, 266, 2, 5393, 5394, 7, 249, 2, 2, 5394, 5430, 5, 1342, 672, 2, 5395, 5396, 7, 250, 2, 2, 5396, 5397, 7, 276, 2, 2, 5397, 5430, 5, 298, 150, 2, 5398, 5399, 7, 325, 2, 2, 5399, 5430, 5, 1342, 672, 2, 5400, 5401, 7, 353, 2, 2, 5401, 5430, 5, 1342, 672, 2, 5402, 5403, 7, 362, 2, 2, 5403, 5430, 5, 530, 266, 2, 5404, 5405, 7, 32, 2, 2, 5405, 5406, 7, 352, 2, 2, 5406, 5407, 7, 70, 2, 2, 5407, 5408, 7, 325, 2, 2, 5408, 5430, 5, 1342, 672, 2, 5409, 5410, 7, 32, 2, 2, 5410, 5411, 7, 331, 2, 2, 5411, 5412, 7, 70, 2, 2, 5412, 5413, 7, 325, 2, 2, 5413, 5430, 5, 1342, 672, 2, 5414, 5415, 7, 32, 2, 2, 5415, 5416, 7, 214, 2, 2, 5416, 5417, 7, 70, 2, 2, 5417, 5418, 7, 325, 2, 2, 5418, 5430, 5, 1342, 672, 2, 5419, 5420, 7, 32, 2, 2, 5420, 5421, 7, 459, 2, 2, 5421, 5422, 7, 70, 2, 2, 5422, 5423, 7, 325, 2, 2, 5423, 5430, 5, 1342, 672, 2, 5424, 5425, 7, 32, 2, 2, 5425, 5426, 7, 457, 2, 2, 5426, 5427, 7, 70, 2, 2, 5427, 5428, 7, 325, 2, 2, 5428, 5430, 5, 1342, 672, 2, 5429, 5371, 3, 2, 2, 2, 5429, 5372, 3, 2, 2, 2, 5429, 5374, 3, 2, 2, 2, 5429, 5376, 3, 2, 2, 2, 5429, 5380, 3, 2, 2, 2, 5429, 5383, 3, 2, 2, 2, 5429, 5385, 3, 2, 2, 2, 5429, 5387, 3, 2, 2, 2, 5429, 5389, 3, 2, 2, 2, 5429, 5391, 3, 2, 2, 2, 5429, 5393, 3, 2, 2, 2, 5429, 5395, 3, 2, 2, 2, 5429, 5398, 3, 2, 2, 2, 5429, 5400, 3, 2, 2, 2, 5429, 5402, 3, 2, 2, 2, 5429, 5404, 3, 2, 2, 2, 5429, 5409, 3, 2, 2, 2, 5429, 5414, 3, 2, 2, 2, 5429, 5419, 3, 2, 2, 2, 5429, 5424, 3, 2, 2, 2, 5430, 575, 3, 2, 2, 2, 5431, 5436, 5, 578, 290, 2, 5432, 5433, 7, 8, 2, 2, 5433, 5435, 5, 578, 290, 2, 5434, 5432, 3, 2, 2, 2, 5435, 5438, 3, 2, 2, 2, 5436, 5434, 3, 2, 2, 2, 5436, 5437, 3, 2, 2, 2, 5437, 577, 3, 2, 2, 2, 5438, 5436, 3, 2, 2, 2, 5439, 5443, 5, 1374, 688, 2, 5440, 5441, 7, 68, 2, 2, 5441, 5443, 5, 1374, 688, 2, 5442, 5439, 3, 2, 2, 2, 5442, 5440, 3, 2, 2, 2, 5443, 579, 3, 2, 2, 2, 5444, 5445, 7, 107, 2, 2, 5445, 5446, 7, 67, 2, 2, 5446, 5447, 7, 281, 2, 2, 5447, 581, 3, 2, 2, 2, 5448, 5449, 7, 67, 2, 2, 5449, 5450, 5, 570, 286, 2, 5450, 5451, 7, 96, 2, 2, 5451, 5453, 5, 1376, 689, 2, 5452, 5454, 5, 586, 294, 2, 5453, 5452, 3, 2, 2, 2, 5453, 5454, 3, 2, 2, 2, 5454, 5456, 3, 2, 2, 2, 5455, 5457, 5, 588, 295, 2, 5456, 5455, 3, 2, 2, 2, 5456, 5457, 3, 2, 2, 2, 5457, 583, 3, 2, 2, 2, 5458, 5459, 7, 319, 2, 2, 5459, 5460, 5, 570, 286, 2, 5460, 5461, 7, 66, 2, 2, 5461, 5463, 5, 1376, 689, 2, 5462, 5464, 5, 588, 295, 2, 5463, 5462, 3, 2, 2, 2, 5463, 5464, 3, 2, 2, 2, 5464, 5466, 3, 2, 2, 2, 5465, 5467, 5, 108, 55, 2, 5466, 5465, 3, 2, 2, 2, 5466, 5467, 3, 2, 2, 2, 5467, 5482, 3, 2, 2, 2, 5468, 5469, 7, 319, 2, 2, 5469, 5470, 7, 136, 2, 2, 5470, 5471, 7, 281, 2, 2, 5471, 5472, 7, 64, 2, 2, 5472, 5473, 5, 570, 286, 2, 5473, 5474, 7, 66, 2, 2, 5474, 5476, 5, 1376, 689, 2, 5475, 5477, 5, 588, 295, 2, 5476, 5475, 3, 2, 2, 2, 5476, 5477, 3, 2, 2, 2, 5477, 5479, 3, 2, 2, 2, 5478, 5480, 5, 108, 55, 2, 5479, 5478, 3, 2, 2, 2, 5479, 5480, 3, 2, 2, 2, 5480, 5482, 3, 2, 2, 2, 5481, 5458, 3, 2, 2, 2, 5481, 5468, 3, 2, 2, 2, 5482, 585, 3, 2, 2, 2, 5483, 5484, 7, 107, 2, 2, 5484, 5485, 7, 136, 2, 2, 5485, 5486, 7, 281, 2, 2, 5486, 587, 3, 2, 2, 2, 5487, 5488, 7, 216, 2, 2, 5488, 5489, 7, 149, 2, 2, 5489, 5490, 5, 1374, 688, 2, 5490, 589, 3, 2, 2, 2, 5491, 5492, 7, 140, 2, 2, 5492, 5493, 7, 55, 2, 2, 5493, 5494, 7, 296, 2, 2, 5494, 5495, 5, 592, 297, 2, 5495, 5496, 5, 596, 299, 2, 5496, 591, 3, 2, 2, 2, 5497, 5499, 5, 594, 298, 2, 5498, 5497, 3, 2, 2, 2, 5499, 5502, 3, 2, 2, 2, 5500, 5498, 3, 2, 2, 2, 5500, 5501, 3, 2, 2, 2, 5501, 593, 3, 2, 2, 2, 5502, 5500, 3, 2, 2, 2, 5503, 5504, 7, 70, 2, 2, 5504, 5505, 7, 325, 2, 2, 5505, 5513, 5, 1342, 672, 2, 5506, 5507, 7, 64, 2, 2, 5507, 5508, 7, 320, 2, 2, 5508, 5513, 5, 1376, 689, 2, 5509, 5510, 7, 64, 2, 2, 5510, 5511, 7, 101, 2, 2, 5511, 5513, 5, 1376, 689, 2, 5512, 5503, 3, 2, 2, 2, 5512, 5506, 3, 2, 2, 2, 5512, 5509, 3, 2, 2, 2, 5513, 595, 3, 2, 2, 2, 5514, 5515, 7, 67, 2, 2, 5515, 5516, 5, 564, 283, 2, 5516, 5517, 7, 82, 2, 2, 5517, 5518, 5, 598, 300, 2, 5518, 5519, 7, 96, 2, 2, 5519, 5521, 5, 576, 289, 2, 5520, 5522, 5, 580, 291, 2, 5521, 5520, 3, 2, 2, 2, 5521, 5522, 3, 2, 2, 2, 5522, 5545, 3, 2, 2, 2, 5523, 5524, 7, 319, 2, 2, 5524, 5525, 5, 564, 283, 2, 5525, 5526, 7, 82, 2, 2, 5526, 5527, 5, 598, 300, 2, 5527, 5528, 7, 66, 2, 2, 5528, 5530, 5, 576, 289, 2, 5529, 5531, 5, 108, 55, 2, 5530, 5529, 3, 2, 2, 2, 5530, 5531, 3, 2, 2, 2, 5531, 5545, 3, 2, 2, 2, 5532, 5533, 7, 319, 2, 2, 5533, 5534, 7, 67, 2, 2, 5534, 5535, 7, 281, 2, 2, 5535, 5536, 7, 64, 2, 2, 5536, 5537, 5, 564, 283, 2, 5537, 5538, 7, 82, 2, 2, 5538, 5539, 5, 598, 300, 2, 5539, 5540, 7, 66, 2, 2, 5540, 5542, 5, 576, 289, 2, 5541, 5543, 5, 108, 55, 2, 5542, 5541, 3, 2, 2, 2, 5542, 5543, 3, 2, 2, 2, 5543, 5545, 3, 2, 2, 2, 5544, 5514, 3, 2, 2, 2, 5544, 5523, 3, 2, 2, 2, 5544, 5532, 3, 2, 2, 2, 5545, 597, 3, 2, 2, 2, 5546, 5547, 9, 34, 2, 2, 5547, 599, 3, 2, 2, 2, 5548, 5550, 7, 48, 2, 2, 5549, 5551, 5, 602, 302, 2, 5550, 5549, 3, 2, 2, 2, 5550, 5551, 3, 2, 2, 2, 5551, 5552, 3, 2, 2, 2, 5552, 5554, 7, 228, 2, 2, 5553, 5555, 5, 604, 303, 2, 5554, 5553, 3, 2, 2, 2, 5554, 5555, 3, 2, 2, 2, 5555, 5557, 3, 2, 2, 2, 5556, 5558, 5, 606, 304, 2, 5557, 5556, 3, 2, 2, 2, 5557, 5558, 3, 2, 2, 2, 5558, 5559, 3, 2, 2, 2, 5559, 5560, 7, 82, 2, 2, 5560, 5562, 5, 1078, 540, 2, 5561, 5563, 5, 608, 305, 2, 5562, 5561, 3, 2, 2, 2, 5562, 5563, 3, 2, 2, 2, 5563, 5564, 3, 2, 2, 2, 5564, 5565, 7, 4, 2, 2, 5565, 5566, 5, 610, 306, 2, 5566, 5568, 7, 5, 2, 2, 5567, 5569, 5, 616, 309, 2, 5568, 5567, 3, 2, 2, 2, 5568, 5569, 3, 2, 2, 2, 5569, 5571, 3, 2, 2, 2, 5570, 5572, 5, 118, 60, 2, 5571, 5570, 3, 2, 2, 2, 5571, 5572, 3, 2, 2, 2, 5572, 5574, 3, 2, 2, 2, 5573, 5575, 5, 258, 130, 2, 5574, 5573, 3, 2, 2, 2, 5574, 5575, 3, 2, 2, 2, 5575, 5577, 3, 2, 2, 2, 5576, 5578, 5, 1098, 550, 2, 5577, 5576, 3, 2, 2, 2, 5577, 5578, 3, 2, 2, 2, 5578, 5612, 3, 2, 2, 2, 5579, 5581, 7, 48, 2, 2, 5580, 5582, 5, 602, 302, 2, 5581, 5580, 3, 2, 2, 2, 5581, 5582, 3, 2, 2, 2, 5582, 5583, 3, 2, 2, 2, 5583, 5585, 7, 228, 2, 2, 5584, 5586, 5, 604, 303, 2, 5585, 5584, 3, 2, 2, 2, 5585, 5586, 3, 2, 2, 2, 5586, 5587, 3, 2, 2, 2, 5587, 5588, 7, 222, 2, 2, 5588, 5589, 7, 79, 2, 2, 5589, 5590, 7, 398, 2, 2, 5590, 5591, 5, 1344, 673, 2, 5591, 5592, 7, 82, 2, 2, 5592, 5594, 5, 1078, 540, 2, 5593, 5595, 5, 608, 305, 2, 5594, 5593, 3, 2, 2, 2, 5594, 5595, 3, 2, 2, 2, 5595, 5596, 3, 2, 2, 2, 5596, 5597, 7, 4, 2, 2, 5597, 5598, 5, 610, 306, 2, 5598, 5600, 7, 5, 2, 2, 5599, 5601, 5, 616, 309, 2, 5600, 5599, 3, 2, 2, 2, 5600, 5601, 3, 2, 2, 2, 5601, 5603, 3, 2, 2, 2, 5602, 5604, 5, 118, 60, 2, 5603, 5602, 3, 2, 2, 2, 5603, 5604, 3, 2, 2, 2, 5604, 5606, 3, 2, 2, 2, 5605, 5607, 5, 258, 130, 2, 5606, 5605, 3, 2, 2, 2, 5606, 5607, 3, 2, 2, 2, 5607, 5609, 3, 2, 2, 2, 5608, 5610, 5, 1098, 550, 2, 5609, 5608, 3, 2, 2, 2, 5609, 5610, 3, 2, 2, 2, 5610, 5612, 3, 2, 2, 2, 5611, 5548, 3, 2, 2, 2, 5611, 5579, 3, 2, 2, 2, 5612, 601, 3, 2, 2, 2, 5613, 5614, 7, 100, 2, 2, 5614, 603, 3, 2, 2, 2, 5615, 5616, 7, 111, 2, 2, 5616, 605, 3, 2, 2, 2, 5617, 5618, 5, 1344, 673, 2, 5618, 607, 3, 2, 2, 2, 5619, 5620, 7, 102, 2, 2, 5620, 5621, 5, 1344, 673, 2, 5621, 609, 3, 2, 2, 2, 5622, 5627, 5, 614, 308, 2, 5623, 5624, 7, 8, 2, 2, 5624, 5626, 5, 614, 308, 2, 5625, 5623, 3, 2, 2, 2, 5626, 5629, 3, 2, 2, 2, 5627, 5625, 3, 2, 2, 2, 5627, 5628, 3, 2, 2, 2, 5628, 611, 3, 2, 2, 2, 5629, 5627, 3, 2, 2, 2, 5630, 5632, 5, 620, 311, 2, 5631, 5630, 3, 2, 2, 2, 5631, 5632, 3, 2, 2, 2, 5632, 5634, 3, 2, 2, 2, 5633, 5635, 5, 622, 312, 2, 5634, 5633, 3, 2, 2, 2, 5634, 5635, 3, 2, 2, 2, 5635, 5637, 3, 2, 2, 2, 5636, 5638, 5, 624, 313, 2, 5637, 5636, 3, 2, 2, 2, 5637, 5638, 3, 2, 2, 2, 5638, 5640, 3, 2, 2, 2, 5639, 5641, 5, 626, 314, 2, 5640, 5639, 3, 2, 2, 2, 5640, 5641, 3, 2, 2, 2, 5641, 5654, 3, 2, 2, 2, 5642, 5644, 5, 620, 311, 2, 5643, 5642, 3, 2, 2, 2, 5643, 5644, 3, 2, 2, 2, 5644, 5645, 3, 2, 2, 2, 5645, 5646, 5, 532, 267, 2, 5646, 5648, 5, 116, 59, 2, 5647, 5649, 5, 624, 313, 2, 5648, 5647, 3, 2, 2, 2, 5648, 5649, 3, 2, 2, 2, 5649, 5651, 3, 2, 2, 2, 5650, 5652, 5, 626, 314, 2, 5651, 5650, 3, 2, 2, 2, 5651, 5652, 3, 2, 2, 2, 5652, 5654, 3, 2, 2, 2, 5653, 5631, 3, 2, 2, 2, 5653, 5643, 3, 2, 2, 2, 5654, 613, 3, 2, 2, 2, 5655, 5656, 5, 1378, 690, 2, 5656, 5657, 5, 612, 307, 2, 5657, 5667, 3, 2, 2, 2, 5658, 5659, 5, 1216, 609, 2, 5659, 5660, 5, 612, 307, 2, 5660, 5667, 3, 2, 2, 2, 5661, 5662, 7, 4, 2, 2, 5662, 5663, 5, 1166, 584, 2, 5663, 5664, 7, 5, 2, 2, 5664, 5665, 5, 612, 307, 2, 5665, 5667, 3, 2, 2, 2, 5666, 5655, 3, 2, 2, 2, 5666, 5658, 3, 2, 2, 2, 5666, 5661, 3, 2, 2, 2, 5667, 615, 3, 2, 2, 2, 5668, 5669, 7, 443, 2, 2, 5669, 5670, 7, 4, 2, 2, 5670, 5671, 5, 618, 310, 2, 5671, 5672, 7, 5, 2, 2, 5672, 617, 3, 2, 2, 2, 5673, 5678, 5, 614, 308, 2, 5674, 5675, 7, 8, 2, 2, 5675, 5677, 5, 614, 308, 2, 5676, 5674, 3, 2, 2, 2, 5677, 5680, 3, 2, 2, 2, 5678, 5676, 3, 2, 2, 2, 5678, 5679, 3, 2, 2, 2, 5679, 619, 3, 2, 2, 2, 5680, 5678, 3, 2, 2, 2, 5681, 5682, 7, 45, 2, 2, 5682, 5683, 5, 532, 267, 2, 5683, 621, 3, 2, 2, 2, 5684, 5685, 5, 532, 267, 2, 5685, 623, 3, 2, 2, 2, 5686, 5687, 9, 35, 2, 2, 5687, 625, 3, 2, 2, 2, 5688, 5689, 7, 275, 2, 2, 5689, 5693, 7, 209, 2, 2, 5690, 5691, 7, 275, 2, 2, 5691, 5693, 7, 251, 2, 2, 5692, 5688, 3, 2, 2, 2, 5692, 5690, 3, 2, 2, 2, 5693, 627, 3, 2, 2, 2, 5694, 5696, 7, 48, 2, 2, 5695, 5697, 5, 632, 317, 2, 5696, 5695, 3, 2, 2, 2, 5696, 5697, 3, 2, 2, 2, 5697, 5698, 3, 2, 2, 2, 5698, 5699, 9, 30, 2, 2, 5699, 5700, 5, 1350, 676, 2, 5700, 5710, 5, 642, 322, 2, 5701, 5708, 7, 318, 2, 2, 5702, 5709, 5, 652, 327, 2, 5703, 5704, 7, 94, 2, 2, 5704, 5705, 7, 4, 2, 2, 5705, 5706, 5, 682, 342, 2, 5706, 5707, 7, 5, 2, 2, 5707, 5709, 3, 2, 2, 2, 5708, 5702, 3, 2, 2, 2, 5708, 5703, 3, 2, 2, 2, 5709, 5711, 3, 2, 2, 2, 5710, 5701, 3, 2, 2, 2, 5710, 5711, 3, 2, 2, 2, 5711, 5712, 3, 2, 2, 2, 5712, 5715, 5, 668, 335, 2, 5713, 5714, 7, 107, 2, 2, 5714, 5716, 5, 630, 316, 2, 5715, 5713, 3, 2, 2, 2, 5715, 5716, 3, 2, 2, 2, 5716, 629, 3, 2, 2, 2, 5717, 5718, 7, 4, 2, 2, 5718, 5723, 5, 1378, 690, 2, 5719, 5720, 7, 8, 2, 2, 5720, 5722, 5, 1378, 690, 2, 5721, 5719, 3, 2, 2, 2, 5722, 5725, 3, 2, 2, 2, 5723, 5721, 3, 2, 2, 2, 5723, 5724, 3, 2, 2, 2, 5724, 5726, 3, 2, 2, 2, 5725, 5723, 3, 2, 2, 2, 5726, 5727, 7, 5, 2, 2, 5727, 631, 3, 2, 2, 2, 5728, 5729, 7, 84, 2, 2, 5729, 5730, 7, 313, 2, 2, 5730, 633, 3, 2, 2, 2, 5731, 5733, 7, 4, 2, 2, 5732, 5734, 5, 636, 319, 2, 5733, 5732, 3, 2, 2, 2, 5733, 5734, 3, 2, 2, 2, 5734, 5735, 3, 2, 2, 2, 5735, 5736, 7, 5, 2, 2, 5736, 635, 3, 2, 2, 2, 5737, 5742, 5, 646, 324, 2, 5738, 5739, 7, 8, 2, 2, 5739, 5741, 5, 646, 324, 2, 5740, 5738, 3, 2, 2, 2, 5741, 5744, 3, 2, 2, 2, 5742, 5740, 3, 2, 2, 2, 5742, 5743, 3, 2, 2, 2, 5743, 637, 3, 2, 2, 2, 5744, 5742, 3, 2, 2, 2, 5745, 5750, 5, 640, 321, 2, 5746, 5747, 7, 8, 2, 2, 5747, 5749, 5, 640, 321, 2, 5748, 5746, 3, 2, 2, 2, 5749, 5752, 3, 2, 2, 2, 5750, 5748, 3, 2, 2, 2, 5750, 5751, 3, 2, 2, 2, 5751, 639, 3, 2, 2, 2, 5752, 5750, 3, 2, 2, 2, 5753, 5754, 5, 1350, 676, 2, 5754, 5755, 5, 634, 318, 2, 5755, 5762, 3, 2, 2, 2, 5756, 5762, 5, 1402, 702, 2, 5757, 5759, 5, 1378, 690, 2, 5758, 5760, 5, 1326, 664, 2, 5759, 5758, 3, 2, 2, 2, 5759, 5760, 3, 2, 2, 2, 5760, 5762, 3, 2, 2, 2, 5761, 5753, 3, 2, 2, 2, 5761, 5756, 3, 2, 2, 2, 5761, 5757, 3, 2, 2, 2, 5762, 641, 3, 2, 2, 2, 5763, 5765, 7, 4, 2, 2, 5764, 5766, 5, 644, 323, 2, 5765, 5764, 3, 2, 2, 2, 5765, 5766, 3, 2, 2, 2, 5766, 5767, 3, 2, 2, 2, 5767, 5768, 7, 5, 2, 2, 5768, 643, 3, 2, 2, 2, 5769, 5774, 5, 656, 329, 2, 5770, 5771, 7, 8, 2, 2, 5771, 5773, 5, 656, 329, 2, 5772, 5770, 3, 2, 2, 2, 5773, 5776, 3, 2, 2, 2, 5774, 5772, 3, 2, 2, 2, 5774, 5775, 3, 2, 2, 2, 5775, 645, 3, 2, 2, 2, 5776, 5774, 3, 2, 2, 2, 5777, 5779, 5, 648, 325, 2, 5778, 5780, 5, 650, 326, 2, 5779, 5778, 3, 2, 2, 2, 5779, 5780, 3, 2, 2, 2, 5780, 5781, 3, 2, 2, 2, 5781, 5782, 5, 654, 328, 2, 5782, 5791, 3, 2, 2, 2, 5783, 5785, 5, 650, 326, 2, 5784, 5786, 5, 648, 325, 2, 5785, 5784, 3, 2, 2, 2, 5785, 5786, 3, 2, 2, 2, 5786, 5787, 3, 2, 2, 2, 5787, 5788, 5, 654, 328, 2, 5788, 5791, 3, 2, 2, 2, 5789, 5791, 5, 654, 328, 2, 5790, 5777, 3, 2, 2, 2, 5790, 5783, 3, 2, 2, 2, 5790, 5789, 3, 2, 2, 2, 5791, 647, 3, 2, 2, 2, 5792, 5794, 7, 70, 2, 2, 5793, 5795, 7, 455, 2, 2, 5794, 5793, 3, 2, 2, 2, 5794, 5795, 3, 2, 2, 2, 5795, 5800, 3, 2, 2, 2, 5796, 5800, 7, 455, 2, 2, 5797, 5800, 7, 402, 2, 2, 5798, 5800, 7, 103, 2, 2, 5799, 5792, 3, 2, 2, 2, 5799, 5796, 3, 2, 2, 2, 5799, 5797, 3, 2, 2, 2, 5799, 5798, 3, 2, 2, 2, 5800, 649, 3, 2, 2, 2, 5801, 5802, 5, 1388, 695, 2, 5802, 651, 3, 2, 2, 2, 5803, 5804, 5, 654, 328, 2, 5804, 653, 3, 2, 2, 2, 5805, 5818, 5, 1122, 562, 2, 5806, 5807, 5, 1388, 695, 2, 5807, 5808, 5, 534, 268, 2, 5808, 5809, 7, 29, 2, 2, 5809, 5810, 7, 362, 2, 2, 5810, 5818, 3, 2, 2, 2, 5811, 5812, 7, 417, 2, 2, 5812, 5813, 5, 1388, 695, 2, 5813, 5814, 5, 534, 268, 2, 5814, 5815, 7, 29, 2, 2, 5815, 5816, 7, 362, 2, 2, 5816, 5818, 3, 2, 2, 2, 5817, 5805, 3, 2, 2, 2, 5817, 5806, 3, 2, 2, 2, 5817, 5811, 3, 2, 2, 2, 5818, 655, 3, 2, 2, 2, 5819, 5822, 5, 646, 324, 2, 5820, 5821, 9, 36, 2, 2, 5821, 5823, 5, 1166, 584, 2, 5822, 5820, 3, 2, 2, 2, 5822, 5823, 3, 2, 2, 2, 5823, 657, 3, 2, 2, 2, 5824, 5825, 5, 646, 324, 2, 5825, 659, 3, 2, 2, 2, 5826, 5837, 7, 4, 2, 2, 5827, 5838, 7, 11, 2, 2, 5828, 5838, 5, 662, 332, 2, 5829, 5830, 7, 85, 2, 2, 5830, 5831, 7, 149, 2, 2, 5831, 5838, 5, 662, 332, 2, 5832, 5833, 5, 662, 332, 2, 5833, 5834, 7, 85, 2, 2, 5834, 5835, 7, 149, 2, 2, 5835, 5836, 5, 662, 332, 2, 5836, 5838, 3, 2, 2, 2, 5837, 5827, 3, 2, 2, 2, 5837, 5828, 3, 2, 2, 2, 5837, 5829, 3, 2, 2, 2, 5837, 5832, 3, 2, 2, 2, 5838, 5839, 3, 2, 2, 2, 5839, 5840, 7, 5, 2, 2, 5840, 661, 3, 2, 2, 2, 5841, 5846, 5, 658, 330, 2, 5842, 5843, 7, 8, 2, 2, 5843, 5845, 5, 658, 330, 2, 5844, 5842, 3, 2, 2, 2, 5845, 5848, 3, 2, 2, 2, 5846, 5844, 3, 2, 2, 2, 5846, 5847, 3, 2, 2, 2, 5847, 663, 3, 2, 2, 2, 5848, 5846, 3, 2, 2, 2, 5849, 5850, 5, 1350, 676, 2, 5850, 5851, 5, 660, 331, 2, 5851, 665, 3, 2, 2, 2, 5852, 5857, 5, 664, 333, 2, 5853, 5854, 7, 8, 2, 2, 5854, 5856, 5, 664, 333, 2, 5855, 5853, 3, 2, 2, 2, 5856, 5859, 3, 2, 2, 2, 5857, 5855, 3, 2, 2, 2, 5857, 5858, 3, 2, 2, 2, 5858, 667, 3, 2, 2, 2, 5859, 5857, 3, 2, 2, 2, 5860, 5862, 5, 672, 337, 2, 5861, 5860, 3, 2, 2, 2, 5862, 5863, 3, 2, 2, 2, 5863, 5861, 3, 2, 2, 2, 5863, 5864, 3, 2, 2, 2, 5864, 669, 3, 2, 2, 2, 5865, 5866, 7, 151, 2, 2, 5866, 5867, 7, 82, 2, 2, 5867, 5868, 7, 80, 2, 2, 5868, 5901, 7, 460, 2, 2, 5869, 5870, 7, 318, 2, 2, 5870, 5871, 7, 80, 2, 2, 5871, 5872, 7, 82, 2, 2, 5872, 5873, 7, 80, 2, 2, 5873, 5901, 7, 460, 2, 2, 5874, 5901, 7, 348, 2, 2, 5875, 5901, 7, 224, 2, 2, 5876, 5901, 7, 340, 2, 2, 5877, 5901, 7, 379, 2, 2, 5878, 5879, 7, 207, 2, 2, 5879, 5880, 7, 329, 2, 2, 5880, 5901, 7, 183, 2, 2, 5881, 5882, 7, 207, 2, 2, 5882, 5883, 7, 329, 2, 2, 5883, 5901, 7, 245, 2, 2, 5884, 5885, 7, 329, 2, 2, 5885, 5901, 7, 183, 2, 2, 5886, 5887, 7, 329, 2, 2, 5887, 5901, 7, 245, 2, 2, 5888, 5901, 7, 252, 2, 2, 5889, 5890, 7, 79, 2, 2, 5890, 5901, 7, 252, 2, 2, 5891, 5892, 7, 172, 2, 2, 5892, 5901, 5, 296, 149, 2, 5893, 5894, 7, 322, 2, 2, 5894, 5901, 5, 296, 149, 2, 5895, 5896, 7, 461, 2, 2, 5896, 5901, 5, 532, 267, 2, 5897, 5901, 5, 82, 42, 2, 5898, 5899, 7, 462, 2, 2, 5899, 5901, 5, 1378, 690, 2, 5900, 5865, 3, 2, 2, 2, 5900, 5869, 3, 2, 2, 2, 5900, 5874, 3, 2, 2, 2, 5900, 5875, 3, 2, 2, 2, 5900, 5876, 3, 2, 2, 2, 5900, 5877, 3, 2, 2, 2, 5900, 5878, 3, 2, 2, 2, 5900, 5881, 3, 2, 2, 2, 5900, 5884, 3, 2, 2, 2, 5900, 5886, 3, 2, 2, 2, 5900, 5888, 3, 2, 2, 2, 5900, 5889, 3, 2, 2, 2, 5900, 5891, 3, 2, 2, 2, 5900, 5893, 3, 2, 2, 2, 5900, 5895, 3, 2, 2, 2, 5900, 5897, 3, 2, 2, 2, 5900, 5898, 3, 2, 2, 2, 5901, 671, 3, 2, 2, 2, 5902, 5903, 7, 38, 2, 2, 5903, 5911, 5, 674, 338, 2, 5904, 5905, 7, 249, 2, 2, 5905, 5911, 5, 72, 37, 2, 5906, 5907, 7, 445, 2, 2, 5907, 5911, 5, 676, 339, 2, 5908, 5911, 7, 106, 2, 2, 5909, 5911, 5, 670, 336, 2, 5910, 5902, 3, 2, 2, 2, 5910, 5904, 3, 2, 2, 2, 5910, 5906, 3, 2, 2, 2, 5910, 5908, 3, 2, 2, 2, 5910, 5909, 3, 2, 2, 2, 5911, 673, 3, 2, 2, 2, 5912, 5918, 5, 1362, 682, 2, 5913, 5914, 5, 1362, 682, 2, 5914, 5915, 7, 8, 2, 2, 5915, 5916, 5, 1362, 682, 2, 5916, 5918, 3, 2, 2, 2, 5917, 5912, 3, 2, 2, 2, 5917, 5913, 3, 2, 2, 2, 5918, 675, 3, 2, 2, 2, 5919, 5920, 7, 64, 2, 2, 5920, 5921, 7, 362, 2, 2, 5921, 5928, 5, 1122, 562, 2, 5922, 5923, 7, 8, 2, 2, 5923, 5924, 7, 64, 2, 2, 5924, 5925, 7, 362, 2, 2, 5925, 5927, 5, 1122, 562, 2, 5926, 5922, 3, 2, 2, 2, 5927, 5930, 3, 2, 2, 2, 5928, 5926, 3, 2, 2, 2, 5928, 5929, 3, 2, 2, 2, 5929, 677, 3, 2, 2, 2, 5930, 5928, 3, 2, 2, 2, 5931, 5932, 7, 107, 2, 2, 5932, 5933, 5, 468, 235, 2, 5933, 679, 3, 2, 2, 2, 5934, 5935, 5, 650, 326, 2, 5935, 5936, 5, 654, 328, 2, 5936, 681, 3, 2, 2, 2, 5937, 5942, 5, 680, 341, 2, 5938, 5939, 7, 8, 2, 2, 5939, 5941, 5, 680, 341, 2, 5940, 5938, 3, 2, 2, 2, 5941, 5944, 3, 2, 2, 2, 5942, 5940, 3, 2, 2, 2, 5942, 5943, 3, 2, 2, 2, 5943, 683, 3, 2, 2, 2, 5944, 5942, 3, 2, 2, 2, 5945, 5946, 7, 140, 2, 2, 5946, 5947, 9, 37, 2, 2, 5947, 5948, 5, 640, 321, 2, 5948, 5950, 5, 686, 344, 2, 5949, 5951, 5, 688, 345, 2, 5950, 5949, 3, 2, 2, 2, 5950, 5951, 3, 2, 2, 2, 5951, 685, 3, 2, 2, 2, 5952, 5954, 5, 670, 336, 2, 5953, 5952, 3, 2, 2, 2, 5954, 5955, 3, 2, 2, 2, 5955, 5953, 3, 2, 2, 2, 5955, 5956, 3, 2, 2, 2, 5956, 687, 3, 2, 2, 2, 5957, 5958, 7, 317, 2, 2, 5958, 689, 3, 2, 2, 2, 5959, 5960, 7, 193, 2, 2, 5960, 5961, 7, 213, 2, 2, 5961, 5963, 5, 638, 320, 2, 5962, 5964, 5, 108, 55, 2, 5963, 5962, 3, 2, 2, 2, 5963, 5964, 3, 2, 2, 2, 5964, 6002, 3, 2, 2, 2, 5965, 5966, 7, 193, 2, 2, 5966, 5967, 7, 213, 2, 2, 5967, 5968, 7, 222, 2, 2, 5968, 5969, 7, 398, 2, 2, 5969, 5971, 5, 638, 320, 2, 5970, 5972, 5, 108, 55, 2, 5971, 5970, 3, 2, 2, 2, 5971, 5972, 3, 2, 2, 2, 5972, 6002, 3, 2, 2, 2, 5973, 5974, 7, 193, 2, 2, 5974, 5975, 7, 298, 2, 2, 5975, 5977, 5, 638, 320, 2, 5976, 5978, 5, 108, 55, 2, 5977, 5976, 3, 2, 2, 2, 5977, 5978, 3, 2, 2, 2, 5978, 6002, 3, 2, 2, 2, 5979, 5980, 7, 193, 2, 2, 5980, 5981, 7, 298, 2, 2, 5981, 5982, 7, 222, 2, 2, 5982, 5983, 7, 398, 2, 2, 5983, 5985, 5, 638, 320, 2, 5984, 5986, 5, 108, 55, 2, 5985, 5984, 3, 2, 2, 2, 5985, 5986, 3, 2, 2, 2, 5986, 6002, 3, 2, 2, 2, 5987, 5988, 7, 193, 2, 2, 5988, 5989, 7, 444, 2, 2, 5989, 5991, 5, 638, 320, 2, 5990, 5992, 5, 108, 55, 2, 5991, 5990, 3, 2, 2, 2, 5991, 5992, 3, 2, 2, 2, 5992, 6002, 3, 2, 2, 2, 5993, 5994, 7, 193, 2, 2, 5994, 5995, 7, 444, 2, 2, 5995, 5996, 7, 222, 2, 2, 5996, 5997, 7, 398, 2, 2, 5997, 5999, 5, 638, 320, 2, 5998, 6000, 5, 108, 55, 2, 5999, 5998, 3, 2, 2, 2, 5999, 6000, 3, 2, 2, 2, 6000, 6002, 3, 2, 2, 2, 6001, 5959, 3, 2, 2, 2, 6001, 5965, 3, 2, 2, 2, 6001, 5973, 3, 2, 2, 2, 6001, 5979, 3, 2, 2, 2, 6001, 5987, 3, 2, 2, 2, 6001, 5993, 3, 2, 2, 2, 6002, 691, 3, 2, 2, 2, 6003, 6004, 7, 193, 2, 2, 6004, 6005, 7, 138, 2, 2, 6005, 6007, 5, 666, 334, 2, 6006, 6008, 5, 108, 55, 2, 6007, 6006, 3, 2, 2, 2, 6007, 6008, 3, 2, 2, 2, 6008, 6018, 3, 2, 2, 2, 6009, 6010, 7, 193, 2, 2, 6010, 6011, 7, 138, 2, 2, 6011, 6012, 7, 222, 2, 2, 6012, 6013, 7, 398, 2, 2, 6013, 6015, 5, 666, 334, 2, 6014, 6016, 5, 108, 55, 2, 6015, 6014, 3, 2, 2, 2, 6015, 6016, 3, 2, 2, 2, 6016, 6018, 3, 2, 2, 2, 6017, 6003, 3, 2, 2, 2, 6017, 6009, 3, 2, 2, 2, 6018, 693, 3, 2, 2, 2, 6019, 6020, 7, 193, 2, 2, 6020, 6021, 7, 280, 2, 2, 6021, 6023, 5, 700, 351, 2, 6022, 6024, 5, 108, 55, 2, 6023, 6022, 3, 2, 2, 2, 6023, 6024, 3, 2, 2, 2, 6024, 6034, 3, 2, 2, 2, 6025, 6026, 7, 193, 2, 2, 6026, 6027, 7, 280, 2, 2, 6027, 6028, 7, 222, 2, 2, 6028, 6029, 7, 398, 2, 2, 6029, 6031, 5, 700, 351, 2, 6030, 6032, 5, 108, 55, 2, 6031, 6030, 3, 2, 2, 2, 6031, 6032, 3, 2, 2, 2, 6032, 6034, 3, 2, 2, 2, 6033, 6019, 3, 2, 2, 2, 6033, 6025, 3, 2, 2, 2, 6034, 695, 3, 2, 2, 2, 6035, 6036, 7, 4, 2, 2, 6036, 6037, 5, 1122, 562, 2, 6037, 6038, 7, 5, 2, 2, 6038, 6058, 3, 2, 2, 2, 6039, 6040, 7, 4, 2, 2, 6040, 6041, 5, 1122, 562, 2, 6041, 6042, 7, 8, 2, 2, 6042, 6043, 5, 1122, 562, 2, 6043, 6044, 7, 5, 2, 2, 6044, 6058, 3, 2, 2, 2, 6045, 6046, 7, 4, 2, 2, 6046, 6047, 7, 409, 2, 2, 6047, 6048, 7, 8, 2, 2, 6048, 6049, 5, 1122, 562, 2, 6049, 6050, 7, 5, 2, 2, 6050, 6058, 3, 2, 2, 2, 6051, 6052, 7, 4, 2, 2, 6052, 6053, 5, 1122, 562, 2, 6053, 6054, 7, 8, 2, 2, 6054, 6055, 7, 409, 2, 2, 6055, 6056, 7, 5, 2, 2, 6056, 6058, 3, 2, 2, 2, 6057, 6035, 3, 2, 2, 2, 6057, 6039, 3, 2, 2, 2, 6057, 6045, 3, 2, 2, 2, 6057, 6051, 3, 2, 2, 2, 6058, 697, 3, 2, 2, 2, 6059, 6060, 5, 1378, 690, 2, 6060, 6061, 7, 13, 2, 2, 6061, 6063, 3, 2, 2, 2, 6062, 6059, 3, 2, 2, 2, 6063, 6066, 3, 2, 2, 2, 6064, 6062, 3, 2, 2, 2, 6064, 6065, 3, 2, 2, 2, 6065, 6067, 3, 2, 2, 2, 6066, 6064, 3, 2, 2, 2, 6067, 6068, 5, 1272, 637, 2, 6068, 699, 3, 2, 2, 2, 6069, 6074, 5, 702, 352, 2, 6070, 6071, 7, 8, 2, 2, 6071, 6073, 5, 702, 352, 2, 6072, 6070, 3, 2, 2, 2, 6073, 6076, 3, 2, 2, 2, 6074, 6072, 3, 2, 2, 2, 6074, 6075, 3, 2, 2, 2, 6075, 701, 3, 2, 2, 2, 6076, 6074, 3, 2, 2, 2, 6077, 6078, 5, 698, 350, 2, 6078, 6079, 5, 696, 349, 2, 6079, 703, 3, 2, 2, 2, 6080, 6081, 7, 59, 2, 2, 6081, 6082, 5, 706, 354, 2, 6082, 705, 3, 2, 2, 2, 6083, 6085, 5, 708, 355, 2, 6084, 6083, 3, 2, 2, 2, 6085, 6086, 3, 2, 2, 2, 6086, 6084, 3, 2, 2, 2, 6086, 6087, 3, 2, 2, 2, 6087, 707, 3, 2, 2, 2, 6088, 6092, 5, 1362, 682, 2, 6089, 6090, 7, 249, 2, 2, 6090, 6092, 5, 72, 37, 2, 6091, 6088, 3, 2, 2, 2, 6091, 6089, 3, 2, 2, 2, 6092, 709, 3, 2, 2, 2, 6093, 6094, 7, 48, 2, 2, 6094, 6095, 7, 43, 2, 2, 6095, 6096, 7, 4, 2, 2, 6096, 6097, 5, 1122, 562, 2, 6097, 6098, 7, 38, 2, 2, 6098, 6099, 5, 1122, 562, 2, 6099, 6100, 7, 5, 2, 2, 6100, 6101, 7, 107, 2, 2, 6101, 6102, 7, 213, 2, 2, 6102, 6104, 5, 640, 321, 2, 6103, 6105, 5, 712, 357, 2, 6104, 6103, 3, 2, 2, 2, 6104, 6105, 3, 2, 2, 2, 6105, 6131, 3, 2, 2, 2, 6106, 6107, 7, 48, 2, 2, 6107, 6108, 7, 43, 2, 2, 6108, 6109, 7, 4, 2, 2, 6109, 6110, 5, 1122, 562, 2, 6110, 6111, 7, 38, 2, 2, 6111, 6112, 5, 1122, 562, 2, 6112, 6113, 7, 5, 2, 2, 6113, 6114, 7, 381, 2, 2, 6114, 6116, 7, 213, 2, 2, 6115, 6117, 5, 712, 357, 2, 6116, 6115, 3, 2, 2, 2, 6116, 6117, 3, 2, 2, 2, 6117, 6131, 3, 2, 2, 2, 6118, 6119, 7, 48, 2, 2, 6119, 6120, 7, 43, 2, 2, 6120, 6121, 7, 4, 2, 2, 6121, 6122, 5, 1122, 562, 2, 6122, 6123, 7, 38, 2, 2, 6123, 6124, 5, 1122, 562, 2, 6124, 6125, 7, 5, 2, 2, 6125, 6126, 7, 107, 2, 2, 6126, 6128, 7, 402, 2, 2, 6127, 6129, 5, 712, 357, 2, 6128, 6127, 3, 2, 2, 2, 6128, 6129, 3, 2, 2, 2, 6129, 6131, 3, 2, 2, 2, 6130, 6093, 3, 2, 2, 2, 6130, 6106, 3, 2, 2, 2, 6130, 6118, 3, 2, 2, 2, 6131, 711, 3, 2, 2, 2, 6132, 6133, 7, 38, 2, 2, 6133, 6137, 7, 225, 2, 2, 6134, 6135, 7, 38, 2, 2, 6135, 6137, 7, 143, 2, 2, 6136, 6132, 3, 2, 2, 2, 6136, 6134, 3, 2, 2, 2, 6137, 713, 3, 2, 2, 2, 6138, 6139, 7, 193, 2, 2, 6139, 6141, 7, 43, 2, 2, 6140, 6142, 5, 716, 359, 2, 6141, 6140, 3, 2, 2, 2, 6141, 6142, 3, 2, 2, 2, 6142, 6143, 3, 2, 2, 2, 6143, 6144, 7, 4, 2, 2, 6144, 6145, 5, 1122, 562, 2, 6145, 6146, 7, 38, 2, 2, 6146, 6147, 5, 1122, 562, 2, 6147, 6149, 7, 5, 2, 2, 6148, 6150, 5, 108, 55, 2, 6149, 6148, 3, 2, 2, 2, 6149, 6150, 3, 2, 2, 2, 6150, 715, 3, 2, 2, 2, 6151, 6152, 7, 222, 2, 2, 6152, 6153, 7, 398, 2, 2, 6153, 717, 3, 2, 2, 2, 6154, 6156, 7, 48, 2, 2, 6155, 6157, 5, 632, 317, 2, 6156, 6155, 3, 2, 2, 2, 6156, 6157, 3, 2, 2, 2, 6157, 6158, 3, 2, 2, 2, 6158, 6159, 7, 445, 2, 2, 6159, 6160, 7, 64, 2, 2, 6160, 6161, 5, 1122, 562, 2, 6161, 6162, 7, 249, 2, 2, 6162, 6163, 5, 1344, 673, 2, 6163, 6164, 7, 4, 2, 2, 6164, 6165, 5, 720, 361, 2, 6165, 6166, 7, 5, 2, 2, 6166, 719, 3, 2, 2, 2, 6167, 6168, 7, 66, 2, 2, 6168, 6169, 7, 463, 2, 2, 6169, 6170, 7, 107, 2, 2, 6170, 6171, 7, 213, 2, 2, 6171, 6172, 5, 640, 321, 2, 6172, 6173, 7, 8, 2, 2, 6173, 6174, 7, 96, 2, 2, 6174, 6175, 7, 463, 2, 2, 6175, 6176, 7, 107, 2, 2, 6176, 6177, 7, 213, 2, 2, 6177, 6178, 5, 640, 321, 2, 6178, 6202, 3, 2, 2, 2, 6179, 6180, 7, 96, 2, 2, 6180, 6181, 7, 463, 2, 2, 6181, 6182, 7, 107, 2, 2, 6182, 6183, 7, 213, 2, 2, 6183, 6184, 5, 640, 321, 2, 6184, 6185, 7, 8, 2, 2, 6185, 6186, 7, 66, 2, 2, 6186, 6187, 7, 463, 2, 2, 6187, 6188, 7, 107, 2, 2, 6188, 6189, 7, 213, 2, 2, 6189, 6190, 5, 640, 321, 2, 6190, 6202, 3, 2, 2, 2, 6191, 6192, 7, 66, 2, 2, 6192, 6193, 7, 463, 2, 2, 6193, 6194, 7, 107, 2, 2, 6194, 6195, 7, 213, 2, 2, 6195, 6202, 5, 640, 321, 2, 6196, 6197, 7, 96, 2, 2, 6197, 6198, 7, 463, 2, 2, 6198, 6199, 7, 107, 2, 2, 6199, 6200, 7, 213, 2, 2, 6200, 6202, 5, 640, 321, 2, 6201, 6167, 3, 2, 2, 2, 6201, 6179, 3, 2, 2, 2, 6201, 6191, 3, 2, 2, 2, 6201, 6196, 3, 2, 2, 2, 6202, 721, 3, 2, 2, 2, 6203, 6204, 7, 193, 2, 2, 6204, 6206, 7, 445, 2, 2, 6205, 6207, 5, 716, 359, 2, 6206, 6205, 3, 2, 2, 2, 6206, 6207, 3, 2, 2, 2, 6207, 6208, 3, 2, 2, 2, 6208, 6209, 7, 64, 2, 2, 6209, 6210, 5, 1122, 562, 2, 6210, 6211, 7, 249, 2, 2, 6211, 6213, 5, 1344, 673, 2, 6212, 6214, 5, 108, 55, 2, 6213, 6212, 3, 2, 2, 2, 6213, 6214, 3, 2, 2, 2, 6214, 723, 3, 2, 2, 2, 6215, 6216, 7, 308, 2, 2, 6216, 6218, 5, 726, 364, 2, 6217, 6219, 5, 604, 303, 2, 6218, 6217, 3, 2, 2, 2, 6218, 6219, 3, 2, 2, 2, 6219, 6220, 3, 2, 2, 2, 6220, 6221, 5, 1340, 671, 2, 6221, 6250, 3, 2, 2, 2, 6222, 6223, 7, 308, 2, 2, 6223, 6225, 5, 728, 365, 2, 6224, 6226, 5, 604, 303, 2, 6225, 6224, 3, 2, 2, 2, 6225, 6226, 3, 2, 2, 2, 6226, 6227, 3, 2, 2, 2, 6227, 6228, 5, 1344, 673, 2, 6228, 6250, 3, 2, 2, 2, 6229, 6230, 7, 308, 2, 2, 6230, 6231, 7, 4, 2, 2, 6231, 6232, 5, 730, 366, 2, 6232, 6233, 7, 5, 2, 2, 6233, 6235, 5, 726, 364, 2, 6234, 6236, 5, 604, 303, 2, 6235, 6234, 3, 2, 2, 2, 6235, 6236, 3, 2, 2, 2, 6236, 6237, 3, 2, 2, 2, 6237, 6238, 5, 1340, 671, 2, 6238, 6250, 3, 2, 2, 2, 6239, 6240, 7, 308, 2, 2, 6240, 6241, 7, 4, 2, 2, 6241, 6242, 5, 730, 366, 2, 6242, 6243, 7, 5, 2, 2, 6243, 6245, 5, 728, 365, 2, 6244, 6246, 5, 604, 303, 2, 6245, 6244, 3, 2, 2, 2, 6245, 6246, 3, 2, 2, 2, 6246, 6247, 3, 2, 2, 2, 6247, 6248, 5, 1344, 673, 2, 6248, 6250, 3, 2, 2, 2, 6249, 6215, 3, 2, 2, 2, 6249, 6222, 3, 2, 2, 2, 6249, 6229, 3, 2, 2, 2, 6249, 6239, 3, 2, 2, 2, 6250, 725, 3, 2, 2, 2, 6251, 6252, 9, 26, 2, 2, 6252, 727, 3, 2, 2, 2, 6253, 6254, 9, 38, 2, 2, 6254, 729, 3, 2, 2, 2, 6255, 6260, 5, 732, 367, 2, 6256, 6257, 7, 8, 2, 2, 6257, 6259, 5, 732, 367, 2, 6258, 6256, 3, 2, 2, 2, 6259, 6262, 3, 2, 2, 2, 6260, 6258, 3, 2, 2, 2, 6260, 6261, 3, 2, 2, 2, 6261, 731, 3, 2, 2, 2, 6262, 6260, 3, 2, 2, 2, 6263, 6264, 7, 130, 2, 2, 6264, 733, 3, 2, 2, 2, 6265, 6266, 7, 140, 2, 2, 6266, 6267, 7, 353, 2, 2, 6267, 6268, 5, 1344, 673, 2, 6268, 6269, 7, 335, 2, 2, 6269, 6270, 5, 116, 59, 2, 6270, 6278, 3, 2, 2, 2, 6271, 6272, 7, 140, 2, 2, 6272, 6273, 7, 353, 2, 2, 6273, 6274, 5, 1344, 673, 2, 6274, 6275, 7, 315, 2, 2, 6275, 6276, 5, 116, 59, 2, 6276, 6278, 3, 2, 2, 2, 6277, 6265, 3, 2, 2, 2, 6277, 6271, 3, 2, 2, 2, 6278, 735, 3, 2, 2, 2, 6279, 6280, 7, 140, 2, 2, 6280, 6281, 7, 138, 2, 2, 6281, 6282, 5, 664, 333, 2, 6282, 6283, 7, 311, 2, 2, 6283, 6284, 7, 96, 2, 2, 6284, 6285, 5, 1344, 673, 2, 6285, 6767, 3, 2, 2, 2, 6286, 6287, 7, 140, 2, 2, 6287, 6288, 7, 110, 2, 2, 6288, 6289, 5, 532, 267, 2, 6289, 6290, 7, 311, 2, 2, 6290, 6291, 7, 96, 2, 2, 6291, 6292, 5, 1344, 673, 2, 6292, 6767, 3, 2, 2, 2, 6293, 6294, 7, 140, 2, 2, 6294, 6295, 7, 170, 2, 2, 6295, 6296, 5, 532, 267, 2, 6296, 6297, 7, 311, 2, 2, 6297, 6298, 7, 96, 2, 2, 6298, 6299, 5, 1344, 673, 2, 6299, 6767, 3, 2, 2, 2, 6300, 6301, 7, 140, 2, 2, 6301, 6302, 7, 177, 2, 2, 6302, 6303, 5, 1344, 673, 2, 6303, 6304, 7, 311, 2, 2, 6304, 6305, 7, 96, 2, 2, 6305, 6306, 5, 1344, 673, 2, 6306, 6767, 3, 2, 2, 2, 6307, 6308, 7, 140, 2, 2, 6308, 6309, 7, 191, 2, 2, 6309, 6310, 5, 532, 267, 2, 6310, 6311, 7, 311, 2, 2, 6311, 6312, 7, 96, 2, 2, 6312, 6313, 5, 1344, 673, 2, 6313, 6767, 3, 2, 2, 2, 6314, 6315, 7, 140, 2, 2, 6315, 6316, 7, 191, 2, 2, 6316, 6317, 5, 532, 267, 2, 6317, 6318, 7, 311, 2, 2, 6318, 6319, 7, 47, 2, 2, 6319, 6320, 5, 1344, 673, 2, 6320, 6321, 7, 96, 2, 2, 6321, 6322, 5, 1344, 673, 2, 6322, 6767, 3, 2, 2, 2, 6323, 6324, 7, 140, 2, 2, 6324, 6325, 7, 65, 2, 2, 6325, 6326, 7, 176, 2, 2, 6326, 6327, 7, 383, 2, 2, 6327, 6328, 5, 1344, 673, 2, 6328, 6329, 7, 311, 2, 2, 6329, 6330, 7, 96, 2, 2, 6330, 6331, 5, 1344, 673, 2, 6331, 6767, 3, 2, 2, 2, 6332, 6333, 7, 140, 2, 2, 6333, 6334, 7, 213, 2, 2, 6334, 6335, 5, 640, 321, 2, 6335, 6336, 7, 311, 2, 2, 6336, 6337, 7, 96, 2, 2, 6337, 6338, 5, 1344, 673, 2, 6338, 6767, 3, 2, 2, 2, 6339, 6340, 7, 140, 2, 2, 6340, 6341, 7, 68, 2, 2, 6341, 6342, 5, 1372, 687, 2, 6342, 6343, 7, 311, 2, 2, 6343, 6344, 7, 96, 2, 2, 6344, 6345, 5, 1372, 687, 2, 6345, 6767, 3, 2, 2, 2, 6346, 6348, 7, 140, 2, 2, 6347, 6349, 5, 312, 157, 2, 6348, 6347, 3, 2, 2, 2, 6348, 6349, 3, 2, 2, 2, 6349, 6350, 3, 2, 2, 2, 6350, 6351, 7, 249, 2, 2, 6351, 6352, 5, 1344, 673, 2, 6352, 6353, 7, 311, 2, 2, 6353, 6354, 7, 96, 2, 2, 6354, 6355, 5, 1344, 673, 2, 6355, 6767, 3, 2, 2, 2, 6356, 6357, 7, 140, 2, 2, 6357, 6358, 7, 280, 2, 2, 6358, 6359, 7, 158, 2, 2, 6359, 6360, 5, 532, 267, 2, 6360, 6361, 7, 102, 2, 2, 6361, 6362, 5, 1344, 673, 2, 6362, 6363, 7, 311, 2, 2, 6363, 6364, 7, 96, 2, 2, 6364, 6365, 5, 1344, 673, 2, 6365, 6767, 3, 2, 2, 2, 6366, 6367, 7, 140, 2, 2, 6367, 6368, 7, 280, 2, 2, 6368, 6369, 7, 208, 2, 2, 6369, 6370, 5, 532, 267, 2, 6370, 6371, 7, 102, 2, 2, 6371, 6372, 5, 1344, 673, 2, 6372, 6373, 7, 311, 2, 2, 6373, 6374, 7, 96, 2, 2, 6374, 6375, 5, 1344, 673, 2, 6375, 6767, 3, 2, 2, 2, 6376, 6377, 7, 140, 2, 2, 6377, 6378, 7, 447, 2, 2, 6378, 6379, 5, 1344, 673, 2, 6379, 6380, 7, 82, 2, 2, 6380, 6381, 5, 1340, 671, 2, 6381, 6382, 7, 311, 2, 2, 6382, 6383, 7, 96, 2, 2, 6383, 6384, 5, 1344, 673, 2, 6384, 6767, 3, 2, 2, 2, 6385, 6386, 7, 140, 2, 2, 6386, 6387, 7, 447, 2, 2, 6387, 6388, 7, 222, 2, 2, 6388, 6389, 7, 398, 2, 2, 6389, 6390, 5, 1344, 673, 2, 6390, 6391, 7, 82, 2, 2, 6391, 6392, 5, 1340, 671, 2, 6392, 6393, 7, 311, 2, 2, 6393, 6394, 7, 96, 2, 2, 6394, 6395, 5, 1344, 673, 2, 6395, 6767, 3, 2, 2, 2, 6396, 6397, 7, 140, 2, 2, 6397, 6398, 7, 298, 2, 2, 6398, 6399, 5, 640, 321, 2, 6399, 6400, 7, 311, 2, 2, 6400, 6401, 7, 96, 2, 2, 6401, 6402, 5, 1344, 673, 2, 6402, 6767, 3, 2, 2, 2, 6403, 6404, 7, 140, 2, 2, 6404, 6405, 7, 454, 2, 2, 6405, 6406, 5, 1344, 673, 2, 6406, 6407, 7, 311, 2, 2, 6407, 6408, 7, 96, 2, 2, 6408, 6409, 5, 1344, 673, 2, 6409, 6767, 3, 2, 2, 2, 6410, 6411, 7, 140, 2, 2, 6411, 6412, 7, 444, 2, 2, 6412, 6413, 5, 640, 321, 2, 6413, 6414, 7, 311, 2, 2, 6414, 6415, 7, 96, 2, 2, 6415, 6416, 5, 1344, 673, 2, 6416, 6767, 3, 2, 2, 2, 6417, 6418, 7, 140, 2, 2, 6418, 6419, 7, 325, 2, 2, 6419, 6420, 5, 1344, 673, 2, 6420, 6421, 7, 311, 2, 2, 6421, 6422, 7, 96, 2, 2, 6422, 6423, 5, 1344, 673, 2, 6423, 6767, 3, 2, 2, 2, 6424, 6425, 7, 140, 2, 2, 6425, 6426, 7, 333, 2, 2, 6426, 6427, 5, 1344, 673, 2, 6427, 6428, 7, 311, 2, 2, 6428, 6429, 7, 96, 2, 2, 6429, 6430, 5, 1344, 673, 2, 6430, 6767, 3, 2, 2, 2, 6431, 6432, 7, 140, 2, 2, 6432, 6433, 7, 453, 2, 2, 6433, 6434, 5, 1344, 673, 2, 6434, 6435, 7, 311, 2, 2, 6435, 6436, 7, 96, 2, 2, 6436, 6437, 5, 1344, 673, 2, 6437, 6767, 3, 2, 2, 2, 6438, 6439, 7, 140, 2, 2, 6439, 6440, 7, 94, 2, 2, 6440, 6441, 5, 1078, 540, 2, 6441, 6442, 7, 311, 2, 2, 6442, 6443, 7, 96, 2, 2, 6443, 6444, 5, 1344, 673, 2, 6444, 6767, 3, 2, 2, 2, 6445, 6446, 7, 140, 2, 2, 6446, 6447, 7, 94, 2, 2, 6447, 6448, 7, 222, 2, 2, 6448, 6449, 7, 398, 2, 2, 6449, 6450, 5, 1078, 540, 2, 6450, 6451, 7, 311, 2, 2, 6451, 6452, 7, 96, 2, 2, 6452, 6453, 5, 1344, 673, 2, 6453, 6767, 3, 2, 2, 2, 6454, 6455, 7, 140, 2, 2, 6455, 6456, 7, 330, 2, 2, 6456, 6457, 5, 1340, 671, 2, 6457, 6458, 7, 311, 2, 2, 6458, 6459, 7, 96, 2, 2, 6459, 6460, 5, 1344, 673, 2, 6460, 6767, 3, 2, 2, 2, 6461, 6462, 7, 140, 2, 2, 6462, 6463, 7, 330, 2, 2, 6463, 6464, 7, 222, 2, 2, 6464, 6465, 7, 398, 2, 2, 6465, 6466, 5, 1340, 671, 2, 6466, 6467, 7, 311, 2, 2, 6467, 6468, 7, 96, 2, 2, 6468, 6469, 5, 1344, 673, 2, 6469, 6767, 3, 2, 2, 2, 6470, 6471, 7, 140, 2, 2, 6471, 6472, 7, 378, 2, 2, 6472, 6473, 5, 1340, 671, 2, 6473, 6474, 7, 311, 2, 2, 6474, 6475, 7, 96, 2, 2, 6475, 6476, 5, 1344, 673, 2, 6476, 6767, 3, 2, 2, 2, 6477, 6478, 7, 140, 2, 2, 6478, 6479, 7, 378, 2, 2, 6479, 6480, 7, 222, 2, 2, 6480, 6481, 7, 398, 2, 2, 6481, 6482, 5, 1340, 671, 2, 6482, 6483, 7, 311, 2, 2, 6483, 6484, 7, 96, 2, 2, 6484, 6485, 5, 1344, 673, 2, 6485, 6767, 3, 2, 2, 2, 6486, 6487, 7, 140, 2, 2, 6487, 6488, 7, 261, 2, 2, 6488, 6489, 7, 378, 2, 2, 6489, 6490, 5, 1340, 671, 2, 6490, 6491, 7, 311, 2, 2, 6491, 6492, 7, 96, 2, 2, 6492, 6493, 5, 1344, 673, 2, 6493, 6767, 3, 2, 2, 2, 6494, 6495, 7, 140, 2, 2, 6495, 6496, 7, 261, 2, 2, 6496, 6497, 7, 378, 2, 2, 6497, 6498, 7, 222, 2, 2, 6498, 6499, 7, 398, 2, 2, 6499, 6500, 5, 1340, 671, 2, 6500, 6501, 7, 311, 2, 2, 6501, 6502, 7, 96, 2, 2, 6502, 6503, 5, 1344, 673, 2, 6503, 6767, 3, 2, 2, 2, 6504, 6505, 7, 140, 2, 2, 6505, 6506, 7, 228, 2, 2, 6506, 6507, 5, 1340, 671, 2, 6507, 6508, 7, 311, 2, 2, 6508, 6509, 7, 96, 2, 2, 6509, 6510, 5, 1344, 673, 2, 6510, 6767, 3, 2, 2, 2, 6511, 6512, 7, 140, 2, 2, 6512, 6513, 7, 228, 2, 2, 6513, 6514, 7, 222, 2, 2, 6514, 6515, 7, 398, 2, 2, 6515, 6516, 5, 1340, 671, 2, 6516, 6517, 7, 311, 2, 2, 6517, 6518, 7, 96, 2, 2, 6518, 6519, 5, 1344, 673, 2, 6519, 6767, 3, 2, 2, 2, 6520, 6521, 7, 140, 2, 2, 6521, 6522, 7, 65, 2, 2, 6522, 6523, 7, 94, 2, 2, 6523, 6524, 5, 1078, 540, 2, 6524, 6525, 7, 311, 2, 2, 6525, 6526, 7, 96, 2, 2, 6526, 6527, 5, 1344, 673, 2, 6527, 6767, 3, 2, 2, 2, 6528, 6529, 7, 140, 2, 2, 6529, 6530, 7, 65, 2, 2, 6530, 6531, 7, 94, 2, 2, 6531, 6532, 7, 222, 2, 2, 6532, 6533, 7, 398, 2, 2, 6533, 6534, 5, 1078, 540, 2, 6534, 6535, 7, 311, 2, 2, 6535, 6536, 7, 96, 2, 2, 6536, 6537, 5, 1344, 673, 2, 6537, 6767, 3, 2, 2, 2, 6538, 6539, 7, 140, 2, 2, 6539, 6540, 7, 94, 2, 2, 6540, 6541, 5, 1078, 540, 2, 6541, 6543, 7, 311, 2, 2, 6542, 6544, 5, 738, 370, 2, 6543, 6542, 3, 2, 2, 2, 6543, 6544, 3, 2, 2, 2, 6544, 6545, 3, 2, 2, 2, 6545, 6546, 5, 1344, 673, 2, 6546, 6547, 7, 96, 2, 2, 6547, 6548, 5, 1344, 673, 2, 6548, 6767, 3, 2, 2, 2, 6549, 6550, 7, 140, 2, 2, 6550, 6551, 7, 94, 2, 2, 6551, 6552, 7, 222, 2, 2, 6552, 6553, 7, 398, 2, 2, 6553, 6554, 5, 1078, 540, 2, 6554, 6556, 7, 311, 2, 2, 6555, 6557, 5, 738, 370, 2, 6556, 6555, 3, 2, 2, 2, 6556, 6557, 3, 2, 2, 2, 6557, 6558, 3, 2, 2, 2, 6558, 6559, 5, 1344, 673, 2, 6559, 6560, 7, 96, 2, 2, 6560, 6561, 5, 1344, 673, 2, 6561, 6767, 3, 2, 2, 2, 6562, 6563, 7, 140, 2, 2, 6563, 6564, 7, 378, 2, 2, 6564, 6565, 5, 1340, 671, 2, 6565, 6567, 7, 311, 2, 2, 6566, 6568, 5, 738, 370, 2, 6567, 6566, 3, 2, 2, 2, 6567, 6568, 3, 2, 2, 2, 6568, 6569, 3, 2, 2, 2, 6569, 6570, 5, 1344, 673, 2, 6570, 6571, 7, 96, 2, 2, 6571, 6572, 5, 1344, 673, 2, 6572, 6767, 3, 2, 2, 2, 6573, 6574, 7, 140, 2, 2, 6574, 6575, 7, 378, 2, 2, 6575, 6576, 7, 222, 2, 2, 6576, 6577, 7, 398, 2, 2, 6577, 6578, 5, 1340, 671, 2, 6578, 6580, 7, 311, 2, 2, 6579, 6581, 5, 738, 370, 2, 6580, 6579, 3, 2, 2, 2, 6580, 6581, 3, 2, 2, 2, 6581, 6582, 3, 2, 2, 2, 6582, 6583, 5, 1344, 673, 2, 6583, 6584, 7, 96, 2, 2, 6584, 6585, 5, 1344, 673, 2, 6585, 6767, 3, 2, 2, 2, 6586, 6587, 7, 140, 2, 2, 6587, 6588, 7, 261, 2, 2, 6588, 6589, 7, 378, 2, 2, 6589, 6590, 5, 1340, 671, 2, 6590, 6592, 7, 311, 2, 2, 6591, 6593, 5, 738, 370, 2, 6592, 6591, 3, 2, 2, 2, 6592, 6593, 3, 2, 2, 2, 6593, 6594, 3, 2, 2, 2, 6594, 6595, 5, 1344, 673, 2, 6595, 6596, 7, 96, 2, 2, 6596, 6597, 5, 1344, 673, 2, 6597, 6767, 3, 2, 2, 2, 6598, 6599, 7, 140, 2, 2, 6599, 6600, 7, 261, 2, 2, 6600, 6601, 7, 378, 2, 2, 6601, 6602, 7, 222, 2, 2, 6602, 6603, 7, 398, 2, 2, 6603, 6604, 5, 1340, 671, 2, 6604, 6606, 7, 311, 2, 2, 6605, 6607, 5, 738, 370, 2, 6606, 6605, 3, 2, 2, 2, 6606, 6607, 3, 2, 2, 2, 6607, 6608, 3, 2, 2, 2, 6608, 6609, 5, 1344, 673, 2, 6609, 6610, 7, 96, 2, 2, 6610, 6611, 5, 1344, 673, 2, 6611, 6767, 3, 2, 2, 2, 6612, 6613, 7, 140, 2, 2, 6613, 6614, 7, 94, 2, 2, 6614, 6615, 5, 1078, 540, 2, 6615, 6616, 7, 311, 2, 2, 6616, 6617, 7, 47, 2, 2, 6617, 6618, 5, 1344, 673, 2, 6618, 6619, 7, 96, 2, 2, 6619, 6620, 5, 1344, 673, 2, 6620, 6767, 3, 2, 2, 2, 6621, 6622, 7, 140, 2, 2, 6622, 6623, 7, 94, 2, 2, 6623, 6624, 7, 222, 2, 2, 6624, 6625, 7, 398, 2, 2, 6625, 6626, 5, 1078, 540, 2, 6626, 6627, 7, 311, 2, 2, 6627, 6628, 7, 47, 2, 2, 6628, 6629, 5, 1344, 673, 2, 6629, 6630, 7, 96, 2, 2, 6630, 6631, 5, 1344, 673, 2, 6631, 6767, 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, 1078, 540, 2, 6636, 6638, 7, 311, 2, 2, 6637, 6639, 5, 738, 370, 2, 6638, 6637, 3, 2, 2, 2, 6638, 6639, 3, 2, 2, 2, 6639, 6640, 3, 2, 2, 2, 6640, 6641, 5, 1344, 673, 2, 6641, 6642, 7, 96, 2, 2, 6642, 6643, 5, 1344, 673, 2, 6643, 6767, 3, 2, 2, 2, 6644, 6645, 7, 140, 2, 2, 6645, 6646, 7, 65, 2, 2, 6646, 6647, 7, 94, 2, 2, 6647, 6648, 7, 222, 2, 2, 6648, 6649, 7, 398, 2, 2, 6649, 6650, 5, 1078, 540, 2, 6650, 6652, 7, 311, 2, 2, 6651, 6653, 5, 738, 370, 2, 6652, 6651, 3, 2, 2, 2, 6652, 6653, 3, 2, 2, 2, 6653, 6654, 3, 2, 2, 2, 6654, 6655, 5, 1344, 673, 2, 6655, 6656, 7, 96, 2, 2, 6656, 6657, 5, 1344, 673, 2, 6657, 6767, 3, 2, 2, 2, 6658, 6659, 7, 140, 2, 2, 6659, 6660, 7, 323, 2, 2, 6660, 6661, 5, 1344, 673, 2, 6661, 6662, 7, 82, 2, 2, 6662, 6663, 5, 1340, 671, 2, 6663, 6664, 7, 311, 2, 2, 6664, 6665, 7, 96, 2, 2, 6665, 6666, 5, 1344, 673, 2, 6666, 6767, 3, 2, 2, 2, 6667, 6668, 7, 140, 2, 2, 6668, 6669, 7, 359, 2, 2, 6669, 6670, 5, 1344, 673, 2, 6670, 6671, 7, 82, 2, 2, 6671, 6672, 5, 1340, 671, 2, 6672, 6673, 7, 311, 2, 2, 6673, 6674, 7, 96, 2, 2, 6674, 6675, 5, 1344, 673, 2, 6675, 6767, 3, 2, 2, 2, 6676, 6677, 7, 140, 2, 2, 6677, 6678, 7, 200, 2, 2, 6678, 6679, 7, 359, 2, 2, 6679, 6680, 5, 1344, 673, 2, 6680, 6681, 7, 311, 2, 2, 6681, 6682, 7, 96, 2, 2, 6682, 6683, 5, 1344, 673, 2, 6683, 6767, 3, 2, 2, 2, 6684, 6685, 7, 140, 2, 2, 6685, 6686, 7, 320, 2, 2, 6686, 6687, 5, 1372, 687, 2, 6687, 6688, 7, 311, 2, 2, 6688, 6689, 7, 96, 2, 2, 6689, 6690, 5, 1372, 687, 2, 6690, 6767, 3, 2, 2, 2, 6691, 6692, 7, 140, 2, 2, 6692, 6693, 7, 101, 2, 2, 6693, 6694, 5, 1372, 687, 2, 6694, 6695, 7, 311, 2, 2, 6695, 6696, 7, 96, 2, 2, 6696, 6697, 5, 1372, 687, 2, 6697, 6767, 3, 2, 2, 2, 6698, 6699, 7, 140, 2, 2, 6699, 6700, 7, 353, 2, 2, 6700, 6701, 5, 1344, 673, 2, 6701, 6702, 7, 311, 2, 2, 6702, 6703, 7, 96, 2, 2, 6703, 6704, 5, 1344, 673, 2, 6704, 6767, 3, 2, 2, 2, 6705, 6706, 7, 140, 2, 2, 6706, 6707, 7, 344, 2, 2, 6707, 6708, 5, 532, 267, 2, 6708, 6709, 7, 311, 2, 2, 6709, 6710, 7, 96, 2, 2, 6710, 6711, 5, 1344, 673, 2, 6711, 6767, 3, 2, 2, 2, 6712, 6713, 7, 140, 2, 2, 6713, 6714, 7, 357, 2, 2, 6714, 6715, 7, 327, 2, 2, 6715, 6716, 7, 285, 2, 2, 6716, 6717, 5, 532, 267, 2, 6717, 6718, 7, 311, 2, 2, 6718, 6719, 7, 96, 2, 2, 6719, 6720, 5, 1344, 673, 2, 6720, 6767, 3, 2, 2, 2, 6721, 6722, 7, 140, 2, 2, 6722, 6723, 7, 357, 2, 2, 6723, 6724, 7, 327, 2, 2, 6724, 6725, 7, 187, 2, 2, 6725, 6726, 5, 532, 267, 2, 6726, 6727, 7, 311, 2, 2, 6727, 6728, 7, 96, 2, 2, 6728, 6729, 5, 1344, 673, 2, 6729, 6767, 3, 2, 2, 2, 6730, 6731, 7, 140, 2, 2, 6731, 6732, 7, 357, 2, 2, 6732, 6733, 7, 327, 2, 2, 6733, 6734, 7, 355, 2, 2, 6734, 6735, 5, 532, 267, 2, 6735, 6736, 7, 311, 2, 2, 6736, 6737, 7, 96, 2, 2, 6737, 6738, 5, 1344, 673, 2, 6738, 6767, 3, 2, 2, 2, 6739, 6740, 7, 140, 2, 2, 6740, 6741, 7, 357, 2, 2, 6741, 6742, 7, 327, 2, 2, 6742, 6743, 7, 165, 2, 2, 6743, 6744, 5, 532, 267, 2, 6744, 6745, 7, 311, 2, 2, 6745, 6746, 7, 96, 2, 2, 6746, 6747, 5, 1344, 673, 2, 6747, 6767, 3, 2, 2, 2, 6748, 6749, 7, 140, 2, 2, 6749, 6750, 7, 362, 2, 2, 6750, 6751, 5, 532, 267, 2, 6751, 6752, 7, 311, 2, 2, 6752, 6753, 7, 96, 2, 2, 6753, 6754, 5, 1344, 673, 2, 6754, 6767, 3, 2, 2, 2, 6755, 6756, 7, 140, 2, 2, 6756, 6757, 7, 362, 2, 2, 6757, 6758, 5, 532, 267, 2, 6758, 6759, 7, 311, 2, 2, 6759, 6760, 7, 145, 2, 2, 6760, 6761, 5, 1344, 673, 2, 6761, 6762, 7, 96, 2, 2, 6762, 6764, 5, 1344, 673, 2, 6763, 6765, 5, 108, 55, 2, 6764, 6763, 3, 2, 2, 2, 6764, 6765, 3, 2, 2, 2, 6765, 6767, 3, 2, 2, 2, 6766, 6279, 3, 2, 2, 2, 6766, 6286, 3, 2, 2, 2, 6766, 6293, 3, 2, 2, 2, 6766, 6300, 3, 2, 2, 2, 6766, 6307, 3, 2, 2, 2, 6766, 6314, 3, 2, 2, 2, 6766, 6323, 3, 2, 2, 2, 6766, 6332, 3, 2, 2, 2, 6766, 6339, 3, 2, 2, 2, 6766, 6346, 3, 2, 2, 2, 6766, 6356, 3, 2, 2, 2, 6766, 6366, 3, 2, 2, 2, 6766, 6376, 3, 2, 2, 2, 6766, 6385, 3, 2, 2, 2, 6766, 6396, 3, 2, 2, 2, 6766, 6403, 3, 2, 2, 2, 6766, 6410, 3, 2, 2, 2, 6766, 6417, 3, 2, 2, 2, 6766, 6424, 3, 2, 2, 2, 6766, 6431, 3, 2, 2, 2, 6766, 6438, 3, 2, 2, 2, 6766, 6445, 3, 2, 2, 2, 6766, 6454, 3, 2, 2, 2, 6766, 6461, 3, 2, 2, 2, 6766, 6470, 3, 2, 2, 2, 6766, 6477, 3, 2, 2, 2, 6766, 6486, 3, 2, 2, 2, 6766, 6494, 3, 2, 2, 2, 6766, 6504, 3, 2, 2, 2, 6766, 6511, 3, 2, 2, 2, 6766, 6520, 3, 2, 2, 2, 6766, 6528, 3, 2, 2, 2, 6766, 6538, 3, 2, 2, 2, 6766, 6549, 3, 2, 2, 2, 6766, 6562, 3, 2, 2, 2, 6766, 6573, 3, 2, 2, 2, 6766, 6586, 3, 2, 2, 2, 6766, 6598, 3, 2, 2, 2, 6766, 6612, 3, 2, 2, 2, 6766, 6621, 3, 2, 2, 2, 6766, 6632, 3, 2, 2, 2, 6766, 6644, 3, 2, 2, 2, 6766, 6658, 3, 2, 2, 2, 6766, 6667, 3, 2, 2, 2, 6766, 6676, 3, 2, 2, 2, 6766, 6684, 3, 2, 2, 2, 6766, 6691, 3, 2, 2, 2, 6766, 6698, 3, 2, 2, 2, 6766, 6705, 3, 2, 2, 2, 6766, 6712, 3, 2, 2, 2, 6766, 6721, 3, 2, 2, 2, 6766, 6730, 3, 2, 2, 2, 6766, 6739, 3, 2, 2, 2, 6766, 6748, 3, 2, 2, 2, 6766, 6755, 3, 2, 2, 2, 6767, 737, 3, 2, 2, 2, 6768, 6769, 7, 46, 2, 2, 6769, 739, 3, 2, 2, 2, 6770, 6771, 7, 335, 2, 2, 6771, 6772, 7, 176, 2, 2, 6772, 741, 3, 2, 2, 2, 6773, 6774, 7, 140, 2, 2, 6774, 6775, 7, 213, 2, 2, 6775, 6777, 5, 640, 321, 2, 6776, 6778, 5, 744, 373, 2, 6777, 6776, 3, 2, 2, 2, 6777, 6778, 3, 2, 2, 2, 6778, 6779, 3, 2, 2, 2, 6779, 6780, 7, 464, 2, 2, 6780, 6781, 7, 82, 2, 2, 6781, 6782, 7, 206, 2, 2, 6782, 6783, 5, 1344, 673, 2, 6783, 6843, 3, 2, 2, 2, 6784, 6785, 7, 140, 2, 2, 6785, 6786, 7, 298, 2, 2, 6786, 6788, 5, 640, 321, 2, 6787, 6789, 5, 744, 373, 2, 6788, 6787, 3, 2, 2, 2, 6788, 6789, 3, 2, 2, 2, 6789, 6790, 3, 2, 2, 2, 6790, 6791, 7, 464, 2, 2, 6791, 6792, 7, 82, 2, 2, 6792, 6793, 7, 206, 2, 2, 6793, 6794, 5, 1344, 673, 2, 6794, 6843, 3, 2, 2, 2, 6795, 6796, 7, 140, 2, 2, 6796, 6797, 7, 444, 2, 2, 6797, 6799, 5, 640, 321, 2, 6798, 6800, 5, 744, 373, 2, 6799, 6798, 3, 2, 2, 2, 6799, 6800, 3, 2, 2, 2, 6800, 6801, 3, 2, 2, 2, 6801, 6802, 7, 464, 2, 2, 6802, 6803, 7, 82, 2, 2, 6803, 6804, 7, 206, 2, 2, 6804, 6805, 5, 1344, 673, 2, 6805, 6843, 3, 2, 2, 2, 6806, 6807, 7, 140, 2, 2, 6807, 6808, 7, 359, 2, 2, 6808, 6809, 5, 1344, 673, 2, 6809, 6810, 7, 82, 2, 2, 6810, 6812, 5, 1340, 671, 2, 6811, 6813, 5, 744, 373, 2, 6812, 6811, 3, 2, 2, 2, 6812, 6813, 3, 2, 2, 2, 6813, 6814, 3, 2, 2, 2, 6814, 6815, 7, 464, 2, 2, 6815, 6816, 7, 82, 2, 2, 6816, 6817, 7, 206, 2, 2, 6817, 6818, 5, 1344, 673, 2, 6818, 6843, 3, 2, 2, 2, 6819, 6820, 7, 140, 2, 2, 6820, 6821, 7, 261, 2, 2, 6821, 6822, 7, 378, 2, 2, 6822, 6824, 5, 1340, 671, 2, 6823, 6825, 5, 744, 373, 2, 6824, 6823, 3, 2, 2, 2, 6824, 6825, 3, 2, 2, 2, 6825, 6826, 3, 2, 2, 2, 6826, 6827, 7, 464, 2, 2, 6827, 6828, 7, 82, 2, 2, 6828, 6829, 7, 206, 2, 2, 6829, 6830, 5, 1344, 673, 2, 6830, 6843, 3, 2, 2, 2, 6831, 6832, 7, 140, 2, 2, 6832, 6833, 7, 228, 2, 2, 6833, 6835, 5, 1340, 671, 2, 6834, 6836, 5, 744, 373, 2, 6835, 6834, 3, 2, 2, 2, 6835, 6836, 3, 2, 2, 2, 6836, 6837, 3, 2, 2, 2, 6837, 6838, 7, 464, 2, 2, 6838, 6839, 7, 82, 2, 2, 6839, 6840, 7, 206, 2, 2, 6840, 6841, 5, 1344, 673, 2, 6841, 6843, 3, 2, 2, 2, 6842, 6773, 3, 2, 2, 2, 6842, 6784, 3, 2, 2, 2, 6842, 6795, 3, 2, 2, 2, 6842, 6806, 3, 2, 2, 2, 6842, 6819, 3, 2, 2, 2, 6842, 6831, 3, 2, 2, 2, 6843, 743, 3, 2, 2, 2, 6844, 6845, 7, 271, 2, 2, 6845, 745, 3, 2, 2, 2, 6846, 6847, 7, 140, 2, 2, 6847, 6848, 7, 138, 2, 2, 6848, 6849, 5, 664, 333, 2, 6849, 6850, 7, 335, 2, 2, 6850, 6851, 7, 325, 2, 2, 6851, 6852, 5, 1344, 673, 2, 6852, 7064, 3, 2, 2, 2, 6853, 6854, 7, 140, 2, 2, 6854, 6855, 7, 110, 2, 2, 6855, 6856, 5, 532, 267, 2, 6856, 6857, 7, 335, 2, 2, 6857, 6858, 7, 325, 2, 2, 6858, 6859, 5, 1344, 673, 2, 6859, 7064, 3, 2, 2, 2, 6860, 6861, 7, 140, 2, 2, 6861, 6862, 7, 170, 2, 2, 6862, 6863, 5, 532, 267, 2, 6863, 6864, 7, 335, 2, 2, 6864, 6865, 7, 325, 2, 2, 6865, 6866, 5, 1344, 673, 2, 6866, 7064, 3, 2, 2, 2, 6867, 6868, 7, 140, 2, 2, 6868, 6869, 7, 191, 2, 2, 6869, 6870, 5, 532, 267, 2, 6870, 6871, 7, 335, 2, 2, 6871, 6872, 7, 325, 2, 2, 6872, 6873, 5, 1344, 673, 2, 6873, 7064, 3, 2, 2, 2, 6874, 6875, 7, 140, 2, 2, 6875, 6876, 7, 206, 2, 2, 6876, 6877, 5, 1344, 673, 2, 6877, 6878, 7, 335, 2, 2, 6878, 6879, 7, 325, 2, 2, 6879, 6880, 5, 1344, 673, 2, 6880, 7064, 3, 2, 2, 2, 6881, 6882, 7, 140, 2, 2, 6882, 6883, 7, 213, 2, 2, 6883, 6884, 5, 640, 321, 2, 6884, 6885, 7, 335, 2, 2, 6885, 6886, 7, 325, 2, 2, 6886, 6887, 5, 1344, 673, 2, 6887, 7064, 3, 2, 2, 2, 6888, 6889, 7, 140, 2, 2, 6889, 6890, 7, 280, 2, 2, 6890, 6891, 5, 702, 352, 2, 6891, 6892, 7, 335, 2, 2, 6892, 6893, 7, 325, 2, 2, 6893, 6894, 5, 1344, 673, 2, 6894, 7064, 3, 2, 2, 2, 6895, 6896, 7, 140, 2, 2, 6896, 6897, 7, 280, 2, 2, 6897, 6898, 7, 158, 2, 2, 6898, 6899, 5, 532, 267, 2, 6899, 6900, 7, 102, 2, 2, 6900, 6901, 5, 1344, 673, 2, 6901, 6902, 7, 335, 2, 2, 6902, 6903, 7, 325, 2, 2, 6903, 6904, 5, 1344, 673, 2, 6904, 7064, 3, 2, 2, 2, 6905, 6906, 7, 140, 2, 2, 6906, 6907, 7, 280, 2, 2, 6907, 6908, 7, 208, 2, 2, 6908, 6909, 5, 532, 267, 2, 6909, 6910, 7, 102, 2, 2, 6910, 6911, 5, 1344, 673, 2, 6911, 6912, 7, 335, 2, 2, 6912, 6913, 7, 325, 2, 2, 6913, 6914, 5, 1344, 673, 2, 6914, 7064, 3, 2, 2, 2, 6915, 6916, 7, 140, 2, 2, 6916, 6917, 7, 298, 2, 2, 6917, 6918, 5, 640, 321, 2, 6918, 6919, 7, 335, 2, 2, 6919, 6920, 7, 325, 2, 2, 6920, 6921, 5, 1344, 673, 2, 6921, 7064, 3, 2, 2, 2, 6922, 6923, 7, 140, 2, 2, 6923, 6924, 7, 444, 2, 2, 6924, 6925, 5, 640, 321, 2, 6925, 6926, 7, 335, 2, 2, 6926, 6927, 7, 325, 2, 2, 6927, 6928, 5, 1344, 673, 2, 6928, 7064, 3, 2, 2, 2, 6929, 6930, 7, 140, 2, 2, 6930, 6931, 7, 94, 2, 2, 6931, 6932, 5, 1078, 540, 2, 6932, 6933, 7, 335, 2, 2, 6933, 6934, 7, 325, 2, 2, 6934, 6935, 5, 1344, 673, 2, 6935, 7064, 3, 2, 2, 2, 6936, 6937, 7, 140, 2, 2, 6937, 6938, 7, 94, 2, 2, 6938, 6939, 7, 222, 2, 2, 6939, 6940, 7, 398, 2, 2, 6940, 6941, 5, 1078, 540, 2, 6941, 6942, 7, 335, 2, 2, 6942, 6943, 7, 325, 2, 2, 6943, 6944, 5, 1344, 673, 2, 6944, 7064, 3, 2, 2, 2, 6945, 6946, 7, 140, 2, 2, 6946, 6947, 7, 344, 2, 2, 6947, 6948, 5, 532, 267, 2, 6948, 6949, 7, 335, 2, 2, 6949, 6950, 7, 325, 2, 2, 6950, 6951, 5, 1344, 673, 2, 6951, 7064, 3, 2, 2, 2, 6952, 6953, 7, 140, 2, 2, 6953, 6954, 7, 357, 2, 2, 6954, 6955, 7, 327, 2, 2, 6955, 6956, 7, 285, 2, 2, 6956, 6957, 5, 532, 267, 2, 6957, 6958, 7, 335, 2, 2, 6958, 6959, 7, 325, 2, 2, 6959, 6960, 5, 1344, 673, 2, 6960, 7064, 3, 2, 2, 2, 6961, 6962, 7, 140, 2, 2, 6962, 6963, 7, 357, 2, 2, 6963, 6964, 7, 327, 2, 2, 6964, 6965, 7, 187, 2, 2, 6965, 6966, 5, 532, 267, 2, 6966, 6967, 7, 335, 2, 2, 6967, 6968, 7, 325, 2, 2, 6968, 6969, 5, 1344, 673, 2, 6969, 7064, 3, 2, 2, 2, 6970, 6971, 7, 140, 2, 2, 6971, 6972, 7, 357, 2, 2, 6972, 6973, 7, 327, 2, 2, 6973, 6974, 7, 355, 2, 2, 6974, 6975, 5, 532, 267, 2, 6975, 6976, 7, 335, 2, 2, 6976, 6977, 7, 325, 2, 2, 6977, 6978, 5, 1344, 673, 2, 6978, 7064, 3, 2, 2, 2, 6979, 6980, 7, 140, 2, 2, 6980, 6981, 7, 357, 2, 2, 6981, 6982, 7, 327, 2, 2, 6982, 6983, 7, 165, 2, 2, 6983, 6984, 5, 532, 267, 2, 6984, 6985, 7, 335, 2, 2, 6985, 6986, 7, 325, 2, 2, 6986, 6987, 5, 1344, 673, 2, 6987, 7064, 3, 2, 2, 2, 6988, 6989, 7, 140, 2, 2, 6989, 6990, 7, 330, 2, 2, 6990, 6991, 5, 1340, 671, 2, 6991, 6992, 7, 335, 2, 2, 6992, 6993, 7, 325, 2, 2, 6993, 6994, 5, 1344, 673, 2, 6994, 7064, 3, 2, 2, 2, 6995, 6996, 7, 140, 2, 2, 6996, 6997, 7, 330, 2, 2, 6997, 6998, 7, 222, 2, 2, 6998, 6999, 7, 398, 2, 2, 6999, 7000, 5, 1340, 671, 2, 7000, 7001, 7, 335, 2, 2, 7001, 7002, 7, 325, 2, 2, 7002, 7003, 5, 1344, 673, 2, 7003, 7064, 3, 2, 2, 2, 7004, 7005, 7, 140, 2, 2, 7005, 7006, 7, 378, 2, 2, 7006, 7007, 5, 1340, 671, 2, 7007, 7008, 7, 335, 2, 2, 7008, 7009, 7, 325, 2, 2, 7009, 7010, 5, 1344, 673, 2, 7010, 7064, 3, 2, 2, 2, 7011, 7012, 7, 140, 2, 2, 7012, 7013, 7, 378, 2, 2, 7013, 7014, 7, 222, 2, 2, 7014, 7015, 7, 398, 2, 2, 7015, 7016, 5, 1340, 671, 2, 7016, 7017, 7, 335, 2, 2, 7017, 7018, 7, 325, 2, 2, 7018, 7019, 5, 1344, 673, 2, 7019, 7064, 3, 2, 2, 2, 7020, 7021, 7, 140, 2, 2, 7021, 7022, 7, 261, 2, 2, 7022, 7023, 7, 378, 2, 2, 7023, 7024, 5, 1340, 671, 2, 7024, 7025, 7, 335, 2, 2, 7025, 7026, 7, 325, 2, 2, 7026, 7027, 5, 1344, 673, 2, 7027, 7064, 3, 2, 2, 2, 7028, 7029, 7, 140, 2, 2, 7029, 7030, 7, 261, 2, 2, 7030, 7031, 7, 378, 2, 2, 7031, 7032, 7, 222, 2, 2, 7032, 7033, 7, 398, 2, 2, 7033, 7034, 5, 1340, 671, 2, 7034, 7035, 7, 335, 2, 2, 7035, 7036, 7, 325, 2, 2, 7036, 7037, 5, 1344, 673, 2, 7037, 7064, 3, 2, 2, 2, 7038, 7039, 7, 140, 2, 2, 7039, 7040, 7, 65, 2, 2, 7040, 7041, 7, 94, 2, 2, 7041, 7042, 5, 1078, 540, 2, 7042, 7043, 7, 335, 2, 2, 7043, 7044, 7, 325, 2, 2, 7044, 7045, 5, 1344, 673, 2, 7045, 7064, 3, 2, 2, 2, 7046, 7047, 7, 140, 2, 2, 7047, 7048, 7, 65, 2, 2, 7048, 7049, 7, 94, 2, 2, 7049, 7050, 7, 222, 2, 2, 7050, 7051, 7, 398, 2, 2, 7051, 7052, 5, 1078, 540, 2, 7052, 7053, 7, 335, 2, 2, 7053, 7054, 7, 325, 2, 2, 7054, 7055, 5, 1344, 673, 2, 7055, 7064, 3, 2, 2, 2, 7056, 7057, 7, 140, 2, 2, 7057, 7058, 7, 362, 2, 2, 7058, 7059, 5, 532, 267, 2, 7059, 7060, 7, 335, 2, 2, 7060, 7061, 7, 325, 2, 2, 7061, 7062, 5, 1344, 673, 2, 7062, 7064, 3, 2, 2, 2, 7063, 6846, 3, 2, 2, 2, 7063, 6853, 3, 2, 2, 2, 7063, 6860, 3, 2, 2, 2, 7063, 6867, 3, 2, 2, 2, 7063, 6874, 3, 2, 2, 2, 7063, 6881, 3, 2, 2, 2, 7063, 6888, 3, 2, 2, 2, 7063, 6895, 3, 2, 2, 2, 7063, 6905, 3, 2, 2, 2, 7063, 6915, 3, 2, 2, 2, 7063, 6922, 3, 2, 2, 2, 7063, 6929, 3, 2, 2, 2, 7063, 6936, 3, 2, 2, 2, 7063, 6945, 3, 2, 2, 2, 7063, 6952, 3, 2, 2, 2, 7063, 6961, 3, 2, 2, 2, 7063, 6970, 3, 2, 2, 2, 7063, 6979, 3, 2, 2, 2, 7063, 6988, 3, 2, 2, 2, 7063, 6995, 3, 2, 2, 2, 7063, 7004, 3, 2, 2, 2, 7063, 7011, 3, 2, 2, 2, 7063, 7020, 3, 2, 2, 2, 7063, 7028, 3, 2, 2, 2, 7063, 7038, 3, 2, 2, 2, 7063, 7046, 3, 2, 2, 2, 7063, 7056, 3, 2, 2, 2, 7064, 747, 3, 2, 2, 2, 7065, 7066, 7, 140, 2, 2, 7066, 7067, 7, 280, 2, 2, 7067, 7068, 5, 702, 352, 2, 7068, 7069, 7, 335, 2, 2, 7069, 7070, 7, 4, 2, 2, 7070, 7071, 5, 750, 376, 2, 7071, 7072, 7, 5, 2, 2, 7072, 749, 3, 2, 2, 2, 7073, 7078, 5, 752, 377, 2, 7074, 7075, 7, 8, 2, 2, 7075, 7077, 5, 752, 377, 2, 7076, 7074, 3, 2, 2, 2, 7077, 7080, 3, 2, 2, 2, 7078, 7076, 3, 2, 2, 2, 7078, 7079, 3, 2, 2, 2, 7079, 751, 3, 2, 2, 2, 7080, 7078, 3, 2, 2, 2, 7081, 7082, 5, 1392, 697, 2, 7082, 7083, 7, 12, 2, 2, 7083, 7084, 7, 409, 2, 2, 7084, 7090, 3, 2, 2, 2, 7085, 7086, 5, 1392, 697, 2, 7086, 7087, 7, 12, 2, 2, 7087, 7088, 5, 754, 378, 2, 7088, 7090, 3, 2, 2, 2, 7089, 7081, 3, 2, 2, 2, 7089, 7085, 3, 2, 2, 2, 7090, 753, 3, 2, 2, 2, 7091, 7097, 5, 654, 328, 2, 7092, 7097, 5, 1404, 703, 2, 7093, 7097, 5, 1278, 640, 2, 7094, 7097, 5, 296, 149, 2, 7095, 7097, 5, 1362, 682, 2, 7096, 7091, 3, 2, 2, 2, 7096, 7092, 3, 2, 2, 2, 7096, 7093, 3, 2, 2, 2, 7096, 7094, 3, 2, 2, 2, 7096, 7095, 3, 2, 2, 2, 7097, 755, 3, 2, 2, 2, 7098, 7099, 7, 140, 2, 2, 7099, 7100, 7, 362, 2, 2, 7100, 7101, 5, 532, 267, 2, 7101, 7102, 7, 335, 2, 2, 7102, 7103, 7, 4, 2, 2, 7103, 7104, 5, 750, 376, 2, 7104, 7105, 7, 5, 2, 2, 7105, 757, 3, 2, 2, 2, 7106, 7107, 7, 140, 2, 2, 7107, 7108, 7, 138, 2, 2, 7108, 7109, 5, 664, 333, 2, 7109, 7110, 7, 284, 2, 2, 7110, 7111, 7, 96, 2, 2, 7111, 7112, 5, 1374, 688, 2, 7112, 7292, 3, 2, 2, 2, 7113, 7114, 7, 140, 2, 2, 7114, 7115, 7, 110, 2, 2, 7115, 7116, 5, 532, 267, 2, 7116, 7117, 7, 284, 2, 2, 7117, 7118, 7, 96, 2, 2, 7118, 7119, 5, 1374, 688, 2, 7119, 7292, 3, 2, 2, 2, 7120, 7121, 7, 140, 2, 2, 7121, 7122, 7, 170, 2, 2, 7122, 7123, 5, 532, 267, 2, 7123, 7124, 7, 284, 2, 2, 7124, 7125, 7, 96, 2, 2, 7125, 7126, 5, 1374, 688, 2, 7126, 7292, 3, 2, 2, 2, 7127, 7128, 7, 140, 2, 2, 7128, 7129, 7, 177, 2, 2, 7129, 7130, 5, 1344, 673, 2, 7130, 7131, 7, 284, 2, 2, 7131, 7132, 7, 96, 2, 2, 7132, 7133, 5, 1374, 688, 2, 7133, 7292, 3, 2, 2, 2, 7134, 7135, 7, 140, 2, 2, 7135, 7136, 7, 191, 2, 2, 7136, 7137, 5, 532, 267, 2, 7137, 7138, 7, 284, 2, 2, 7138, 7139, 7, 96, 2, 2, 7139, 7140, 5, 1374, 688, 2, 7140, 7292, 3, 2, 2, 2, 7141, 7142, 7, 140, 2, 2, 7142, 7143, 7, 213, 2, 2, 7143, 7144, 5, 640, 321, 2, 7144, 7145, 7, 284, 2, 2, 7145, 7146, 7, 96, 2, 2, 7146, 7147, 5, 1374, 688, 2, 7147, 7292, 3, 2, 2, 2, 7148, 7150, 7, 140, 2, 2, 7149, 7151, 5, 312, 157, 2, 7150, 7149, 3, 2, 2, 2, 7150, 7151, 3, 2, 2, 2, 7151, 7152, 3, 2, 2, 2, 7152, 7153, 7, 249, 2, 2, 7153, 7154, 5, 1344, 673, 2, 7154, 7155, 7, 284, 2, 2, 7155, 7156, 7, 96, 2, 2, 7156, 7157, 5, 1374, 688, 2, 7157, 7292, 3, 2, 2, 2, 7158, 7159, 7, 140, 2, 2, 7159, 7160, 7, 250, 2, 2, 7160, 7161, 7, 276, 2, 2, 7161, 7162, 5, 296, 149, 2, 7162, 7163, 7, 284, 2, 2, 7163, 7164, 7, 96, 2, 2, 7164, 7165, 5, 1374, 688, 2, 7165, 7292, 3, 2, 2, 2, 7166, 7167, 7, 140, 2, 2, 7167, 7168, 7, 280, 2, 2, 7168, 7169, 5, 702, 352, 2, 7169, 7170, 7, 284, 2, 2, 7170, 7171, 7, 96, 2, 2, 7171, 7172, 5, 1374, 688, 2, 7172, 7292, 3, 2, 2, 2, 7173, 7174, 7, 140, 2, 2, 7174, 7175, 7, 280, 2, 2, 7175, 7176, 7, 158, 2, 2, 7176, 7177, 5, 532, 267, 2, 7177, 7178, 7, 102, 2, 2, 7178, 7179, 5, 1344, 673, 2, 7179, 7180, 7, 284, 2, 2, 7180, 7181, 7, 96, 2, 2, 7181, 7182, 5, 1374, 688, 2, 7182, 7292, 3, 2, 2, 2, 7183, 7184, 7, 140, 2, 2, 7184, 7185, 7, 280, 2, 2, 7185, 7186, 7, 208, 2, 2, 7186, 7187, 5, 532, 267, 2, 7187, 7188, 7, 102, 2, 2, 7188, 7189, 5, 1344, 673, 2, 7189, 7190, 7, 284, 2, 2, 7190, 7191, 7, 96, 2, 2, 7191, 7192, 5, 1374, 688, 2, 7192, 7292, 3, 2, 2, 2, 7193, 7194, 7, 140, 2, 2, 7194, 7195, 7, 298, 2, 2, 7195, 7196, 5, 640, 321, 2, 7196, 7197, 7, 284, 2, 2, 7197, 7198, 7, 96, 2, 2, 7198, 7199, 5, 1374, 688, 2, 7199, 7292, 3, 2, 2, 2, 7200, 7201, 7, 140, 2, 2, 7201, 7202, 7, 444, 2, 2, 7202, 7203, 5, 640, 321, 2, 7203, 7204, 7, 284, 2, 2, 7204, 7205, 7, 96, 2, 2, 7205, 7206, 5, 1374, 688, 2, 7206, 7292, 3, 2, 2, 2, 7207, 7208, 7, 140, 2, 2, 7208, 7209, 7, 325, 2, 2, 7209, 7210, 5, 1344, 673, 2, 7210, 7211, 7, 284, 2, 2, 7211, 7212, 7, 96, 2, 2, 7212, 7213, 5, 1374, 688, 2, 7213, 7292, 3, 2, 2, 2, 7214, 7215, 7, 140, 2, 2, 7215, 7216, 7, 362, 2, 2, 7216, 7217, 5, 532, 267, 2, 7217, 7218, 7, 284, 2, 2, 7218, 7219, 7, 96, 2, 2, 7219, 7220, 5, 1374, 688, 2, 7220, 7292, 3, 2, 2, 2, 7221, 7222, 7, 140, 2, 2, 7222, 7223, 7, 353, 2, 2, 7223, 7224, 5, 1344, 673, 2, 7224, 7225, 7, 284, 2, 2, 7225, 7226, 7, 96, 2, 2, 7226, 7227, 5, 1374, 688, 2, 7227, 7292, 3, 2, 2, 2, 7228, 7229, 7, 140, 2, 2, 7229, 7230, 7, 344, 2, 2, 7230, 7231, 5, 532, 267, 2, 7231, 7232, 7, 284, 2, 2, 7232, 7233, 7, 96, 2, 2, 7233, 7234, 5, 1374, 688, 2, 7234, 7292, 3, 2, 2, 2, 7235, 7236, 7, 140, 2, 2, 7236, 7237, 7, 357, 2, 2, 7237, 7238, 7, 327, 2, 2, 7238, 7239, 7, 187, 2, 2, 7239, 7240, 5, 532, 267, 2, 7240, 7241, 7, 284, 2, 2, 7241, 7242, 7, 96, 2, 2, 7242, 7243, 5, 1374, 688, 2, 7243, 7292, 3, 2, 2, 2, 7244, 7245, 7, 140, 2, 2, 7245, 7246, 7, 357, 2, 2, 7246, 7247, 7, 327, 2, 2, 7247, 7248, 7, 165, 2, 2, 7248, 7249, 5, 532, 267, 2, 7249, 7250, 7, 284, 2, 2, 7250, 7251, 7, 96, 2, 2, 7251, 7252, 5, 1374, 688, 2, 7252, 7292, 3, 2, 2, 2, 7253, 7254, 7, 140, 2, 2, 7254, 7255, 7, 65, 2, 2, 7255, 7256, 7, 176, 2, 2, 7256, 7257, 7, 383, 2, 2, 7257, 7258, 5, 1344, 673, 2, 7258, 7259, 7, 284, 2, 2, 7259, 7260, 7, 96, 2, 2, 7260, 7261, 5, 1374, 688, 2, 7261, 7292, 3, 2, 2, 2, 7262, 7263, 7, 140, 2, 2, 7263, 7264, 7, 333, 2, 2, 7264, 7265, 5, 1344, 673, 2, 7265, 7266, 7, 284, 2, 2, 7266, 7267, 7, 96, 2, 2, 7267, 7268, 5, 1374, 688, 2, 7268, 7292, 3, 2, 2, 2, 7269, 7270, 7, 140, 2, 2, 7270, 7271, 7, 200, 2, 2, 7271, 7272, 7, 359, 2, 2, 7272, 7273, 5, 1344, 673, 2, 7273, 7274, 7, 284, 2, 2, 7274, 7275, 7, 96, 2, 2, 7275, 7276, 5, 1374, 688, 2, 7276, 7292, 3, 2, 2, 2, 7277, 7278, 7, 140, 2, 2, 7278, 7279, 7, 454, 2, 2, 7279, 7280, 5, 1344, 673, 2, 7280, 7281, 7, 284, 2, 2, 7281, 7282, 7, 96, 2, 2, 7282, 7283, 5, 1374, 688, 2, 7283, 7292, 3, 2, 2, 2, 7284, 7285, 7, 140, 2, 2, 7285, 7286, 7, 453, 2, 2, 7286, 7287, 5, 1344, 673, 2, 7287, 7288, 7, 284, 2, 2, 7288, 7289, 7, 96, 2, 2, 7289, 7290, 5, 1374, 688, 2, 7290, 7292, 3, 2, 2, 2, 7291, 7106, 3, 2, 2, 2, 7291, 7113, 3, 2, 2, 2, 7291, 7120, 3, 2, 2, 2, 7291, 7127, 3, 2, 2, 2, 7291, 7134, 3, 2, 2, 2, 7291, 7141, 3, 2, 2, 2, 7291, 7148, 3, 2, 2, 2, 7291, 7158, 3, 2, 2, 2, 7291, 7166, 3, 2, 2, 2, 7291, 7173, 3, 2, 2, 2, 7291, 7183, 3, 2, 2, 2, 7291, 7193, 3, 2, 2, 2, 7291, 7200, 3, 2, 2, 2, 7291, 7207, 3, 2, 2, 2, 7291, 7214, 3, 2, 2, 2, 7291, 7221, 3, 2, 2, 2, 7291, 7228, 3, 2, 2, 2, 7291, 7235, 3, 2, 2, 2, 7291, 7244, 3, 2, 2, 2, 7291, 7253, 3, 2, 2, 2, 7291, 7262, 3, 2, 2, 2, 7291, 7269, 3, 2, 2, 2, 7291, 7277, 3, 2, 2, 2, 7291, 7284, 3, 2, 2, 2, 7292, 759, 3, 2, 2, 2, 7293, 7294, 7, 48, 2, 2, 7294, 7295, 7, 454, 2, 2, 7295, 7297, 5, 1344, 673, 2, 7296, 7298, 5, 762, 382, 2, 7297, 7296, 3, 2, 2, 2, 7297, 7298, 3, 2, 2, 2, 7298, 7300, 3, 2, 2, 2, 7299, 7301, 5, 678, 340, 2, 7300, 7299, 3, 2, 2, 2, 7300, 7301, 3, 2, 2, 2, 7301, 761, 3, 2, 2, 2, 7302, 7303, 5, 764, 383, 2, 7303, 763, 3, 2, 2, 2, 7304, 7305, 7, 64, 2, 2, 7305, 7306, 7, 94, 2, 2, 7306, 7311, 5, 1080, 541, 2, 7307, 7308, 7, 64, 2, 2, 7308, 7309, 7, 32, 2, 2, 7309, 7311, 7, 352, 2, 2, 7310, 7304, 3, 2, 2, 2, 7310, 7307, 3, 2, 2, 2, 7311, 765, 3, 2, 2, 2, 7312, 7313, 7, 140, 2, 2, 7313, 7314, 7, 454, 2, 2, 7314, 7315, 5, 1344, 673, 2, 7315, 7316, 7, 335, 2, 2, 7316, 7317, 5, 468, 235, 2, 7317, 7340, 3, 2, 2, 2, 7318, 7319, 7, 140, 2, 2, 7319, 7320, 7, 454, 2, 2, 7320, 7321, 5, 1344, 673, 2, 7321, 7322, 7, 135, 2, 2, 7322, 7323, 7, 94, 2, 2, 7323, 7324, 5, 1080, 541, 2, 7324, 7340, 3, 2, 2, 2, 7325, 7326, 7, 140, 2, 2, 7326, 7327, 7, 454, 2, 2, 7327, 7328, 5, 1344, 673, 2, 7328, 7329, 7, 335, 2, 2, 7329, 7330, 7, 94, 2, 2, 7330, 7331, 5, 1080, 541, 2, 7331, 7340, 3, 2, 2, 2, 7332, 7333, 7, 140, 2, 2, 7333, 7334, 7, 454, 2, 2, 7334, 7335, 5, 1344, 673, 2, 7335, 7336, 7, 193, 2, 2, 7336, 7337, 7, 94, 2, 2, 7337, 7338, 5, 1080, 541, 2, 7338, 7340, 3, 2, 2, 2, 7339, 7312, 3, 2, 2, 2, 7339, 7318, 3, 2, 2, 2, 7339, 7325, 3, 2, 2, 2, 7339, 7332, 3, 2, 2, 2, 7340, 767, 3, 2, 2, 2, 7341, 7342, 7, 48, 2, 2, 7342, 7343, 7, 453, 2, 2, 7343, 7344, 5, 1344, 673, 2, 7344, 7345, 7, 166, 2, 2, 7345, 7346, 5, 1362, 682, 2, 7346, 7347, 7, 454, 2, 2, 7347, 7349, 5, 770, 386, 2, 7348, 7350, 5, 678, 340, 2, 7349, 7348, 3, 2, 2, 2, 7349, 7350, 3, 2, 2, 2, 7350, 769, 3, 2, 2, 2, 7351, 7356, 5, 772, 387, 2, 7352, 7353, 7, 8, 2, 2, 7353, 7355, 5, 772, 387, 2, 7354, 7352, 3, 2, 2, 2, 7355, 7358, 3, 2, 2, 2, 7356, 7354, 3, 2, 2, 2, 7356, 7357, 3, 2, 2, 2, 7357, 771, 3, 2, 2, 2, 7358, 7356, 3, 2, 2, 2, 7359, 7360, 5, 1392, 697, 2, 7360, 773, 3, 2, 2, 2, 7361, 7362, 7, 140, 2, 2, 7362, 7363, 7, 453, 2, 2, 7363, 7364, 5, 1344, 673, 2, 7364, 7365, 7, 335, 2, 2, 7365, 7366, 5, 468, 235, 2, 7366, 7401, 3, 2, 2, 2, 7367, 7368, 7, 140, 2, 2, 7368, 7369, 7, 453, 2, 2, 7369, 7370, 5, 1344, 673, 2, 7370, 7371, 7, 166, 2, 2, 7371, 7372, 5, 1362, 682, 2, 7372, 7401, 3, 2, 2, 2, 7373, 7374, 7, 140, 2, 2, 7374, 7375, 7, 453, 2, 2, 7375, 7376, 5, 1344, 673, 2, 7376, 7377, 7, 307, 2, 2, 7377, 7379, 7, 454, 2, 2, 7378, 7380, 5, 678, 340, 2, 7379, 7378, 3, 2, 2, 2, 7379, 7380, 3, 2, 2, 2, 7380, 7401, 3, 2, 2, 2, 7381, 7382, 7, 140, 2, 2, 7382, 7383, 7, 453, 2, 2, 7383, 7384, 5, 1344, 673, 2, 7384, 7385, 7, 335, 2, 2, 7385, 7386, 7, 454, 2, 2, 7386, 7388, 5, 770, 386, 2, 7387, 7389, 5, 678, 340, 2, 7388, 7387, 3, 2, 2, 2, 7388, 7389, 3, 2, 2, 2, 7389, 7401, 3, 2, 2, 2, 7390, 7391, 7, 140, 2, 2, 7391, 7392, 7, 453, 2, 2, 7392, 7393, 5, 1344, 673, 2, 7393, 7394, 7, 195, 2, 2, 7394, 7401, 3, 2, 2, 2, 7395, 7396, 7, 140, 2, 2, 7396, 7397, 7, 453, 2, 2, 7397, 7398, 5, 1344, 673, 2, 7398, 7399, 7, 188, 2, 2, 7399, 7401, 3, 2, 2, 2, 7400, 7361, 3, 2, 2, 2, 7400, 7367, 3, 2, 2, 2, 7400, 7373, 3, 2, 2, 2, 7400, 7381, 3, 2, 2, 2, 7400, 7390, 3, 2, 2, 2, 7400, 7395, 3, 2, 2, 2, 7401, 775, 3, 2, 2, 2, 7402, 7403, 7, 193, 2, 2, 7403, 7404, 7, 453, 2, 2, 7404, 7406, 5, 1344, 673, 2, 7405, 7407, 5, 108, 55, 2, 7406, 7405, 3, 2, 2, 2, 7406, 7407, 3, 2, 2, 2, 7407, 7417, 3, 2, 2, 2, 7408, 7409, 7, 193, 2, 2, 7409, 7410, 7, 453, 2, 2, 7410, 7411, 7, 222, 2, 2, 7411, 7412, 7, 398, 2, 2, 7412, 7414, 5, 1344, 673, 2, 7413, 7415, 5, 108, 55, 2, 7414, 7413, 3, 2, 2, 2, 7414, 7415, 3, 2, 2, 2, 7415, 7417, 3, 2, 2, 2, 7416, 7402, 3, 2, 2, 2, 7416, 7408, 3, 2, 2, 2, 7417, 777, 3, 2, 2, 2, 7418, 7420, 7, 48, 2, 2, 7419, 7421, 5, 632, 317, 2, 7420, 7419, 3, 2, 2, 2, 7420, 7421, 3, 2, 2, 2, 7421, 7422, 3, 2, 2, 2, 7422, 7423, 7, 323, 2, 2, 7423, 7424, 5, 1344, 673, 2, 7424, 7425, 7, 38, 2, 2, 7425, 7426, 7, 82, 2, 2, 7426, 7427, 5, 788, 395, 2, 7427, 7428, 7, 96, 2, 2, 7428, 7430, 5, 1340, 671, 2, 7429, 7431, 5, 1098, 550, 2, 7430, 7429, 3, 2, 2, 2, 7430, 7431, 3, 2, 2, 2, 7431, 7432, 3, 2, 2, 2, 7432, 7434, 7, 59, 2, 2, 7433, 7435, 5, 790, 396, 2, 7434, 7433, 3, 2, 2, 2, 7434, 7435, 3, 2, 2, 2, 7435, 7436, 3, 2, 2, 2, 7436, 7437, 5, 780, 391, 2, 7437, 779, 3, 2, 2, 2, 7438, 7445, 7, 272, 2, 2, 7439, 7445, 5, 784, 393, 2, 7440, 7441, 7, 4, 2, 2, 7441, 7442, 5, 782, 392, 2, 7442, 7443, 7, 5, 2, 2, 7443, 7445, 3, 2, 2, 2, 7444, 7438, 3, 2, 2, 2, 7444, 7439, 3, 2, 2, 2, 7444, 7440, 3, 2, 2, 2, 7445, 781, 3, 2, 2, 2, 7446, 7448, 5, 786, 394, 2, 7447, 7446, 3, 2, 2, 2, 7447, 7448, 3, 2, 2, 2, 7448, 7455, 3, 2, 2, 2, 7449, 7451, 7, 9, 2, 2, 7450, 7452, 5, 786, 394, 2, 7451, 7450, 3, 2, 2, 2, 7451, 7452, 3, 2, 2, 2, 7452, 7454, 3, 2, 2, 2, 7453, 7449, 3, 2, 2, 2, 7454, 7457, 3, 2, 2, 2, 7455, 7453, 3, 2, 2, 2, 7455, 7456, 3, 2, 2, 2, 7456, 783, 3, 2, 2, 2, 7457, 7455, 3, 2, 2, 2, 7458, 7464, 5, 966, 484, 2, 7459, 7464, 5, 916, 459, 2, 7460, 7464, 5, 948, 475, 2, 7461, 7464, 5, 934, 468, 2, 7462, 7464, 5, 792, 397, 2, 7463, 7458, 3, 2, 2, 2, 7463, 7459, 3, 2, 2, 2, 7463, 7460, 3, 2, 2, 2, 7463, 7461, 3, 2, 2, 2, 7463, 7462, 3, 2, 2, 2, 7464, 785, 3, 2, 2, 2, 7465, 7466, 5, 784, 393, 2, 7466, 787, 3, 2, 2, 2, 7467, 7468, 9, 39, 2, 2, 7468, 789, 3, 2, 2, 2, 7469, 7470, 9, 40, 2, 2, 7470, 791, 3, 2, 2, 2, 7471, 7472, 7, 273, 2, 2, 7472, 7474, 5, 1378, 690, 2, 7473, 7475, 5, 794, 398, 2, 7474, 7473, 3, 2, 2, 2, 7474, 7475, 3, 2, 2, 2, 7475, 793, 3, 2, 2, 2, 7476, 7477, 7, 8, 2, 2, 7477, 7478, 5, 1362, 682, 2, 7478, 795, 3, 2, 2, 2, 7479, 7480, 7, 254, 2, 2, 7480, 7481, 5, 1378, 690, 2, 7481, 797, 3, 2, 2, 2, 7482, 7483, 7, 368, 2, 2, 7483, 7487, 5, 1378, 690, 2, 7484, 7485, 7, 368, 2, 2, 7485, 7487, 7, 11, 2, 2, 7486, 7482, 3, 2, 2, 2, 7486, 7484, 3, 2, 2, 2, 7487, 799, 3, 2, 2, 2, 7488, 7490, 7, 131, 2, 2, 7489, 7491, 5, 802, 402, 2, 7490, 7489, 3, 2, 2, 2, 7490, 7491, 3, 2, 2, 2, 7491, 7493, 3, 2, 2, 2, 7492, 7494, 5, 810, 406, 2, 7493, 7492, 3, 2, 2, 2, 7493, 7494, 3, 2, 2, 2, 7494, 7558, 3, 2, 2, 2, 7495, 7497, 7, 148, 2, 2, 7496, 7498, 5, 802, 402, 2, 7497, 7496, 3, 2, 2, 2, 7497, 7498, 3, 2, 2, 2, 7498, 7500, 3, 2, 2, 2, 7499, 7501, 5, 808, 405, 2, 7500, 7499, 3, 2, 2, 2, 7500, 7501, 3, 2, 2, 2, 7501, 7558, 3, 2, 2, 2, 7502, 7503, 7, 342, 2, 2, 7503, 7505, 7, 358, 2, 2, 7504, 7506, 5, 808, 405, 2, 7505, 7504, 3, 2, 2, 2, 7505, 7506, 3, 2, 2, 2, 7506, 7558, 3, 2, 2, 2, 7507, 7509, 7, 163, 2, 2, 7508, 7510, 5, 802, 402, 2, 7509, 7508, 3, 2, 2, 2, 7509, 7510, 3, 2, 2, 2, 7510, 7512, 3, 2, 2, 2, 7511, 7513, 5, 810, 406, 2, 7512, 7511, 3, 2, 2, 2, 7512, 7513, 3, 2, 2, 2, 7513, 7558, 3, 2, 2, 2, 7514, 7516, 7, 456, 2, 2, 7515, 7517, 5, 802, 402, 2, 7516, 7515, 3, 2, 2, 2, 7516, 7517, 3, 2, 2, 2, 7517, 7519, 3, 2, 2, 2, 7518, 7520, 5, 810, 406, 2, 7519, 7518, 3, 2, 2, 2, 7519, 7520, 3, 2, 2, 2, 7520, 7558, 3, 2, 2, 2, 7521, 7523, 7, 321, 2, 2, 7522, 7524, 5, 802, 402, 2, 7523, 7522, 3, 2, 2, 2, 7523, 7524, 3, 2, 2, 2, 7524, 7526, 3, 2, 2, 2, 7525, 7527, 5, 810, 406, 2, 7526, 7525, 3, 2, 2, 2, 7526, 7527, 3, 2, 2, 2, 7527, 7558, 3, 2, 2, 2, 7528, 7529, 7, 324, 2, 2, 7529, 7558, 5, 1378, 690, 2, 7530, 7531, 7, 310, 2, 2, 7531, 7532, 7, 324, 2, 2, 7532, 7558, 5, 1378, 690, 2, 7533, 7534, 7, 310, 2, 2, 7534, 7558, 5, 1378, 690, 2, 7535, 7537, 7, 321, 2, 2, 7536, 7538, 5, 802, 402, 2, 7537, 7536, 3, 2, 2, 2, 7537, 7538, 3, 2, 2, 2, 7538, 7539, 3, 2, 2, 2, 7539, 7540, 7, 96, 2, 2, 7540, 7541, 7, 324, 2, 2, 7541, 7558, 5, 1378, 690, 2, 7542, 7544, 7, 321, 2, 2, 7543, 7545, 5, 802, 402, 2, 7544, 7543, 3, 2, 2, 2, 7544, 7545, 3, 2, 2, 2, 7545, 7546, 3, 2, 2, 2, 7546, 7547, 7, 96, 2, 2, 7547, 7558, 5, 1378, 690, 2, 7548, 7549, 7, 292, 2, 2, 7549, 7550, 7, 358, 2, 2, 7550, 7558, 5, 1362, 682, 2, 7551, 7552, 7, 163, 2, 2, 7552, 7553, 7, 293, 2, 2, 7553, 7558, 5, 1362, 682, 2, 7554, 7555, 7, 321, 2, 2, 7555, 7556, 7, 293, 2, 2, 7556, 7558, 5, 1362, 682, 2, 7557, 7488, 3, 2, 2, 2, 7557, 7495, 3, 2, 2, 2, 7557, 7502, 3, 2, 2, 2, 7557, 7507, 3, 2, 2, 2, 7557, 7514, 3, 2, 2, 2, 7557, 7521, 3, 2, 2, 2, 7557, 7528, 3, 2, 2, 2, 7557, 7530, 3, 2, 2, 2, 7557, 7533, 3, 2, 2, 2, 7557, 7535, 3, 2, 2, 2, 7557, 7542, 3, 2, 2, 2, 7557, 7548, 3, 2, 2, 2, 7557, 7551, 3, 2, 2, 2, 7557, 7554, 3, 2, 2, 2, 7558, 801, 3, 2, 2, 2, 7559, 7560, 9, 41, 2, 2, 7560, 803, 3, 2, 2, 2, 7561, 7562, 7, 246, 2, 2, 7562, 7563, 7, 253, 2, 2, 7563, 7572, 5, 64, 33, 2, 7564, 7565, 7, 302, 2, 2, 7565, 7572, 7, 83, 2, 2, 7566, 7567, 7, 302, 2, 2, 7567, 7572, 7, 384, 2, 2, 7568, 7572, 7, 56, 2, 2, 7569, 7570, 7, 79, 2, 2, 7570, 7572, 7, 56, 2, 2, 7571, 7561, 3, 2, 2, 2, 7571, 7564, 3, 2, 2, 2, 7571, 7566, 3, 2, 2, 2, 7571, 7568, 3, 2, 2, 2, 7571, 7569, 3, 2, 2, 2, 7572, 805, 3, 2, 2, 2, 7573, 7580, 5, 804, 403, 2, 7574, 7576, 7, 8, 2, 2, 7575, 7574, 3, 2, 2, 2, 7575, 7576, 3, 2, 2, 2, 7576, 7577, 3, 2, 2, 2, 7577, 7579, 5, 804, 403, 2, 7578, 7575, 3, 2, 2, 2, 7579, 7582, 3, 2, 2, 2, 7580, 7578, 3, 2, 2, 2, 7580, 7581, 3, 2, 2, 2, 7581, 807, 3, 2, 2, 2, 7582, 7580, 3, 2, 2, 2, 7583, 7584, 5, 806, 404, 2, 7584, 809, 3, 2, 2, 2, 7585, 7587, 7, 35, 2, 2, 7586, 7588, 7, 271, 2, 2, 7587, 7586, 3, 2, 2, 2, 7587, 7588, 3, 2, 2, 2, 7588, 7589, 3, 2, 2, 2, 7589, 7590, 7, 155, 2, 2, 7590, 811, 3, 2, 2, 2, 7591, 7594, 7, 48, 2, 2, 7592, 7593, 7, 84, 2, 2, 7593, 7595, 7, 313, 2, 2, 7594, 7592, 3, 2, 2, 2, 7594, 7595, 3, 2, 2, 2, 7595, 7597, 3, 2, 2, 2, 7596, 7598, 5, 174, 88, 2, 7597, 7596, 3, 2, 2, 2, 7597, 7598, 3, 2, 2, 2, 7598, 7616, 3, 2, 2, 2, 7599, 7600, 7, 378, 2, 2, 7600, 7602, 5, 1340, 671, 2, 7601, 7603, 5, 218, 110, 2, 7602, 7601, 3, 2, 2, 2, 7602, 7603, 3, 2, 2, 2, 7603, 7605, 3, 2, 2, 2, 7604, 7606, 5, 118, 60, 2, 7605, 7604, 3, 2, 2, 2, 7605, 7606, 3, 2, 2, 2, 7606, 7617, 3, 2, 2, 2, 7607, 7608, 7, 305, 2, 2, 7608, 7609, 7, 378, 2, 2, 7609, 7610, 5, 1340, 671, 2, 7610, 7611, 7, 4, 2, 2, 7611, 7612, 5, 220, 111, 2, 7612, 7614, 7, 5, 2, 2, 7613, 7615, 5, 118, 60, 2, 7614, 7613, 3, 2, 2, 2, 7614, 7615, 3, 2, 2, 2, 7615, 7617, 3, 2, 2, 2, 7616, 7599, 3, 2, 2, 2, 7616, 7607, 3, 2, 2, 2, 7617, 7618, 3, 2, 2, 2, 7618, 7619, 7, 38, 2, 2, 7619, 7621, 5, 966, 484, 2, 7620, 7622, 5, 814, 408, 2, 7621, 7620, 3, 2, 2, 2, 7621, 7622, 3, 2, 2, 2, 7622, 813, 3, 2, 2, 2, 7623, 7625, 7, 107, 2, 2, 7624, 7626, 9, 42, 2, 2, 7625, 7624, 3, 2, 2, 2, 7625, 7626, 3, 2, 2, 2, 7626, 7627, 3, 2, 2, 2, 7627, 7628, 7, 44, 2, 2, 7628, 7629, 7, 281, 2, 2, 7629, 815, 3, 2, 2, 2, 7630, 7631, 7, 255, 2, 2, 7631, 7632, 5, 1348, 675, 2, 7632, 817, 3, 2, 2, 2, 7633, 7634, 7, 48, 2, 2, 7634, 7635, 7, 177, 2, 2, 7635, 7637, 5, 1344, 673, 2, 7636, 7638, 5, 16, 9, 2, 7637, 7636, 3, 2, 2, 2, 7637, 7638, 3, 2, 2, 2, 7638, 7640, 3, 2, 2, 2, 7639, 7641, 5, 820, 411, 2, 7640, 7639, 3, 2, 2, 2, 7640, 7641, 3, 2, 2, 2, 7641, 819, 3, 2, 2, 2, 7642, 7643, 5, 822, 412, 2, 7643, 821, 3, 2, 2, 2, 7644, 7646, 5, 824, 413, 2, 7645, 7644, 3, 2, 2, 2, 7646, 7647, 3, 2, 2, 2, 7647, 7645, 3, 2, 2, 2, 7647, 7648, 3, 2, 2, 2, 7648, 823, 3, 2, 2, 2, 7649, 7651, 5, 826, 414, 2, 7650, 7652, 5, 828, 415, 2, 7651, 7650, 3, 2, 2, 2, 7651, 7652, 3, 2, 2, 2, 7652, 7656, 3, 2, 2, 2, 7653, 7657, 5, 1368, 685, 2, 7654, 7657, 5, 66, 34, 2, 7655, 7657, 7, 55, 2, 2, 7656, 7653, 3, 2, 2, 2, 7656, 7654, 3, 2, 2, 2, 7656, 7655, 3, 2, 2, 2, 7657, 825, 3, 2, 2, 2, 7658, 7667, 5, 1394, 698, 2, 7659, 7660, 7, 166, 2, 2, 7660, 7667, 7, 76, 2, 2, 7661, 7667, 7, 196, 2, 2, 7662, 7667, 7, 257, 2, 2, 7663, 7667, 7, 284, 2, 2, 7664, 7667, 7, 353, 2, 2, 7665, 7667, 7, 355, 2, 2, 7666, 7658, 3, 2, 2, 2, 7666, 7659, 3, 2, 2, 2, 7666, 7661, 3, 2, 2, 2, 7666, 7662, 3, 2, 2, 2, 7666, 7663, 3, 2, 2, 2, 7666, 7664, 3, 2, 2, 2, 7666, 7665, 3, 2, 2, 2, 7667, 827, 3, 2, 2, 2, 7668, 7669, 7, 12, 2, 2, 7669, 829, 3, 2, 2, 2, 7670, 7671, 7, 140, 2, 2, 7671, 7672, 7, 177, 2, 2, 7672, 7683, 5, 1344, 673, 2, 7673, 7675, 7, 107, 2, 2, 7674, 7676, 5, 820, 411, 2, 7675, 7674, 3, 2, 2, 2, 7675, 7676, 3, 2, 2, 2, 7676, 7684, 3, 2, 2, 2, 7677, 7679, 5, 820, 411, 2, 7678, 7677, 3, 2, 2, 2, 7678, 7679, 3, 2, 2, 2, 7679, 7684, 3, 2, 2, 2, 7680, 7681, 7, 335, 2, 2, 7681, 7682, 7, 353, 2, 2, 7682, 7684, 5, 1344, 673, 2, 7683, 7673, 3, 2, 2, 2, 7683, 7678, 3, 2, 2, 2, 7683, 7680, 3, 2, 2, 2, 7684, 831, 3, 2, 2, 2, 7685, 7686, 7, 140, 2, 2, 7686, 7687, 7, 177, 2, 2, 7687, 7688, 5, 1344, 673, 2, 7688, 7689, 5, 80, 41, 2, 7689, 833, 3, 2, 2, 2, 7690, 7691, 7, 193, 2, 2, 7691, 7694, 7, 177, 2, 2, 7692, 7693, 7, 222, 2, 2, 7693, 7695, 7, 398, 2, 2, 7694, 7692, 3, 2, 2, 2, 7694, 7695, 3, 2, 2, 2, 7695, 7696, 3, 2, 2, 2, 7696, 7704, 5, 1344, 673, 2, 7697, 7699, 5, 16, 9, 2, 7698, 7697, 3, 2, 2, 2, 7698, 7699, 3, 2, 2, 2, 7699, 7700, 3, 2, 2, 2, 7700, 7701, 7, 4, 2, 2, 7701, 7702, 5, 836, 419, 2, 7702, 7703, 7, 5, 2, 2, 7703, 7705, 3, 2, 2, 2, 7704, 7698, 3, 2, 2, 2, 7704, 7705, 3, 2, 2, 2, 7705, 835, 3, 2, 2, 2, 7706, 7711, 5, 838, 420, 2, 7707, 7708, 7, 8, 2, 2, 7708, 7710, 5, 838, 420, 2, 7709, 7707, 3, 2, 2, 2, 7710, 7713, 3, 2, 2, 2, 7711, 7709, 3, 2, 2, 2, 7711, 7712, 3, 2, 2, 2, 7712, 837, 3, 2, 2, 2, 7713, 7711, 3, 2, 2, 2, 7714, 7715, 7, 211, 2, 2, 7715, 839, 3, 2, 2, 2, 7716, 7717, 7, 140, 2, 2, 7717, 7718, 7, 110, 2, 2, 7718, 7719, 5, 532, 267, 2, 7719, 7720, 7, 307, 2, 2, 7720, 7721, 7, 377, 2, 2, 7721, 841, 3, 2, 2, 2, 7722, 7723, 7, 140, 2, 2, 7723, 7724, 7, 351, 2, 2, 7724, 7725, 9, 43, 2, 2, 7725, 7726, 5, 54, 28, 2, 7726, 843, 3, 2, 2, 2, 7727, 7728, 7, 48, 2, 2, 7728, 7729, 7, 191, 2, 2, 7729, 7731, 5, 532, 267, 2, 7730, 7732, 5, 848, 425, 2, 7731, 7730, 3, 2, 2, 2, 7731, 7732, 3, 2, 2, 2, 7732, 7733, 3, 2, 2, 2, 7733, 7734, 5, 1122, 562, 2, 7734, 7735, 5, 194, 98, 2, 7735, 845, 3, 2, 2, 2, 7736, 7737, 7, 140, 2, 2, 7737, 7738, 7, 191, 2, 2, 7738, 7761, 5, 532, 267, 2, 7739, 7762, 5, 106, 54, 2, 7740, 7741, 7, 193, 2, 2, 7741, 7742, 7, 79, 2, 2, 7742, 7762, 7, 80, 2, 2, 7743, 7744, 7, 335, 2, 2, 7744, 7745, 7, 79, 2, 2, 7745, 7762, 7, 80, 2, 2, 7746, 7747, 7, 135, 2, 2, 7747, 7762, 5, 212, 107, 2, 7748, 7749, 7, 193, 2, 2, 7749, 7752, 7, 47, 2, 2, 7750, 7751, 7, 222, 2, 2, 7751, 7753, 7, 398, 2, 2, 7752, 7750, 3, 2, 2, 2, 7752, 7753, 3, 2, 2, 2, 7753, 7754, 3, 2, 2, 2, 7754, 7756, 5, 1344, 673, 2, 7755, 7757, 5, 108, 55, 2, 7756, 7755, 3, 2, 2, 2, 7756, 7757, 3, 2, 2, 2, 7757, 7762, 3, 2, 2, 2, 7758, 7759, 7, 374, 2, 2, 7759, 7760, 7, 47, 2, 2, 7760, 7762, 5, 1344, 673, 2, 7761, 7739, 3, 2, 2, 2, 7761, 7740, 3, 2, 2, 2, 7761, 7743, 3, 2, 2, 2, 7761, 7746, 3, 2, 2, 2, 7761, 7748, 3, 2, 2, 2, 7761, 7758, 3, 2, 2, 2, 7762, 847, 3, 2, 2, 2, 7763, 7764, 7, 38, 2, 2, 7764, 849, 3, 2, 2, 2, 7765, 7766, 7, 140, 2, 2, 7766, 7767, 7, 357, 2, 2, 7767, 7768, 7, 327, 2, 2, 7768, 7769, 7, 187, 2, 2, 7769, 7770, 5, 532, 267, 2, 7770, 7771, 5, 468, 235, 2, 7771, 851, 3, 2, 2, 2, 7772, 7773, 7, 140, 2, 2, 7773, 7774, 7, 357, 2, 2, 7774, 7775, 7, 327, 2, 2, 7775, 7776, 7, 165, 2, 2, 7776, 7777, 5, 532, 267, 2, 7777, 7778, 7, 135, 2, 2, 7778, 7779, 7, 259, 2, 2, 7779, 7780, 7, 64, 2, 2, 7780, 7781, 5, 1342, 672, 2, 7781, 7782, 5, 854, 428, 2, 7782, 7783, 5, 530, 266, 2, 7783, 7845, 3, 2, 2, 2, 7784, 7785, 7, 140, 2, 2, 7785, 7786, 7, 357, 2, 2, 7786, 7787, 7, 327, 2, 2, 7787, 7788, 7, 165, 2, 2, 7788, 7789, 5, 532, 267, 2, 7789, 7790, 7, 140, 2, 2, 7790, 7791, 7, 259, 2, 2, 7791, 7792, 7, 64, 2, 2, 7792, 7793, 5, 1342, 672, 2, 7793, 7794, 5, 854, 428, 2, 7794, 7795, 5, 530, 266, 2, 7795, 7845, 3, 2, 2, 2, 7796, 7797, 7, 140, 2, 2, 7797, 7798, 7, 357, 2, 2, 7798, 7799, 7, 327, 2, 2, 7799, 7800, 7, 165, 2, 2, 7800, 7801, 5, 532, 267, 2, 7801, 7802, 7, 140, 2, 2, 7802, 7803, 7, 259, 2, 2, 7803, 7804, 7, 313, 2, 2, 7804, 7805, 5, 532, 267, 2, 7805, 7806, 5, 854, 428, 2, 7806, 7807, 5, 532, 267, 2, 7807, 7845, 3, 2, 2, 2, 7808, 7809, 7, 140, 2, 2, 7809, 7810, 7, 357, 2, 2, 7810, 7811, 7, 327, 2, 2, 7811, 7812, 7, 165, 2, 2, 7812, 7813, 5, 532, 267, 2, 7813, 7814, 7, 140, 2, 2, 7814, 7815, 7, 259, 2, 2, 7815, 7816, 7, 64, 2, 2, 7816, 7817, 5, 1342, 672, 2, 7817, 7818, 7, 313, 2, 2, 7818, 7819, 5, 532, 267, 2, 7819, 7820, 5, 854, 428, 2, 7820, 7821, 5, 532, 267, 2, 7821, 7845, 3, 2, 2, 2, 7822, 7823, 7, 140, 2, 2, 7823, 7824, 7, 357, 2, 2, 7824, 7825, 7, 327, 2, 2, 7825, 7826, 7, 165, 2, 2, 7826, 7827, 5, 532, 267, 2, 7827, 7828, 7, 193, 2, 2, 7828, 7829, 7, 259, 2, 2, 7829, 7830, 7, 64, 2, 2, 7830, 7831, 5, 1342, 672, 2, 7831, 7845, 3, 2, 2, 2, 7832, 7833, 7, 140, 2, 2, 7833, 7834, 7, 357, 2, 2, 7834, 7835, 7, 327, 2, 2, 7835, 7836, 7, 165, 2, 2, 7836, 7837, 5, 532, 267, 2, 7837, 7838, 7, 193, 2, 2, 7838, 7839, 7, 259, 2, 2, 7839, 7840, 7, 222, 2, 2, 7840, 7841, 7, 398, 2, 2, 7841, 7842, 7, 64, 2, 2, 7842, 7843, 5, 1342, 672, 2, 7843, 7845, 3, 2, 2, 2, 7844, 7772, 3, 2, 2, 2, 7844, 7784, 3, 2, 2, 2, 7844, 7796, 3, 2, 2, 2, 7844, 7808, 3, 2, 2, 2, 7844, 7822, 3, 2, 2, 2, 7844, 7832, 3, 2, 2, 2, 7845, 853, 3, 2, 2, 2, 7846, 7847, 7, 107, 2, 2, 7847, 855, 3, 2, 2, 2, 7848, 7850, 7, 48, 2, 2, 7849, 7851, 5, 496, 249, 2, 7850, 7849, 3, 2, 2, 2, 7850, 7851, 3, 2, 2, 2, 7851, 7852, 3, 2, 2, 2, 7852, 7853, 7, 170, 2, 2, 7853, 7854, 5, 532, 267, 2, 7854, 7855, 7, 64, 2, 2, 7855, 7856, 5, 1362, 682, 2, 7856, 7857, 7, 96, 2, 2, 7857, 7858, 5, 1362, 682, 2, 7858, 7859, 7, 66, 2, 2, 7859, 7860, 5, 532, 267, 2, 7860, 857, 3, 2, 2, 2, 7861, 7863, 7, 160, 2, 2, 7862, 7864, 5, 878, 440, 2, 7863, 7862, 3, 2, 2, 2, 7863, 7864, 3, 2, 2, 2, 7864, 7865, 3, 2, 2, 2, 7865, 7867, 5, 1340, 671, 2, 7866, 7868, 5, 860, 431, 2, 7867, 7866, 3, 2, 2, 2, 7867, 7868, 3, 2, 2, 2, 7868, 7882, 3, 2, 2, 2, 7869, 7871, 7, 160, 2, 2, 7870, 7872, 5, 878, 440, 2, 7871, 7870, 3, 2, 2, 2, 7871, 7872, 3, 2, 2, 2, 7872, 7882, 3, 2, 2, 2, 7873, 7875, 7, 160, 2, 2, 7874, 7876, 5, 878, 440, 2, 7875, 7874, 3, 2, 2, 2, 7875, 7876, 3, 2, 2, 2, 7876, 7877, 3, 2, 2, 2, 7877, 7878, 5, 1344, 673, 2, 7878, 7879, 7, 82, 2, 2, 7879, 7880, 5, 1340, 671, 2, 7880, 7882, 3, 2, 2, 2, 7881, 7861, 3, 2, 2, 2, 7881, 7869, 3, 2, 2, 2, 7881, 7873, 3, 2, 2, 2, 7882, 859, 3, 2, 2, 2, 7883, 7884, 7, 102, 2, 2, 7884, 7885, 5, 1344, 673, 2, 7885, 861, 3, 2, 2, 2, 7886, 7888, 7, 372, 2, 2, 7887, 7889, 5, 880, 441, 2, 7888, 7887, 3, 2, 2, 2, 7888, 7889, 3, 2, 2, 2, 7889, 7891, 3, 2, 2, 2, 7890, 7892, 5, 882, 442, 2, 7891, 7890, 3, 2, 2, 2, 7891, 7892, 3, 2, 2, 2, 7892, 7894, 3, 2, 2, 2, 7893, 7895, 5, 878, 440, 2, 7894, 7893, 3, 2, 2, 2, 7894, 7895, 3, 2, 2, 2, 7895, 7897, 3, 2, 2, 2, 7896, 7898, 5, 876, 439, 2, 7897, 7896, 3, 2, 2, 2, 7897, 7898, 3, 2, 2, 2, 7898, 7900, 3, 2, 2, 2, 7899, 7901, 5, 890, 446, 2, 7900, 7899, 3, 2, 2, 2, 7900, 7901, 3, 2, 2, 2, 7901, 7910, 3, 2, 2, 2, 7902, 7903, 7, 372, 2, 2, 7903, 7904, 7, 4, 2, 2, 7904, 7905, 5, 866, 434, 2, 7905, 7907, 7, 5, 2, 2, 7906, 7908, 5, 890, 446, 2, 7907, 7906, 3, 2, 2, 2, 7907, 7908, 3, 2, 2, 2, 7908, 7910, 3, 2, 2, 2, 7909, 7886, 3, 2, 2, 2, 7909, 7902, 3, 2, 2, 2, 7910, 863, 3, 2, 2, 2, 7911, 7913, 5, 868, 435, 2, 7912, 7914, 5, 878, 440, 2, 7913, 7912, 3, 2, 2, 2, 7913, 7914, 3, 2, 2, 2, 7914, 7916, 3, 2, 2, 2, 7915, 7917, 5, 890, 446, 2, 7916, 7915, 3, 2, 2, 2, 7916, 7917, 3, 2, 2, 2, 7917, 7926, 3, 2, 2, 2, 7918, 7919, 5, 868, 435, 2, 7919, 7920, 7, 4, 2, 2, 7920, 7921, 5, 866, 434, 2, 7921, 7923, 7, 5, 2, 2, 7922, 7924, 5, 890, 446, 2, 7923, 7922, 3, 2, 2, 2, 7923, 7924, 3, 2, 2, 2, 7924, 7926, 3, 2, 2, 2, 7925, 7911, 3, 2, 2, 2, 7925, 7918, 3, 2, 2, 2, 7926, 865, 3, 2, 2, 2, 7927, 7932, 5, 870, 436, 2, 7928, 7929, 7, 8, 2, 2, 7929, 7931, 5, 870, 436, 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, 867, 3, 2, 2, 2, 7934, 7932, 3, 2, 2, 2, 7935, 7936, 9, 44, 2, 2, 7936, 869, 3, 2, 2, 2, 7937, 7939, 5, 872, 437, 2, 7938, 7940, 5, 874, 438, 2, 7939, 7938, 3, 2, 2, 2, 7939, 7940, 3, 2, 2, 2, 7940, 871, 3, 2, 2, 2, 7941, 7944, 5, 1390, 696, 2, 7942, 7944, 5, 868, 435, 2, 7943, 7941, 3, 2, 2, 2, 7943, 7942, 3, 2, 2, 2, 7944, 873, 3, 2, 2, 2, 7945, 7948, 5, 66, 34, 2, 7946, 7948, 5, 296, 149, 2, 7947, 7945, 3, 2, 2, 2, 7947, 7946, 3, 2, 2, 2, 7948, 875, 3, 2, 2, 2, 7949, 7950, 5, 868, 435, 2, 7950, 877, 3, 2, 2, 2, 7951, 7952, 7, 130, 2, 2, 7952, 879, 3, 2, 2, 2, 7953, 7954, 7, 115, 2, 2, 7954, 881, 3, 2, 2, 2, 7955, 7956, 7, 114, 2, 2, 7956, 883, 3, 2, 2, 2, 7957, 7958, 7, 4, 2, 2, 7958, 7959, 5, 1342, 672, 2, 7959, 7960, 7, 5, 2, 2, 7960, 885, 3, 2, 2, 2, 7961, 7963, 5, 1340, 671, 2, 7962, 7964, 5, 884, 443, 2, 7963, 7962, 3, 2, 2, 2, 7963, 7964, 3, 2, 2, 2, 7964, 887, 3, 2, 2, 2, 7965, 7970, 5, 886, 444, 2, 7966, 7967, 7, 8, 2, 2, 7967, 7969, 5, 886, 444, 2, 7968, 7966, 3, 2, 2, 2, 7969, 7972, 3, 2, 2, 2, 7970, 7968, 3, 2, 2, 2, 7970, 7971, 3, 2, 2, 2, 7971, 889, 3, 2, 2, 2, 7972, 7970, 3, 2, 2, 2, 7973, 7974, 5, 888, 445, 2, 7974, 891, 3, 2, 2, 2, 7975, 7976, 7, 205, 2, 2, 7976, 7994, 5, 894, 448, 2, 7977, 7978, 7, 205, 2, 2, 7978, 7980, 5, 868, 435, 2, 7979, 7981, 5, 878, 440, 2, 7980, 7979, 3, 2, 2, 2, 7980, 7981, 3, 2, 2, 2, 7981, 7982, 3, 2, 2, 2, 7982, 7983, 5, 894, 448, 2, 7983, 7994, 3, 2, 2, 2, 7984, 7985, 7, 205, 2, 2, 7985, 7986, 7, 130, 2, 2, 7986, 7994, 5, 894, 448, 2, 7987, 7988, 7, 205, 2, 2, 7988, 7989, 7, 4, 2, 2, 7989, 7990, 5, 896, 449, 2, 7990, 7991, 7, 5, 2, 2, 7991, 7992, 5, 894, 448, 2, 7992, 7994, 3, 2, 2, 2, 7993, 7975, 3, 2, 2, 2, 7993, 7977, 3, 2, 2, 2, 7993, 7984, 3, 2, 2, 2, 7993, 7987, 3, 2, 2, 2, 7994, 893, 3, 2, 2, 2, 7995, 8005, 5, 966, 484, 2, 7996, 8005, 5, 916, 459, 2, 7997, 8005, 5, 948, 475, 2, 7998, 8005, 5, 934, 468, 2, 7999, 8005, 5, 958, 480, 2, 8000, 8005, 5, 268, 135, 2, 8001, 8005, 5, 274, 138, 2, 8002, 8005, 5, 280, 141, 2, 8003, 8005, 5, 910, 456, 2, 8004, 7995, 3, 2, 2, 2, 8004, 7996, 3, 2, 2, 2, 8004, 7997, 3, 2, 2, 2, 8004, 7998, 3, 2, 2, 2, 8004, 7999, 3, 2, 2, 2, 8004, 8000, 3, 2, 2, 2, 8004, 8001, 3, 2, 2, 2, 8004, 8002, 3, 2, 2, 2, 8004, 8003, 3, 2, 2, 2, 8005, 895, 3, 2, 2, 2, 8006, 8011, 5, 898, 450, 2, 8007, 8008, 7, 8, 2, 2, 8008, 8010, 5, 898, 450, 2, 8009, 8007, 3, 2, 2, 2, 8010, 8013, 3, 2, 2, 2, 8011, 8009, 3, 2, 2, 2, 8011, 8012, 3, 2, 2, 2, 8012, 897, 3, 2, 2, 2, 8013, 8011, 3, 2, 2, 2, 8014, 8016, 5, 900, 451, 2, 8015, 8017, 5, 902, 452, 2, 8016, 8015, 3, 2, 2, 2, 8016, 8017, 3, 2, 2, 2, 8017, 899, 3, 2, 2, 2, 8018, 8021, 5, 1390, 696, 2, 8019, 8021, 5, 868, 435, 2, 8020, 8018, 3, 2, 2, 2, 8020, 8019, 3, 2, 2, 2, 8021, 901, 3, 2, 2, 2, 8022, 8025, 5, 66, 34, 2, 8023, 8025, 5, 296, 149, 2, 8024, 8022, 3, 2, 2, 2, 8024, 8023, 3, 2, 2, 2, 8025, 903, 3, 2, 2, 2, 8026, 8027, 7, 292, 2, 2, 8027, 8029, 5, 1344, 673, 2, 8028, 8030, 5, 906, 454, 2, 8029, 8028, 3, 2, 2, 2, 8029, 8030, 3, 2, 2, 2, 8030, 8031, 3, 2, 2, 2, 8031, 8032, 7, 38, 2, 2, 8032, 8033, 5, 908, 455, 2, 8033, 905, 3, 2, 2, 2, 8034, 8035, 7, 4, 2, 2, 8035, 8036, 5, 1288, 645, 2, 8036, 8037, 7, 5, 2, 2, 8037, 907, 3, 2, 2, 2, 8038, 8043, 5, 966, 484, 2, 8039, 8043, 5, 916, 459, 2, 8040, 8043, 5, 948, 475, 2, 8041, 8043, 5, 934, 468, 2, 8042, 8038, 3, 2, 2, 2, 8042, 8039, 3, 2, 2, 2, 8042, 8040, 3, 2, 2, 2, 8042, 8041, 3, 2, 2, 2, 8043, 909, 3, 2, 2, 2, 8044, 8045, 7, 204, 2, 2, 8045, 8047, 5, 1344, 673, 2, 8046, 8048, 5, 912, 457, 2, 8047, 8046, 3, 2, 2, 2, 8047, 8048, 3, 2, 2, 2, 8048, 8083, 3, 2, 2, 2, 8049, 8051, 7, 48, 2, 2, 8050, 8052, 5, 174, 88, 2, 8051, 8050, 3, 2, 2, 2, 8051, 8052, 3, 2, 2, 2, 8052, 8053, 3, 2, 2, 2, 8053, 8054, 7, 94, 2, 2, 8054, 8055, 5, 270, 136, 2, 8055, 8056, 7, 38, 2, 2, 8056, 8057, 7, 204, 2, 2, 8057, 8059, 5, 1344, 673, 2, 8058, 8060, 5, 912, 457, 2, 8059, 8058, 3, 2, 2, 2, 8059, 8060, 3, 2, 2, 2, 8060, 8062, 3, 2, 2, 2, 8061, 8063, 5, 272, 137, 2, 8062, 8061, 3, 2, 2, 2, 8062, 8063, 3, 2, 2, 2, 8063, 8083, 3, 2, 2, 2, 8064, 8066, 7, 48, 2, 2, 8065, 8067, 5, 174, 88, 2, 8066, 8065, 3, 2, 2, 2, 8066, 8067, 3, 2, 2, 2, 8067, 8068, 3, 2, 2, 2, 8068, 8069, 7, 94, 2, 2, 8069, 8070, 7, 222, 2, 2, 8070, 8071, 7, 79, 2, 2, 8071, 8072, 7, 398, 2, 2, 8072, 8073, 5, 270, 136, 2, 8073, 8074, 7, 38, 2, 2, 8074, 8075, 7, 204, 2, 2, 8075, 8077, 5, 1344, 673, 2, 8076, 8078, 5, 912, 457, 2, 8077, 8076, 3, 2, 2, 2, 8077, 8078, 3, 2, 2, 2, 8078, 8080, 3, 2, 2, 2, 8079, 8081, 5, 272, 137, 2, 8080, 8079, 3, 2, 2, 2, 8080, 8081, 3, 2, 2, 2, 8081, 8083, 3, 2, 2, 2, 8082, 8044, 3, 2, 2, 2, 8082, 8049, 3, 2, 2, 2, 8082, 8064, 3, 2, 2, 2, 8083, 911, 3, 2, 2, 2, 8084, 8085, 7, 4, 2, 2, 8085, 8086, 5, 1282, 642, 2, 8086, 8087, 7, 5, 2, 2, 8087, 913, 3, 2, 2, 2, 8088, 8089, 7, 179, 2, 2, 8089, 8099, 5, 1344, 673, 2, 8090, 8091, 7, 179, 2, 2, 8091, 8092, 7, 292, 2, 2, 8092, 8099, 5, 1344, 673, 2, 8093, 8094, 7, 179, 2, 2, 8094, 8099, 7, 32, 2, 2, 8095, 8096, 7, 179, 2, 2, 8096, 8097, 7, 292, 2, 2, 8097, 8099, 7, 32, 2, 2, 8098, 8088, 3, 2, 2, 2, 8098, 8090, 3, 2, 2, 2, 8098, 8093, 3, 2, 2, 2, 8098, 8095, 3, 2, 2, 2, 8099, 915, 3, 2, 2, 2, 8100, 8102, 5, 988, 495, 2, 8101, 8100, 3, 2, 2, 2, 8101, 8102, 3, 2, 2, 2, 8102, 8103, 3, 2, 2, 2, 8103, 8104, 7, 243, 2, 2, 8104, 8105, 7, 73, 2, 2, 8105, 8106, 5, 918, 460, 2, 8106, 8108, 5, 920, 461, 2, 8107, 8109, 5, 928, 465, 2, 8108, 8107, 3, 2, 2, 2, 8108, 8109, 3, 2, 2, 2, 8109, 8111, 3, 2, 2, 2, 8110, 8112, 5, 932, 467, 2, 8111, 8110, 3, 2, 2, 2, 8111, 8112, 3, 2, 2, 2, 8112, 917, 3, 2, 2, 2, 8113, 8116, 5, 1340, 671, 2, 8114, 8115, 7, 38, 2, 2, 8115, 8117, 5, 1378, 690, 2, 8116, 8114, 3, 2, 2, 2, 8116, 8117, 3, 2, 2, 2, 8117, 919, 3, 2, 2, 2, 8118, 8138, 5, 966, 484, 2, 8119, 8120, 7, 465, 2, 2, 8120, 8121, 5, 922, 462, 2, 8121, 8122, 7, 452, 2, 2, 8122, 8123, 5, 966, 484, 2, 8123, 8138, 3, 2, 2, 2, 8124, 8125, 7, 4, 2, 2, 8125, 8126, 5, 924, 463, 2, 8126, 8131, 7, 5, 2, 2, 8127, 8128, 7, 465, 2, 2, 8128, 8129, 5, 922, 462, 2, 8129, 8130, 7, 452, 2, 2, 8130, 8132, 3, 2, 2, 2, 8131, 8127, 3, 2, 2, 2, 8131, 8132, 3, 2, 2, 2, 8132, 8133, 3, 2, 2, 2, 8133, 8134, 5, 966, 484, 2, 8134, 8138, 3, 2, 2, 2, 8135, 8136, 7, 55, 2, 2, 8136, 8138, 7, 424, 2, 2, 8137, 8118, 3, 2, 2, 2, 8137, 8119, 3, 2, 2, 2, 8137, 8124, 3, 2, 2, 2, 8137, 8135, 3, 2, 2, 2, 8138, 921, 3, 2, 2, 2, 8139, 8140, 9, 45, 2, 2, 8140, 923, 3, 2, 2, 2, 8141, 8146, 5, 926, 464, 2, 8142, 8143, 7, 8, 2, 2, 8143, 8145, 5, 926, 464, 2, 8144, 8142, 3, 2, 2, 2, 8145, 8148, 3, 2, 2, 2, 8146, 8144, 3, 2, 2, 2, 8146, 8147, 3, 2, 2, 2, 8147, 925, 3, 2, 2, 2, 8148, 8146, 3, 2, 2, 2, 8149, 8150, 5, 1378, 690, 2, 8150, 8151, 5, 1328, 665, 2, 8151, 927, 3, 2, 2, 2, 8152, 8153, 7, 82, 2, 2, 8153, 8155, 7, 466, 2, 2, 8154, 8156, 5, 930, 466, 2, 8155, 8154, 3, 2, 2, 2, 8155, 8156, 3, 2, 2, 2, 8156, 8157, 3, 2, 2, 2, 8157, 8165, 7, 59, 2, 2, 8158, 8159, 7, 371, 2, 2, 8159, 8160, 7, 335, 2, 2, 8160, 8162, 5, 950, 476, 2, 8161, 8163, 5, 1098, 550, 2, 8162, 8161, 3, 2, 2, 2, 8162, 8163, 3, 2, 2, 2, 8163, 8166, 3, 2, 2, 2, 8164, 8166, 7, 272, 2, 2, 8165, 8158, 3, 2, 2, 2, 8165, 8164, 3, 2, 2, 2, 8166, 929, 3, 2, 2, 2, 8167, 8168, 7, 4, 2, 2, 8168, 8169, 5, 610, 306, 2, 8169, 8171, 7, 5, 2, 2, 8170, 8172, 5, 1098, 550, 2, 8171, 8170, 3, 2, 2, 2, 8171, 8172, 3, 2, 2, 2, 8172, 8177, 3, 2, 2, 2, 8173, 8174, 7, 82, 2, 2, 8174, 8175, 7, 47, 2, 2, 8175, 8177, 5, 1344, 673, 2, 8176, 8167, 3, 2, 2, 2, 8176, 8173, 3, 2, 2, 2, 8177, 931, 3, 2, 2, 2, 8178, 8179, 7, 89, 2, 2, 8179, 8180, 5, 1332, 667, 2, 8180, 933, 3, 2, 2, 2, 8181, 8183, 5, 988, 495, 2, 8182, 8181, 3, 2, 2, 2, 8182, 8183, 3, 2, 2, 2, 8183, 8184, 3, 2, 2, 2, 8184, 8185, 7, 184, 2, 2, 8185, 8186, 7, 66, 2, 2, 8186, 8188, 5, 1082, 542, 2, 8187, 8189, 5, 936, 469, 2, 8188, 8187, 3, 2, 2, 2, 8188, 8189, 3, 2, 2, 2, 8189, 8191, 3, 2, 2, 2, 8190, 8192, 5, 1100, 551, 2, 8191, 8190, 3, 2, 2, 2, 8191, 8192, 3, 2, 2, 2, 8192, 8194, 3, 2, 2, 2, 8193, 8195, 5, 932, 467, 2, 8194, 8193, 3, 2, 2, 2, 8194, 8195, 3, 2, 2, 2, 8195, 935, 3, 2, 2, 2, 8196, 8197, 7, 102, 2, 2, 8197, 8198, 5, 1064, 533, 2, 8198, 937, 3, 2, 2, 2, 8199, 8201, 7, 258, 2, 2, 8200, 8202, 5, 996, 499, 2, 8201, 8200, 3, 2, 2, 2, 8201, 8202, 3, 2, 2, 2, 8202, 8203, 3, 2, 2, 2, 8203, 8205, 5, 1080, 541, 2, 8204, 8206, 5, 940, 471, 2, 8205, 8204, 3, 2, 2, 2, 8205, 8206, 3, 2, 2, 2, 8206, 8208, 3, 2, 2, 2, 8207, 8209, 5, 944, 473, 2, 8208, 8207, 3, 2, 2, 2, 8208, 8209, 3, 2, 2, 2, 8209, 939, 3, 2, 2, 2, 8210, 8211, 7, 70, 2, 2, 8211, 8212, 5, 942, 472, 2, 8212, 8213, 7, 265, 2, 2, 8213, 941, 3, 2, 2, 2, 8214, 8215, 7, 133, 2, 2, 8215, 8227, 9, 46, 2, 2, 8216, 8217, 7, 416, 2, 2, 8217, 8227, 9, 46, 2, 2, 8218, 8223, 7, 336, 2, 2, 8219, 8220, 7, 371, 2, 2, 8220, 8224, 7, 203, 2, 2, 8221, 8222, 7, 416, 2, 2, 8222, 8224, 7, 203, 2, 2, 8223, 8219, 3, 2, 2, 2, 8223, 8221, 3, 2, 2, 2, 8223, 8224, 3, 2, 2, 2, 8224, 8227, 3, 2, 2, 2, 8225, 8227, 7, 203, 2, 2, 8226, 8214, 3, 2, 2, 2, 8226, 8216, 3, 2, 2, 2, 8226, 8218, 3, 2, 2, 2, 8226, 8225, 3, 2, 2, 2, 8227, 943, 3, 2, 2, 2, 8228, 8229, 7, 274, 2, 2, 8229, 945, 3, 2, 2, 2, 8230, 8234, 7, 274, 2, 2, 8231, 8232, 7, 467, 2, 2, 8232, 8234, 7, 468, 2, 2, 8233, 8230, 3, 2, 2, 2, 8233, 8231, 3, 2, 2, 2, 8234, 947, 3, 2, 2, 2, 8235, 8237, 5, 988, 495, 2, 8236, 8235, 3, 2, 2, 2, 8236, 8237, 3, 2, 2, 2, 8237, 8238, 3, 2, 2, 2, 8238, 8239, 7, 371, 2, 2, 8239, 8240, 5, 1082, 542, 2, 8240, 8241, 7, 335, 2, 2, 8241, 8243, 5, 950, 476, 2, 8242, 8244, 5, 1062, 532, 2, 8243, 8242, 3, 2, 2, 2, 8243, 8244, 3, 2, 2, 2, 8244, 8246, 3, 2, 2, 2, 8245, 8247, 5, 1100, 551, 2, 8246, 8245, 3, 2, 2, 2, 8246, 8247, 3, 2, 2, 2, 8247, 8249, 3, 2, 2, 2, 8248, 8250, 5, 932, 467, 2, 8249, 8248, 3, 2, 2, 2, 8249, 8250, 3, 2, 2, 2, 8250, 949, 3, 2, 2, 2, 8251, 8256, 5, 952, 477, 2, 8252, 8253, 7, 8, 2, 2, 8253, 8255, 5, 952, 477, 2, 8254, 8252, 3, 2, 2, 2, 8255, 8258, 3, 2, 2, 2, 8256, 8254, 3, 2, 2, 2, 8256, 8257, 3, 2, 2, 2, 8257, 951, 3, 2, 2, 2, 8258, 8256, 3, 2, 2, 2, 8259, 8260, 5, 954, 478, 2, 8260, 8261, 7, 12, 2, 2, 8261, 8262, 5, 1166, 584, 2, 8262, 8270, 3, 2, 2, 2, 8263, 8264, 7, 4, 2, 2, 8264, 8265, 5, 956, 479, 2, 8265, 8266, 7, 5, 2, 2, 8266, 8267, 7, 12, 2, 2, 8267, 8268, 5, 1166, 584, 2, 8268, 8270, 3, 2, 2, 2, 8269, 8259, 3, 2, 2, 2, 8269, 8263, 3, 2, 2, 2, 8270, 953, 3, 2, 2, 2, 8271, 8272, 5, 1378, 690, 2, 8272, 8273, 5, 1328, 665, 2, 8273, 955, 3, 2, 2, 2, 8274, 8279, 5, 954, 478, 2, 8275, 8276, 7, 8, 2, 2, 8276, 8278, 5, 954, 478, 2, 8277, 8275, 3, 2, 2, 2, 8278, 8281, 3, 2, 2, 2, 8279, 8277, 3, 2, 2, 2, 8279, 8280, 3, 2, 2, 2, 8280, 957, 3, 2, 2, 2, 8281, 8279, 3, 2, 2, 2, 8282, 8283, 7, 180, 2, 2, 8283, 8284, 5, 960, 481, 2, 8284, 8285, 5, 962, 482, 2, 8285, 8286, 7, 174, 2, 2, 8286, 8287, 5, 964, 483, 2, 8287, 8288, 7, 64, 2, 2, 8288, 8289, 5, 966, 484, 2, 8289, 959, 3, 2, 2, 2, 8290, 8291, 5, 1344, 673, 2, 8291, 961, 3, 2, 2, 2, 8292, 8293, 7, 271, 2, 2, 8293, 8298, 7, 326, 2, 2, 8294, 8298, 7, 326, 2, 2, 8295, 8298, 7, 109, 2, 2, 8296, 8298, 7, 242, 2, 2, 8297, 8292, 3, 2, 2, 2, 8297, 8294, 3, 2, 2, 2, 8297, 8295, 3, 2, 2, 2, 8297, 8296, 3, 2, 2, 2, 8298, 8301, 3, 2, 2, 2, 8299, 8297, 3, 2, 2, 2, 8299, 8300, 3, 2, 2, 2, 8300, 963, 3, 2, 2, 2, 8301, 8299, 3, 2, 2, 2, 8302, 8308, 3, 2, 2, 2, 8303, 8304, 7, 107, 2, 2, 8304, 8308, 7, 219, 2, 2, 8305, 8306, 7, 381, 2, 2, 8306, 8308, 7, 219, 2, 2, 8307, 8302, 3, 2, 2, 2, 8307, 8303, 3, 2, 2, 2, 8307, 8305, 3, 2, 2, 2, 8308, 965, 3, 2, 2, 2, 8309, 8312, 5, 970, 486, 2, 8310, 8312, 5, 968, 485, 2, 8311, 8309, 3, 2, 2, 2, 8311, 8310, 3, 2, 2, 2, 8312, 967, 3, 2, 2, 2, 8313, 8314, 7, 4, 2, 2, 8314, 8315, 5, 970, 486, 2, 8315, 8316, 7, 5, 2, 2, 8316, 8322, 3, 2, 2, 2, 8317, 8318, 7, 4, 2, 2, 8318, 8319, 5, 968, 485, 2, 8319, 8320, 7, 5, 2, 2, 8320, 8322, 3, 2, 2, 2, 8321, 8313, 3, 2, 2, 2, 8321, 8317, 3, 2, 2, 2, 8322, 969, 3, 2, 2, 2, 8323, 8325, 5, 972, 487, 2, 8324, 8326, 5, 1004, 503, 2, 8325, 8324, 3, 2, 2, 2, 8325, 8326, 3, 2, 2, 2, 8326, 8335, 3, 2, 2, 2, 8327, 8329, 5, 1048, 525, 2, 8328, 8330, 5, 1014, 508, 2, 8329, 8328, 3, 2, 2, 2, 8329, 8330, 3, 2, 2, 2, 8330, 8336, 3, 2, 2, 2, 8331, 8333, 5, 1012, 507, 2, 8332, 8334, 5, 1050, 526, 2, 8333, 8332, 3, 2, 2, 2, 8333, 8334, 3, 2, 2, 2, 8334, 8336, 3, 2, 2, 2, 8335, 8327, 3, 2, 2, 2, 8335, 8331, 3, 2, 2, 2, 8335, 8336, 3, 2, 2, 2, 8336, 8353, 3, 2, 2, 2, 8337, 8338, 5, 980, 491, 2, 8338, 8340, 5, 972, 487, 2, 8339, 8341, 5, 1004, 503, 2, 8340, 8339, 3, 2, 2, 2, 8340, 8341, 3, 2, 2, 2, 8341, 8350, 3, 2, 2, 2, 8342, 8344, 5, 1048, 525, 2, 8343, 8345, 5, 1014, 508, 2, 8344, 8343, 3, 2, 2, 2, 8344, 8345, 3, 2, 2, 2, 8345, 8351, 3, 2, 2, 2, 8346, 8348, 5, 1012, 507, 2, 8347, 8349, 5, 1050, 526, 2, 8348, 8347, 3, 2, 2, 2, 8348, 8349, 3, 2, 2, 2, 8349, 8351, 3, 2, 2, 2, 8350, 8342, 3, 2, 2, 2, 8350, 8346, 3, 2, 2, 2, 8350, 8351, 3, 2, 2, 2, 8351, 8353, 3, 2, 2, 2, 8352, 8323, 3, 2, 2, 2, 8352, 8337, 3, 2, 2, 2, 8353, 971, 3, 2, 2, 2, 8354, 8357, 5, 974, 488, 2, 8355, 8357, 5, 968, 485, 2, 8356, 8354, 3, 2, 2, 2, 8356, 8355, 3, 2, 2, 2, 8357, 973, 3, 2, 2, 2, 8358, 8374, 7, 90, 2, 2, 8359, 8361, 5, 1002, 502, 2, 8360, 8359, 3, 2, 2, 2, 8360, 8361, 3, 2, 2, 2, 8361, 8363, 3, 2, 2, 2, 8362, 8364, 5, 990, 496, 2, 8363, 8362, 3, 2, 2, 2, 8363, 8364, 3, 2, 2, 2, 8364, 8366, 3, 2, 2, 2, 8365, 8367, 5, 1330, 666, 2, 8366, 8365, 3, 2, 2, 2, 8366, 8367, 3, 2, 2, 2, 8367, 8375, 3, 2, 2, 2, 8368, 8370, 5, 1000, 501, 2, 8369, 8368, 3, 2, 2, 2, 8369, 8370, 3, 2, 2, 2, 8370, 8372, 3, 2, 2, 2, 8371, 8373, 5, 1332, 667, 2, 8372, 8371, 3, 2, 2, 2, 8372, 8373, 3, 2, 2, 2, 8373, 8375, 3, 2, 2, 2, 8374, 8360, 3, 2, 2, 2, 8374, 8369, 3, 2, 2, 2, 8375, 8377, 3, 2, 2, 2, 8376, 8378, 5, 990, 496, 2, 8377, 8376, 3, 2, 2, 2, 8377, 8378, 3, 2, 2, 2, 8378, 8380, 3, 2, 2, 2, 8379, 8381, 5, 1062, 532, 2, 8380, 8379, 3, 2, 2, 2, 8380, 8381, 3, 2, 2, 2, 8381, 8383, 3, 2, 2, 2, 8382, 8384, 5, 1098, 550, 2, 8383, 8382, 3, 2, 2, 2, 8383, 8384, 3, 2, 2, 2, 8384, 8386, 3, 2, 2, 2, 8385, 8387, 5, 1032, 517, 2, 8386, 8385, 3, 2, 2, 2, 8386, 8387, 3, 2, 2, 2, 8387, 8389, 3, 2, 2, 2, 8388, 8390, 5, 1046, 524, 2, 8389, 8388, 3, 2, 2, 2, 8389, 8390, 3, 2, 2, 2, 8390, 8392, 3, 2, 2, 2, 8391, 8393, 5, 1242, 622, 2, 8392, 8391, 3, 2, 2, 2, 8392, 8393, 3, 2, 2, 2, 8393, 8404, 3, 2, 2, 2, 8394, 8404, 5, 1060, 531, 2, 8395, 8396, 7, 94, 2, 2, 8396, 8404, 5, 1078, 540, 2, 8397, 8398, 5, 968, 485, 2, 8398, 8401, 5, 978, 490, 2, 8399, 8402, 5, 974, 488, 2, 8400, 8402, 5, 968, 485, 2, 8401, 8399, 3, 2, 2, 2, 8401, 8400, 3, 2, 2, 2, 8402, 8404, 3, 2, 2, 2, 8403, 8358, 3, 2, 2, 2, 8403, 8394, 3, 2, 2, 2, 8403, 8395, 3, 2, 2, 2, 8403, 8397, 3, 2, 2, 2, 8404, 8412, 3, 2, 2, 2, 8405, 8408, 5, 978, 490, 2, 8406, 8409, 5, 974, 488, 2, 8407, 8409, 5, 968, 485, 2, 8408, 8406, 3, 2, 2, 2, 8408, 8407, 3, 2, 2, 2, 8409, 8411, 3, 2, 2, 2, 8410, 8405, 3, 2, 2, 2, 8411, 8414, 3, 2, 2, 2, 8412, 8410, 3, 2, 2, 2, 8412, 8413, 3, 2, 2, 2, 8413, 975, 3, 2, 2, 2, 8414, 8412, 3, 2, 2, 2, 8415, 8419, 7, 99, 2, 2, 8416, 8419, 7, 72, 2, 2, 8417, 8419, 7, 61, 2, 2, 8418, 8415, 3, 2, 2, 2, 8418, 8416, 3, 2, 2, 2, 8418, 8417, 3, 2, 2, 2, 8419, 977, 3, 2, 2, 2, 8420, 8422, 5, 976, 489, 2, 8421, 8423, 5, 998, 500, 2, 8422, 8421, 3, 2, 2, 2, 8422, 8423, 3, 2, 2, 2, 8423, 979, 3, 2, 2, 2, 8424, 8426, 7, 107, 2, 2, 8425, 8427, 7, 305, 2, 2, 8426, 8425, 3, 2, 2, 2, 8426, 8427, 3, 2, 2, 2, 8427, 8428, 3, 2, 2, 2, 8428, 8429, 5, 982, 492, 2, 8429, 981, 3, 2, 2, 2, 8430, 8435, 5, 984, 493, 2, 8431, 8432, 7, 8, 2, 2, 8432, 8434, 5, 984, 493, 2, 8433, 8431, 3, 2, 2, 2, 8434, 8437, 3, 2, 2, 2, 8435, 8433, 3, 2, 2, 2, 8435, 8436, 3, 2, 2, 2, 8436, 983, 3, 2, 2, 2, 8437, 8435, 3, 2, 2, 2, 8438, 8440, 5, 1344, 673, 2, 8439, 8441, 5, 884, 443, 2, 8440, 8439, 3, 2, 2, 2, 8440, 8441, 3, 2, 2, 2, 8441, 8442, 3, 2, 2, 2, 8442, 8444, 7, 38, 2, 2, 8443, 8445, 5, 986, 494, 2, 8444, 8443, 3, 2, 2, 2, 8444, 8445, 3, 2, 2, 2, 8445, 8446, 3, 2, 2, 2, 8446, 8447, 7, 4, 2, 2, 8447, 8448, 5, 908, 455, 2, 8448, 8449, 7, 5, 2, 2, 8449, 985, 3, 2, 2, 2, 8450, 8454, 7, 261, 2, 2, 8451, 8452, 7, 79, 2, 2, 8452, 8454, 7, 261, 2, 2, 8453, 8450, 3, 2, 2, 2, 8453, 8451, 3, 2, 2, 2, 8454, 987, 3, 2, 2, 2, 8455, 8456, 5, 980, 491, 2, 8456, 989, 3, 2, 2, 2, 8457, 8462, 7, 73, 2, 2, 8458, 8459, 5, 992, 497, 2, 8459, 8460, 5, 994, 498, 2, 8460, 8463, 3, 2, 2, 2, 8461, 8463, 5, 1576, 789, 2, 8462, 8458, 3, 2, 2, 2, 8462, 8461, 3, 2, 2, 2, 8463, 991, 3, 2, 2, 2, 8464, 8467, 3, 2, 2, 2, 8465, 8467, 7, 348, 2, 2, 8466, 8464, 3, 2, 2, 2, 8466, 8465, 3, 2, 2, 2, 8467, 993, 3, 2, 2, 2, 8468, 8470, 9, 47, 2, 2, 8469, 8468, 3, 2, 2, 2, 8469, 8470, 3, 2, 2, 2, 8470, 8471, 3, 2, 2, 2, 8471, 8473, 9, 19, 2, 2, 8472, 8474, 5, 996, 499, 2, 8473, 8472, 3, 2, 2, 2, 8473, 8474, 3, 2, 2, 2, 8474, 8475, 3, 2, 2, 2, 8475, 8485, 5, 1340, 671, 2, 8476, 8478, 7, 369, 2, 2, 8477, 8479, 5, 996, 499, 2, 8478, 8477, 3, 2, 2, 2, 8478, 8479, 3, 2, 2, 2, 8479, 8480, 3, 2, 2, 2, 8480, 8485, 5, 1340, 671, 2, 8481, 8482, 7, 94, 2, 2, 8482, 8485, 5, 1340, 671, 2, 8483, 8485, 5, 1340, 671, 2, 8484, 8469, 3, 2, 2, 2, 8484, 8476, 3, 2, 2, 2, 8484, 8481, 3, 2, 2, 2, 8484, 8483, 3, 2, 2, 2, 8485, 995, 3, 2, 2, 2, 8486, 8487, 7, 94, 2, 2, 8487, 997, 3, 2, 2, 2, 8488, 8489, 9, 48, 2, 2, 8489, 999, 3, 2, 2, 2, 8490, 8496, 7, 58, 2, 2, 8491, 8492, 7, 82, 2, 2, 8492, 8493, 7, 4, 2, 2, 8493, 8494, 5, 1282, 642, 2, 8494, 8495, 7, 5, 2, 2, 8495, 8497, 3, 2, 2, 2, 8496, 8491, 3, 2, 2, 2, 8496, 8497, 3, 2, 2, 2, 8497, 1001, 3, 2, 2, 2, 8498, 8499, 7, 32, 2, 2, 8499, 1003, 3, 2, 2, 2, 8500, 8501, 5, 1006, 504, 2, 8501, 1005, 3, 2, 2, 2, 8502, 8503, 7, 85, 2, 2, 8503, 8504, 7, 149, 2, 2, 8504, 8505, 5, 1008, 505, 2, 8505, 1007, 3, 2, 2, 2, 8506, 8511, 5, 1010, 506, 2, 8507, 8508, 7, 8, 2, 2, 8508, 8510, 5, 1010, 506, 2, 8509, 8507, 3, 2, 2, 2, 8510, 8513, 3, 2, 2, 2, 8511, 8509, 3, 2, 2, 2, 8511, 8512, 3, 2, 2, 2, 8512, 1009, 3, 2, 2, 2, 8513, 8511, 3, 2, 2, 2, 8514, 8518, 5, 1166, 584, 2, 8515, 8516, 7, 102, 2, 2, 8516, 8519, 5, 1278, 640, 2, 8517, 8519, 5, 624, 313, 2, 8518, 8515, 3, 2, 2, 2, 8518, 8517, 3, 2, 2, 2, 8518, 8519, 3, 2, 2, 2, 8519, 8521, 3, 2, 2, 2, 8520, 8522, 5, 626, 314, 2, 8521, 8520, 3, 2, 2, 2, 8521, 8522, 3, 2, 2, 2, 8522, 1011, 3, 2, 2, 2, 8523, 8525, 5, 1016, 509, 2, 8524, 8526, 5, 1018, 510, 2, 8525, 8524, 3, 2, 2, 2, 8525, 8526, 3, 2, 2, 2, 8526, 8532, 3, 2, 2, 2, 8527, 8529, 5, 1018, 510, 2, 8528, 8530, 5, 1016, 509, 2, 8529, 8528, 3, 2, 2, 2, 8529, 8530, 3, 2, 2, 2, 8530, 8532, 3, 2, 2, 2, 8531, 8523, 3, 2, 2, 2, 8531, 8527, 3, 2, 2, 2, 8532, 1013, 3, 2, 2, 2, 8533, 8534, 5, 1012, 507, 2, 8534, 1015, 3, 2, 2, 2, 8535, 8536, 7, 76, 2, 2, 8536, 8539, 5, 1020, 511, 2, 8537, 8538, 7, 8, 2, 2, 8538, 8540, 5, 1022, 512, 2, 8539, 8537, 3, 2, 2, 2, 8539, 8540, 3, 2, 2, 2, 8540, 8559, 3, 2, 2, 2, 8541, 8542, 7, 63, 2, 2, 8542, 8556, 5, 1030, 516, 2, 8543, 8544, 5, 1024, 513, 2, 8544, 8548, 5, 1028, 515, 2, 8545, 8549, 7, 83, 2, 2, 8546, 8547, 7, 107, 2, 2, 8547, 8549, 7, 469, 2, 2, 8548, 8545, 3, 2, 2, 2, 8548, 8546, 3, 2, 2, 2, 8549, 8557, 3, 2, 2, 2, 8550, 8554, 5, 1028, 515, 2, 8551, 8555, 7, 83, 2, 2, 8552, 8553, 7, 107, 2, 2, 8553, 8555, 7, 469, 2, 2, 8554, 8551, 3, 2, 2, 2, 8554, 8552, 3, 2, 2, 2, 8555, 8557, 3, 2, 2, 2, 8556, 8543, 3, 2, 2, 2, 8556, 8550, 3, 2, 2, 2, 8557, 8559, 3, 2, 2, 2, 8558, 8535, 3, 2, 2, 2, 8558, 8541, 3, 2, 2, 2, 8559, 1017, 3, 2, 2, 2, 8560, 8565, 7, 81, 2, 2, 8561, 8566, 5, 1022, 512, 2, 8562, 8563, 5, 1024, 513, 2, 8563, 8564, 5, 1028, 515, 2, 8564, 8566, 3, 2, 2, 2, 8565, 8561, 3, 2, 2, 2, 8565, 8562, 3, 2, 2, 2, 8566, 1019, 3, 2, 2, 2, 8567, 8570, 5, 1166, 584, 2, 8568, 8570, 7, 32, 2, 2, 8569, 8567, 3, 2, 2, 2, 8569, 8568, 3, 2, 2, 2, 8570, 1021, 3, 2, 2, 2, 8571, 8572, 5, 1166, 584, 2, 8572, 1023, 3, 2, 2, 2, 8573, 8579, 5, 1208, 605, 2, 8574, 8575, 7, 14, 2, 2, 8575, 8579, 5, 1026, 514, 2, 8576, 8577, 7, 15, 2, 2, 8577, 8579, 5, 1026, 514, 2, 8578, 8573, 3, 2, 2, 2, 8578, 8574, 3, 2, 2, 2, 8578, 8576, 3, 2, 2, 2, 8579, 1025, 3, 2, 2, 2, 8580, 8583, 5, 1360, 681, 2, 8581, 8583, 5, 1358, 680, 2, 8582, 8580, 3, 2, 2, 2, 8582, 8581, 3, 2, 2, 2, 8583, 1027, 3, 2, 2, 2, 8584, 8585, 9, 49, 2, 2, 8585, 1029, 3, 2, 2, 2, 8586, 8587, 9, 50, 2, 2, 8587, 1031, 3, 2, 2, 2, 8588, 8589, 7, 68, 2, 2, 8589, 8590, 7, 149, 2, 2, 8590, 8591, 5, 1034, 518, 2, 8591, 1033, 3, 2, 2, 2, 8592, 8597, 5, 1036, 519, 2, 8593, 8594, 7, 8, 2, 2, 8594, 8596, 5, 1036, 519, 2, 8595, 8593, 3, 2, 2, 2, 8596, 8599, 3, 2, 2, 2, 8597, 8595, 3, 2, 2, 2, 8597, 8598, 3, 2, 2, 2, 8598, 1035, 3, 2, 2, 2, 8599, 8597, 3, 2, 2, 2, 8600, 8606, 5, 1166, 584, 2, 8601, 8606, 5, 1038, 520, 2, 8602, 8606, 5, 1042, 522, 2, 8603, 8606, 5, 1040, 521, 2, 8604, 8606, 5, 1044, 523, 2, 8605, 8600, 3, 2, 2, 2, 8605, 8601, 3, 2, 2, 2, 8605, 8602, 3, 2, 2, 2, 8605, 8603, 3, 2, 2, 2, 8605, 8604, 3, 2, 2, 2, 8606, 1037, 3, 2, 2, 2, 8607, 8608, 7, 4, 2, 2, 8608, 8609, 7, 5, 2, 2, 8609, 1039, 3, 2, 2, 2, 8610, 8611, 7, 470, 2, 2, 8611, 8612, 7, 4, 2, 2, 8612, 8613, 5, 1282, 642, 2, 8613, 8614, 7, 5, 2, 2, 8614, 1041, 3, 2, 2, 2, 8615, 8616, 7, 471, 2, 2, 8616, 8617, 7, 4, 2, 2, 8617, 8618, 5, 1282, 642, 2, 8618, 8619, 7, 5, 2, 2, 8619, 1043, 3, 2, 2, 2, 8620, 8621, 7, 472, 2, 2, 8621, 8622, 7, 473, 2, 2, 8622, 8623, 7, 4, 2, 2, 8623, 8624, 5, 1034, 518, 2, 8624, 8625, 7, 5, 2, 2, 8625, 1045, 3, 2, 2, 2, 8626, 8627, 7, 69, 2, 2, 8627, 8628, 5, 1166, 584, 2, 8628, 1047, 3, 2, 2, 2, 8629, 8634, 5, 1052, 527, 2, 8630, 8631, 7, 64, 2, 2, 8631, 8632, 7, 302, 2, 2, 8632, 8634, 7, 83, 2, 2, 8633, 8629, 3, 2, 2, 2, 8633, 8630, 3, 2, 2, 2, 8634, 1049, 3, 2, 2, 2, 8635, 8636, 5, 1048, 525, 2, 8636, 1051, 3, 2, 2, 2, 8637, 8639, 5, 1054, 528, 2, 8638, 8637, 3, 2, 2, 2, 8639, 8640, 3, 2, 2, 2, 8640, 8638, 3, 2, 2, 2, 8640, 8641, 3, 2, 2, 2, 8641, 1053, 3, 2, 2, 2, 8642, 8644, 5, 1056, 529, 2, 8643, 8645, 5, 1058, 530, 2, 8644, 8643, 3, 2, 2, 2, 8644, 8645, 3, 2, 2, 2, 8645, 8647, 3, 2, 2, 2, 8646, 8648, 5, 946, 474, 2, 8647, 8646, 3, 2, 2, 2, 8647, 8648, 3, 2, 2, 2, 8648, 1055, 3, 2, 2, 2, 8649, 8659, 7, 64, 2, 2, 8650, 8651, 7, 271, 2, 2, 8651, 8653, 7, 247, 2, 2, 8652, 8650, 3, 2, 2, 2, 8652, 8653, 3, 2, 2, 2, 8653, 8654, 3, 2, 2, 2, 8654, 8660, 7, 371, 2, 2, 8655, 8657, 7, 247, 2, 2, 8656, 8655, 3, 2, 2, 2, 8656, 8657, 3, 2, 2, 2, 8657, 8658, 3, 2, 2, 2, 8658, 8660, 7, 336, 2, 2, 8659, 8652, 3, 2, 2, 2, 8659, 8656, 3, 2, 2, 2, 8660, 1057, 3, 2, 2, 2, 8661, 8662, 7, 277, 2, 2, 8662, 8663, 5, 1336, 669, 2, 8663, 1059, 3, 2, 2, 2, 8664, 8665, 7, 424, 2, 2, 8665, 8666, 7, 4, 2, 2, 8666, 8667, 5, 1282, 642, 2, 8667, 8675, 7, 5, 2, 2, 8668, 8669, 7, 8, 2, 2, 8669, 8670, 7, 4, 2, 2, 8670, 8671, 5, 1282, 642, 2, 8671, 8672, 7, 5, 2, 2, 8672, 8674, 3, 2, 2, 2, 8673, 8668, 3, 2, 2, 2, 8674, 8677, 3, 2, 2, 2, 8675, 8673, 3, 2, 2, 2, 8675, 8676, 3, 2, 2, 2, 8676, 1061, 3, 2, 2, 2, 8677, 8675, 3, 2, 2, 2, 8678, 8679, 7, 66, 2, 2, 8679, 8680, 5, 1064, 533, 2, 8680, 1063, 3, 2, 2, 2, 8681, 8686, 5, 1066, 534, 2, 8682, 8683, 7, 8, 2, 2, 8683, 8685, 5, 1066, 534, 2, 8684, 8682, 3, 2, 2, 2, 8685, 8688, 3, 2, 2, 2, 8686, 8684, 3, 2, 2, 2, 8686, 8687, 3, 2, 2, 2, 8687, 1065, 3, 2, 2, 2, 8688, 8686, 3, 2, 2, 2, 8689, 8691, 5, 1078, 540, 2, 8690, 8692, 5, 1070, 536, 2, 8691, 8690, 3, 2, 2, 2, 8691, 8692, 3, 2, 2, 2, 8692, 8694, 3, 2, 2, 2, 8693, 8695, 5, 1084, 543, 2, 8694, 8693, 3, 2, 2, 2, 8694, 8695, 3, 2, 2, 2, 8695, 8748, 3, 2, 2, 2, 8696, 8698, 5, 1088, 545, 2, 8697, 8699, 5, 1072, 537, 2, 8698, 8697, 3, 2, 2, 2, 8698, 8699, 3, 2, 2, 2, 8699, 8748, 3, 2, 2, 2, 8700, 8702, 5, 1108, 555, 2, 8701, 8703, 5, 1070, 536, 2, 8702, 8701, 3, 2, 2, 2, 8702, 8703, 3, 2, 2, 2, 8703, 8748, 3, 2, 2, 2, 8704, 8706, 5, 968, 485, 2, 8705, 8707, 5, 1070, 536, 2, 8706, 8705, 3, 2, 2, 2, 8706, 8707, 3, 2, 2, 2, 8707, 8748, 3, 2, 2, 2, 8708, 8721, 7, 74, 2, 2, 8709, 8711, 5, 1108, 555, 2, 8710, 8712, 5, 1070, 536, 2, 8711, 8710, 3, 2, 2, 2, 8711, 8712, 3, 2, 2, 2, 8712, 8722, 3, 2, 2, 2, 8713, 8715, 5, 1088, 545, 2, 8714, 8716, 5, 1072, 537, 2, 8715, 8714, 3, 2, 2, 2, 8715, 8716, 3, 2, 2, 2, 8716, 8722, 3, 2, 2, 2, 8717, 8719, 5, 968, 485, 2, 8718, 8720, 5, 1070, 536, 2, 8719, 8718, 3, 2, 2, 2, 8719, 8720, 3, 2, 2, 2, 8720, 8722, 3, 2, 2, 2, 8721, 8709, 3, 2, 2, 2, 8721, 8713, 3, 2, 2, 2, 8721, 8717, 3, 2, 2, 2, 8722, 8748, 3, 2, 2, 2, 8723, 8724, 7, 4, 2, 2, 8724, 8741, 5, 1066, 534, 2, 8725, 8726, 7, 112, 2, 2, 8726, 8727, 7, 120, 2, 2, 8727, 8742, 5, 1066, 534, 2, 8728, 8730, 7, 123, 2, 2, 8729, 8731, 5, 1074, 538, 2, 8730, 8729, 3, 2, 2, 2, 8730, 8731, 3, 2, 2, 2, 8731, 8732, 3, 2, 2, 2, 8732, 8733, 7, 120, 2, 2, 8733, 8742, 5, 1066, 534, 2, 8734, 8736, 5, 1074, 538, 2, 8735, 8734, 3, 2, 2, 2, 8735, 8736, 3, 2, 2, 2, 8736, 8737, 3, 2, 2, 2, 8737, 8738, 7, 120, 2, 2, 8738, 8739, 5, 1066, 534, 2, 8739, 8740, 5, 1076, 539, 2, 8740, 8742, 3, 2, 2, 2, 8741, 8725, 3, 2, 2, 2, 8741, 8728, 3, 2, 2, 2, 8741, 8735, 3, 2, 2, 2, 8741, 8742, 3, 2, 2, 2, 8742, 8743, 3, 2, 2, 2, 8743, 8745, 7, 5, 2, 2, 8744, 8746, 5, 1070, 536, 2, 8745, 8744, 3, 2, 2, 2, 8745, 8746, 3, 2, 2, 2, 8746, 8748, 3, 2, 2, 2, 8747, 8689, 3, 2, 2, 2, 8747, 8696, 3, 2, 2, 2, 8747, 8700, 3, 2, 2, 2, 8747, 8704, 3, 2, 2, 2, 8747, 8708, 3, 2, 2, 2, 8747, 8723, 3, 2, 2, 2, 8748, 8767, 3, 2, 2, 2, 8749, 8750, 7, 112, 2, 2, 8750, 8751, 7, 120, 2, 2, 8751, 8766, 5, 1066, 534, 2, 8752, 8754, 7, 123, 2, 2, 8753, 8755, 5, 1074, 538, 2, 8754, 8753, 3, 2, 2, 2, 8754, 8755, 3, 2, 2, 2, 8755, 8756, 3, 2, 2, 2, 8756, 8757, 7, 120, 2, 2, 8757, 8766, 5, 1066, 534, 2, 8758, 8760, 5, 1074, 538, 2, 8759, 8758, 3, 2, 2, 2, 8759, 8760, 3, 2, 2, 2, 8760, 8761, 3, 2, 2, 2, 8761, 8762, 7, 120, 2, 2, 8762, 8763, 5, 1066, 534, 2, 8763, 8764, 5, 1076, 539, 2, 8764, 8766, 3, 2, 2, 2, 8765, 8749, 3, 2, 2, 2, 8765, 8752, 3, 2, 2, 2, 8765, 8759, 3, 2, 2, 2, 8766, 8769, 3, 2, 2, 2, 8767, 8765, 3, 2, 2, 2, 8767, 8768, 3, 2, 2, 2, 8768, 1067, 3, 2, 2, 2, 8769, 8767, 3, 2, 2, 2, 8770, 8772, 7, 38, 2, 2, 8771, 8770, 3, 2, 2, 2, 8771, 8772, 3, 2, 2, 2, 8772, 8773, 3, 2, 2, 2, 8773, 8778, 5, 1378, 690, 2, 8774, 8775, 7, 4, 2, 2, 8775, 8776, 5, 1342, 672, 2, 8776, 8777, 7, 5, 2, 2, 8777, 8779, 3, 2, 2, 2, 8778, 8774, 3, 2, 2, 2, 8778, 8779, 3, 2, 2, 2, 8779, 1069, 3, 2, 2, 2, 8780, 8781, 5, 1068, 535, 2, 8781, 1071, 3, 2, 2, 2, 8782, 8795, 5, 1068, 535, 2, 8783, 8785, 7, 38, 2, 2, 8784, 8786, 5, 1378, 690, 2, 8785, 8784, 3, 2, 2, 2, 8785, 8786, 3, 2, 2, 2, 8786, 8789, 3, 2, 2, 2, 8787, 8789, 5, 1378, 690, 2, 8788, 8783, 3, 2, 2, 2, 8788, 8787, 3, 2, 2, 2, 8789, 8790, 3, 2, 2, 2, 8790, 8791, 7, 4, 2, 2, 8791, 8792, 5, 1104, 553, 2, 8792, 8793, 7, 5, 2, 2, 8793, 8795, 3, 2, 2, 2, 8794, 8782, 3, 2, 2, 2, 8794, 8788, 3, 2, 2, 2, 8795, 1073, 3, 2, 2, 2, 8796, 8798, 9, 51, 2, 2, 8797, 8799, 7, 125, 2, 2, 8798, 8797, 3, 2, 2, 2, 8798, 8799, 3, 2, 2, 2, 8799, 1075, 3, 2, 2, 2, 8800, 8801, 7, 102, 2, 2, 8801, 8802, 7, 4, 2, 2, 8802, 8803, 5, 1342, 672, 2, 8803, 8804, 7, 5, 2, 2, 8804, 8808, 3, 2, 2, 2, 8805, 8806, 7, 82, 2, 2, 8806, 8808, 5, 1166, 584, 2, 8807, 8800, 3, 2, 2, 2, 8807, 8805, 3, 2, 2, 2, 8808, 1077, 3, 2, 2, 2, 8809, 8811, 7, 83, 2, 2, 8810, 8809, 3, 2, 2, 2, 8810, 8811, 3, 2, 2, 2, 8811, 8812, 3, 2, 2, 2, 8812, 8814, 5, 1340, 671, 2, 8813, 8815, 7, 11, 2, 2, 8814, 8813, 3, 2, 2, 2, 8814, 8815, 3, 2, 2, 2, 8815, 8825, 3, 2, 2, 2, 8816, 8822, 7, 83, 2, 2, 8817, 8823, 5, 1340, 671, 2, 8818, 8819, 7, 4, 2, 2, 8819, 8820, 5, 1340, 671, 2, 8820, 8821, 7, 5, 2, 2, 8821, 8823, 3, 2, 2, 2, 8822, 8817, 3, 2, 2, 2, 8822, 8818, 3, 2, 2, 2, 8823, 8825, 3, 2, 2, 2, 8824, 8810, 3, 2, 2, 2, 8824, 8816, 3, 2, 2, 2, 8825, 1079, 3, 2, 2, 2, 8826, 8831, 5, 1078, 540, 2, 8827, 8828, 7, 8, 2, 2, 8828, 8830, 5, 1078, 540, 2, 8829, 8827, 3, 2, 2, 2, 8830, 8833, 3, 2, 2, 2, 8831, 8829, 3, 2, 2, 2, 8831, 8832, 3, 2, 2, 2, 8832, 1081, 3, 2, 2, 2, 8833, 8831, 3, 2, 2, 2, 8834, 8839, 5, 1078, 540, 2, 8835, 8837, 7, 38, 2, 2, 8836, 8835, 3, 2, 2, 2, 8836, 8837, 3, 2, 2, 2, 8837, 8838, 3, 2, 2, 2, 8838, 8840, 5, 1378, 690, 2, 8839, 8836, 3, 2, 2, 2, 8839, 8840, 3, 2, 2, 2, 8840, 1083, 3, 2, 2, 2, 8841, 8842, 7, 474, 2, 2, 8842, 8843, 5, 1350, 676, 2, 8843, 8844, 7, 4, 2, 2, 8844, 8845, 5, 1282, 642, 2, 8845, 8847, 7, 5, 2, 2, 8846, 8848, 5, 1086, 544, 2, 8847, 8846, 3, 2, 2, 2, 8847, 8848, 3, 2, 2, 2, 8848, 1085, 3, 2, 2, 2, 8849, 8850, 7, 312, 2, 2, 8850, 8851, 7, 4, 2, 2, 8851, 8852, 5, 1166, 584, 2, 8852, 8853, 7, 5, 2, 2, 8853, 1087, 3, 2, 2, 2, 8854, 8856, 5, 1216, 609, 2, 8855, 8857, 5, 1096, 549, 2, 8856, 8855, 3, 2, 2, 2, 8856, 8857, 3, 2, 2, 2, 8857, 8867, 3, 2, 2, 2, 8858, 8859, 7, 322, 2, 2, 8859, 8860, 7, 66, 2, 2, 8860, 8861, 7, 4, 2, 2, 8861, 8862, 5, 1092, 547, 2, 8862, 8864, 7, 5, 2, 2, 8863, 8865, 5, 1096, 549, 2, 8864, 8863, 3, 2, 2, 2, 8864, 8865, 3, 2, 2, 2, 8865, 8867, 3, 2, 2, 2, 8866, 8854, 3, 2, 2, 2, 8866, 8858, 3, 2, 2, 2, 8867, 1089, 3, 2, 2, 2, 8868, 8870, 5, 1216, 609, 2, 8869, 8871, 5, 1094, 548, 2, 8870, 8869, 3, 2, 2, 2, 8870, 8871, 3, 2, 2, 2, 8871, 1091, 3, 2, 2, 2, 8872, 8877, 5, 1090, 546, 2, 8873, 8874, 7, 8, 2, 2, 8874, 8876, 5, 1090, 546, 2, 8875, 8873, 3, 2, 2, 2, 8876, 8879, 3, 2, 2, 2, 8877, 8875, 3, 2, 2, 2, 8877, 8878, 3, 2, 2, 2, 8878, 1093, 3, 2, 2, 2, 8879, 8877, 3, 2, 2, 2, 8880, 8881, 7, 38, 2, 2, 8881, 8882, 7, 4, 2, 2, 8882, 8883, 5, 1104, 553, 2, 8883, 8884, 7, 5, 2, 2, 8884, 1095, 3, 2, 2, 2, 8885, 8886, 7, 107, 2, 2, 8886, 8887, 7, 475, 2, 2, 8887, 1097, 3, 2, 2, 2, 8888, 8889, 7, 105, 2, 2, 8889, 8890, 5, 1166, 584, 2, 8890, 1099, 3, 2, 2, 2, 8891, 8896, 7, 105, 2, 2, 8892, 8893, 7, 436, 2, 2, 8893, 8894, 7, 277, 2, 2, 8894, 8897, 5, 960, 481, 2, 8895, 8897, 5, 1166, 584, 2, 8896, 8892, 3, 2, 2, 2, 8896, 8895, 3, 2, 2, 2, 8897, 1101, 3, 2, 2, 2, 8898, 8899, 5, 1104, 553, 2, 8899, 1103, 3, 2, 2, 2, 8900, 8905, 5, 1106, 554, 2, 8901, 8902, 7, 8, 2, 2, 8902, 8904, 5, 1106, 554, 2, 8903, 8901, 3, 2, 2, 2, 8904, 8907, 3, 2, 2, 2, 8905, 8903, 3, 2, 2, 2, 8905, 8906, 3, 2, 2, 2, 8906, 1105, 3, 2, 2, 2, 8907, 8905, 3, 2, 2, 2, 8908, 8909, 5, 1378, 690, 2, 8909, 8911, 5, 1122, 562, 2, 8910, 8912, 5, 110, 56, 2, 8911, 8910, 3, 2, 2, 2, 8911, 8912, 3, 2, 2, 2, 8912, 1107, 3, 2, 2, 2, 8913, 8914, 7, 476, 2, 2, 8914, 8930, 7, 4, 2, 2, 8915, 8916, 5, 1208, 605, 2, 8916, 8917, 5, 1234, 618, 2, 8917, 8918, 7, 477, 2, 2, 8918, 8919, 5, 1110, 556, 2, 8919, 8931, 3, 2, 2, 2, 8920, 8921, 7, 478, 2, 2, 8921, 8922, 7, 4, 2, 2, 8922, 8923, 5, 1118, 560, 2, 8923, 8924, 7, 5, 2, 2, 8924, 8925, 7, 8, 2, 2, 8925, 8926, 5, 1208, 605, 2, 8926, 8927, 5, 1234, 618, 2, 8927, 8928, 7, 477, 2, 2, 8928, 8929, 5, 1110, 556, 2, 8929, 8931, 3, 2, 2, 2, 8930, 8915, 3, 2, 2, 2, 8930, 8920, 3, 2, 2, 2, 8931, 8932, 3, 2, 2, 2, 8932, 8933, 7, 5, 2, 2, 8933, 1109, 3, 2, 2, 2, 8934, 8939, 5, 1112, 557, 2, 8935, 8936, 7, 8, 2, 2, 8936, 8938, 5, 1112, 557, 2, 8937, 8935, 3, 2, 2, 2, 8938, 8941, 3, 2, 2, 2, 8939, 8937, 3, 2, 2, 2, 8939, 8940, 3, 2, 2, 2, 8940, 1111, 3, 2, 2, 2, 8941, 8939, 3, 2, 2, 2, 8942, 8949, 5, 1378, 690, 2, 8943, 8945, 5, 1122, 562, 2, 8944, 8946, 5, 1114, 558, 2, 8945, 8944, 3, 2, 2, 2, 8945, 8946, 3, 2, 2, 2, 8946, 8950, 3, 2, 2, 2, 8947, 8948, 7, 64, 2, 2, 8948, 8950, 7, 475, 2, 2, 8949, 8943, 3, 2, 2, 2, 8949, 8947, 3, 2, 2, 2, 8950, 1113, 3, 2, 2, 2, 8951, 8953, 5, 1116, 559, 2, 8952, 8951, 3, 2, 2, 2, 8953, 8954, 3, 2, 2, 2, 8954, 8952, 3, 2, 2, 2, 8954, 8955, 3, 2, 2, 2, 8955, 1115, 3, 2, 2, 2, 8956, 8957, 7, 55, 2, 2, 8957, 8965, 5, 1166, 584, 2, 8958, 8959, 5, 1394, 698, 2, 8959, 8960, 5, 1166, 584, 2, 8960, 8965, 3, 2, 2, 2, 8961, 8962, 7, 79, 2, 2, 8962, 8965, 7, 80, 2, 2, 8963, 8965, 7, 80, 2, 2, 8964, 8956, 3, 2, 2, 2, 8964, 8958, 3, 2, 2, 2, 8964, 8961, 3, 2, 2, 2, 8964, 8963, 3, 2, 2, 2, 8965, 1117, 3, 2, 2, 2, 8966, 8971, 5, 1120, 561, 2, 8967, 8968, 7, 8, 2, 2, 8968, 8970, 5, 1120, 561, 2, 8969, 8967, 3, 2, 2, 2, 8970, 8973, 3, 2, 2, 2, 8971, 8969, 3, 2, 2, 2, 8971, 8972, 3, 2, 2, 2, 8972, 1119, 3, 2, 2, 2, 8973, 8971, 3, 2, 2, 2, 8974, 8975, 5, 1206, 604, 2, 8975, 8976, 7, 38, 2, 2, 8976, 8977, 5, 1392, 697, 2, 8977, 8981, 3, 2, 2, 2, 8978, 8979, 7, 55, 2, 2, 8979, 8981, 5, 1206, 604, 2, 8980, 8974, 3, 2, 2, 2, 8980, 8978, 3, 2, 2, 2, 8981, 1121, 3, 2, 2, 2, 8982, 8984, 7, 417, 2, 2, 8983, 8982, 3, 2, 2, 2, 8983, 8984, 3, 2, 2, 2, 8984, 8985, 3, 2, 2, 2, 8985, 8994, 5, 1126, 564, 2, 8986, 8995, 5, 1124, 563, 2, 8987, 8992, 7, 37, 2, 2, 8988, 8989, 7, 6, 2, 2, 8989, 8990, 5, 1360, 681, 2, 8990, 8991, 7, 7, 2, 2, 8991, 8993, 3, 2, 2, 2, 8992, 8988, 3, 2, 2, 2, 8992, 8993, 3, 2, 2, 2, 8993, 8995, 3, 2, 2, 2, 8994, 8986, 3, 2, 2, 2, 8994, 8987, 3, 2, 2, 2, 8995, 9001, 3, 2, 2, 2, 8996, 8997, 5, 1340, 671, 2, 8997, 8998, 7, 29, 2, 2, 8998, 8999, 9, 52, 2, 2, 8999, 9001, 3, 2, 2, 2, 9000, 8983, 3, 2, 2, 2, 9000, 8996, 3, 2, 2, 2, 9001, 1123, 3, 2, 2, 2, 9002, 9004, 7, 6, 2, 2, 9003, 9005, 5, 1360, 681, 2, 9004, 9003, 3, 2, 2, 2, 9004, 9005, 3, 2, 2, 2, 9005, 9006, 3, 2, 2, 2, 9006, 9008, 7, 7, 2, 2, 9007, 9002, 3, 2, 2, 2, 9008, 9011, 3, 2, 2, 2, 9009, 9007, 3, 2, 2, 2, 9009, 9010, 3, 2, 2, 2, 9010, 1125, 3, 2, 2, 2, 9011, 9009, 3, 2, 2, 2, 9012, 9028, 5, 1130, 566, 2, 9013, 9028, 5, 1134, 568, 2, 9014, 9028, 5, 1138, 570, 2, 9015, 9028, 5, 1146, 574, 2, 9016, 9028, 5, 1154, 578, 2, 9017, 9025, 5, 1156, 579, 2, 9018, 9020, 5, 1160, 581, 2, 9019, 9018, 3, 2, 2, 2, 9019, 9020, 3, 2, 2, 2, 9020, 9026, 3, 2, 2, 2, 9021, 9022, 7, 4, 2, 2, 9022, 9023, 5, 1360, 681, 2, 9023, 9024, 7, 5, 2, 2, 9024, 9026, 3, 2, 2, 2, 9025, 9019, 3, 2, 2, 2, 9025, 9021, 3, 2, 2, 2, 9026, 9028, 3, 2, 2, 2, 9027, 9012, 3, 2, 2, 2, 9027, 9013, 3, 2, 2, 2, 9027, 9014, 3, 2, 2, 2, 9027, 9015, 3, 2, 2, 2, 9027, 9016, 3, 2, 2, 2, 9027, 9017, 3, 2, 2, 2, 9028, 1127, 3, 2, 2, 2, 9029, 9034, 5, 1134, 568, 2, 9030, 9034, 5, 1140, 571, 2, 9031, 9034, 5, 1148, 575, 2, 9032, 9034, 5, 1154, 578, 2, 9033, 9029, 3, 2, 2, 2, 9033, 9030, 3, 2, 2, 2, 9033, 9031, 3, 2, 2, 2, 9033, 9032, 3, 2, 2, 2, 9034, 1129, 3, 2, 2, 2, 9035, 9037, 5, 1388, 695, 2, 9036, 9038, 5, 534, 268, 2, 9037, 9036, 3, 2, 2, 2, 9037, 9038, 3, 2, 2, 2, 9038, 9040, 3, 2, 2, 2, 9039, 9041, 5, 1132, 567, 2, 9040, 9039, 3, 2, 2, 2, 9040, 9041, 3, 2, 2, 2, 9041, 1131, 3, 2, 2, 2, 9042, 9043, 7, 4, 2, 2, 9043, 9044, 5, 1282, 642, 2, 9044, 9045, 7, 5, 2, 2, 9045, 1133, 3, 2, 2, 2, 9046, 9071, 7, 403, 2, 2, 9047, 9071, 7, 404, 2, 2, 9048, 9071, 7, 418, 2, 2, 9049, 9071, 7, 390, 2, 2, 9050, 9071, 7, 415, 2, 2, 9051, 9053, 7, 400, 2, 2, 9052, 9054, 5, 1136, 569, 2, 9053, 9052, 3, 2, 2, 2, 9053, 9054, 3, 2, 2, 2, 9054, 9071, 3, 2, 2, 2, 9055, 9056, 7, 192, 2, 2, 9056, 9071, 7, 414, 2, 2, 9057, 9059, 7, 397, 2, 2, 9058, 9060, 5, 1132, 567, 2, 9059, 9058, 3, 2, 2, 2, 9059, 9060, 3, 2, 2, 2, 9060, 9071, 3, 2, 2, 2, 9061, 9063, 7, 396, 2, 2, 9062, 9064, 5, 1132, 567, 2, 9063, 9062, 3, 2, 2, 2, 9063, 9064, 3, 2, 2, 2, 9064, 9071, 3, 2, 2, 2, 9065, 9067, 7, 411, 2, 2, 9066, 9068, 5, 1132, 567, 2, 9067, 9066, 3, 2, 2, 2, 9067, 9068, 3, 2, 2, 2, 9068, 9071, 3, 2, 2, 2, 9069, 9071, 7, 392, 2, 2, 9070, 9046, 3, 2, 2, 2, 9070, 9047, 3, 2, 2, 2, 9070, 9048, 3, 2, 2, 2, 9070, 9049, 3, 2, 2, 2, 9070, 9050, 3, 2, 2, 2, 9070, 9051, 3, 2, 2, 2, 9070, 9055, 3, 2, 2, 2, 9070, 9057, 3, 2, 2, 2, 9070, 9061, 3, 2, 2, 2, 9070, 9065, 3, 2, 2, 2, 9070, 9069, 3, 2, 2, 2, 9071, 1135, 3, 2, 2, 2, 9072, 9073, 7, 4, 2, 2, 9073, 9074, 5, 1360, 681, 2, 9074, 9075, 7, 5, 2, 2, 9075, 1137, 3, 2, 2, 2, 9076, 9079, 5, 1142, 572, 2, 9077, 9079, 5, 1144, 573, 2, 9078, 9076, 3, 2, 2, 2, 9078, 9077, 3, 2, 2, 2, 9079, 1139, 3, 2, 2, 2, 9080, 9083, 5, 1142, 572, 2, 9081, 9083, 5, 1144, 573, 2, 9082, 9080, 3, 2, 2, 2, 9082, 9081, 3, 2, 2, 2, 9083, 1141, 3, 2, 2, 2, 9084, 9086, 7, 391, 2, 2, 9085, 9087, 5, 1152, 577, 2, 9086, 9085, 3, 2, 2, 2, 9086, 9087, 3, 2, 2, 2, 9087, 9088, 3, 2, 2, 2, 9088, 9089, 7, 4, 2, 2, 9089, 9090, 5, 1282, 642, 2, 9090, 9091, 7, 5, 2, 2, 9091, 1143, 3, 2, 2, 2, 9092, 9094, 7, 391, 2, 2, 9093, 9095, 5, 1152, 577, 2, 9094, 9093, 3, 2, 2, 2, 9094, 9095, 3, 2, 2, 2, 9095, 1145, 3, 2, 2, 2, 9096, 9101, 5, 1150, 576, 2, 9097, 9098, 7, 4, 2, 2, 9098, 9099, 5, 1360, 681, 2, 9099, 9100, 7, 5, 2, 2, 9100, 9102, 3, 2, 2, 2, 9101, 9097, 3, 2, 2, 2, 9101, 9102, 3, 2, 2, 2, 9102, 1147, 3, 2, 2, 2, 9103, 9108, 5, 1150, 576, 2, 9104, 9105, 7, 4, 2, 2, 9105, 9106, 5, 1360, 681, 2, 9106, 9107, 7, 5, 2, 2, 9107, 9109, 3, 2, 2, 2, 9108, 9104, 3, 2, 2, 2, 9108, 9109, 3, 2, 2, 2, 9109, 1149, 3, 2, 2, 2, 9110, 9112, 9, 53, 2, 2, 9111, 9113, 5, 1152, 577, 2, 9112, 9111, 3, 2, 2, 2, 9112, 9113, 3, 2, 2, 2, 9113, 9121, 3, 2, 2, 2, 9114, 9121, 7, 425, 2, 2, 9115, 9116, 7, 407, 2, 2, 9116, 9118, 9, 54, 2, 2, 9117, 9119, 5, 1152, 577, 2, 9118, 9117, 3, 2, 2, 2, 9118, 9119, 3, 2, 2, 2, 9119, 9121, 3, 2, 2, 2, 9120, 9110, 3, 2, 2, 2, 9120, 9114, 3, 2, 2, 2, 9120, 9115, 3, 2, 2, 2, 9121, 1151, 3, 2, 2, 2, 9122, 9123, 7, 376, 2, 2, 9123, 1153, 3, 2, 2, 2, 9124, 9129, 9, 55, 2, 2, 9125, 9126, 7, 4, 2, 2, 9126, 9127, 5, 1360, 681, 2, 9127, 9128, 7, 5, 2, 2, 9128, 9130, 3, 2, 2, 2, 9129, 9125, 3, 2, 2, 2, 9129, 9130, 3, 2, 2, 2, 9130, 9132, 3, 2, 2, 2, 9131, 9133, 5, 1158, 580, 2, 9132, 9131, 3, 2, 2, 2, 9132, 9133, 3, 2, 2, 2, 9133, 1155, 3, 2, 2, 2, 9134, 9135, 7, 405, 2, 2, 9135, 1157, 3, 2, 2, 2, 9136, 9137, 7, 107, 2, 2, 9137, 9138, 7, 420, 2, 2, 9138, 9143, 7, 388, 2, 2, 9139, 9140, 7, 381, 2, 2, 9140, 9141, 7, 420, 2, 2, 9141, 9143, 7, 388, 2, 2, 9142, 9136, 3, 2, 2, 2, 9142, 9139, 3, 2, 2, 2, 9143, 1159, 3, 2, 2, 2, 9144, 9170, 7, 386, 2, 2, 9145, 9170, 7, 266, 2, 2, 9146, 9170, 7, 178, 2, 2, 9147, 9170, 7, 220, 2, 2, 9148, 9170, 7, 263, 2, 2, 9149, 9170, 5, 1162, 582, 2, 9150, 9151, 7, 386, 2, 2, 9151, 9152, 7, 96, 2, 2, 9152, 9170, 7, 266, 2, 2, 9153, 9154, 7, 178, 2, 2, 9154, 9158, 7, 96, 2, 2, 9155, 9159, 7, 220, 2, 2, 9156, 9159, 7, 263, 2, 2, 9157, 9159, 5, 1162, 582, 2, 9158, 9155, 3, 2, 2, 2, 9158, 9156, 3, 2, 2, 2, 9158, 9157, 3, 2, 2, 2, 9159, 9170, 3, 2, 2, 2, 9160, 9161, 7, 220, 2, 2, 9161, 9164, 7, 96, 2, 2, 9162, 9165, 7, 263, 2, 2, 9163, 9165, 5, 1162, 582, 2, 9164, 9162, 3, 2, 2, 2, 9164, 9163, 3, 2, 2, 2, 9165, 9170, 3, 2, 2, 2, 9166, 9167, 7, 263, 2, 2, 9167, 9168, 7, 96, 2, 2, 9168, 9170, 5, 1162, 582, 2, 9169, 9144, 3, 2, 2, 2, 9169, 9145, 3, 2, 2, 2, 9169, 9146, 3, 2, 2, 2, 9169, 9147, 3, 2, 2, 2, 9169, 9148, 3, 2, 2, 2, 9169, 9149, 3, 2, 2, 2, 9169, 9150, 3, 2, 2, 2, 9169, 9153, 3, 2, 2, 2, 9169, 9160, 3, 2, 2, 2, 9169, 9166, 3, 2, 2, 2, 9170, 1161, 3, 2, 2, 2, 9171, 9176, 7, 328, 2, 2, 9172, 9173, 7, 4, 2, 2, 9173, 9174, 5, 1360, 681, 2, 9174, 9175, 7, 5, 2, 2, 9175, 9177, 3, 2, 2, 2, 9176, 9172, 3, 2, 2, 2, 9176, 9177, 3, 2, 2, 2, 9177, 1163, 3, 2, 2, 2, 9178, 9179, 7, 199, 2, 2, 9179, 9180, 5, 1166, 584, 2, 9180, 1165, 3, 2, 2, 2, 9181, 9182, 5, 1168, 585, 2, 9182, 1167, 3, 2, 2, 2, 9183, 9185, 5, 1170, 586, 2, 9184, 9186, 5, 1276, 639, 2, 9185, 9184, 3, 2, 2, 2, 9185, 9186, 3, 2, 2, 2, 9186, 1169, 3, 2, 2, 2, 9187, 9192, 5, 1172, 587, 2, 9188, 9189, 9, 56, 2, 2, 9189, 9191, 5, 1172, 587, 2, 9190, 9188, 3, 2, 2, 2, 9191, 9194, 3, 2, 2, 2, 9192, 9190, 3, 2, 2, 2, 9192, 9193, 3, 2, 2, 2, 9193, 1171, 3, 2, 2, 2, 9194, 9192, 3, 2, 2, 2, 9195, 9200, 5, 1174, 588, 2, 9196, 9197, 7, 84, 2, 2, 9197, 9199, 5, 1174, 588, 2, 9198, 9196, 3, 2, 2, 2, 9199, 9202, 3, 2, 2, 2, 9200, 9198, 3, 2, 2, 2, 9200, 9201, 3, 2, 2, 2, 9201, 1173, 3, 2, 2, 2, 9202, 9200, 3, 2, 2, 2, 9203, 9208, 5, 1176, 589, 2, 9204, 9205, 7, 35, 2, 2, 9205, 9207, 5, 1176, 589, 2, 9206, 9204, 3, 2, 2, 2, 9207, 9210, 3, 2, 2, 2, 9208, 9206, 3, 2, 2, 2, 9208, 9209, 3, 2, 2, 2, 9209, 1175, 3, 2, 2, 2, 9210, 9208, 3, 2, 2, 2, 9211, 9217, 5, 1178, 590, 2, 9212, 9214, 7, 79, 2, 2, 9213, 9212, 3, 2, 2, 2, 9213, 9214, 3, 2, 2, 2, 9214, 9215, 3, 2, 2, 2, 9215, 9216, 7, 70, 2, 2, 9216, 9218, 5, 1308, 655, 2, 9217, 9213, 3, 2, 2, 2, 9217, 9218, 3, 2, 2, 2, 9218, 1177, 3, 2, 2, 2, 9219, 9221, 7, 79, 2, 2, 9220, 9219, 3, 2, 2, 2, 9220, 9221, 3, 2, 2, 2, 9221, 9222, 3, 2, 2, 2, 9222, 9223, 5, 1180, 591, 2, 9223, 1179, 3, 2, 2, 2, 9224, 9226, 5, 1182, 592, 2, 9225, 9227, 9, 57, 2, 2, 9226, 9225, 3, 2, 2, 2, 9226, 9227, 3, 2, 2, 2, 9227, 1181, 3, 2, 2, 2, 9228, 9252, 5, 1184, 593, 2, 9229, 9231, 7, 118, 2, 2, 9230, 9232, 7, 79, 2, 2, 9231, 9230, 3, 2, 2, 2, 9231, 9232, 3, 2, 2, 2, 9232, 9250, 3, 2, 2, 2, 9233, 9251, 7, 80, 2, 2, 9234, 9251, 7, 98, 2, 2, 9235, 9251, 7, 62, 2, 2, 9236, 9251, 7, 367, 2, 2, 9237, 9238, 7, 58, 2, 2, 9238, 9239, 7, 66, 2, 2, 9239, 9251, 5, 1166, 584, 2, 9240, 9241, 7, 277, 2, 2, 9241, 9242, 7, 4, 2, 2, 9242, 9243, 5, 1288, 645, 2, 9243, 9244, 7, 5, 2, 2, 9244, 9251, 3, 2, 2, 2, 9245, 9251, 7, 190, 2, 2, 9246, 9248, 5, 1298, 650, 2, 9247, 9246, 3, 2, 2, 2, 9247, 9248, 3, 2, 2, 2, 9248, 9249, 3, 2, 2, 2, 9249, 9251, 7, 480, 2, 2, 9250, 9233, 3, 2, 2, 2, 9250, 9234, 3, 2, 2, 2, 9250, 9235, 3, 2, 2, 2, 9250, 9236, 3, 2, 2, 2, 9250, 9237, 3, 2, 2, 2, 9250, 9240, 3, 2, 2, 2, 9250, 9245, 3, 2, 2, 2, 9250, 9247, 3, 2, 2, 2, 9251, 9253, 3, 2, 2, 2, 9252, 9229, 3, 2, 2, 2, 9252, 9253, 3, 2, 2, 2, 9253, 1183, 3, 2, 2, 2, 9254, 9266, 5, 1186, 594, 2, 9255, 9256, 9, 58, 2, 2, 9256, 9267, 5, 1186, 594, 2, 9257, 9258, 5, 1280, 641, 2, 9258, 9264, 5, 1270, 636, 2, 9259, 9265, 5, 968, 485, 2, 9260, 9261, 7, 4, 2, 2, 9261, 9262, 5, 1166, 584, 2, 9262, 9263, 7, 5, 2, 2, 9263, 9265, 3, 2, 2, 2, 9264, 9259, 3, 2, 2, 2, 9264, 9260, 3, 2, 2, 2, 9265, 9267, 3, 2, 2, 2, 9266, 9255, 3, 2, 2, 2, 9266, 9257, 3, 2, 2, 2, 9266, 9267, 3, 2, 2, 2, 9267, 1185, 3, 2, 2, 2, 9268, 9286, 5, 1188, 595, 2, 9269, 9271, 7, 79, 2, 2, 9270, 9269, 3, 2, 2, 2, 9270, 9271, 3, 2, 2, 2, 9271, 9280, 3, 2, 2, 2, 9272, 9281, 7, 122, 2, 2, 9273, 9281, 7, 116, 2, 2, 9274, 9275, 7, 129, 2, 2, 9275, 9281, 7, 96, 2, 2, 9276, 9278, 7, 389, 2, 2, 9277, 9279, 7, 93, 2, 2, 9278, 9277, 3, 2, 2, 2, 9278, 9279, 3, 2, 2, 2, 9279, 9281, 3, 2, 2, 2, 9280, 9272, 3, 2, 2, 2, 9280, 9273, 3, 2, 2, 2, 9280, 9274, 3, 2, 2, 2, 9280, 9276, 3, 2, 2, 2, 9281, 9282, 3, 2, 2, 2, 9282, 9284, 5, 1188, 595, 2, 9283, 9285, 5, 1164, 583, 2, 9284, 9283, 3, 2, 2, 2, 9284, 9285, 3, 2, 2, 2, 9285, 9287, 3, 2, 2, 2, 9286, 9270, 3, 2, 2, 2, 9286, 9287, 3, 2, 2, 2, 9287, 1187, 3, 2, 2, 2, 9288, 9294, 5, 1190, 596, 2, 9289, 9290, 5, 1276, 639, 2, 9290, 9291, 5, 1190, 596, 2, 9291, 9293, 3, 2, 2, 2, 9292, 9289, 3, 2, 2, 2, 9293, 9296, 3, 2, 2, 2, 9294, 9292, 3, 2, 2, 2, 9294, 9295, 3, 2, 2, 2, 9295, 1189, 3, 2, 2, 2, 9296, 9294, 3, 2, 2, 2, 9297, 9299, 5, 1276, 639, 2, 9298, 9297, 3, 2, 2, 2, 9298, 9299, 3, 2, 2, 2, 9299, 9300, 3, 2, 2, 2, 9300, 9301, 5, 1192, 597, 2, 9301, 1191, 3, 2, 2, 2, 9302, 9307, 5, 1194, 598, 2, 9303, 9304, 9, 59, 2, 2, 9304, 9306, 5, 1194, 598, 2, 9305, 9303, 3, 2, 2, 2, 9306, 9309, 3, 2, 2, 2, 9307, 9305, 3, 2, 2, 2, 9307, 9308, 3, 2, 2, 2, 9308, 1193, 3, 2, 2, 2, 9309, 9307, 3, 2, 2, 2, 9310, 9315, 5, 1196, 599, 2, 9311, 9312, 9, 60, 2, 2, 9312, 9314, 5, 1196, 599, 2, 9313, 9311, 3, 2, 2, 2, 9314, 9317, 3, 2, 2, 2, 9315, 9313, 3, 2, 2, 2, 9315, 9316, 3, 2, 2, 2, 9316, 1195, 3, 2, 2, 2, 9317, 9315, 3, 2, 2, 2, 9318, 9321, 5, 1198, 600, 2, 9319, 9320, 7, 17, 2, 2, 9320, 9322, 5, 1166, 584, 2, 9321, 9319, 3, 2, 2, 2, 9321, 9322, 3, 2, 2, 2, 9322, 1197, 3, 2, 2, 2, 9323, 9325, 9, 59, 2, 2, 9324, 9323, 3, 2, 2, 2, 9324, 9325, 3, 2, 2, 2, 9325, 9326, 3, 2, 2, 2, 9326, 9327, 5, 1200, 601, 2, 9327, 1199, 3, 2, 2, 2, 9328, 9333, 5, 1202, 602, 2, 9329, 9330, 7, 144, 2, 2, 9330, 9331, 7, 420, 2, 2, 9331, 9332, 7, 388, 2, 2, 9332, 9334, 5, 1166, 584, 2, 9333, 9329, 3, 2, 2, 2, 9333, 9334, 3, 2, 2, 2, 9334, 1201, 3, 2, 2, 2, 9335, 9338, 5, 1204, 603, 2, 9336, 9337, 7, 45, 2, 2, 9337, 9339, 5, 532, 267, 2, 9338, 9336, 3, 2, 2, 2, 9338, 9339, 3, 2, 2, 2, 9339, 1203, 3, 2, 2, 2, 9340, 9345, 5, 1208, 605, 2, 9341, 9342, 7, 28, 2, 2, 9342, 9344, 5, 1122, 562, 2, 9343, 9341, 3, 2, 2, 2, 9344, 9347, 3, 2, 2, 2, 9345, 9343, 3, 2, 2, 2, 9345, 9346, 3, 2, 2, 2, 9346, 1205, 3, 2, 2, 2, 9347, 9345, 3, 2, 2, 2, 9348, 9349, 8, 604, 1, 2, 9349, 9356, 5, 1208, 605, 2, 9350, 9351, 9, 59, 2, 2, 9351, 9356, 5, 1206, 604, 11, 9352, 9353, 5, 1276, 639, 2, 9353, 9354, 5, 1206, 604, 5, 9354, 9356, 3, 2, 2, 2, 9355, 9348, 3, 2, 2, 2, 9355, 9350, 3, 2, 2, 2, 9355, 9352, 3, 2, 2, 2, 9356, 9396, 3, 2, 2, 2, 9357, 9358, 12, 10, 2, 2, 9358, 9359, 7, 17, 2, 2, 9359, 9395, 5, 1206, 604, 11, 9360, 9361, 12, 9, 2, 2, 9361, 9362, 9, 60, 2, 2, 9362, 9395, 5, 1206, 604, 10, 9363, 9364, 12, 8, 2, 2, 9364, 9365, 9, 59, 2, 2, 9365, 9395, 5, 1206, 604, 9, 9366, 9367, 12, 7, 2, 2, 9367, 9368, 5, 1276, 639, 2, 9368, 9369, 5, 1206, 604, 8, 9369, 9395, 3, 2, 2, 2, 9370, 9371, 12, 6, 2, 2, 9371, 9372, 9, 58, 2, 2, 9372, 9395, 5, 1206, 604, 7, 9373, 9374, 12, 12, 2, 2, 9374, 9375, 7, 28, 2, 2, 9375, 9395, 5, 1122, 562, 2, 9376, 9377, 12, 4, 2, 2, 9377, 9395, 5, 1276, 639, 2, 9378, 9379, 12, 3, 2, 2, 9379, 9381, 7, 118, 2, 2, 9380, 9382, 7, 79, 2, 2, 9381, 9380, 3, 2, 2, 2, 9381, 9382, 3, 2, 2, 2, 9382, 9392, 3, 2, 2, 2, 9383, 9384, 7, 58, 2, 2, 9384, 9385, 7, 66, 2, 2, 9385, 9393, 5, 1206, 604, 2, 9386, 9387, 7, 277, 2, 2, 9387, 9388, 7, 4, 2, 2, 9388, 9389, 5, 1288, 645, 2, 9389, 9390, 7, 5, 2, 2, 9390, 9393, 3, 2, 2, 2, 9391, 9393, 7, 190, 2, 2, 9392, 9383, 3, 2, 2, 2, 9392, 9386, 3, 2, 2, 2, 9392, 9391, 3, 2, 2, 2, 9393, 9395, 3, 2, 2, 2, 9394, 9357, 3, 2, 2, 2, 9394, 9360, 3, 2, 2, 2, 9394, 9363, 3, 2, 2, 2, 9394, 9366, 3, 2, 2, 2, 9394, 9370, 3, 2, 2, 2, 9394, 9373, 3, 2, 2, 2, 9394, 9376, 3, 2, 2, 2, 9394, 9378, 3, 2, 2, 2, 9395, 9398, 3, 2, 2, 2, 9396, 9394, 3, 2, 2, 2, 9396, 9397, 3, 2, 2, 2, 9397, 1207, 3, 2, 2, 2, 9398, 9396, 3, 2, 2, 2, 9399, 9400, 7, 398, 2, 2, 9400, 9436, 5, 968, 485, 2, 9401, 9404, 7, 37, 2, 2, 9402, 9405, 5, 968, 485, 2, 9403, 9405, 5, 1290, 646, 2, 9404, 9402, 3, 2, 2, 2, 9404, 9403, 3, 2, 2, 2, 9405, 9436, 3, 2, 2, 2, 9406, 9407, 7, 30, 2, 2, 9407, 9436, 5, 1328, 665, 2, 9408, 9409, 7, 472, 2, 2, 9409, 9410, 7, 4, 2, 2, 9410, 9411, 5, 1282, 642, 2, 9411, 9412, 7, 5, 2, 2, 9412, 9436, 3, 2, 2, 2, 9413, 9414, 7, 100, 2, 2, 9414, 9436, 5, 968, 485, 2, 9415, 9436, 5, 1320, 661, 2, 9416, 9436, 5, 1352, 677, 2, 9417, 9436, 5, 1210, 606, 2, 9418, 9419, 7, 4, 2, 2, 9419, 9420, 5, 1166, 584, 2, 9420, 9421, 7, 5, 2, 2, 9421, 9422, 5, 1328, 665, 2, 9422, 9436, 3, 2, 2, 2, 9423, 9436, 5, 1310, 656, 2, 9424, 9436, 5, 1214, 608, 2, 9425, 9427, 5, 968, 485, 2, 9426, 9428, 5, 1326, 664, 2, 9427, 9426, 3, 2, 2, 2, 9427, 9428, 3, 2, 2, 2, 9428, 9436, 3, 2, 2, 2, 9429, 9436, 5, 1266, 634, 2, 9430, 9436, 5, 1268, 635, 2, 9431, 9432, 5, 1264, 633, 2, 9432, 9433, 7, 127, 2, 2, 9433, 9434, 5, 1264, 633, 2, 9434, 9436, 3, 2, 2, 2, 9435, 9399, 3, 2, 2, 2, 9435, 9401, 3, 2, 2, 2, 9435, 9406, 3, 2, 2, 2, 9435, 9408, 3, 2, 2, 2, 9435, 9413, 3, 2, 2, 2, 9435, 9415, 3, 2, 2, 2, 9435, 9416, 3, 2, 2, 2, 9435, 9417, 3, 2, 2, 2, 9435, 9418, 3, 2, 2, 2, 9435, 9423, 3, 2, 2, 2, 9435, 9424, 3, 2, 2, 2, 9435, 9425, 3, 2, 2, 2, 9435, 9429, 3, 2, 2, 2, 9435, 9430, 3, 2, 2, 2, 9435, 9431, 3, 2, 2, 2, 9436, 1209, 3, 2, 2, 2, 9437, 9438, 7, 552, 2, 2, 9438, 1211, 3, 2, 2, 2, 9439, 9440, 5, 1350, 676, 2, 9440, 9462, 7, 4, 2, 2, 9441, 9445, 5, 1284, 643, 2, 9442, 9443, 7, 8, 2, 2, 9443, 9444, 7, 103, 2, 2, 9444, 9446, 5, 1286, 644, 2, 9445, 9442, 3, 2, 2, 2, 9445, 9446, 3, 2, 2, 2, 9446, 9448, 3, 2, 2, 2, 9447, 9449, 5, 1004, 503, 2, 9448, 9447, 3, 2, 2, 2, 9448, 9449, 3, 2, 2, 2, 9449, 9463, 3, 2, 2, 2, 9450, 9451, 7, 103, 2, 2, 9451, 9453, 5, 1286, 644, 2, 9452, 9454, 5, 1004, 503, 2, 9453, 9452, 3, 2, 2, 2, 9453, 9454, 3, 2, 2, 2, 9454, 9463, 3, 2, 2, 2, 9455, 9456, 9, 48, 2, 2, 9456, 9458, 5, 1284, 643, 2, 9457, 9459, 5, 1004, 503, 2, 9458, 9457, 3, 2, 2, 2, 9458, 9459, 3, 2, 2, 2, 9459, 9463, 3, 2, 2, 2, 9460, 9463, 7, 11, 2, 2, 9461, 9463, 3, 2, 2, 2, 9462, 9441, 3, 2, 2, 2, 9462, 9450, 3, 2, 2, 2, 9462, 9455, 3, 2, 2, 2, 9462, 9460, 3, 2, 2, 2, 9462, 9461, 3, 2, 2, 2, 9463, 9464, 3, 2, 2, 2, 9464, 9465, 7, 5, 2, 2, 9465, 1213, 3, 2, 2, 2, 9466, 9468, 5, 1212, 607, 2, 9467, 9469, 5, 1238, 620, 2, 9468, 9467, 3, 2, 2, 2, 9468, 9469, 3, 2, 2, 2, 9469, 9471, 3, 2, 2, 2, 9470, 9472, 5, 1240, 621, 2, 9471, 9470, 3, 2, 2, 2, 9471, 9472, 3, 2, 2, 2, 9472, 9474, 3, 2, 2, 2, 9473, 9475, 5, 1248, 625, 2, 9474, 9473, 3, 2, 2, 2, 9474, 9475, 3, 2, 2, 2, 9475, 9478, 3, 2, 2, 2, 9476, 9478, 5, 1218, 610, 2, 9477, 9466, 3, 2, 2, 2, 9477, 9476, 3, 2, 2, 2, 9478, 1215, 3, 2, 2, 2, 9479, 9482, 5, 1212, 607, 2, 9480, 9482, 5, 1218, 610, 2, 9481, 9479, 3, 2, 2, 2, 9481, 9480, 3, 2, 2, 2, 9482, 1217, 3, 2, 2, 2, 9483, 9484, 7, 110, 2, 2, 9484, 9485, 7, 64, 2, 2, 9485, 9486, 7, 4, 2, 2, 9486, 9487, 5, 1166, 584, 2, 9487, 9488, 7, 5, 2, 2, 9488, 9668, 3, 2, 2, 2, 9489, 9668, 7, 50, 2, 2, 9490, 9495, 7, 52, 2, 2, 9491, 9492, 7, 4, 2, 2, 9492, 9493, 5, 1360, 681, 2, 9493, 9494, 7, 5, 2, 2, 9494, 9496, 3, 2, 2, 2, 9495, 9491, 3, 2, 2, 2, 9495, 9496, 3, 2, 2, 2, 9496, 9668, 3, 2, 2, 2, 9497, 9502, 7, 53, 2, 2, 9498, 9499, 7, 4, 2, 2, 9499, 9500, 5, 1360, 681, 2, 9500, 9501, 7, 5, 2, 2, 9501, 9503, 3, 2, 2, 2, 9502, 9498, 3, 2, 2, 2, 9502, 9503, 3, 2, 2, 2, 9503, 9668, 3, 2, 2, 2, 9504, 9509, 7, 77, 2, 2, 9505, 9506, 7, 4, 2, 2, 9506, 9507, 5, 1360, 681, 2, 9507, 9508, 7, 5, 2, 2, 9508, 9510, 3, 2, 2, 2, 9509, 9505, 3, 2, 2, 2, 9509, 9510, 3, 2, 2, 2, 9510, 9668, 3, 2, 2, 2, 9511, 9516, 7, 78, 2, 2, 9512, 9513, 7, 4, 2, 2, 9513, 9514, 5, 1360, 681, 2, 9514, 9515, 7, 5, 2, 2, 9515, 9517, 3, 2, 2, 2, 9516, 9512, 3, 2, 2, 2, 9516, 9517, 3, 2, 2, 2, 9517, 9668, 3, 2, 2, 2, 9518, 9668, 7, 51, 2, 2, 9519, 9668, 7, 54, 2, 2, 9520, 9668, 7, 91, 2, 2, 9521, 9668, 7, 101, 2, 2, 9522, 9668, 7, 49, 2, 2, 9523, 9668, 7, 113, 2, 2, 9524, 9525, 7, 43, 2, 2, 9525, 9526, 7, 4, 2, 2, 9526, 9527, 5, 1166, 584, 2, 9527, 9528, 7, 38, 2, 2, 9528, 9529, 5, 1122, 562, 2, 9529, 9530, 7, 5, 2, 2, 9530, 9668, 3, 2, 2, 2, 9531, 9532, 7, 399, 2, 2, 9532, 9534, 7, 4, 2, 2, 9533, 9535, 5, 1294, 648, 2, 9534, 9533, 3, 2, 2, 2, 9534, 9535, 3, 2, 2, 2, 9535, 9536, 3, 2, 2, 2, 9536, 9668, 7, 5, 2, 2, 9537, 9538, 7, 491, 2, 2, 9538, 9539, 7, 4, 2, 2, 9539, 9542, 5, 1166, 584, 2, 9540, 9541, 7, 8, 2, 2, 9541, 9543, 5, 1298, 650, 2, 9542, 9540, 3, 2, 2, 2, 9542, 9543, 3, 2, 2, 2, 9543, 9544, 3, 2, 2, 2, 9544, 9545, 7, 5, 2, 2, 9545, 9668, 3, 2, 2, 2, 9546, 9547, 7, 412, 2, 2, 9547, 9548, 7, 4, 2, 2, 9548, 9549, 5, 1300, 651, 2, 9549, 9550, 7, 5, 2, 2, 9550, 9668, 3, 2, 2, 2, 9551, 9552, 7, 413, 2, 2, 9552, 9554, 7, 4, 2, 2, 9553, 9555, 5, 1302, 652, 2, 9554, 9553, 3, 2, 2, 2, 9554, 9555, 3, 2, 2, 2, 9555, 9556, 3, 2, 2, 2, 9556, 9668, 7, 5, 2, 2, 9557, 9558, 7, 419, 2, 2, 9558, 9560, 7, 4, 2, 2, 9559, 9561, 5, 1304, 653, 2, 9560, 9559, 3, 2, 2, 2, 9560, 9561, 3, 2, 2, 2, 9561, 9562, 3, 2, 2, 2, 9562, 9668, 7, 5, 2, 2, 9563, 9564, 7, 422, 2, 2, 9564, 9565, 7, 4, 2, 2, 9565, 9566, 5, 1166, 584, 2, 9566, 9567, 7, 38, 2, 2, 9567, 9568, 5, 1122, 562, 2, 9568, 9569, 7, 5, 2, 2, 9569, 9668, 3, 2, 2, 2, 9570, 9571, 7, 423, 2, 2, 9571, 9573, 7, 4, 2, 2, 9572, 9574, 9, 61, 2, 2, 9573, 9572, 3, 2, 2, 2, 9573, 9574, 3, 2, 2, 2, 9574, 9575, 3, 2, 2, 2, 9575, 9576, 5, 1306, 654, 2, 9576, 9577, 7, 5, 2, 2, 9577, 9668, 3, 2, 2, 2, 9578, 9579, 7, 410, 2, 2, 9579, 9580, 7, 4, 2, 2, 9580, 9581, 5, 1166, 584, 2, 9581, 9582, 7, 8, 2, 2, 9582, 9583, 5, 1166, 584, 2, 9583, 9584, 7, 5, 2, 2, 9584, 9668, 3, 2, 2, 2, 9585, 9586, 7, 395, 2, 2, 9586, 9587, 7, 4, 2, 2, 9587, 9588, 5, 1282, 642, 2, 9588, 9589, 7, 5, 2, 2, 9589, 9668, 3, 2, 2, 2, 9590, 9591, 7, 401, 2, 2, 9591, 9592, 7, 4, 2, 2, 9592, 9593, 5, 1282, 642, 2, 9593, 9594, 7, 5, 2, 2, 9594, 9668, 3, 2, 2, 2, 9595, 9596, 7, 406, 2, 2, 9596, 9597, 7, 4, 2, 2, 9597, 9598, 5, 1282, 642, 2, 9598, 9599, 7, 5, 2, 2, 9599, 9668, 3, 2, 2, 2, 9600, 9601, 7, 427, 2, 2, 9601, 9602, 7, 4, 2, 2, 9602, 9603, 5, 1282, 642, 2, 9603, 9604, 7, 5, 2, 2, 9604, 9668, 3, 2, 2, 2, 9605, 9606, 7, 428, 2, 2, 9606, 9607, 7, 4, 2, 2, 9607, 9608, 7, 268, 2, 2, 9608, 9614, 5, 1392, 697, 2, 9609, 9612, 7, 8, 2, 2, 9610, 9613, 5, 1224, 613, 2, 9611, 9613, 5, 1282, 642, 2, 9612, 9610, 3, 2, 2, 2, 9612, 9611, 3, 2, 2, 2, 9613, 9615, 3, 2, 2, 2, 9614, 9609, 3, 2, 2, 2, 9614, 9615, 3, 2, 2, 2, 9615, 9616, 3, 2, 2, 2, 9616, 9617, 7, 5, 2, 2, 9617, 9668, 3, 2, 2, 2, 9618, 9619, 7, 429, 2, 2, 9619, 9620, 7, 4, 2, 2, 9620, 9621, 5, 1208, 605, 2, 9621, 9622, 5, 1234, 618, 2, 9622, 9623, 7, 5, 2, 2, 9623, 9668, 3, 2, 2, 2, 9624, 9625, 7, 430, 2, 2, 9625, 9626, 7, 4, 2, 2, 9626, 9627, 5, 1226, 614, 2, 9627, 9628, 7, 5, 2, 2, 9628, 9668, 3, 2, 2, 2, 9629, 9630, 7, 431, 2, 2, 9630, 9631, 7, 4, 2, 2, 9631, 9632, 5, 1230, 616, 2, 9632, 9634, 5, 1166, 584, 2, 9633, 9635, 5, 1232, 617, 2, 9634, 9633, 3, 2, 2, 2, 9634, 9635, 3, 2, 2, 2, 9635, 9636, 3, 2, 2, 2, 9636, 9637, 7, 5, 2, 2, 9637, 9668, 3, 2, 2, 2, 9638, 9639, 7, 432, 2, 2, 9639, 9640, 7, 4, 2, 2, 9640, 9641, 7, 268, 2, 2, 9641, 9644, 5, 1392, 697, 2, 9642, 9643, 7, 8, 2, 2, 9643, 9645, 5, 1166, 584, 2, 9644, 9642, 3, 2, 2, 2, 9644, 9645, 3, 2, 2, 2, 9645, 9646, 3, 2, 2, 2, 9646, 9647, 7, 5, 2, 2, 9647, 9668, 3, 2, 2, 2, 9648, 9649, 7, 433, 2, 2, 9649, 9650, 7, 4, 2, 2, 9650, 9651, 7, 385, 2, 2, 9651, 9652, 5, 1166, 584, 2, 9652, 9653, 7, 8, 2, 2, 9653, 9655, 5, 1220, 611, 2, 9654, 9656, 5, 1222, 612, 2, 9655, 9654, 3, 2, 2, 2, 9655, 9656, 3, 2, 2, 2, 9656, 9657, 3, 2, 2, 2, 9657, 9658, 7, 5, 2, 2, 9658, 9668, 3, 2, 2, 2, 9659, 9660, 7, 434, 2, 2, 9660, 9661, 7, 4, 2, 2, 9661, 9662, 5, 1230, 616, 2, 9662, 9663, 5, 1166, 584, 2, 9663, 9664, 7, 38, 2, 2, 9664, 9665, 5, 1126, 564, 2, 9665, 9666, 7, 5, 2, 2, 9666, 9668, 3, 2, 2, 2, 9667, 9483, 3, 2, 2, 2, 9667, 9489, 3, 2, 2, 2, 9667, 9490, 3, 2, 2, 2, 9667, 9497, 3, 2, 2, 2, 9667, 9504, 3, 2, 2, 2, 9667, 9511, 3, 2, 2, 2, 9667, 9518, 3, 2, 2, 2, 9667, 9519, 3, 2, 2, 2, 9667, 9520, 3, 2, 2, 2, 9667, 9521, 3, 2, 2, 2, 9667, 9522, 3, 2, 2, 2, 9667, 9523, 3, 2, 2, 2, 9667, 9524, 3, 2, 2, 2, 9667, 9531, 3, 2, 2, 2, 9667, 9537, 3, 2, 2, 2, 9667, 9546, 3, 2, 2, 2, 9667, 9551, 3, 2, 2, 2, 9667, 9557, 3, 2, 2, 2, 9667, 9563, 3, 2, 2, 2, 9667, 9570, 3, 2, 2, 2, 9667, 9578, 3, 2, 2, 2, 9667, 9585, 3, 2, 2, 2, 9667, 9590, 3, 2, 2, 2, 9667, 9595, 3, 2, 2, 2, 9667, 9600, 3, 2, 2, 2, 9667, 9605, 3, 2, 2, 2, 9667, 9618, 3, 2, 2, 2, 9667, 9624, 3, 2, 2, 2, 9667, 9629, 3, 2, 2, 2, 9667, 9638, 3, 2, 2, 2, 9667, 9648, 3, 2, 2, 2, 9667, 9659, 3, 2, 2, 2, 9668, 1219, 3, 2, 2, 2, 9669, 9670, 7, 377, 2, 2, 9670, 9675, 5, 1166, 584, 2, 9671, 9672, 7, 377, 2, 2, 9672, 9673, 7, 271, 2, 2, 9673, 9675, 7, 452, 2, 2, 9674, 9669, 3, 2, 2, 2, 9674, 9671, 3, 2, 2, 2, 9675, 1221, 3, 2, 2, 2, 9676, 9677, 7, 8, 2, 2, 9677, 9678, 7, 341, 2, 2, 9678, 9687, 7, 387, 2, 2, 9679, 9680, 7, 8, 2, 2, 9680, 9681, 7, 341, 2, 2, 9681, 9687, 7, 271, 2, 2, 9682, 9683, 7, 8, 2, 2, 9683, 9684, 7, 341, 2, 2, 9684, 9685, 7, 271, 2, 2, 9685, 9687, 7, 452, 2, 2, 9686, 9676, 3, 2, 2, 2, 9686, 9679, 3, 2, 2, 2, 9686, 9682, 3, 2, 2, 2, 9687, 1223, 3, 2, 2, 2, 9688, 9689, 7, 426, 2, 2, 9689, 9690, 7, 4, 2, 2, 9690, 9691, 5, 1226, 614, 2, 9691, 9692, 7, 5, 2, 2, 9692, 1225, 3, 2, 2, 2, 9693, 9698, 5, 1228, 615, 2, 9694, 9695, 7, 8, 2, 2, 9695, 9697, 5, 1228, 615, 2, 9696, 9694, 3, 2, 2, 2, 9697, 9700, 3, 2, 2, 2, 9698, 9696, 3, 2, 2, 2, 9698, 9699, 3, 2, 2, 2, 9699, 1227, 3, 2, 2, 2, 9700, 9698, 3, 2, 2, 2, 9701, 9704, 5, 1166, 584, 2, 9702, 9703, 7, 38, 2, 2, 9703, 9705, 5, 1392, 697, 2, 9704, 9702, 3, 2, 2, 2, 9704, 9705, 3, 2, 2, 2, 9705, 1229, 3, 2, 2, 2, 9706, 9707, 9, 62, 2, 2, 9707, 1231, 3, 2, 2, 2, 9708, 9709, 7, 294, 2, 2, 9709, 9713, 7, 380, 2, 2, 9710, 9711, 7, 349, 2, 2, 9711, 9713, 7, 380, 2, 2, 9712, 9708, 3, 2, 2, 2, 9712, 9710, 3, 2, 2, 2, 9713, 1233, 3, 2, 2, 2, 9714, 9715, 7, 288, 2, 2, 9715, 9730, 5, 1208, 605, 2, 9716, 9717, 7, 288, 2, 2, 9717, 9718, 5, 1208, 605, 2, 9718, 9719, 5, 1236, 619, 2, 9719, 9730, 3, 2, 2, 2, 9720, 9721, 7, 288, 2, 2, 9721, 9722, 5, 1236, 619, 2, 9722, 9723, 5, 1208, 605, 2, 9723, 9730, 3, 2, 2, 2, 9724, 9725, 7, 288, 2, 2, 9725, 9726, 5, 1236, 619, 2, 9726, 9727, 5, 1208, 605, 2, 9727, 9728, 5, 1236, 619, 2, 9728, 9730, 3, 2, 2, 2, 9729, 9714, 3, 2, 2, 2, 9729, 9716, 3, 2, 2, 2, 9729, 9720, 3, 2, 2, 2, 9729, 9724, 3, 2, 2, 2, 9730, 1235, 3, 2, 2, 2, 9731, 9732, 7, 149, 2, 2, 9732, 9733, 9, 63, 2, 2, 9733, 1237, 3, 2, 2, 2, 9734, 9735, 7, 481, 2, 2, 9735, 9736, 7, 68, 2, 2, 9736, 9737, 7, 4, 2, 2, 9737, 9738, 5, 1006, 504, 2, 9738, 9739, 7, 5, 2, 2, 9739, 1239, 3, 2, 2, 2, 9740, 9741, 7, 482, 2, 2, 9741, 9742, 7, 4, 2, 2, 9742, 9743, 7, 105, 2, 2, 9743, 9744, 5, 1166, 584, 2, 9744, 9745, 7, 5, 2, 2, 9745, 1241, 3, 2, 2, 2, 9746, 9747, 7, 106, 2, 2, 9747, 9748, 5, 1244, 623, 2, 9748, 1243, 3, 2, 2, 2, 9749, 9754, 5, 1246, 624, 2, 9750, 9751, 7, 8, 2, 2, 9751, 9753, 5, 1246, 624, 2, 9752, 9750, 3, 2, 2, 2, 9753, 9756, 3, 2, 2, 2, 9754, 9752, 3, 2, 2, 2, 9754, 9755, 3, 2, 2, 2, 9755, 1245, 3, 2, 2, 2, 9756, 9754, 3, 2, 2, 2, 9757, 9758, 5, 1378, 690, 2, 9758, 9759, 7, 38, 2, 2, 9759, 9760, 5, 1250, 626, 2, 9760, 1247, 3, 2, 2, 2, 9761, 9764, 7, 126, 2, 2, 9762, 9765, 5, 1250, 626, 2, 9763, 9765, 5, 1378, 690, 2, 9764, 9762, 3, 2, 2, 2, 9764, 9763, 3, 2, 2, 2, 9765, 1249, 3, 2, 2, 2, 9766, 9768, 7, 4, 2, 2, 9767, 9769, 5, 1252, 627, 2, 9768, 9767, 3, 2, 2, 2, 9768, 9769, 3, 2, 2, 2, 9769, 9771, 3, 2, 2, 2, 9770, 9772, 5, 1254, 628, 2, 9771, 9770, 3, 2, 2, 2, 9771, 9772, 3, 2, 2, 2, 9772, 9774, 3, 2, 2, 2, 9773, 9775, 5, 1004, 503, 2, 9774, 9773, 3, 2, 2, 2, 9774, 9775, 3, 2, 2, 2, 9775, 9777, 3, 2, 2, 2, 9776, 9778, 5, 1256, 629, 2, 9777, 9776, 3, 2, 2, 2, 9777, 9778, 3, 2, 2, 2, 9778, 9779, 3, 2, 2, 2, 9779, 9780, 7, 5, 2, 2, 9780, 1251, 3, 2, 2, 2, 9781, 9782, 5, 1378, 690, 2, 9782, 1253, 3, 2, 2, 2, 9783, 9784, 7, 287, 2, 2, 9784, 9785, 7, 149, 2, 2, 9785, 9786, 5, 1282, 642, 2, 9786, 1255, 3, 2, 2, 2, 9787, 9788, 7, 301, 2, 2, 9788, 9790, 5, 1258, 630, 2, 9789, 9791, 5, 1262, 632, 2, 9790, 9789, 3, 2, 2, 2, 9790, 9791, 3, 2, 2, 2, 9791, 9803, 3, 2, 2, 2, 9792, 9793, 7, 322, 2, 2, 9793, 9795, 5, 1258, 630, 2, 9794, 9796, 5, 1262, 632, 2, 9795, 9794, 3, 2, 2, 2, 9795, 9796, 3, 2, 2, 2, 9796, 9803, 3, 2, 2, 2, 9797, 9798, 7, 483, 2, 2, 9798, 9800, 5, 1258, 630, 2, 9799, 9801, 5, 1262, 632, 2, 9800, 9799, 3, 2, 2, 2, 9800, 9801, 3, 2, 2, 2, 9801, 9803, 3, 2, 2, 2, 9802, 9787, 3, 2, 2, 2, 9802, 9792, 3, 2, 2, 2, 9802, 9797, 3, 2, 2, 2, 9803, 1257, 3, 2, 2, 2, 9804, 9811, 5, 1260, 631, 2, 9805, 9806, 7, 389, 2, 2, 9806, 9807, 5, 1260, 631, 2, 9807, 9808, 7, 35, 2, 2, 9808, 9809, 5, 1260, 631, 2, 9809, 9811, 3, 2, 2, 2, 9810, 9804, 3, 2, 2, 2, 9810, 9805, 3, 2, 2, 2, 9811, 1259, 3, 2, 2, 2, 9812, 9813, 7, 364, 2, 2, 9813, 9820, 9, 64, 2, 2, 9814, 9815, 7, 436, 2, 2, 9815, 9820, 7, 416, 2, 2, 9816, 9817, 5, 1166, 584, 2, 9817, 9818, 9, 64, 2, 2, 9818, 9820, 3, 2, 2, 2, 9819, 9812, 3, 2, 2, 2, 9819, 9814, 3, 2, 2, 2, 9819, 9816, 3, 2, 2, 2, 9820, 1261, 3, 2, 2, 2, 9821, 9828, 7, 201, 2, 2, 9822, 9823, 7, 436, 2, 2, 9823, 9829, 7, 416, 2, 2, 9824, 9829, 7, 68, 2, 2, 9825, 9829, 7, 469, 2, 2, 9826, 9827, 7, 271, 2, 2, 9827, 9829, 7, 484, 2, 2, 9828, 9822, 3, 2, 2, 2, 9828, 9824, 3, 2, 2, 2, 9828, 9825, 3, 2, 2, 2, 9828, 9826, 3, 2, 2, 2, 9829, 1263, 3, 2, 2, 2, 9830, 9831, 7, 416, 2, 2, 9831, 9833, 7, 4, 2, 2, 9832, 9834, 5, 1282, 642, 2, 9833, 9832, 3, 2, 2, 2, 9833, 9834, 3, 2, 2, 2, 9834, 9835, 3, 2, 2, 2, 9835, 9843, 7, 5, 2, 2, 9836, 9837, 7, 4, 2, 2, 9837, 9838, 5, 1282, 642, 2, 9838, 9839, 7, 8, 2, 2, 9839, 9840, 5, 1166, 584, 2, 9840, 9841, 7, 5, 2, 2, 9841, 9843, 3, 2, 2, 2, 9842, 9830, 3, 2, 2, 2, 9842, 9836, 3, 2, 2, 2, 9843, 1265, 3, 2, 2, 2, 9844, 9845, 7, 416, 2, 2, 9845, 9847, 7, 4, 2, 2, 9846, 9848, 5, 1282, 642, 2, 9847, 9846, 3, 2, 2, 2, 9847, 9848, 3, 2, 2, 2, 9848, 9849, 3, 2, 2, 2, 9849, 9850, 7, 5, 2, 2, 9850, 1267, 3, 2, 2, 2, 9851, 9852, 7, 4, 2, 2, 9852, 9853, 5, 1282, 642, 2, 9853, 9854, 7, 8, 2, 2, 9854, 9855, 5, 1166, 584, 2, 9855, 9856, 7, 5, 2, 2, 9856, 1269, 3, 2, 2, 2, 9857, 9858, 9, 65, 2, 2, 9858, 1271, 3, 2, 2, 2, 9859, 9862, 7, 31, 2, 2, 9860, 9862, 5, 1274, 638, 2, 9861, 9859, 3, 2, 2, 2, 9861, 9860, 3, 2, 2, 2, 9862, 1273, 3, 2, 2, 2, 9863, 9864, 9, 66, 2, 2, 9864, 1275, 3, 2, 2, 2, 9865, 9872, 7, 31, 2, 2, 9866, 9867, 7, 280, 2, 2, 9867, 9868, 7, 4, 2, 2, 9868, 9869, 5, 698, 350, 2, 9869, 9870, 7, 5, 2, 2, 9870, 9872, 3, 2, 2, 2, 9871, 9865, 3, 2, 2, 2, 9871, 9866, 3, 2, 2, 2, 9872, 1277, 3, 2, 2, 2, 9873, 9880, 5, 1272, 637, 2, 9874, 9875, 7, 280, 2, 2, 9875, 9876, 7, 4, 2, 2, 9876, 9877, 5, 698, 350, 2, 9877, 9878, 7, 5, 2, 2, 9878, 9880, 3, 2, 2, 2, 9879, 9873, 3, 2, 2, 2, 9879, 9874, 3, 2, 2, 2, 9880, 1279, 3, 2, 2, 2, 9881, 9894, 5, 1272, 637, 2, 9882, 9883, 7, 280, 2, 2, 9883, 9884, 7, 4, 2, 2, 9884, 9885, 5, 698, 350, 2, 9885, 9886, 7, 5, 2, 2, 9886, 9894, 3, 2, 2, 2, 9887, 9894, 7, 122, 2, 2, 9888, 9889, 7, 79, 2, 2, 9889, 9894, 7, 122, 2, 2, 9890, 9894, 7, 116, 2, 2, 9891, 9892, 7, 79, 2, 2, 9892, 9894, 7, 116, 2, 2, 9893, 9881, 3, 2, 2, 2, 9893, 9882, 3, 2, 2, 2, 9893, 9887, 3, 2, 2, 2, 9893, 9888, 3, 2, 2, 2, 9893, 9890, 3, 2, 2, 2, 9893, 9891, 3, 2, 2, 2, 9894, 1281, 3, 2, 2, 2, 9895, 9900, 5, 1166, 584, 2, 9896, 9897, 7, 8, 2, 2, 9897, 9899, 5, 1166, 584, 2, 9898, 9896, 3, 2, 2, 2, 9899, 9902, 3, 2, 2, 2, 9900, 9898, 3, 2, 2, 2, 9900, 9901, 3, 2, 2, 2, 9901, 1283, 3, 2, 2, 2, 9902, 9900, 3, 2, 2, 2, 9903, 9908, 5, 1286, 644, 2, 9904, 9905, 7, 8, 2, 2, 9905, 9907, 5, 1286, 644, 2, 9906, 9904, 3, 2, 2, 2, 9907, 9910, 3, 2, 2, 2, 9908, 9906, 3, 2, 2, 2, 9908, 9909, 3, 2, 2, 2, 9909, 1285, 3, 2, 2, 2, 9910, 9908, 3, 2, 2, 2, 9911, 9917, 5, 1166, 584, 2, 9912, 9913, 5, 650, 326, 2, 9913, 9914, 9, 67, 2, 2, 9914, 9915, 5, 1166, 584, 2, 9915, 9917, 3, 2, 2, 2, 9916, 9911, 3, 2, 2, 2, 9916, 9912, 3, 2, 2, 2, 9917, 1287, 3, 2, 2, 2, 9918, 9923, 5, 1122, 562, 2, 9919, 9920, 7, 8, 2, 2, 9920, 9922, 5, 1122, 562, 2, 9921, 9919, 3, 2, 2, 2, 9922, 9925, 3, 2, 2, 2, 9923, 9921, 3, 2, 2, 2, 9923, 9924, 3, 2, 2, 2, 9924, 1289, 3, 2, 2, 2, 9925, 9923, 3, 2, 2, 2, 9926, 9929, 7, 6, 2, 2, 9927, 9930, 5, 1282, 642, 2, 9928, 9930, 5, 1292, 647, 2, 9929, 9927, 3, 2, 2, 2, 9929, 9928, 3, 2, 2, 2, 9929, 9930, 3, 2, 2, 2, 9930, 9931, 3, 2, 2, 2, 9931, 9932, 7, 7, 2, 2, 9932, 1291, 3, 2, 2, 2, 9933, 9938, 5, 1290, 646, 2, 9934, 9935, 7, 8, 2, 2, 9935, 9937, 5, 1290, 646, 2, 9936, 9934, 3, 2, 2, 2, 9937, 9940, 3, 2, 2, 2, 9938, 9936, 3, 2, 2, 2, 9938, 9939, 3, 2, 2, 2, 9939, 1293, 3, 2, 2, 2, 9940, 9938, 3, 2, 2, 2, 9941, 9942, 5, 1296, 649, 2, 9942, 9943, 7, 66, 2, 2, 9943, 9944, 5, 1166, 584, 2, 9944, 1295, 3, 2, 2, 2, 9945, 9954, 5, 1394, 698, 2, 9946, 9954, 7, 386, 2, 2, 9947, 9954, 7, 266, 2, 2, 9948, 9954, 7, 178, 2, 2, 9949, 9954, 7, 220, 2, 2, 9950, 9954, 7, 263, 2, 2, 9951, 9954, 7, 328, 2, 2, 9952, 9954, 5, 1362, 682, 2, 9953, 9945, 3, 2, 2, 2, 9953, 9946, 3, 2, 2, 2, 9953, 9947, 3, 2, 2, 2, 9953, 9948, 3, 2, 2, 2, 9953, 9949, 3, 2, 2, 2, 9953, 9950, 3, 2, 2, 2, 9953, 9951, 3, 2, 2, 2, 9953, 9952, 3, 2, 2, 2, 9954, 1297, 3, 2, 2, 2, 9955, 9956, 9, 68, 2, 2, 9956, 1299, 3, 2, 2, 2, 9957, 9958, 5, 1166, 584, 2, 9958, 9959, 7, 86, 2, 2, 9959, 9960, 5, 1166, 584, 2, 9960, 9961, 7, 66, 2, 2, 9961, 9964, 5, 1166, 584, 2, 9962, 9963, 7, 64, 2, 2, 9963, 9965, 5, 1166, 584, 2, 9964, 9962, 3, 2, 2, 2, 9964, 9965, 3, 2, 2, 2, 9965, 1301, 3, 2, 2, 2, 9966, 9967, 5, 1206, 604, 2, 9967, 9968, 7, 70, 2, 2, 9968, 9969, 5, 1206, 604, 2, 9969, 1303, 3, 2, 2, 2, 9970, 9971, 5, 1166, 584, 2, 9971, 9972, 7, 66, 2, 2, 9972, 9973, 5, 1166, 584, 2, 9973, 9974, 7, 64, 2, 2, 9974, 9975, 5, 1166, 584, 2, 9975, 9998, 3, 2, 2, 2, 9976, 9977, 5, 1166, 584, 2, 9977, 9978, 7, 64, 2, 2, 9978, 9979, 5, 1166, 584, 2, 9979, 9980, 7, 66, 2, 2, 9980, 9981, 5, 1166, 584, 2, 9981, 9998, 3, 2, 2, 2, 9982, 9983, 5, 1166, 584, 2, 9983, 9984, 7, 66, 2, 2, 9984, 9985, 5, 1166, 584, 2, 9985, 9998, 3, 2, 2, 2, 9986, 9987, 5, 1166, 584, 2, 9987, 9988, 7, 64, 2, 2, 9988, 9989, 5, 1166, 584, 2, 9989, 9998, 3, 2, 2, 2, 9990, 9991, 5, 1166, 584, 2, 9991, 9992, 7, 129, 2, 2, 9992, 9993, 5, 1166, 584, 2, 9993, 9994, 7, 199, 2, 2, 9994, 9995, 5, 1166, 584, 2, 9995, 9998, 3, 2, 2, 2, 9996, 9998, 5, 1282, 642, 2, 9997, 9970, 3, 2, 2, 2, 9997, 9976, 3, 2, 2, 2, 9997, 9982, 3, 2, 2, 2, 9997, 9986, 3, 2, 2, 2, 9997, 9990, 3, 2, 2, 2, 9997, 9996, 3, 2, 2, 2, 9998, 1305, 3, 2, 2, 2, 9999, 10000, 5, 1166, 584, 2, 10000, 10001, 7, 66, 2, 2, 10001, 10002, 5, 1282, 642, 2, 10002, 10007, 3, 2, 2, 2, 10003, 10004, 7, 66, 2, 2, 10004, 10007, 5, 1282, 642, 2, 10005, 10007, 5, 1282, 642, 2, 10006, 9999, 3, 2, 2, 2, 10006, 10003, 3, 2, 2, 2, 10006, 10005, 3, 2, 2, 2, 10007, 1307, 3, 2, 2, 2, 10008, 10014, 5, 968, 485, 2, 10009, 10010, 7, 4, 2, 2, 10010, 10011, 5, 1282, 642, 2, 10011, 10012, 7, 5, 2, 2, 10012, 10014, 3, 2, 2, 2, 10013, 10008, 3, 2, 2, 2, 10013, 10009, 3, 2, 2, 2, 10014, 1309, 3, 2, 2, 2, 10015, 10017, 7, 42, 2, 2, 10016, 10018, 5, 1318, 660, 2, 10017, 10016, 3, 2, 2, 2, 10017, 10018, 3, 2, 2, 2, 10018, 10019, 3, 2, 2, 2, 10019, 10021, 5, 1312, 657, 2, 10020, 10022, 5, 1316, 659, 2, 10021, 10020, 3, 2, 2, 2, 10021, 10022, 3, 2, 2, 2, 10022, 10023, 3, 2, 2, 2, 10023, 10024, 7, 456, 2, 2, 10024, 1311, 3, 2, 2, 2, 10025, 10027, 5, 1314, 658, 2, 10026, 10025, 3, 2, 2, 2, 10027, 10028, 3, 2, 2, 2, 10028, 10026, 3, 2, 2, 2, 10028, 10029, 3, 2, 2, 2, 10029, 1313, 3, 2, 2, 2, 10030, 10031, 7, 104, 2, 2, 10031, 10032, 5, 1166, 584, 2, 10032, 10033, 7, 95, 2, 2, 10033, 10034, 5, 1166, 584, 2, 10034, 1315, 3, 2, 2, 2, 10035, 10036, 7, 60, 2, 2, 10036, 10037, 5, 1166, 584, 2, 10037, 1317, 3, 2, 2, 2, 10038, 10039, 5, 1166, 584, 2, 10039, 1319, 3, 2, 2, 2, 10040, 10042, 5, 1378, 690, 2, 10041, 10043, 5, 1326, 664, 2, 10042, 10041, 3, 2, 2, 2, 10042, 10043, 3, 2, 2, 2, 10043, 1321, 3, 2, 2, 2, 10044, 10047, 7, 13, 2, 2, 10045, 10048, 5, 1346, 674, 2, 10046, 10048, 7, 11, 2, 2, 10047, 10045, 3, 2, 2, 2, 10047, 10046, 3, 2, 2, 2, 10048, 10062, 3, 2, 2, 2, 10049, 10058, 7, 6, 2, 2, 10050, 10059, 5, 1166, 584, 2, 10051, 10053, 5, 1324, 663, 2, 10052, 10051, 3, 2, 2, 2, 10052, 10053, 3, 2, 2, 2, 10053, 10054, 3, 2, 2, 2, 10054, 10056, 7, 10, 2, 2, 10055, 10057, 5, 1324, 663, 2, 10056, 10055, 3, 2, 2, 2, 10056, 10057, 3, 2, 2, 2, 10057, 10059, 3, 2, 2, 2, 10058, 10050, 3, 2, 2, 2, 10058, 10052, 3, 2, 2, 2, 10059, 10060, 3, 2, 2, 2, 10060, 10062, 7, 7, 2, 2, 10061, 10044, 3, 2, 2, 2, 10061, 10049, 3, 2, 2, 2, 10062, 1323, 3, 2, 2, 2, 10063, 10064, 5, 1166, 584, 2, 10064, 1325, 3, 2, 2, 2, 10065, 10067, 5, 1322, 662, 2, 10066, 10065, 3, 2, 2, 2, 10067, 10068, 3, 2, 2, 2, 10068, 10066, 3, 2, 2, 2, 10068, 10069, 3, 2, 2, 2, 10069, 1327, 3, 2, 2, 2, 10070, 10072, 5, 1322, 662, 2, 10071, 10070, 3, 2, 2, 2, 10072, 10075, 3, 2, 2, 2, 10073, 10071, 3, 2, 2, 2, 10073, 10074, 3, 2, 2, 2, 10074, 1329, 3, 2, 2, 2, 10075, 10073, 3, 2, 2, 2, 10076, 10077, 5, 1332, 667, 2, 10077, 1331, 3, 2, 2, 2, 10078, 10083, 5, 1334, 668, 2, 10079, 10080, 7, 8, 2, 2, 10080, 10082, 5, 1334, 668, 2, 10081, 10079, 3, 2, 2, 2, 10082, 10085, 3, 2, 2, 2, 10083, 10081, 3, 2, 2, 2, 10083, 10084, 3, 2, 2, 2, 10084, 1333, 3, 2, 2, 2, 10085, 10083, 3, 2, 2, 2, 10086, 10091, 5, 1166, 584, 2, 10087, 10088, 7, 38, 2, 2, 10088, 10092, 5, 1392, 697, 2, 10089, 10092, 5, 1394, 698, 2, 10090, 10092, 3, 2, 2, 2, 10091, 10087, 3, 2, 2, 2, 10091, 10089, 3, 2, 2, 2, 10091, 10090, 3, 2, 2, 2, 10092, 10095, 3, 2, 2, 2, 10093, 10095, 7, 11, 2, 2, 10094, 10086, 3, 2, 2, 2, 10094, 10093, 3, 2, 2, 2, 10095, 1335, 3, 2, 2, 2, 10096, 10101, 5, 1340, 671, 2, 10097, 10098, 7, 8, 2, 2, 10098, 10100, 5, 1340, 671, 2, 10099, 10097, 3, 2, 2, 2, 10100, 10103, 3, 2, 2, 2, 10101, 10099, 3, 2, 2, 2, 10101, 10102, 3, 2, 2, 2, 10102, 1337, 3, 2, 2, 2, 10103, 10101, 3, 2, 2, 2, 10104, 10106, 5, 1378, 690, 2, 10105, 10107, 5, 1326, 664, 2, 10106, 10105, 3, 2, 2, 2, 10106, 10107, 3, 2, 2, 2, 10107, 1339, 3, 2, 2, 2, 10108, 10110, 5, 1378, 690, 2, 10109, 10111, 5, 1326, 664, 2, 10110, 10109, 3, 2, 2, 2, 10110, 10111, 3, 2, 2, 2, 10111, 1341, 3, 2, 2, 2, 10112, 10117, 5, 1344, 673, 2, 10113, 10114, 7, 8, 2, 2, 10114, 10116, 5, 1344, 673, 2, 10115, 10113, 3, 2, 2, 2, 10116, 10119, 3, 2, 2, 2, 10117, 10115, 3, 2, 2, 2, 10117, 10118, 3, 2, 2, 2, 10118, 1343, 3, 2, 2, 2, 10119, 10117, 3, 2, 2, 2, 10120, 10121, 5, 1378, 690, 2, 10121, 1345, 3, 2, 2, 2, 10122, 10123, 5, 1392, 697, 2, 10123, 1347, 3, 2, 2, 2, 10124, 10125, 5, 1362, 682, 2, 10125, 1349, 3, 2, 2, 2, 10126, 10131, 5, 1388, 695, 2, 10127, 10128, 5, 1378, 690, 2, 10128, 10129, 5, 1326, 664, 2, 10129, 10131, 3, 2, 2, 2, 10130, 10126, 3, 2, 2, 2, 10130, 10127, 3, 2, 2, 2, 10131, 1351, 3, 2, 2, 2, 10132, 10168, 5, 1360, 681, 2, 10133, 10168, 5, 1358, 680, 2, 10134, 10168, 5, 1362, 682, 2, 10135, 10168, 5, 1356, 679, 2, 10136, 10168, 5, 1354, 678, 2, 10137, 10147, 5, 1350, 676, 2, 10138, 10148, 5, 1362, 682, 2, 10139, 10140, 7, 4, 2, 2, 10140, 10142, 5, 1284, 643, 2, 10141, 10143, 5, 1004, 503, 2, 10142, 10141, 3, 2, 2, 2, 10142, 10143, 3, 2, 2, 2, 10143, 10144, 3, 2, 2, 2, 10144, 10145, 7, 5, 2, 2, 10145, 10146, 5, 1362, 682, 2, 10146, 10148, 3, 2, 2, 2, 10147, 10138, 3, 2, 2, 2, 10147, 10139, 3, 2, 2, 2, 10148, 10168, 3, 2, 2, 2, 10149, 10150, 5, 1128, 565, 2, 10150, 10151, 5, 1362, 682, 2, 10151, 10168, 3, 2, 2, 2, 10152, 10162, 5, 1156, 579, 2, 10153, 10155, 5, 1362, 682, 2, 10154, 10156, 5, 1160, 581, 2, 10155, 10154, 3, 2, 2, 2, 10155, 10156, 3, 2, 2, 2, 10156, 10163, 3, 2, 2, 2, 10157, 10158, 7, 4, 2, 2, 10158, 10159, 5, 1360, 681, 2, 10159, 10160, 7, 5, 2, 2, 10160, 10161, 5, 1362, 682, 2, 10161, 10163, 3, 2, 2, 2, 10162, 10153, 3, 2, 2, 2, 10162, 10157, 3, 2, 2, 2, 10163, 10168, 3, 2, 2, 2, 10164, 10168, 7, 98, 2, 2, 10165, 10168, 7, 62, 2, 2, 10166, 10168, 7, 80, 2, 2, 10167, 10132, 3, 2, 2, 2, 10167, 10133, 3, 2, 2, 2, 10167, 10134, 3, 2, 2, 2, 10167, 10135, 3, 2, 2, 2, 10167, 10136, 3, 2, 2, 2, 10167, 10137, 3, 2, 2, 2, 10167, 10149, 3, 2, 2, 2, 10167, 10152, 3, 2, 2, 2, 10167, 10164, 3, 2, 2, 2, 10167, 10165, 3, 2, 2, 2, 10167, 10166, 3, 2, 2, 2, 10168, 1353, 3, 2, 2, 2, 10169, 10170, 7, 545, 2, 2, 10170, 1355, 3, 2, 2, 2, 10171, 10172, 7, 541, 2, 2, 10172, 1357, 3, 2, 2, 2, 10173, 10174, 7, 551, 2, 2, 10174, 1359, 3, 2, 2, 2, 10175, 10176, 7, 549, 2, 2, 10176, 1361, 3, 2, 2, 2, 10177, 10179, 5, 1364, 683, 2, 10178, 10180, 5, 1366, 684, 2, 10179, 10178, 3, 2, 2, 2, 10179, 10180, 3, 2, 2, 2, 10180, 1363, 3, 2, 2, 2, 10181, 10193, 7, 536, 2, 2, 10182, 10193, 7, 538, 2, 2, 10183, 10187, 7, 540, 2, 2, 10184, 10186, 7, 566, 2, 2, 10185, 10184, 3, 2, 2, 2, 10186, 10189, 3, 2, 2, 2, 10187, 10185, 3, 2, 2, 2, 10187, 10188, 3, 2, 2, 2, 10188, 10190, 3, 2, 2, 2, 10189, 10187, 3, 2, 2, 2, 10190, 10193, 7, 567, 2, 2, 10191, 10193, 7, 562, 2, 2, 10192, 10181, 3, 2, 2, 2, 10192, 10182, 3, 2, 2, 2, 10192, 10183, 3, 2, 2, 2, 10192, 10191, 3, 2, 2, 2, 10193, 1365, 3, 2, 2, 2, 10194, 10195, 7, 489, 2, 2, 10195, 10196, 5, 1364, 683, 2, 10196, 1367, 3, 2, 2, 2, 10197, 10203, 5, 1360, 681, 2, 10198, 10199, 7, 14, 2, 2, 10199, 10203, 5, 1360, 681, 2, 10200, 10201, 7, 15, 2, 2, 10201, 10203, 5, 1360, 681, 2, 10202, 10197, 3, 2, 2, 2, 10202, 10198, 3, 2, 2, 2, 10202, 10200, 3, 2, 2, 2, 10203, 1369, 3, 2, 2, 2, 10204, 10205, 5, 1374, 688, 2, 10205, 1371, 3, 2, 2, 2, 10206, 10207, 5, 1374, 688, 2, 10207, 1373, 3, 2, 2, 2, 10208, 10213, 5, 1390, 696, 2, 10209, 10213, 7, 54, 2, 2, 10210, 10213, 7, 91, 2, 2, 10211, 10213, 7, 526, 2, 2, 10212, 10208, 3, 2, 2, 2, 10212, 10209, 3, 2, 2, 2, 10212, 10210, 3, 2, 2, 2, 10212, 10211, 3, 2, 2, 2, 10213, 1375, 3, 2, 2, 2, 10214, 10219, 5, 1374, 688, 2, 10215, 10216, 7, 8, 2, 2, 10216, 10218, 5, 1374, 688, 2, 10217, 10215, 3, 2, 2, 2, 10218, 10221, 3, 2, 2, 2, 10219, 10217, 3, 2, 2, 2, 10219, 10220, 3, 2, 2, 2, 10220, 1377, 3, 2, 2, 2, 10221, 10219, 3, 2, 2, 2, 10222, 10227, 5, 1394, 698, 2, 10223, 10227, 5, 1398, 700, 2, 10224, 10227, 5, 1400, 701, 2, 10225, 10227, 5, 1618, 810, 2, 10226, 10222, 3, 2, 2, 2, 10226, 10223, 3, 2, 2, 2, 10226, 10224, 3, 2, 2, 2, 10226, 10225, 3, 2, 2, 2, 10227, 1379, 3, 2, 2, 2, 10228, 10229, 5, 1394, 698, 2, 10229, 1381, 3, 2, 2, 2, 10230, 10243, 5, 678, 340, 2, 10231, 10232, 7, 4, 2, 2, 10232, 10233, 5, 1166, 584, 2, 10233, 10234, 7, 5, 2, 2, 10234, 10235, 3, 2, 2, 2, 10235, 10237, 5, 1394, 698, 2, 10236, 10238, 5, 624, 313, 2, 10237, 10236, 3, 2, 2, 2, 10237, 10238, 3, 2, 2, 2, 10238, 10240, 3, 2, 2, 2, 10239, 10241, 5, 626, 314, 2, 10240, 10239, 3, 2, 2, 2, 10240, 10241, 3, 2, 2, 2, 10241, 10243, 3, 2, 2, 2, 10242, 10230, 3, 2, 2, 2, 10242, 10231, 3, 2, 2, 2, 10243, 1383, 3, 2, 2, 2, 10244, 10245, 7, 107, 2, 2, 10245, 10247, 5, 116, 59, 2, 10246, 10244, 3, 2, 2, 2, 10246, 10247, 3, 2, 2, 2, 10247, 10249, 3, 2, 2, 2, 10248, 10250, 5, 260, 131, 2, 10249, 10248, 3, 2, 2, 2, 10249, 10250, 3, 2, 2, 2, 10250, 1385, 3, 2, 2, 2, 10251, 10252, 7, 105, 2, 2, 10252, 10253, 5, 1394, 698, 2, 10253, 1387, 3, 2, 2, 2, 10254, 10259, 5, 1394, 698, 2, 10255, 10259, 5, 1398, 700, 2, 10256, 10259, 5, 1618, 810, 2, 10257, 10259, 5, 1402, 702, 2, 10258, 10254, 3, 2, 2, 2, 10258, 10255, 3, 2, 2, 2, 10258, 10256, 3, 2, 2, 2, 10258, 10257, 3, 2, 2, 2, 10259, 1389, 3, 2, 2, 2, 10260, 10265, 5, 1394, 698, 2, 10261, 10265, 5, 1398, 700, 2, 10262, 10265, 5, 1400, 701, 2, 10263, 10265, 5, 1402, 702, 2, 10264, 10260, 3, 2, 2, 2, 10264, 10261, 3, 2, 2, 2, 10264, 10262, 3, 2, 2, 2, 10264, 10263, 3, 2, 2, 2, 10265, 1391, 3, 2, 2, 2, 10266, 10273, 5, 1394, 698, 2, 10267, 10273, 5, 1618, 810, 2, 10268, 10273, 5, 1398, 700, 2, 10269, 10273, 5, 1400, 701, 2, 10270, 10273, 5, 1402, 702, 2, 10271, 10273, 5, 1404, 703, 2, 10272, 10266, 3, 2, 2, 2, 10272, 10267, 3, 2, 2, 2, 10272, 10268, 3, 2, 2, 2, 10272, 10269, 3, 2, 2, 2, 10272, 10270, 3, 2, 2, 2, 10272, 10271, 3, 2, 2, 2, 10273, 1393, 3, 2, 2, 2, 10274, 10276, 7, 527, 2, 2, 10275, 10277, 5, 1366, 684, 2, 10276, 10275, 3, 2, 2, 2, 10276, 10277, 3, 2, 2, 2, 10277, 10284, 3, 2, 2, 2, 10278, 10284, 7, 528, 2, 2, 10279, 10284, 7, 532, 2, 2, 10280, 10284, 5, 1210, 606, 2, 10281, 10284, 5, 1396, 699, 2, 10282, 10284, 5, 1618, 810, 2, 10283, 10274, 3, 2, 2, 2, 10283, 10278, 3, 2, 2, 2, 10283, 10279, 3, 2, 2, 2, 10283, 10280, 3, 2, 2, 2, 10283, 10281, 3, 2, 2, 2, 10283, 10282, 3, 2, 2, 2, 10284, 1395, 3, 2, 2, 2, 10285, 10286, 7, 553, 2, 2, 10286, 1397, 3, 2, 2, 2, 10287, 10288, 9, 69, 2, 2, 10288, 1399, 3, 2, 2, 2, 10289, 10341, 7, 389, 2, 2, 10290, 10341, 7, 390, 2, 2, 10291, 10341, 5, 1138, 570, 2, 10292, 10341, 7, 392, 2, 2, 10293, 10341, 7, 393, 2, 2, 10294, 10341, 5, 1146, 574, 2, 10295, 10341, 7, 395, 2, 2, 10296, 10341, 7, 396, 2, 2, 10297, 10341, 7, 397, 2, 2, 10298, 10341, 7, 398, 2, 2, 10299, 10341, 7, 399, 2, 2, 10300, 10341, 7, 400, 2, 2, 10301, 10341, 7, 401, 2, 2, 10302, 10341, 7, 472, 2, 2, 10303, 10341, 7, 402, 2, 2, 10304, 10341, 7, 403, 2, 2, 10305, 10341, 7, 404, 2, 2, 10306, 10341, 7, 405, 2, 2, 10307, 10341, 7, 406, 2, 2, 10308, 10341, 7, 407, 2, 2, 10309, 10341, 7, 408, 2, 2, 10310, 10341, 7, 409, 2, 2, 10311, 10341, 7, 491, 2, 2, 10312, 10341, 7, 410, 2, 2, 10313, 10341, 5, 1134, 568, 2, 10314, 10341, 7, 455, 2, 2, 10315, 10341, 7, 412, 2, 2, 10316, 10341, 7, 413, 2, 2, 10317, 10341, 7, 414, 2, 2, 10318, 10341, 7, 415, 2, 2, 10319, 10341, 7, 416, 2, 2, 10320, 10341, 7, 417, 2, 2, 10321, 10341, 7, 418, 2, 2, 10322, 10341, 7, 419, 2, 2, 10323, 10341, 7, 420, 2, 2, 10324, 10341, 7, 421, 2, 2, 10325, 10341, 7, 422, 2, 2, 10326, 10341, 7, 423, 2, 2, 10327, 10341, 7, 424, 2, 2, 10328, 10341, 7, 425, 2, 2, 10329, 10341, 7, 426, 2, 2, 10330, 10341, 7, 427, 2, 2, 10331, 10341, 7, 428, 2, 2, 10332, 10341, 7, 429, 2, 2, 10333, 10341, 7, 430, 2, 2, 10334, 10341, 7, 478, 2, 2, 10335, 10341, 7, 431, 2, 2, 10336, 10341, 7, 432, 2, 2, 10337, 10341, 7, 433, 2, 2, 10338, 10341, 7, 434, 2, 2, 10339, 10341, 7, 476, 2, 2, 10340, 10289, 3, 2, 2, 2, 10340, 10290, 3, 2, 2, 2, 10340, 10291, 3, 2, 2, 2, 10340, 10292, 3, 2, 2, 2, 10340, 10293, 3, 2, 2, 2, 10340, 10294, 3, 2, 2, 2, 10340, 10295, 3, 2, 2, 2, 10340, 10296, 3, 2, 2, 2, 10340, 10297, 3, 2, 2, 2, 10340, 10298, 3, 2, 2, 2, 10340, 10299, 3, 2, 2, 2, 10340, 10300, 3, 2, 2, 2, 10340, 10301, 3, 2, 2, 2, 10340, 10302, 3, 2, 2, 2, 10340, 10303, 3, 2, 2, 2, 10340, 10304, 3, 2, 2, 2, 10340, 10305, 3, 2, 2, 2, 10340, 10306, 3, 2, 2, 2, 10340, 10307, 3, 2, 2, 2, 10340, 10308, 3, 2, 2, 2, 10340, 10309, 3, 2, 2, 2, 10340, 10310, 3, 2, 2, 2, 10340, 10311, 3, 2, 2, 2, 10340, 10312, 3, 2, 2, 2, 10340, 10313, 3, 2, 2, 2, 10340, 10314, 3, 2, 2, 2, 10340, 10315, 3, 2, 2, 2, 10340, 10316, 3, 2, 2, 2, 10340, 10317, 3, 2, 2, 2, 10340, 10318, 3, 2, 2, 2, 10340, 10319, 3, 2, 2, 2, 10340, 10320, 3, 2, 2, 2, 10340, 10321, 3, 2, 2, 2, 10340, 10322, 3, 2, 2, 2, 10340, 10323, 3, 2, 2, 2, 10340, 10324, 3, 2, 2, 2, 10340, 10325, 3, 2, 2, 2, 10340, 10326, 3, 2, 2, 2, 10340, 10327, 3, 2, 2, 2, 10340, 10328, 3, 2, 2, 2, 10340, 10329, 3, 2, 2, 2, 10340, 10330, 3, 2, 2, 2, 10340, 10331, 3, 2, 2, 2, 10340, 10332, 3, 2, 2, 2, 10340, 10333, 3, 2, 2, 2, 10340, 10334, 3, 2, 2, 2, 10340, 10335, 3, 2, 2, 2, 10340, 10336, 3, 2, 2, 2, 10340, 10337, 3, 2, 2, 2, 10340, 10338, 3, 2, 2, 2, 10340, 10339, 3, 2, 2, 2, 10341, 1401, 3, 2, 2, 2, 10342, 10343, 9, 70, 2, 2, 10343, 1403, 3, 2, 2, 2, 10344, 10345, 9, 71, 2, 2, 10345, 1405, 3, 2, 2, 2, 10346, 10347, 5, 1408, 705, 2, 10347, 10348, 5, 1418, 710, 2, 10348, 10349, 5, 1416, 709, 2, 10349, 1407, 3, 2, 2, 2, 10350, 10352, 5, 1410, 706, 2, 10351, 10350, 3, 2, 2, 2, 10352, 10355, 3, 2, 2, 2, 10353, 10351, 3, 2, 2, 2, 10353, 10354, 3, 2, 2, 2, 10354, 1409, 3, 2, 2, 2, 10355, 10353, 3, 2, 2, 2, 10356, 10357, 5, 1412, 707, 2, 10357, 10358, 7, 281, 2, 2, 10358, 10359, 7, 492, 2, 2, 10359, 10377, 3, 2, 2, 2, 10360, 10361, 5, 1412, 707, 2, 10361, 10362, 7, 493, 2, 2, 10362, 10363, 5, 1414, 708, 2, 10363, 10377, 3, 2, 2, 2, 10364, 10365, 5, 1412, 707, 2, 10365, 10366, 7, 494, 2, 2, 10366, 10367, 7, 495, 2, 2, 10367, 10377, 3, 2, 2, 2, 10368, 10369, 5, 1412, 707, 2, 10369, 10370, 7, 494, 2, 2, 10370, 10371, 7, 496, 2, 2, 10371, 10377, 3, 2, 2, 2, 10372, 10373, 5, 1412, 707, 2, 10373, 10374, 7, 494, 2, 2, 10374, 10375, 7, 497, 2, 2, 10375, 10377, 3, 2, 2, 2, 10376, 10356, 3, 2, 2, 2, 10376, 10360, 3, 2, 2, 2, 10376, 10364, 3, 2, 2, 2, 10376, 10368, 3, 2, 2, 2, 10376, 10372, 3, 2, 2, 2, 10377, 1411, 3, 2, 2, 2, 10378, 10379, 7, 31, 2, 2, 10379, 1413, 3, 2, 2, 2, 10380, 10385, 5, 1362, 682, 2, 10381, 10385, 5, 1404, 703, 2, 10382, 10385, 5, 1618, 810, 2, 10383, 10385, 5, 1398, 700, 2, 10384, 10380, 3, 2, 2, 2, 10384, 10381, 3, 2, 2, 2, 10384, 10382, 3, 2, 2, 2, 10384, 10383, 3, 2, 2, 2, 10385, 1415, 3, 2, 2, 2, 10386, 10389, 3, 2, 2, 2, 10387, 10389, 7, 9, 2, 2, 10388, 10386, 3, 2, 2, 2, 10388, 10387, 3, 2, 2, 2, 10389, 1417, 3, 2, 2, 2, 10390, 10391, 5, 1420, 711, 2, 10391, 10392, 7, 148, 2, 2, 10392, 10393, 5, 1462, 732, 2, 10393, 10394, 5, 1598, 800, 2, 10394, 10395, 7, 456, 2, 2, 10395, 10396, 5, 1612, 807, 2, 10396, 1419, 3, 2, 2, 2, 10397, 10402, 5, 1608, 805, 2, 10398, 10400, 5, 1422, 712, 2, 10399, 10401, 5, 1424, 713, 2, 10400, 10399, 3, 2, 2, 2, 10400, 10401, 3, 2, 2, 2, 10401, 10403, 3, 2, 2, 2, 10402, 10398, 3, 2, 2, 2, 10402, 10403, 3, 2, 2, 2, 10403, 1421, 3, 2, 2, 2, 10404, 10405, 7, 180, 2, 2, 10405, 1423, 3, 2, 2, 2, 10406, 10408, 5, 1428, 715, 2, 10407, 10406, 3, 2, 2, 2, 10408, 10409, 3, 2, 2, 2, 10409, 10407, 3, 2, 2, 2, 10409, 10410, 3, 2, 2, 2, 10410, 1425, 3, 2, 2, 2, 10411, 10412, 7, 20, 2, 2, 10412, 10413, 5, 1616, 809, 2, 10413, 10414, 7, 21, 2, 2, 10414, 1427, 3, 2, 2, 2, 10415, 10419, 5, 1430, 716, 2, 10416, 10419, 7, 180, 2, 2, 10417, 10419, 5, 1426, 714, 2, 10418, 10415, 3, 2, 2, 2, 10418, 10416, 3, 2, 2, 2, 10418, 10417, 3, 2, 2, 2, 10419, 1429, 3, 2, 2, 2, 10420, 10436, 5, 1446, 724, 2, 10421, 10422, 7, 498, 2, 2, 10422, 10423, 7, 64, 2, 2, 10423, 10437, 5, 1444, 723, 2, 10424, 10425, 5, 1448, 725, 2, 10425, 10426, 5, 1450, 726, 2, 10426, 10427, 5, 1452, 727, 2, 10427, 10428, 5, 1454, 728, 2, 10428, 10429, 5, 1456, 729, 2, 10429, 10437, 3, 2, 2, 2, 10430, 10431, 5, 1432, 717, 2, 10431, 10432, 7, 174, 2, 2, 10432, 10433, 5, 1436, 719, 2, 10433, 10434, 5, 1442, 722, 2, 10434, 10435, 5, 1434, 718, 2, 10435, 10437, 3, 2, 2, 2, 10436, 10421, 3, 2, 2, 2, 10436, 10424, 3, 2, 2, 2, 10436, 10430, 3, 2, 2, 2, 10437, 10438, 3, 2, 2, 2, 10438, 10439, 7, 9, 2, 2, 10439, 1431, 3, 2, 2, 2, 10440, 10445, 3, 2, 2, 2, 10441, 10442, 7, 271, 2, 2, 10442, 10445, 7, 326, 2, 2, 10443, 10445, 7, 326, 2, 2, 10444, 10440, 3, 2, 2, 2, 10444, 10441, 3, 2, 2, 2, 10444, 10443, 3, 2, 2, 2, 10445, 1433, 3, 2, 2, 2, 10446, 10447, 5, 966, 484, 2, 10447, 1435, 3, 2, 2, 2, 10448, 10454, 3, 2, 2, 2, 10449, 10450, 7, 4, 2, 2, 10450, 10451, 5, 1438, 720, 2, 10451, 10452, 7, 5, 2, 2, 10452, 10454, 3, 2, 2, 2, 10453, 10448, 3, 2, 2, 2, 10453, 10449, 3, 2, 2, 2, 10454, 1437, 3, 2, 2, 2, 10455, 10460, 5, 1440, 721, 2, 10456, 10457, 7, 8, 2, 2, 10457, 10459, 5, 1440, 721, 2, 10458, 10456, 3, 2, 2, 2, 10459, 10462, 3, 2, 2, 2, 10460, 10458, 3, 2, 2, 2, 10460, 10461, 3, 2, 2, 2, 10461, 1439, 3, 2, 2, 2, 10462, 10460, 3, 2, 2, 2, 10463, 10464, 5, 1446, 724, 2, 10464, 10465, 5, 1450, 726, 2, 10465, 1441, 3, 2, 2, 2, 10466, 10467, 9, 72, 2, 2, 10467, 1443, 3, 2, 2, 2, 10468, 10471, 7, 30, 2, 2, 10469, 10471, 5, 1378, 690, 2, 10470, 10468, 3, 2, 2, 2, 10470, 10469, 3, 2, 2, 2, 10471, 1445, 3, 2, 2, 2, 10472, 10473, 5, 1616, 809, 2, 10473, 1447, 3, 2, 2, 2, 10474, 10477, 3, 2, 2, 2, 10475, 10477, 7, 499, 2, 2, 10476, 10474, 3, 2, 2, 2, 10476, 10475, 3, 2, 2, 2, 10477, 1449, 3, 2, 2, 2, 10478, 10479, 5, 1122, 562, 2, 10479, 1451, 3, 2, 2, 2, 10480, 10484, 3, 2, 2, 2, 10481, 10482, 7, 45, 2, 2, 10482, 10484, 5, 532, 267, 2, 10483, 10480, 3, 2, 2, 2, 10483, 10481, 3, 2, 2, 2, 10484, 1453, 3, 2, 2, 2, 10485, 10489, 3, 2, 2, 2, 10486, 10487, 7, 79, 2, 2, 10487, 10489, 7, 80, 2, 2, 10488, 10485, 3, 2, 2, 2, 10488, 10486, 3, 2, 2, 2, 10489, 1455, 3, 2, 2, 2, 10490, 10495, 3, 2, 2, 2, 10491, 10492, 5, 1458, 730, 2, 10492, 10493, 5, 1620, 811, 2, 10493, 10495, 3, 2, 2, 2, 10494, 10490, 3, 2, 2, 2, 10494, 10491, 3, 2, 2, 2, 10495, 1457, 3, 2, 2, 2, 10496, 10499, 5, 1460, 731, 2, 10497, 10499, 7, 55, 2, 2, 10498, 10496, 3, 2, 2, 2, 10498, 10497, 3, 2, 2, 2, 10499, 1459, 3, 2, 2, 2, 10500, 10501, 9, 73, 2, 2, 10501, 1461, 3, 2, 2, 2, 10502, 10504, 5, 1464, 733, 2, 10503, 10502, 3, 2, 2, 2, 10504, 10507, 3, 2, 2, 2, 10505, 10503, 3, 2, 2, 2, 10505, 10506, 3, 2, 2, 2, 10506, 1463, 3, 2, 2, 2, 10507, 10505, 3, 2, 2, 2, 10508, 10509, 5, 1418, 710, 2, 10509, 10510, 7, 9, 2, 2, 10510, 10536, 3, 2, 2, 2, 10511, 10536, 5, 1530, 766, 2, 10512, 10536, 5, 1534, 768, 2, 10513, 10536, 5, 1472, 737, 2, 10514, 10536, 5, 1488, 745, 2, 10515, 10536, 5, 1494, 748, 2, 10516, 10536, 5, 1504, 753, 2, 10517, 10536, 5, 1506, 754, 2, 10518, 10536, 5, 1508, 755, 2, 10519, 10536, 5, 1522, 762, 2, 10520, 10536, 5, 1526, 764, 2, 10521, 10536, 5, 1546, 774, 2, 10522, 10536, 5, 1552, 777, 2, 10523, 10536, 5, 1554, 778, 2, 10524, 10536, 5, 1466, 734, 2, 10525, 10536, 5, 1468, 735, 2, 10526, 10536, 5, 1474, 738, 2, 10527, 10536, 5, 1562, 782, 2, 10528, 10536, 5, 1574, 788, 2, 10529, 10536, 5, 1582, 792, 2, 10530, 10536, 5, 1584, 793, 2, 10531, 10536, 5, 1586, 794, 2, 10532, 10536, 5, 1588, 795, 2, 10533, 10536, 5, 1590, 796, 2, 10534, 10536, 5, 1594, 798, 2, 10535, 10508, 3, 2, 2, 2, 10535, 10511, 3, 2, 2, 2, 10535, 10512, 3, 2, 2, 2, 10535, 10513, 3, 2, 2, 2, 10535, 10514, 3, 2, 2, 2, 10535, 10515, 3, 2, 2, 2, 10535, 10516, 3, 2, 2, 2, 10535, 10517, 3, 2, 2, 2, 10535, 10518, 3, 2, 2, 2, 10535, 10519, 3, 2, 2, 2, 10535, 10520, 3, 2, 2, 2, 10535, 10521, 3, 2, 2, 2, 10535, 10522, 3, 2, 2, 2, 10535, 10523, 3, 2, 2, 2, 10535, 10524, 3, 2, 2, 2, 10535, 10525, 3, 2, 2, 2, 10535, 10526, 3, 2, 2, 2, 10535, 10527, 3, 2, 2, 2, 10535, 10528, 3, 2, 2, 2, 10535, 10529, 3, 2, 2, 2, 10535, 10530, 3, 2, 2, 2, 10535, 10531, 3, 2, 2, 2, 10535, 10532, 3, 2, 2, 2, 10535, 10533, 3, 2, 2, 2, 10535, 10534, 3, 2, 2, 2, 10536, 1465, 3, 2, 2, 2, 10537, 10538, 7, 500, 2, 2, 10538, 10539, 5, 1624, 813, 2, 10539, 10540, 7, 9, 2, 2, 10540, 1467, 3, 2, 2, 2, 10541, 10542, 7, 435, 2, 2, 10542, 10543, 5, 1616, 809, 2, 10543, 10544, 7, 4, 2, 2, 10544, 10545, 5, 1470, 736, 2, 10545, 10546, 7, 5, 2, 2, 10546, 10547, 7, 9, 2, 2, 10547, 10556, 3, 2, 2, 2, 10548, 10549, 7, 59, 2, 2, 10549, 10550, 5, 1616, 809, 2, 10550, 10551, 7, 4, 2, 2, 10551, 10552, 5, 1470, 736, 2, 10552, 10553, 7, 5, 2, 2, 10553, 10554, 7, 9, 2, 2, 10554, 10556, 3, 2, 2, 2, 10555, 10541, 3, 2, 2, 2, 10555, 10548, 3, 2, 2, 2, 10556, 1469, 3, 2, 2, 2, 10557, 10560, 3, 2, 2, 2, 10558, 10560, 5, 1282, 642, 2, 10559, 10557, 3, 2, 2, 2, 10559, 10558, 3, 2, 2, 2, 10560, 1471, 3, 2, 2, 2, 10561, 10562, 5, 1486, 744, 2, 10562, 10563, 5, 1460, 731, 2, 10563, 10564, 5, 1620, 811, 2, 10564, 10565, 7, 9, 2, 2, 10565, 1473, 3, 2, 2, 2, 10566, 10567, 7, 501, 2, 2, 10567, 10568, 5, 1476, 739, 2, 10568, 10569, 7, 502, 2, 2, 10569, 10570, 5, 1478, 740, 2, 10570, 10571, 7, 9, 2, 2, 10571, 1475, 3, 2, 2, 2, 10572, 10576, 3, 2, 2, 2, 10573, 10576, 7, 436, 2, 2, 10574, 10576, 7, 503, 2, 2, 10575, 10572, 3, 2, 2, 2, 10575, 10573, 3, 2, 2, 2, 10575, 10574, 3, 2, 2, 2, 10576, 1477, 3, 2, 2, 2, 10577, 10582, 5, 1480, 741, 2, 10578, 10579, 7, 8, 2, 2, 10579, 10581, 5, 1480, 741, 2, 10580, 10578, 3, 2, 2, 2, 10581, 10584, 3, 2, 2, 2, 10582, 10580, 3, 2, 2, 2, 10582, 10583, 3, 2, 2, 2, 10583, 1479, 3, 2, 2, 2, 10584, 10582, 3, 2, 2, 2, 10585, 10586, 5, 1484, 743, 2, 10586, 10587, 5, 1460, 731, 2, 10587, 10588, 5, 1482, 742, 2, 10588, 1481, 3, 2, 2, 2, 10589, 10590, 5, 1378, 690, 2, 10590, 1483, 3, 2, 2, 2, 10591, 10592, 5, 1486, 744, 2, 10592, 1485, 3, 2, 2, 2, 10593, 10596, 5, 532, 267, 2, 10594, 10596, 7, 30, 2, 2, 10595, 10593, 3, 2, 2, 2, 10595, 10594, 3, 2, 2, 2, 10596, 10603, 3, 2, 2, 2, 10597, 10598, 7, 6, 2, 2, 10598, 10599, 5, 1626, 814, 2, 10599, 10600, 7, 7, 2, 2, 10600, 10602, 3, 2, 2, 2, 10601, 10597, 3, 2, 2, 2, 10602, 10605, 3, 2, 2, 2, 10603, 10601, 3, 2, 2, 2, 10603, 10604, 3, 2, 2, 2, 10604, 1487, 3, 2, 2, 2, 10605, 10603, 3, 2, 2, 2, 10606, 10607, 7, 222, 2, 2, 10607, 10608, 5, 1622, 812, 2, 10608, 10609, 7, 95, 2, 2, 10609, 10610, 5, 1462, 732, 2, 10610, 10611, 5, 1490, 746, 2, 10611, 10612, 5, 1492, 747, 2, 10612, 10613, 7, 456, 2, 2, 10613, 10614, 7, 222, 2, 2, 10614, 10615, 7, 9, 2, 2, 10615, 1489, 3, 2, 2, 2, 10616, 10617, 7, 504, 2, 2, 10617, 10618, 5, 1166, 584, 2, 10618, 10619, 7, 95, 2, 2, 10619, 10620, 5, 1462, 732, 2, 10620, 10622, 3, 2, 2, 2, 10621, 10616, 3, 2, 2, 2, 10622, 10625, 3, 2, 2, 2, 10623, 10621, 3, 2, 2, 2, 10623, 10624, 3, 2, 2, 2, 10624, 1491, 3, 2, 2, 2, 10625, 10623, 3, 2, 2, 2, 10626, 10630, 3, 2, 2, 2, 10627, 10628, 7, 60, 2, 2, 10628, 10630, 5, 1462, 732, 2, 10629, 10626, 3, 2, 2, 2, 10629, 10627, 3, 2, 2, 2, 10630, 1493, 3, 2, 2, 2, 10631, 10632, 7, 42, 2, 2, 10632, 10633, 5, 1496, 749, 2, 10633, 10634, 5, 1498, 750, 2, 10634, 10635, 5, 1502, 752, 2, 10635, 10636, 7, 456, 2, 2, 10636, 10637, 7, 42, 2, 2, 10637, 10638, 7, 9, 2, 2, 10638, 1495, 3, 2, 2, 2, 10639, 10642, 3, 2, 2, 2, 10640, 10642, 5, 1620, 811, 2, 10641, 10639, 3, 2, 2, 2, 10641, 10640, 3, 2, 2, 2, 10642, 1497, 3, 2, 2, 2, 10643, 10645, 5, 1500, 751, 2, 10644, 10643, 3, 2, 2, 2, 10645, 10646, 3, 2, 2, 2, 10646, 10644, 3, 2, 2, 2, 10646, 10647, 3, 2, 2, 2, 10647, 1499, 3, 2, 2, 2, 10648, 10649, 7, 104, 2, 2, 10649, 10650, 5, 1282, 642, 2, 10650, 10651, 7, 95, 2, 2, 10651, 10652, 5, 1462, 732, 2, 10652, 1501, 3, 2, 2, 2, 10653, 10657, 3, 2, 2, 2, 10654, 10655, 7, 60, 2, 2, 10655, 10657, 5, 1462, 732, 2, 10656, 10653, 3, 2, 2, 2, 10656, 10654, 3, 2, 2, 2, 10657, 1503, 3, 2, 2, 2, 10658, 10659, 5, 1610, 806, 2, 10659, 10660, 5, 1550, 776, 2, 10660, 1505, 3, 2, 2, 2, 10661, 10662, 5, 1610, 806, 2, 10662, 10663, 7, 505, 2, 2, 10663, 10664, 5, 1628, 815, 2, 10664, 10665, 5, 1550, 776, 2, 10665, 1507, 3, 2, 2, 2, 10666, 10667, 5, 1610, 806, 2, 10667, 10668, 7, 64, 2, 2, 10668, 10669, 5, 1510, 756, 2, 10669, 10670, 5, 1550, 776, 2, 10670, 1509, 3, 2, 2, 2, 10671, 10672, 5, 1520, 761, 2, 10672, 10688, 7, 70, 2, 2, 10673, 10674, 5, 960, 481, 2, 10674, 10675, 5, 1514, 758, 2, 10675, 10689, 3, 2, 2, 2, 10676, 10689, 5, 966, 484, 2, 10677, 10689, 5, 892, 447, 2, 10678, 10679, 7, 204, 2, 2, 10679, 10680, 5, 1166, 584, 2, 10680, 10681, 5, 1512, 757, 2, 10681, 10689, 3, 2, 2, 2, 10682, 10683, 5, 1516, 759, 2, 10683, 10684, 5, 1166, 584, 2, 10684, 10685, 7, 26, 2, 2, 10685, 10686, 5, 1166, 584, 2, 10686, 10687, 5, 1518, 760, 2, 10687, 10689, 3, 2, 2, 2, 10688, 10673, 3, 2, 2, 2, 10688, 10676, 3, 2, 2, 2, 10688, 10677, 3, 2, 2, 2, 10688, 10678, 3, 2, 2, 2, 10688, 10682, 3, 2, 2, 2, 10689, 1511, 3, 2, 2, 2, 10690, 10694, 3, 2, 2, 2, 10691, 10692, 7, 102, 2, 2, 10692, 10694, 5, 1282, 642, 2, 10693, 10690, 3, 2, 2, 2, 10693, 10691, 3, 2, 2, 2, 10694, 1513, 3, 2, 2, 2, 10695, 10708, 3, 2, 2, 2, 10696, 10697, 7, 4, 2, 2, 10697, 10702, 5, 1166, 584, 2, 10698, 10699, 7, 8, 2, 2, 10699, 10701, 5, 1166, 584, 2, 10700, 10698, 3, 2, 2, 2, 10701, 10704, 3, 2, 2, 2, 10702, 10700, 3, 2, 2, 2, 10702, 10703, 3, 2, 2, 2, 10703, 10705, 3, 2, 2, 2, 10704, 10702, 3, 2, 2, 2, 10705, 10706, 7, 5, 2, 2, 10706, 10708, 3, 2, 2, 2, 10707, 10695, 3, 2, 2, 2, 10707, 10696, 3, 2, 2, 2, 10708, 1515, 3, 2, 2, 2, 10709, 10712, 3, 2, 2, 2, 10710, 10712, 7, 506, 2, 2, 10711, 10709, 3, 2, 2, 2, 10711, 10710, 3, 2, 2, 2, 10712, 1517, 3, 2, 2, 2, 10713, 10717, 3, 2, 2, 2, 10714, 10715, 7, 149, 2, 2, 10715, 10717, 5, 1166, 584, 2, 10716, 10713, 3, 2, 2, 2, 10716, 10714, 3, 2, 2, 2, 10717, 1519, 3, 2, 2, 2, 10718, 10719, 5, 530, 266, 2, 10719, 1521, 3, 2, 2, 2, 10720, 10721, 5, 1610, 806, 2, 10721, 10722, 7, 507, 2, 2, 10722, 10723, 5, 1520, 761, 2, 10723, 10724, 5, 1524, 763, 2, 10724, 10725, 7, 70, 2, 2, 10725, 10726, 7, 37, 2, 2, 10726, 10727, 5, 1166, 584, 2, 10727, 10728, 5, 1550, 776, 2, 10728, 1523, 3, 2, 2, 2, 10729, 10733, 3, 2, 2, 2, 10730, 10731, 7, 508, 2, 2, 10731, 10733, 5, 1360, 681, 2, 10732, 10729, 3, 2, 2, 2, 10732, 10730, 3, 2, 2, 2, 10733, 1525, 3, 2, 2, 2, 10734, 10735, 5, 1528, 765, 2, 10735, 10737, 5, 1612, 807, 2, 10736, 10738, 5, 1614, 808, 2, 10737, 10736, 3, 2, 2, 2, 10737, 10738, 3, 2, 2, 2, 10738, 10739, 3, 2, 2, 2, 10739, 10740, 7, 9, 2, 2, 10740, 1527, 3, 2, 2, 2, 10741, 10742, 9, 74, 2, 2, 10742, 1529, 3, 2, 2, 2, 10743, 10755, 7, 510, 2, 2, 10744, 10745, 7, 270, 2, 2, 10745, 10756, 5, 1620, 811, 2, 10746, 10752, 7, 511, 2, 2, 10747, 10748, 7, 204, 2, 2, 10748, 10749, 5, 1166, 584, 2, 10749, 10750, 5, 1512, 757, 2, 10750, 10753, 3, 2, 2, 2, 10751, 10753, 5, 966, 484, 2, 10752, 10747, 3, 2, 2, 2, 10752, 10751, 3, 2, 2, 2, 10753, 10756, 3, 2, 2, 2, 10754, 10756, 5, 1532, 767, 2, 10755, 10744, 3, 2, 2, 2, 10755, 10746, 3, 2, 2, 2, 10755, 10754, 3, 2, 2, 2, 10756, 10757, 3, 2, 2, 2, 10757, 10758, 7, 9, 2, 2, 10758, 1531, 3, 2, 2, 2, 10759, 10762, 3, 2, 2, 2, 10760, 10762, 5, 1620, 811, 2, 10761, 10759, 3, 2, 2, 2, 10761, 10760, 3, 2, 2, 2, 10762, 1533, 3, 2, 2, 2, 10763, 10765, 7, 512, 2, 2, 10764, 10766, 5, 1536, 769, 2, 10765, 10764, 3, 2, 2, 2, 10765, 10766, 3, 2, 2, 2, 10766, 10767, 3, 2, 2, 2, 10767, 10768, 5, 1362, 682, 2, 10768, 10769, 5, 1538, 770, 2, 10769, 10770, 5, 1540, 771, 2, 10770, 10771, 7, 9, 2, 2, 10771, 10798, 3, 2, 2, 2, 10772, 10774, 7, 512, 2, 2, 10773, 10775, 5, 1536, 769, 2, 10774, 10773, 3, 2, 2, 2, 10774, 10775, 3, 2, 2, 2, 10775, 10776, 3, 2, 2, 2, 10776, 10777, 5, 1394, 698, 2, 10777, 10778, 5, 1540, 771, 2, 10778, 10779, 7, 9, 2, 2, 10779, 10798, 3, 2, 2, 2, 10780, 10782, 7, 512, 2, 2, 10781, 10783, 5, 1536, 769, 2, 10782, 10781, 3, 2, 2, 2, 10782, 10783, 3, 2, 2, 2, 10783, 10784, 3, 2, 2, 2, 10784, 10785, 7, 513, 2, 2, 10785, 10786, 5, 1362, 682, 2, 10786, 10787, 5, 1540, 771, 2, 10787, 10788, 7, 9, 2, 2, 10788, 10798, 3, 2, 2, 2, 10789, 10791, 7, 512, 2, 2, 10790, 10792, 5, 1536, 769, 2, 10791, 10790, 3, 2, 2, 2, 10791, 10792, 3, 2, 2, 2, 10792, 10793, 3, 2, 2, 2, 10793, 10794, 5, 1540, 771, 2, 10794, 10795, 7, 9, 2, 2, 10795, 10798, 3, 2, 2, 2, 10796, 10798, 7, 512, 2, 2, 10797, 10763, 3, 2, 2, 2, 10797, 10772, 3, 2, 2, 2, 10797, 10780, 3, 2, 2, 2, 10797, 10789, 3, 2, 2, 2, 10797, 10796, 3, 2, 2, 2, 10798, 1535, 3, 2, 2, 2, 10799, 10800, 9, 75, 2, 2, 10800, 1537, 3, 2, 2, 2, 10801, 10809, 3, 2, 2, 2, 10802, 10803, 7, 8, 2, 2, 10803, 10805, 5, 1166, 584, 2, 10804, 10802, 3, 2, 2, 2, 10805, 10806, 3, 2, 2, 2, 10806, 10804, 3, 2, 2, 2, 10806, 10807, 3, 2, 2, 2, 10807, 10809, 3, 2, 2, 2, 10808, 10801, 3, 2, 2, 2, 10808, 10804, 3, 2, 2, 2, 10809, 1539, 3, 2, 2, 2, 10810, 10814, 3, 2, 2, 2, 10811, 10812, 7, 102, 2, 2, 10812, 10814, 5, 1544, 773, 2, 10813, 10810, 3, 2, 2, 2, 10813, 10811, 3, 2, 2, 2, 10814, 1541, 3, 2, 2, 2, 10815, 10816, 5, 1394, 698, 2, 10816, 10817, 7, 12, 2, 2, 10817, 10818, 5, 1166, 584, 2, 10818, 1543, 3, 2, 2, 2, 10819, 10824, 5, 1542, 772, 2, 10820, 10821, 7, 8, 2, 2, 10821, 10823, 5, 1542, 772, 2, 10822, 10820, 3, 2, 2, 2, 10823, 10826, 3, 2, 2, 2, 10824, 10822, 3, 2, 2, 2, 10824, 10825, 3, 2, 2, 2, 10825, 1545, 3, 2, 2, 2, 10826, 10824, 3, 2, 2, 2, 10827, 10828, 7, 520, 2, 2, 10828, 10829, 5, 1620, 811, 2, 10829, 10830, 5, 1548, 775, 2, 10830, 10831, 7, 9, 2, 2, 10831, 1547, 3, 2, 2, 2, 10832, 10836, 3, 2, 2, 2, 10833, 10834, 7, 8, 2, 2, 10834, 10836, 5, 1620, 811, 2, 10835, 10832, 3, 2, 2, 2, 10835, 10833, 3, 2, 2, 2, 10836, 1549, 3, 2, 2, 2, 10837, 10838, 7, 521, 2, 2, 10838, 10839, 5, 1462, 732, 2, 10839, 10840, 7, 456, 2, 2, 10840, 10841, 7, 521, 2, 2, 10841, 10842, 5, 1612, 807, 2, 10842, 10843, 7, 9, 2, 2, 10843, 1551, 3, 2, 2, 2, 10844, 10845, 5, 1630, 816, 2, 10845, 10846, 7, 9, 2, 2, 10846, 1553, 3, 2, 2, 2, 10847, 10848, 7, 204, 2, 2, 10848, 10856, 5, 1166, 584, 2, 10849, 10850, 5, 1560, 781, 2, 10850, 10851, 5, 1556, 779, 2, 10851, 10857, 3, 2, 2, 2, 10852, 10853, 5, 1556, 779, 2, 10853, 10854, 5, 1560, 781, 2, 10854, 10857, 3, 2, 2, 2, 10855, 10857, 3, 2, 2, 2, 10856, 10849, 3, 2, 2, 2, 10856, 10852, 3, 2, 2, 2, 10856, 10855, 3, 2, 2, 2, 10857, 10858, 3, 2, 2, 2, 10858, 10859, 7, 9, 2, 2, 10859, 1555, 3, 2, 2, 2, 10860, 10864, 3, 2, 2, 2, 10861, 10862, 7, 102, 2, 2, 10862, 10864, 5, 1558, 780, 2, 10863, 10860, 3, 2, 2, 2, 10863, 10861, 3, 2, 2, 2, 10864, 1557, 3, 2, 2, 2, 10865, 10870, 5, 1166, 584, 2, 10866, 10867, 7, 8, 2, 2, 10867, 10869, 5, 1166, 584, 2, 10868, 10866, 3, 2, 2, 2, 10869, 10872, 3, 2, 2, 2, 10870, 10868, 3, 2, 2, 2, 10870, 10871, 3, 2, 2, 2, 10871, 1559, 3, 2, 2, 2, 10872, 10870, 3, 2, 2, 2, 10873, 10880, 3, 2, 2, 2, 10874, 10876, 7, 73, 2, 2, 10875, 10877, 7, 348, 2, 2, 10876, 10875, 3, 2, 2, 2, 10876, 10877, 3, 2, 2, 2, 10877, 10878, 3, 2, 2, 2, 10878, 10880, 5, 1576, 789, 2, 10879, 10873, 3, 2, 2, 2, 10879, 10874, 3, 2, 2, 2, 10880, 1561, 3, 2, 2, 2, 10881, 10899, 7, 522, 2, 2, 10882, 10883, 5, 1596, 799, 2, 10883, 10884, 5, 1570, 786, 2, 10884, 10890, 7, 64, 2, 2, 10885, 10891, 5, 966, 484, 2, 10886, 10887, 7, 204, 2, 2, 10887, 10888, 5, 1620, 811, 2, 10888, 10889, 5, 1568, 785, 2, 10889, 10891, 3, 2, 2, 2, 10890, 10885, 3, 2, 2, 2, 10890, 10886, 3, 2, 2, 2, 10891, 10900, 3, 2, 2, 2, 10892, 10897, 5, 1378, 690, 2, 10893, 10894, 7, 4, 2, 2, 10894, 10895, 5, 1566, 784, 2, 10895, 10896, 7, 5, 2, 2, 10896, 10898, 3, 2, 2, 2, 10897, 10893, 3, 2, 2, 2, 10897, 10898, 3, 2, 2, 2, 10898, 10900, 3, 2, 2, 2, 10899, 10882, 3, 2, 2, 2, 10899, 10892, 3, 2, 2, 2, 10900, 10901, 3, 2, 2, 2, 10901, 10902, 7, 9, 2, 2, 10902, 1563, 3, 2, 2, 2, 10903, 10904, 5, 1378, 690, 2, 10904, 10905, 7, 22, 2, 2, 10905, 10906, 5, 1166, 584, 2, 10906, 10909, 3, 2, 2, 2, 10907, 10909, 5, 1166, 584, 2, 10908, 10903, 3, 2, 2, 2, 10908, 10907, 3, 2, 2, 2, 10909, 1565, 3, 2, 2, 2, 10910, 10915, 5, 1564, 783, 2, 10911, 10912, 7, 8, 2, 2, 10912, 10914, 5, 1564, 783, 2, 10913, 10911, 3, 2, 2, 2, 10914, 10917, 3, 2, 2, 2, 10915, 10913, 3, 2, 2, 2, 10915, 10916, 3, 2, 2, 2, 10916, 1567, 3, 2, 2, 2, 10917, 10915, 3, 2, 2, 2, 10918, 10922, 3, 2, 2, 2, 10919, 10920, 7, 102, 2, 2, 10920, 10922, 5, 1282, 642, 2, 10921, 10918, 3, 2, 2, 2, 10921, 10919, 3, 2, 2, 2, 10922, 1569, 3, 2, 2, 2, 10923, 10928, 3, 2, 2, 2, 10924, 10925, 5, 1572, 787, 2, 10925, 10926, 7, 326, 2, 2, 10926, 10928, 3, 2, 2, 2, 10927, 10923, 3, 2, 2, 2, 10927, 10924, 3, 2, 2, 2, 10928, 1571, 3, 2, 2, 2, 10929, 10932, 3, 2, 2, 2, 10930, 10932, 7, 271, 2, 2, 10931, 10929, 3, 2, 2, 2, 10931, 10930, 3, 2, 2, 2, 10932, 1573, 3, 2, 2, 2, 10933, 10935, 7, 63, 2, 2, 10934, 10936, 5, 1580, 791, 2, 10935, 10934, 3, 2, 2, 2, 10935, 10936, 3, 2, 2, 2, 10936, 10937, 3, 2, 2, 2, 10937, 10938, 5, 1578, 790, 2, 10938, 10939, 5, 1596, 799, 2, 10939, 10940, 7, 73, 2, 2, 10940, 10941, 5, 1576, 789, 2, 10941, 10942, 7, 9, 2, 2, 10942, 1575, 3, 2, 2, 2, 10943, 10944, 5, 1282, 642, 2, 10944, 1577, 3, 2, 2, 2, 10945, 10949, 3, 2, 2, 2, 10946, 10949, 7, 66, 2, 2, 10947, 10949, 7, 70, 2, 2, 10948, 10945, 3, 2, 2, 2, 10948, 10946, 3, 2, 2, 2, 10948, 10947, 3, 2, 2, 2, 10949, 1579, 3, 2, 2, 2, 10950, 10966, 7, 270, 2, 2, 10951, 10966, 7, 295, 2, 2, 10952, 10966, 7, 209, 2, 2, 10953, 10966, 7, 251, 2, 2, 10954, 10955, 7, 132, 2, 2, 10955, 10966, 5, 1166, 584, 2, 10956, 10957, 7, 309, 2, 2, 10957, 10966, 5, 1166, 584, 2, 10958, 10966, 5, 1166, 584, 2, 10959, 10966, 7, 32, 2, 2, 10960, 10963, 9, 76, 2, 2, 10961, 10964, 5, 1166, 584, 2, 10962, 10964, 7, 32, 2, 2, 10963, 10961, 3, 2, 2, 2, 10963, 10962, 3, 2, 2, 2, 10963, 10964, 3, 2, 2, 2, 10964, 10966, 3, 2, 2, 2, 10965, 10950, 3, 2, 2, 2, 10965, 10951, 3, 2, 2, 2, 10965, 10952, 3, 2, 2, 2, 10965, 10953, 3, 2, 2, 2, 10965, 10954, 3, 2, 2, 2, 10965, 10956, 3, 2, 2, 2, 10965, 10958, 3, 2, 2, 2, 10965, 10959, 3, 2, 2, 2, 10965, 10960, 3, 2, 2, 2, 10966, 1581, 3, 2, 2, 2, 10967, 10969, 7, 267, 2, 2, 10968, 10970, 5, 1580, 791, 2, 10969, 10968, 3, 2, 2, 2, 10969, 10970, 3, 2, 2, 2, 10970, 10971, 3, 2, 2, 2, 10971, 10972, 5, 1596, 799, 2, 10972, 10973, 7, 9, 2, 2, 10973, 1583, 3, 2, 2, 2, 10974, 10975, 7, 159, 2, 2, 10975, 10976, 5, 1596, 799, 2, 10976, 10977, 7, 9, 2, 2, 10977, 1585, 3, 2, 2, 2, 10978, 10979, 7, 80, 2, 2, 10979, 10980, 7, 9, 2, 2, 10980, 1587, 3, 2, 2, 2, 10981, 10983, 7, 163, 2, 2, 10982, 10984, 5, 1592, 797, 2, 10983, 10982, 3, 2, 2, 2, 10983, 10984, 3, 2, 2, 2, 10984, 10985, 3, 2, 2, 2, 10985, 10986, 7, 9, 2, 2, 10986, 1589, 3, 2, 2, 2, 10987, 10989, 7, 321, 2, 2, 10988, 10990, 5, 1592, 797, 2, 10989, 10988, 3, 2, 2, 2, 10989, 10990, 3, 2, 2, 2, 10990, 10991, 3, 2, 2, 2, 10991, 10992, 7, 9, 2, 2, 10992, 1591, 3, 2, 2, 2, 10993, 10995, 7, 35, 2, 2, 10994, 10996, 7, 271, 2, 2, 10995, 10994, 3, 2, 2, 2, 10995, 10996, 3, 2, 2, 2, 10996, 10997, 3, 2, 2, 2, 10997, 10998, 7, 155, 2, 2, 10998, 1593, 3, 2, 2, 2, 10999, 11000, 7, 335, 2, 2, 11000, 11001, 5, 532, 267, 2, 11001, 11002, 7, 96, 2, 2, 11002, 11003, 7, 55, 2, 2, 11003, 11004, 7, 9, 2, 2, 11004, 11012, 3, 2, 2, 2, 11005, 11008, 7, 315, 2, 2, 11006, 11009, 5, 532, 267, 2, 11007, 11009, 7, 32, 2, 2, 11008, 11006, 3, 2, 2, 2, 11008, 11007, 3, 2, 2, 2, 11009, 11010, 3, 2, 2, 2, 11010, 11012, 7, 9, 2, 2, 11011, 10999, 3, 2, 2, 2, 11011, 11005, 3, 2, 2, 2, 11012, 1595, 3, 2, 2, 2, 11013, 11016, 5, 1378, 690, 2, 11014, 11016, 7, 30, 2, 2, 11015, 11013, 3, 2, 2, 2, 11015, 11014, 3, 2, 2, 2, 11016, 1597, 3, 2, 2, 2, 11017, 11021, 3, 2, 2, 2, 11018, 11019, 7, 519, 2, 2, 11019, 11021, 5, 1600, 801, 2, 11020, 11017, 3, 2, 2, 2, 11020, 11018, 3, 2, 2, 2, 11021, 1599, 3, 2, 2, 2, 11022, 11024, 5, 1602, 802, 2, 11023, 11022, 3, 2, 2, 2, 11024, 11025, 3, 2, 2, 2, 11025, 11023, 3, 2, 2, 2, 11025, 11026, 3, 2, 2, 2, 11026, 1601, 3, 2, 2, 2, 11027, 11028, 7, 104, 2, 2, 11028, 11029, 5, 1604, 803, 2, 11029, 11030, 7, 95, 2, 2, 11030, 11031, 5, 1462, 732, 2, 11031, 1603, 3, 2, 2, 2, 11032, 11037, 5, 1606, 804, 2, 11033, 11034, 7, 84, 2, 2, 11034, 11036, 5, 1606, 804, 2, 11035, 11033, 3, 2, 2, 2, 11036, 11039, 3, 2, 2, 2, 11037, 11035, 3, 2, 2, 2, 11037, 11038, 3, 2, 2, 2, 11038, 1605, 3, 2, 2, 2, 11039, 11037, 3, 2, 2, 2, 11040, 11044, 5, 1616, 809, 2, 11041, 11042, 7, 513, 2, 2, 11042, 11044, 5, 1362, 682, 2, 11043, 11040, 3, 2, 2, 2, 11043, 11041, 3, 2, 2, 2, 11044, 1607, 3, 2, 2, 2, 11045, 11048, 3, 2, 2, 2, 11046, 11048, 5, 1426, 714, 2, 11047, 11045, 3, 2, 2, 2, 11047, 11046, 3, 2, 2, 2, 11048, 1609, 3, 2, 2, 2, 11049, 11052, 3, 2, 2, 2, 11050, 11052, 5, 1426, 714, 2, 11051, 11049, 3, 2, 2, 2, 11051, 11050, 3, 2, 2, 2, 11052, 1611, 3, 2, 2, 2, 11053, 11056, 3, 2, 2, 2, 11054, 11056, 5, 1616, 809, 2, 11055, 11053, 3, 2, 2, 2, 11055, 11054, 3, 2, 2, 2, 11056, 1613, 3, 2, 2, 2, 11057, 11058, 7, 104, 2, 2, 11058, 11059, 5, 1624, 813, 2, 11059, 1615, 3, 2, 2, 2, 11060, 11063, 5, 1378, 690, 2, 11061, 11063, 5, 1618, 810, 2, 11062, 11060, 3, 2, 2, 2, 11062, 11061, 3, 2, 2, 2, 11063, 1617, 3, 2, 2, 2, 11064, 11065, 9, 77, 2, 2, 11065, 1619, 3, 2, 2, 2, 11066, 11068, 5, 1330, 666, 2, 11067, 11066, 3, 2, 2, 2, 11067, 11068, 3, 2, 2, 2, 11068, 11070, 3, 2, 2, 2, 11069, 11071, 5, 990, 496, 2, 11070, 11069, 3, 2, 2, 2, 11070, 11071, 3, 2, 2, 2, 11071, 11073, 3, 2, 2, 2, 11072, 11074, 5, 1062, 532, 2, 11073, 11072, 3, 2, 2, 2, 11073, 11074, 3, 2, 2, 2, 11074, 11076, 3, 2, 2, 2, 11075, 11077, 5, 1098, 550, 2, 11076, 11075, 3, 2, 2, 2, 11076, 11077, 3, 2, 2, 2, 11077, 11079, 3, 2, 2, 2, 11078, 11080, 5, 1032, 517, 2, 11079, 11078, 3, 2, 2, 2, 11079, 11080, 3, 2, 2, 2, 11080, 11082, 3, 2, 2, 2, 11081, 11083, 5, 1046, 524, 2, 11082, 11081, 3, 2, 2, 2, 11082, 11083, 3, 2, 2, 2, 11083, 11085, 3, 2, 2, 2, 11084, 11086, 5, 1242, 622, 2, 11085, 11084, 3, 2, 2, 2, 11085, 11086, 3, 2, 2, 2, 11086, 1621, 3, 2, 2, 2, 11087, 11088, 5, 1620, 811, 2, 11088, 1623, 3, 2, 2, 2, 11089, 11090, 5, 1620, 811, 2, 11090, 1625, 3, 2, 2, 2, 11091, 11092, 5, 1166, 584, 2, 11092, 1627, 3, 2, 2, 2, 11093, 11094, 5, 1166, 584, 2, 11094, 1629, 3, 2, 2, 2, 11095, 11097, 5, 8, 5, 2, 11096, 11098, 5, 1632, 817, 2, 11097, 11096, 3, 2, 2, 2, 11097, 11098, 3, 2, 2, 2, 11098, 1631, 3, 2, 2, 2, 11099, 11100, 7, 73, 2, 2, 11100, 11101, 5, 992, 497, 2, 11101, 11102, 5, 1576, 789, 2, 11102, 1633, 3, 2, 2, 2, 1088, 1640, 1644, 1771, 1775, 1784, 1793, 1799, 1805, 1824, 1836, 1842, 1850, 1858, 1864, 1873, 1881, 1899, 1902, 1907, 1916, 1925, 1929, 1941, 1961, 1974, 1981, 1989, 1994, 2001, 2007, 2014, 2025, 2029, 2033, 2046, 2050, 2055, 2060, 2072, 2081, 2094, 2099, 2110, 2116, 2122, 2127, 2138, 2144, 2150, 2159, 2169, 2184, 2190, 2197, 2202, 2209, 2220, 2244, 2251, 2260, 2269, 2277, 2287, 2296, 2305, 2313, 2321, 2330, 2339, 2343, 2350, 2358, 2368, 2374, 2378, 2382, 2386, 2390, 2395, 2398, 2402, 2423, 2429, 2524, 2531, 2547, 2561, 2571, 2573, 2578, 2582, 2585, 2591, 2593, 2621, 2631, 2644, 2651, 2657, 2661, 2667, 2672, 2675, 2677, 2682, 2686, 2690, 2694, 2698, 2701, 2705, 2713, 2717, 2721, 2730, 2737, 2742, 2749, 2754, 2761, 2766, 2784, 2789, 2801, 2806, 2815, 2822, 2829, 2835, 2840, 2844, 2847, 2850, 2853, 2856, 2859, 2864, 2867, 2870, 2873, 2876, 2879, 2885, 2889, 2892, 2895, 2898, 2901, 2903, 2912, 2927, 2935, 2941, 2945, 2950, 2954, 2961, 2968, 2973, 2977, 2980, 2984, 2987, 2989, 2996, 2999, 3004, 3007, 3014, 3023, 3030, 3035, 3038, 3041, 3043, 3048, 3053, 3066, 3076, 3089, 3092, 3095, 3102, 3110, 3113, 3116, 3123, 3127, 3133, 3136, 3139, 3142, 3154, 3157, 3160, 3164, 3178, 3196, 3207, 3222, 3238, 3259, 3264, 3267, 3271, 3274, 3280, 3283, 3285, 3296, 3305, 3324, 3328, 3339, 3348, 3354, 3360, 3364, 3367, 3370, 3373, 3376, 3382, 3386, 3393, 3399, 3403, 3406, 3409, 3412, 3420, 3424, 3428, 3434, 3438, 3444, 3458, 3467, 3484, 3489, 3492, 3494, 3504, 3511, 3516, 3519, 3522, 3529, 3532, 3534, 3540, 3549, 3559, 3564, 3573, 3582, 3586, 3593, 3603, 3614, 3724, 3732, 3735, 3745, 3750, 3760, 3771, 3783, 3796, 3806, 3819, 3822, 3829, 3838, 3841, 3848, 3850, 3858, 3868, 3870, 3878, 3882, 3887, 3898, 3902, 3907, 3917, 3923, 3936, 3942, 3944, 3951, 3959, 3964, 3979, 3992, 3994, 3998, 4018, 4035, 4038, 4041, 4044, 4047, 4055, 4058, 4061, 4107, 4110, 4113, 4124, 4133, 4137, 4140, 4149, 4155, 4159, 4170, 4180, 4188, 4193, 4205, 4222, 4228, 4235, 4243, 4257, 4285, 4292, 4306, 4321, 4334, 4343, 4368, 4379, 4446, 4457, 4463, 4471, 4482, 4496, 4505, 4515, 4527, 4542, 4553, 4561, 4571, 4578, 4581, 4587, 4590, 4605, 4618, 4647, 4654, 4669, 4678, 4689, 4691, 4700, 4711, 4713, 4720, 4735, 4741, 4749, 4755, 4763, 4773, 4779, 4787, 4793, 4801, 4808, 4817, 4819, 4844, 4851, 4862, 4868, 4877, 4882, 4888, 4895, 4900, 4904, 4907, 4913, 5062, 5066, 5071, 5082, 5093, 5104, 5115, 5126, 5137, 5148, 5160, 5171, 5179, 5186, 5192, 5200, 5205, 5210, 5215, 5221, 5228, 5234, 5240, 5245, 5251, 5258, 5263, 5269, 5276, 5279, 5292, 5301, 5313, 5315, 5333, 5340, 5350, 5355, 5359, 5363, 5367, 5369, 5429, 5436, 5442, 5453, 5456, 5463, 5466, 5476, 5479, 5481, 5500, 5512, 5521, 5530, 5542, 5544, 5550, 5554, 5557, 5562, 5568, 5571, 5574, 5577, 5581, 5585, 5594, 5600, 5603, 5606, 5609, 5611, 5627, 5631, 5634, 5637, 5640, 5643, 5648, 5651, 5653, 5666, 5678, 5692, 5696, 5708, 5710, 5715, 5723, 5733, 5742, 5750, 5759, 5761, 5765, 5774, 5779, 5785, 5790, 5794, 5799, 5817, 5822, 5837, 5846, 5857, 5863, 5900, 5910, 5917, 5928, 5942, 5950, 5955, 5963, 5971, 5977, 5985, 5991, 5999, 6001, 6007, 6015, 6017, 6023, 6031, 6033, 6057, 6064, 6074, 6086, 6091, 6104, 6116, 6128, 6130, 6136, 6141, 6149, 6156, 6201, 6206, 6213, 6218, 6225, 6235, 6245, 6249, 6260, 6277, 6348, 6543, 6556, 6567, 6580, 6592, 6606, 6638, 6652, 6764, 6766, 6777, 6788, 6799, 6812, 6824, 6835, 6842, 7063, 7078, 7089, 7096, 7150, 7291, 7297, 7300, 7310, 7339, 7349, 7356, 7379, 7388, 7400, 7406, 7414, 7416, 7420, 7430, 7434, 7444, 7447, 7451, 7455, 7463, 7474, 7486, 7490, 7493, 7497, 7500, 7505, 7509, 7512, 7516, 7519, 7523, 7526, 7537, 7544, 7557, 7571, 7575, 7580, 7587, 7594, 7597, 7602, 7605, 7614, 7616, 7621, 7625, 7637, 7640, 7647, 7651, 7656, 7666, 7675, 7678, 7683, 7694, 7698, 7704, 7711, 7731, 7752, 7756, 7761, 7844, 7850, 7863, 7867, 7871, 7875, 7881, 7888, 7891, 7894, 7897, 7900, 7907, 7909, 7913, 7916, 7923, 7925, 7932, 7939, 7943, 7947, 7963, 7970, 7980, 7993, 8004, 8011, 8016, 8020, 8024, 8029, 8042, 8047, 8051, 8059, 8062, 8066, 8077, 8080, 8082, 8098, 8101, 8108, 8111, 8116, 8131, 8137, 8146, 8155, 8162, 8165, 8171, 8176, 8182, 8188, 8191, 8194, 8201, 8205, 8208, 8223, 8226, 8233, 8236, 8243, 8246, 8249, 8256, 8269, 8279, 8297, 8299, 8307, 8311, 8321, 8325, 8329, 8333, 8335, 8340, 8344, 8348, 8350, 8352, 8356, 8360, 8363, 8366, 8369, 8372, 8374, 8377, 8380, 8383, 8386, 8389, 8392, 8401, 8403, 8408, 8412, 8418, 8422, 8426, 8435, 8440, 8444, 8453, 8462, 8466, 8469, 8473, 8478, 8484, 8496, 8511, 8518, 8521, 8525, 8529, 8531, 8539, 8548, 8554, 8556, 8558, 8565, 8569, 8578, 8582, 8597, 8605, 8633, 8640, 8644, 8647, 8652, 8656, 8659, 8675, 8686, 8691, 8694, 8698, 8702, 8706, 8711, 8715, 8719, 8721, 8730, 8735, 8741, 8745, 8747, 8754, 8759, 8765, 8767, 8771, 8778, 8785, 8788, 8794, 8798, 8807, 8810, 8814, 8822, 8824, 8831, 8836, 8839, 8847, 8856, 8864, 8866, 8870, 8877, 8896, 8905, 8911, 8930, 8939, 8945, 8949, 8954, 8964, 8971, 8980, 8983, 8992, 8994, 9000, 9004, 9009, 9019, 9025, 9027, 9033, 9037, 9040, 9053, 9059, 9063, 9067, 9070, 9078, 9082, 9086, 9094, 9101, 9108, 9112, 9118, 9120, 9129, 9132, 9142, 9158, 9164, 9169, 9176, 9185, 9192, 9200, 9208, 9213, 9217, 9220, 9226, 9231, 9247, 9250, 9252, 9264, 9266, 9270, 9278, 9280, 9284, 9286, 9294, 9298, 9307, 9315, 9321, 9324, 9333, 9338, 9345, 9355, 9381, 9392, 9394, 9396, 9404, 9427, 9435, 9445, 9448, 9453, 9458, 9462, 9468, 9471, 9474, 9477, 9481, 9495, 9502, 9509, 9516, 9534, 9542, 9554, 9560, 9573, 9612, 9614, 9634, 9644, 9655, 9667, 9674, 9686, 9698, 9704, 9712, 9729, 9754, 9764, 9768, 9771, 9774, 9777, 9790, 9795, 9800, 9802, 9810, 9819, 9828, 9833, 9842, 9847, 9861, 9871, 9879, 9893, 9900, 9908, 9916, 9923, 9929, 9938, 9953, 9964, 9997, 10006, 10013, 10017, 10021, 10028, 10042, 10047, 10052, 10056, 10058, 10061, 10068, 10073, 10083, 10091, 10094, 10101, 10106, 10110, 10117, 10130, 10142, 10147, 10155, 10162, 10167, 10179, 10187, 10192, 10202, 10212, 10219, 10226, 10237, 10240, 10242, 10246, 10249, 10258, 10264, 10272, 10276, 10283, 10340, 10353, 10376, 10384, 10388, 10400, 10402, 10409, 10418, 10436, 10444, 10453, 10460, 10470, 10476, 10483, 10488, 10494, 10498, 10505, 10535, 10555, 10559, 10575, 10582, 10595, 10603, 10623, 10629, 10641, 10646, 10656, 10688, 10693, 10702, 10707, 10711, 10716, 10732, 10737, 10752, 10755, 10761, 10765, 10774, 10782, 10791, 10797, 10806, 10808, 10813, 10824, 10835, 10856, 10863, 10870, 10876, 10879, 10890, 10897, 10899, 10908, 10915, 10921, 10927, 10931, 10935, 10948, 10963, 10965, 10969, 10983, 10989, 10995, 11008, 11011, 11015, 11020, 11025, 11037, 11043, 11047, 11051, 11055, 11062, 11067, 11070, 11073, 11076, 11079, 11082, 11085, 11097] \ No newline at end of file diff --git a/src/lib/pgsql/PostgreSQLParser.tokens b/src/lib/pgsql/PostgreSQLParser.tokens index 149c268..1c441f2 100644 --- a/src/lib/pgsql/PostgreSQLParser.tokens +++ b/src/lib/pgsql/PostgreSQLParser.tokens @@ -27,530 +27,543 @@ 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 -DollarText=551 -EndDollarStringConstant=552 -AfterEscapeStringConstantWithNewlineMode_Continued=553 +KW_ALL=30 +KW_ANALYSE=31 +KW_ANALYZE=32 +KW_AND=33 +KW_ANY=34 +KW_ARRAY=35 +KW_AS=36 +KW_ASC=37 +KW_ASYMMETRIC=38 +KW_BOTH=39 +KW_CASE=40 +KW_CAST=41 +KW_CHECK=42 +KW_COLLATE=43 +KW_COLUMN=44 +KW_CONSTRAINT=45 +KW_CREATE=46 +KW_CURRENT_CATALOG=47 +KW_CURRENT_DATE=48 +KW_CURRENT_ROLE=49 +KW_CURRENT_TIME=50 +KW_CURRENT_TIMESTAMP=51 +KW_CURRENT_USER=52 +KW_DEFAULT=53 +KW_DEFERRABLE=54 +KW_DESC=55 +KW_DISTINCT=56 +KW_DO=57 +KW_ELSE=58 +KW_EXCEPT=59 +KW_FALSE=60 +KW_FETCH=61 +KW_FOR=62 +KW_FOREIGN=63 +KW_FROM=64 +KW_GRANT=65 +KW_GROUP=66 +KW_HAVING=67 +KW_IN=68 +KW_INITIALLY=69 +KW_INTERSECT=70 +KW_INTO=71 +KW_LATERAL=72 +KW_LEADING=73 +KW_LIMIT=74 +KW_LOCALTIME=75 +KW_LOCALTIMESTAMP=76 +KW_NOT=77 +KW_NULL=78 +KW_OFFSET=79 +KW_ON=80 +KW_ONLY=81 +KW_OR=82 +KW_ORDER=83 +KW_PLACING=84 +KW_PRIMARY=85 +KW_REFERENCES=86 +KW_RETURNING=87 +KW_SELECT=88 +KW_SESSION_USER=89 +KW_SOME=90 +KW_SYMMETRIC=91 +KW_TABLE=92 +KW_THEN=93 +KW_TO=94 +KW_TRAILING=95 +KW_TRUE=96 +KW_UNION=97 +KW_UNIQUE=98 +KW_USER=99 +KW_USING=100 +KW_VARIADIC=101 +KW_WHEN=102 +KW_WHERE=103 +KW_WINDOW=104 +KW_WITH=105 +KW_AUTHORIZATION=106 +KW_BINARY=107 +KW_COLLATION=108 +KW_CONCURRENTLY=109 +KW_CROSS=110 +KW_CURRENT_SCHEMA=111 +KW_FREEZE=112 +KW_FULL=113 +KW_ILIKE=114 +KW_INNER=115 +KW_IS=116 +KW_ISNULL=117 +KW_JOIN=118 +KW_LEFT=119 +KW_LIKE=120 +KW_NATURAL=121 +KW_NOTNULL=122 +KW_OUTER=123 +KW_OVER=124 +KW_OVERLAPS=125 +KW_RIGHT=126 +KW_SIMILAR=127 +KW_VERBOSE=128 +KW_ABORT=129 +KW_ABSOLUTE=130 +KW_ACCESS=131 +KW_ACTION=132 +KW_ADD=133 +KW_ADMIN=134 +KW_AFTER=135 +KW_AGGREGATE=136 +KW_ALSO=137 +KW_ALTER=138 +KW_ALWAYS=139 +KW_ASSERTION=140 +KW_ASSIGNMENT=141 +KW_AT=142 +KW_ATTRIBUTE=143 +KW_BACKWARD=144 +KW_BEFORE=145 +KW_BEGIN=146 +KW_BY=147 +KW_CACHE=148 +KW_CALLED=149 +KW_CASCADE=150 +KW_CASCADED=151 +KW_CATALOG=152 +KW_CHAIN=153 +KW_CHARACTERISTICS=154 +KW_CHECKPOINT=155 +KW_CLASS=156 +KW_CLOSE=157 +KW_CLUSTER=158 +KW_COMMENT=159 +KW_COMMENTS=160 +KW_COMMIT=161 +KW_COMMITTED=162 +KW_CONFIGURATION=163 +KW_CONNECTION=164 +KW_CONSTRAINTS=165 +KW_CONTENT=166 +KW_CONTINUE=167 +KW_CONVERSION=168 +KW_COPY=169 +KW_COST=170 +KW_CSV=171 +KW_CURSOR=172 +KW_CYCLE=173 +KW_DATA=174 +KW_DATABASE=175 +KW_DAY=176 +KW_DEALLOCATE=177 +KW_DECLARE=178 +KW_DEFAULTS=179 +KW_DEFERRED=180 +KW_DEFINER=181 +KW_DELETE=182 +KW_DELIMITER=183 +KW_DELIMITERS=184 +KW_DICTIONARY=185 +KW_DISABLE=186 +KW_DISCARD=187 +KW_DOCUMENT=188 +KW_DOMAIN=189 +KW_DOUBLE=190 +KW_DROP=191 +KW_EACH=192 +KW_ENABLE=193 +KW_ENCODING=194 +KW_ENCRYPTED=195 +KW_ENUM=196 +KW_ESCAPE=197 +KW_EVENT=198 +KW_EXCLUDE=199 +KW_EXCLUDING=200 +KW_EXCLUSIVE=201 +KW_EXECUTE=202 +KW_EXPLAIN=203 +KW_EXTENSION=204 +KW_EXTERNAL=205 +KW_FAMILY=206 +KW_FIRST=207 +KW_FOLLOWING=208 +KW_FORCE=209 +KW_FORWARD=210 +KW_FUNCTION=211 +KW_FUNCTIONS=212 +KW_GLOBAL=213 +KW_GRANTED=214 +KW_HANDLER=215 +KW_HEADER=216 +KW_HOLD=217 +KW_HOUR=218 +KW_IDENTITY=219 +KW_IF=220 +KW_IMMEDIATE=221 +KW_IMMUTABLE=222 +KW_IMPLICIT=223 +KW_INCLUDING=224 +KW_INCREMENT=225 +KW_INDEX=226 +KW_INDEXES=227 +KW_INHERIT=228 +KW_NOINHERIT=229 +KW_SUPERUSER=230 +KW_NOSUPERUSER=231 +KW_CREATEDB=232 +KW_NOCREATEDB=233 +KW_CREATEROLE=234 +KW_NOCREATEROLE=235 +KW_CREATEUSER=236 +KW_NOCREATEUSER=237 +KW_INHERITS=238 +KW_INLINE=239 +KW_INSENSITIVE=240 +KW_INSERT=241 +KW_INSTEAD=242 +KW_INVOKER=243 +KW_ISOLATION=244 +KW_KEY=245 +KW_LABEL=246 +KW_LANGUAGE=247 +KW_LARGE=248 +KW_LAST=249 +KW_LEAKPROOF=250 +KW_LEVEL=251 +KW_LISTEN=252 +KW_LOAD=253 +KW_LOCAL=254 +KW_LOCATION=255 +KW_LOCK=256 +KW_MAPPING=257 +KW_MATCH=258 +KW_MATERIALIZED=259 +KW_MAXVALUE=260 +KW_MINUTE=261 +KW_MINVALUE=262 +KW_MODE=263 +KW_MONTH=264 +KW_MOVE=265 +KW_NAME=266 +KW_NAMES=267 +KW_NEXT=268 +KW_NO=269 +KW_NOTHING=270 +KW_NOTIFY=271 +KW_NOWAIT=272 +KW_NULLS=273 +KW_OBJECT=274 +KW_OF=275 +KW_OFF=276 +KW_OIDS=277 +KW_OPERATOR=278 +KW_OPTION=279 +KW_OPTIONS=280 +KW_OWNED=281 +KW_OWNER=282 +KW_PARSER=283 +KW_PARTIAL=284 +KW_PARTITION=285 +KW_PASSING=286 +KW_PASSWORD=287 +KW_PLANS=288 +KW_PRECEDING=289 +KW_PREPARE=290 +KW_PREPARED=291 +KW_PRESERVE=292 +KW_PRIOR=293 +KW_PRIVILEGES=294 +KW_PROCEDURAL=295 +KW_PROCEDURE=296 +KW_PROGRAM=297 +KW_QUOTE=298 +KW_RANGE=299 +KW_READ=300 +KW_REASSIGN=301 +KW_RECHECK=302 +KW_RECURSIVE=303 +KW_REF=304 +KW_REFRESH=305 +KW_REINDEX=306 +KW_RELATIVE=307 +KW_RELEASE=308 +KW_RENAME=309 +KW_REPEATABLE=310 +KW_REPLACE=311 +KW_REPLICA=312 +KW_RESET=313 +KW_RESTART=314 +KW_RESTRICT=315 +KW_RETURNS=316 +KW_REVOKE=317 +KW_ROLE=318 +KW_ROLLBACK=319 +KW_ROWS=320 +KW_RULE=321 +KW_SAVEPOINT=322 +KW_SCHEMA=323 +KW_SCROLL=324 +KW_SEARCH=325 +KW_SECOND=326 +KW_SECURITY=327 +KW_SEQUENCE=328 +KW_SEQUENCES=329 +KW_SERIALIZABLE=330 +KW_SERVER=331 +KW_SESSION=332 +KW_SET=333 +KW_SHARE=334 +KW_SHOW=335 +KW_SIMPLE=336 +KW_SNAPSHOT=337 +KW_STABLE=338 +KW_STANDALONE=339 +KW_START=340 +KW_STATEMENT=341 +KW_STATISTICS=342 +KW_STDIN=343 +KW_STDOUT=344 +KW_STORAGE=345 +KW_STRICT=346 +KW_STRIP=347 +KW_SYSID=348 +KW_SYSTEM=349 +KW_TABLES=350 +KW_TABLESPACE=351 +KW_TEMP=352 +KW_TEMPLATE=353 +KW_TEMPORARY=354 +KW_TEXT=355 +KW_TRANSACTION=356 +KW_TRIGGER=357 +KW_TRUNCATE=358 +KW_TRUSTED=359 +KW_TYPE=360 +KW_TYPES=361 +KW_UNBOUNDED=362 +KW_UNCOMMITTED=363 +KW_UNENCRYPTED=364 +KW_UNKNOWN=365 +KW_UNLISTEN=366 +KW_UNLOGGED=367 +KW_UNTIL=368 +KW_UPDATE=369 +KW_VACUUM=370 +KW_VALID=371 +KW_VALIDATE=372 +KW_VALIDATOR=373 +KW_VARYING=374 +KW_VERSION=375 +KW_VIEW=376 +KW_VOLATILE=377 +KW_WHITESPACE=378 +KW_WITHOUT=379 +KW_WORK=380 +KW_WRAPPER=381 +KW_WRITE=382 +KW_XML=383 +KW_YEAR=384 +KW_YES=385 +KW_ZONE=386 +KW_BETWEEN=387 +KW_BIGINT=388 +KW_BIT=389 +KW_BOOLEAN=390 +KW_CHAR=391 +KW_CHARACTER=392 +KW_COALESCE=393 +KW_DEC=394 +KW_DECIMAL=395 +KW_EXISTS=396 +KW_EXTRACT=397 +KW_FLOAT=398 +KW_GREATEST=399 +KW_INOUT=400 +KW_INT=401 +KW_INTEGER=402 +KW_INTERVAL=403 +KW_LEAST=404 +KW_NATIONAL=405 +KW_NCHAR=406 +KW_NONE=407 +KW_NULLIF=408 +KW_NUMERIC=409 +KW_OVERLAY=410 +KW_POSITION=411 +KW_PRECISION=412 +KW_REAL=413 +KW_ROW=414 +KW_SETOF=415 +KW_SMALLINT=416 +KW_SUBSTRING=417 +KW_TIME=418 +KW_TIMESTAMP=419 +KW_TREAT=420 +KW_TRIM=421 +KW_VALUES=422 +KW_VARCHAR=423 +KW_XMLATTRIBUTES=424 +KW_XMLCONCAT=425 +KW_XMLELEMENT=426 +KW_XMLEXISTS=427 +KW_XMLFOREST=428 +KW_XMLPARSE=429 +KW_XMLPI=430 +KW_XMLROOT=431 +KW_XMLSERIALIZE=432 +KW_CALL=433 +KW_CURRENT=434 +KW_ATTACH=435 +KW_DETACH=436 +KW_EXPRESSION=437 +KW_GENERATED=438 +KW_LOGGED=439 +KW_STORED=440 +KW_INCLUDE=441 +KW_ROUTINE=442 +KW_TRANSFORM=443 +KW_IMPORT=444 +KW_POLICY=445 +KW_METHOD=446 +KW_REFERENCING=447 +KW_NEW=448 +KW_OLD=449 +KW_VALUE=450 +KW_SUBSCRIPTION=451 +KW_PUBLICATION=452 +KW_OUT=453 +KW_END=454 +KW_ROUTINES=455 +KW_SCHEMAS=456 +KW_PROCEDURES=457 +KW_INPUT=458 +KW_SUPPORT=459 +KW_PARALLEL=460 +KW_SQL=461 +KW_DEPENDS=462 +KW_OVERRIDING=463 +KW_CONFLICT=464 +KW_SKIP=465 +KW_LOCKED=466 +KW_TIES=467 +KW_ROLLUP=468 +KW_CUBE=469 +KW_GROUPING=470 +KW_SETS=471 +KW_TABLESAMPLE=472 +KW_ORDINALITY=473 +KW_XMLTABLE=474 +KW_COLUMNS=475 +KW_XMLNAMESPACES=476 +KW_ROWTYPE=477 +KW_NORMALIZED=478 +KW_WITHIN=479 +KW_FILTER=480 +KW_GROUPS=481 +KW_OTHERS=482 +KW_NFC=483 +KW_NFD=484 +KW_NFKC=485 +KW_NFKD=486 +KW_UESCAPE=487 +KW_VIEWS=488 +KW_NORMALIZE=489 +KW_DUMP=490 +KW_PRINT_STRICT_PARAMS=491 +KW_VARIABLE_CONFLICT=492 +KW_ERROR=493 +KW_USE_VARIABLE=494 +KW_USE_COLUMN=495 +KW_ALIAS=496 +KW_CONSTANT=497 +KW_PERFORM=498 +KW_GET=499 +KW_DIAGNOSTICS=500 +KW_STACKED=501 +KW_ELSIF=502 +KW_WHILE=503 +KW_REVERSE=504 +KW_FOREACH=505 +KW_SLICE=506 +KW_EXIT=507 +KW_RETURN=508 +KW_QUERY=509 +KW_RAISE=510 +KW_SQLSTATE=511 +KW_DEBUG=512 +KW_LOG=513 +KW_INFO=514 +KW_NOTICE=515 +KW_WARNING=516 +KW_EXCEPTION=517 +KW_ASSERT=518 +KW_LOOP=519 +KW_OPEN=520 +KW_PEFERENCES=521 +KW_USAGE=522 +KW_CONNECT=523 +KW_PUBLIC=524 +Identifier=525 +QuotedIdentifier=526 +UnterminatedQuotedIdentifier=527 +InvalidQuotedIdentifier=528 +InvalidUnterminatedQuotedIdentifier=529 +UnicodeQuotedIdentifier=530 +UnterminatedUnicodeQuotedIdentifier=531 +InvalidUnicodeQuotedIdentifier=532 +InvalidUnterminatedUnicodeQuotedIdentifier=533 +StringConstant=534 +UnterminatedStringConstant=535 +UnicodeEscapeStringConstant=536 +UnterminatedUnicodeEscapeStringConstant=537 +BeginDollarStringConstant=538 +BinaryStringConstant=539 +UnterminatedBinaryStringConstant=540 +InvalidBinaryStringConstant=541 +InvalidUnterminatedBinaryStringConstant=542 +HexadecimalStringConstant=543 +UnterminatedHexadecimalStringConstant=544 +InvalidHexadecimalStringConstant=545 +InvalidUnterminatedHexadecimalStringConstant=546 +Integral=547 +NumericFail=548 +Numeric=549 +PLSQLVARIABLENAME=550 +PLSQLIDENTIFIER=551 +Whitespace=552 +Newline=553 +LineComment=554 +BlockComment=555 +UnterminatedBlockComment=556 +MetaCommand=557 +EndMetaCommand=558 +ErrorCharacter=559 +EscapeStringConstant=560 +UnterminatedEscapeStringConstant=561 +InvalidEscapeStringConstant=562 +InvalidUnterminatedEscapeStringConstant=563 +DollarText=564 +EndDollarStringConstant=565 +AfterEscapeStringConstantWithNewlineMode_Continued=566 '$'=1 '('=2 ')'=3 @@ -777,288 +790,301 @@ AfterEscapeStringConstantWithNewlineMode_Continued=553 '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 -'\''=553 +'NOINHERIT'=229 +'SUPERUSER'=230 +'NOSUPERUSER'=231 +'CREATEDB'=232 +'NOCREATEDB'=233 +'CREATEROLE'=234 +'NOCREATEROLE'=235 +'CREATEUSER'=236 +'NOCREATEUSER'=237 +'INHERITS'=238 +'INLINE'=239 +'INSENSITIVE'=240 +'INSERT'=241 +'INSTEAD'=242 +'INVOKER'=243 +'ISOLATION'=244 +'KEY'=245 +'LABEL'=246 +'LANGUAGE'=247 +'LARGE'=248 +'LAST'=249 +'LEAKPROOF'=250 +'LEVEL'=251 +'LISTEN'=252 +'LOAD'=253 +'LOCAL'=254 +'LOCATION'=255 +'LOCK'=256 +'MAPPING'=257 +'MATCH'=258 +'MATERIALIZED'=259 +'MAXVALUE'=260 +'MINUTE'=261 +'MINVALUE'=262 +'MODE'=263 +'MONTH'=264 +'MOVE'=265 +'NAME'=266 +'NAMES'=267 +'NEXT'=268 +'NO'=269 +'NOTHING'=270 +'NOTIFY'=271 +'NOWAIT'=272 +'NULLS'=273 +'OBJECT'=274 +'OF'=275 +'OFF'=276 +'OIDS'=277 +'OPERATOR'=278 +'OPTION'=279 +'OPTIONS'=280 +'OWNED'=281 +'OWNER'=282 +'PARSER'=283 +'PARTIAL'=284 +'PARTITION'=285 +'PASSING'=286 +'PASSWORD'=287 +'PLANS'=288 +'PRECEDING'=289 +'PREPARE'=290 +'PREPARED'=291 +'PRESERVE'=292 +'PRIOR'=293 +'PRIVILEGES'=294 +'PROCEDURAL'=295 +'PROCEDURE'=296 +'PROGRAM'=297 +'QUOTE'=298 +'RANGE'=299 +'READ'=300 +'REASSIGN'=301 +'RECHECK'=302 +'RECURSIVE'=303 +'REF'=304 +'REFRESH'=305 +'REINDEX'=306 +'RELATIVE'=307 +'RELEASE'=308 +'RENAME'=309 +'REPEATABLE'=310 +'REPLACE'=311 +'REPLICA'=312 +'RESET'=313 +'RESTART'=314 +'RESTRICT'=315 +'RETURNS'=316 +'REVOKE'=317 +'ROLE'=318 +'ROLLBACK'=319 +'ROWS'=320 +'RULE'=321 +'SAVEPOINT'=322 +'SCHEMA'=323 +'SCROLL'=324 +'SEARCH'=325 +'SECOND'=326 +'SECURITY'=327 +'SEQUENCE'=328 +'SEQUENCES'=329 +'SERIALIZABLE'=330 +'SERVER'=331 +'SESSION'=332 +'SET'=333 +'SHARE'=334 +'SHOW'=335 +'SIMPLE'=336 +'SNAPSHOT'=337 +'STABLE'=338 +'STANDALONE'=339 +'START'=340 +'STATEMENT'=341 +'STATISTICS'=342 +'STDIN'=343 +'STDOUT'=344 +'STORAGE'=345 +'STRICT'=346 +'STRIP'=347 +'SYSID'=348 +'SYSTEM'=349 +'TABLES'=350 +'TABLESPACE'=351 +'TEMP'=352 +'TEMPLATE'=353 +'TEMPORARY'=354 +'TEXT'=355 +'TRANSACTION'=356 +'TRIGGER'=357 +'TRUNCATE'=358 +'TRUSTED'=359 +'TYPE'=360 +'TYPES'=361 +'UNBOUNDED'=362 +'UNCOMMITTED'=363 +'UNENCRYPTED'=364 +'UNKNOWN'=365 +'UNLISTEN'=366 +'UNLOGGED'=367 +'UNTIL'=368 +'UPDATE'=369 +'VACUUM'=370 +'VALID'=371 +'VALIDATE'=372 +'VALIDATOR'=373 +'VARYING'=374 +'VERSION'=375 +'VIEW'=376 +'VOLATILE'=377 +'WHITESPACE'=378 +'WITHOUT'=379 +'WORK'=380 +'WRAPPER'=381 +'WRITE'=382 +'XML'=383 +'YEAR'=384 +'YES'=385 +'ZONE'=386 +'BETWEEN'=387 +'BIGINT'=388 +'BIT'=389 +'BOOLEAN'=390 +'CHAR'=391 +'CHARACTER'=392 +'COALESCE'=393 +'DEC'=394 +'DECIMAL'=395 +'EXISTS'=396 +'EXTRACT'=397 +'FLOAT'=398 +'GREATEST'=399 +'INOUT'=400 +'INT'=401 +'INTEGER'=402 +'INTERVAL'=403 +'LEAST'=404 +'NATIONAL'=405 +'NCHAR'=406 +'NONE'=407 +'NULLIF'=408 +'NUMERIC'=409 +'OVERLAY'=410 +'POSITION'=411 +'PRECISION'=412 +'REAL'=413 +'ROW'=414 +'SETOF'=415 +'SMALLINT'=416 +'SUBSTRING'=417 +'TIME'=418 +'TIMESTAMP'=419 +'TREAT'=420 +'TRIM'=421 +'VALUES'=422 +'VARCHAR'=423 +'XMLATTRIBUTES'=424 +'XMLCONCAT'=425 +'XMLELEMENT'=426 +'XMLEXISTS'=427 +'XMLFOREST'=428 +'XMLPARSE'=429 +'XMLPI'=430 +'XMLROOT'=431 +'XMLSERIALIZE'=432 +'CALL'=433 +'CURRENT'=434 +'ATTACH'=435 +'DETACH'=436 +'EXPRESSION'=437 +'GENERATED'=438 +'LOGGED'=439 +'STORED'=440 +'INCLUDE'=441 +'ROUTINE'=442 +'TRANSFORM'=443 +'IMPORT'=444 +'POLICY'=445 +'METHOD'=446 +'REFERENCING'=447 +'NEW'=448 +'OLD'=449 +'VALUE'=450 +'SUBSCRIPTION'=451 +'PUBLICATION'=452 +'OUT'=453 +'END'=454 +'ROUTINES'=455 +'SCHEMAS'=456 +'PROCEDURES'=457 +'INPUT'=458 +'SUPPORT'=459 +'PARALLEL'=460 +'SQL'=461 +'DEPENDS'=462 +'OVERRIDING'=463 +'CONFLICT'=464 +'SKIP'=465 +'LOCKED'=466 +'TIES'=467 +'ROLLUP'=468 +'CUBE'=469 +'GROUPING'=470 +'SETS'=471 +'TABLESAMPLE'=472 +'ORDINALITY'=473 +'XMLTABLE'=474 +'COLUMNS'=475 +'XMLNAMESPACES'=476 +'ROWTYPE'=477 +'NORMALIZED'=478 +'WITHIN'=479 +'FILTER'=480 +'GROUPS'=481 +'OTHERS'=482 +'NFC'=483 +'NFD'=484 +'NFKC'=485 +'NFKD'=486 +'UESCAPE'=487 +'VIEWS'=488 +'NORMALIZE'=489 +'DUMP'=490 +'PRINT_STRICT_PARAMS'=491 +'VARIABLE_CONFLICT'=492 +'ERROR'=493 +'USE_VARIABLE'=494 +'USE_COLUMN'=495 +'ALIAS'=496 +'CONSTANT'=497 +'PERFORM'=498 +'GET'=499 +'DIAGNOSTICS'=500 +'STACKED'=501 +'ELSIF'=502 +'WHILE'=503 +'REVERSE'=504 +'FOREACH'=505 +'SLICE'=506 +'EXIT'=507 +'RETURN'=508 +'QUERY'=509 +'RAISE'=510 +'SQLSTATE'=511 +'DEBUG'=512 +'LOG'=513 +'INFO'=514 +'NOTICE'=515 +'WARNING'=516 +'EXCEPTION'=517 +'ASSERT'=518 +'LOOP'=519 +'OPEN'=520 +'PEFERENCES'=521 +'USAGE'=522 +'CONNECT'=523 +'PUBLIC'=524 +'\\\\'=558 +'\''=566 diff --git a/src/lib/pgsql/PostgreSQLParser.ts b/src/lib/pgsql/PostgreSQLParser.ts index da4f0be..f91dd99 100644 --- a/src/lib/pgsql/PostgreSQLParser.ts +++ b/src/lib/pgsql/PostgreSQLParser.ts @@ -1,7 +1,4 @@ -// Generated from /Users/ziv/github.com/dt-sql-parser/src/grammar/pgsql/PostgreSQLParser.g4 by ANTLR 4.9.0-SNAPSHOT - - -import PostgreSQLParserBase from "./PostgreSQLParserBase"; +// Generated from /Users/xuxiaoqi/Documents/work/daishu-code/dt-sql-parser/src/grammar/pgsql/PostgreSQLParser.g4 by ANTLR 4.9.0-SNAPSHOT import { ATN } from "antlr4ts/atn/ATN"; @@ -30,7 +27,7 @@ import { PostgreSQLParserListener } from "./PostgreSQLParserListener"; import { PostgreSQLParserVisitor } from "./PostgreSQLParserVisitor"; -export class PostgreSQLParser extends PostgreSQLParserBase { +export class PostgreSQLParser extends Parser { public static readonly Dollar = 1; public static readonly OPEN_PAREN = 2; public static readonly CLOSE_PAREN = 3; @@ -60,530 +57,543 @@ export class PostgreSQLParser extends PostgreSQLParserBase { public static readonly PERCENT = 27; public static readonly PARAM = 28; public static readonly Operator = 29; - public static readonly ALL = 30; - public static readonly ANALYSE = 31; - public static readonly ANALYZE = 32; - public static readonly AND = 33; - public static readonly ANY = 34; - public static readonly ARRAY = 35; - public static readonly AS = 36; - public static readonly ASC = 37; - public static readonly ASYMMETRIC = 38; - public static readonly BOTH = 39; - public static readonly CASE = 40; - public static readonly CAST = 41; - public static readonly CHECK = 42; - public static readonly COLLATE = 43; - public static readonly COLUMN = 44; - public static readonly CONSTRAINT = 45; - public static readonly CREATE = 46; - public static readonly CURRENT_CATALOG = 47; - public static readonly CURRENT_DATE = 48; - public static readonly CURRENT_ROLE = 49; - public static readonly CURRENT_TIME = 50; - public static readonly CURRENT_TIMESTAMP = 51; - public static readonly CURRENT_USER = 52; - public static readonly DEFAULT = 53; - public static readonly DEFERRABLE = 54; - public static readonly DESC = 55; - public static readonly DISTINCT = 56; - public static readonly DO = 57; - public static readonly ELSE = 58; - public static readonly EXCEPT = 59; - public static readonly FALSE_P = 60; - public static readonly FETCH = 61; - public static readonly FOR = 62; - public static readonly FOREIGN = 63; - public static readonly FROM = 64; - public static readonly GRANT = 65; - public static readonly GROUP_P = 66; - public static readonly HAVING = 67; - public static readonly IN_P = 68; - public static readonly INITIALLY = 69; - public static readonly INTERSECT = 70; - public static readonly INTO = 71; - public static readonly LATERAL_P = 72; - public static readonly LEADING = 73; - public static readonly LIMIT = 74; - public static readonly LOCALTIME = 75; - public static readonly LOCALTIMESTAMP = 76; - public static readonly NOT = 77; - public static readonly NULL_P = 78; - public static readonly OFFSET = 79; - public static readonly ON = 80; - public static readonly ONLY = 81; - public static readonly OR = 82; - public static readonly ORDER = 83; - public static readonly PLACING = 84; - public static readonly PRIMARY = 85; - public static readonly REFERENCES = 86; - public static readonly RETURNING = 87; - public static readonly SELECT = 88; - public static readonly SESSION_USER = 89; - public static readonly SOME = 90; - public static readonly SYMMETRIC = 91; - public static readonly TABLE = 92; - public static readonly THEN = 93; - public static readonly TO = 94; - public static readonly TRAILING = 95; - public static readonly TRUE_P = 96; - public static readonly UNION = 97; - public static readonly UNIQUE = 98; - public static readonly USER = 99; - public static readonly USING = 100; - public static readonly VARIADIC = 101; - public static readonly WHEN = 102; - public static readonly WHERE = 103; - public static readonly WINDOW = 104; - public static readonly WITH = 105; - public static readonly AUTHORIZATION = 106; - public static readonly BINARY = 107; - public static readonly COLLATION = 108; - public static readonly CONCURRENTLY = 109; - public static readonly CROSS = 110; - public static readonly CURRENT_SCHEMA = 111; - public static readonly FREEZE = 112; - public static readonly FULL = 113; - public static readonly ILIKE = 114; - public static readonly INNER_P = 115; - public static readonly IS = 116; - public static readonly ISNULL = 117; - public static readonly JOIN = 118; - public static readonly LEFT = 119; - public static readonly LIKE = 120; - public static readonly NATURAL = 121; - public static readonly NOTNULL = 122; - public static readonly OUTER_P = 123; - public static readonly OVER = 124; - public static readonly OVERLAPS = 125; - public static readonly RIGHT = 126; - public static readonly SIMILAR = 127; - public static readonly VERBOSE = 128; - public static readonly ABORT_P = 129; - public static readonly ABSOLUTE_P = 130; - public static readonly ACCESS = 131; - public static readonly ACTION = 132; - public static readonly ADD_P = 133; - public static readonly ADMIN = 134; - public static readonly AFTER = 135; - public static readonly AGGREGATE = 136; - public static readonly ALSO = 137; - public static readonly ALTER = 138; - public static readonly ALWAYS = 139; - public static readonly ASSERTION = 140; - public static readonly ASSIGNMENT = 141; - public static readonly AT = 142; - public static readonly ATTRIBUTE = 143; - public static readonly BACKWARD = 144; - public static readonly BEFORE = 145; - public static readonly BEGIN_P = 146; - public static readonly BY = 147; - public static readonly CACHE = 148; - public static readonly CALLED = 149; - public static readonly CASCADE = 150; - public static readonly CASCADED = 151; - public static readonly CATALOG = 152; - public static readonly CHAIN = 153; - public static readonly CHARACTERISTICS = 154; - public static readonly CHECKPOINT = 155; - public static readonly CLASS = 156; - public static readonly CLOSE = 157; - public static readonly CLUSTER = 158; - public static readonly COMMENT = 159; - public static readonly COMMENTS = 160; - public static readonly COMMIT = 161; - public static readonly COMMITTED = 162; - public static readonly CONFIGURATION = 163; - public static readonly CONNECTION = 164; - public static readonly CONSTRAINTS = 165; - public static readonly CONTENT_P = 166; - public static readonly CONTINUE_P = 167; - public static readonly CONVERSION_P = 168; - public static readonly COPY = 169; - public static readonly COST = 170; - public static readonly CSV = 171; - public static readonly CURSOR = 172; - public static readonly CYCLE = 173; - public static readonly DATA_P = 174; - public static readonly DATABASE = 175; - public static readonly DAY_P = 176; - public static readonly DEALLOCATE = 177; - public static readonly DECLARE = 178; - public static readonly DEFAULTS = 179; - public static readonly DEFERRED = 180; - public static readonly DEFINER = 181; - public static readonly DELETE_P = 182; - public static readonly DELIMITER = 183; - public static readonly DELIMITERS = 184; - public static readonly DICTIONARY = 185; - public static readonly DISABLE_P = 186; - public static readonly DISCARD = 187; - public static readonly DOCUMENT_P = 188; - public static readonly DOMAIN_P = 189; - public static readonly DOUBLE_P = 190; - public static readonly DROP = 191; - public static readonly EACH = 192; - public static readonly ENABLE_P = 193; - public static readonly ENCODING = 194; - public static readonly ENCRYPTED = 195; - public static readonly ENUM_P = 196; - public static readonly ESCAPE = 197; - public static readonly EVENT = 198; - public static readonly EXCLUDE = 199; - public static readonly EXCLUDING = 200; - public static readonly EXCLUSIVE = 201; - public static readonly EXECUTE = 202; - public static readonly EXPLAIN = 203; - public static readonly EXTENSION = 204; - public static readonly EXTERNAL = 205; - public static readonly FAMILY = 206; - public static readonly FIRST_P = 207; - public static readonly FOLLOWING = 208; - public static readonly FORCE = 209; - public static readonly FORWARD = 210; - public static readonly FUNCTION = 211; - public static readonly FUNCTIONS = 212; - public static readonly GLOBAL = 213; - public static readonly GRANTED = 214; - public static readonly HANDLER = 215; - public static readonly HEADER_P = 216; - public static readonly HOLD = 217; - public static readonly HOUR_P = 218; - public static readonly IDENTITY_P = 219; - public static readonly IF_P = 220; - public static readonly IMMEDIATE = 221; - public static readonly IMMUTABLE = 222; - public static readonly IMPLICIT_P = 223; - public static readonly INCLUDING = 224; - public static readonly INCREMENT = 225; - public static readonly INDEX = 226; - public static readonly INDEXES = 227; - public static readonly INHERIT = 228; - public static readonly INHERITS = 229; - public static readonly INLINE_P = 230; - public static readonly INSENSITIVE = 231; - public static readonly INSERT = 232; - public static readonly INSTEAD = 233; - public static readonly INVOKER = 234; - public static readonly ISOLATION = 235; - public static readonly KEY = 236; - public static readonly LABEL = 237; - public static readonly LANGUAGE = 238; - public static readonly LARGE_P = 239; - public static readonly LAST_P = 240; - public static readonly LEAKPROOF = 241; - public static readonly LEVEL = 242; - public static readonly LISTEN = 243; - public static readonly LOAD = 244; - public static readonly LOCAL = 245; - public static readonly LOCATION = 246; - public static readonly LOCK_P = 247; - public static readonly MAPPING = 248; - public static readonly MATCH = 249; - public static readonly MATERIALIZED = 250; - public static readonly MAXVALUE = 251; - public static readonly MINUTE_P = 252; - public static readonly MINVALUE = 253; - public static readonly MODE = 254; - public static readonly MONTH_P = 255; - public static readonly MOVE = 256; - public static readonly NAME_P = 257; - public static readonly NAMES = 258; - public static readonly NEXT = 259; - public static readonly NO = 260; - public static readonly NOTHING = 261; - public static readonly NOTIFY = 262; - public static readonly NOWAIT = 263; - public static readonly NULLS_P = 264; - public static readonly OBJECT_P = 265; - public static readonly OF = 266; - public static readonly OFF = 267; - public static readonly OIDS = 268; - public static readonly OPERATOR = 269; - public static readonly OPTION = 270; - public static readonly OPTIONS = 271; - public static readonly OWNED = 272; - public static readonly OWNER = 273; - public static readonly PARSER = 274; - public static readonly PARTIAL = 275; - public static readonly PARTITION = 276; - public static readonly PASSING = 277; - public static readonly PASSWORD = 278; - public static readonly PLANS = 279; - public static readonly PRECEDING = 280; - public static readonly PREPARE = 281; - public static readonly PREPARED = 282; - public static readonly PRESERVE = 283; - public static readonly PRIOR = 284; - public static readonly PRIVILEGES = 285; - public static readonly PROCEDURAL = 286; - public static readonly PROCEDURE = 287; - public static readonly PROGRAM = 288; - public static readonly QUOTE = 289; - public static readonly RANGE = 290; - public static readonly READ = 291; - public static readonly REASSIGN = 292; - public static readonly RECHECK = 293; - public static readonly RECURSIVE = 294; - public static readonly REF = 295; - public static readonly REFRESH = 296; - public static readonly REINDEX = 297; - public static readonly RELATIVE_P = 298; - public static readonly RELEASE = 299; - public static readonly RENAME = 300; - public static readonly REPEATABLE = 301; - public static readonly REPLACE = 302; - public static readonly REPLICA = 303; - public static readonly RESET = 304; - public static readonly RESTART = 305; - public static readonly RESTRICT = 306; - public static readonly RETURNS = 307; - public static readonly REVOKE = 308; - public static readonly ROLE = 309; - public static readonly ROLLBACK = 310; - public static readonly ROWS = 311; - public static readonly RULE = 312; - public static readonly SAVEPOINT = 313; - public static readonly SCHEMA = 314; - public static readonly SCROLL = 315; - public static readonly SEARCH = 316; - public static readonly SECOND_P = 317; - public static readonly SECURITY = 318; - public static readonly SEQUENCE = 319; - public static readonly SEQUENCES = 320; - public static readonly SERIALIZABLE = 321; - public static readonly SERVER = 322; - public static readonly SESSION = 323; - public static readonly SET = 324; - public static readonly SHARE = 325; - public static readonly SHOW = 326; - public static readonly SIMPLE = 327; - public static readonly SNAPSHOT = 328; - public static readonly STABLE = 329; - public static readonly STANDALONE_P = 330; - public static readonly START = 331; - public static readonly STATEMENT = 332; - public static readonly STATISTICS = 333; - public static readonly STDIN = 334; - public static readonly STDOUT = 335; - public static readonly STORAGE = 336; - public static readonly STRICT_P = 337; - public static readonly STRIP_P = 338; - public static readonly SYSID = 339; - public static readonly SYSTEM_P = 340; - public static readonly TABLES = 341; - public static readonly TABLESPACE = 342; - public static readonly TEMP = 343; - public static readonly TEMPLATE = 344; - public static readonly TEMPORARY = 345; - public static readonly TEXT_P = 346; - public static readonly TRANSACTION = 347; - public static readonly TRIGGER = 348; - public static readonly TRUNCATE = 349; - public static readonly TRUSTED = 350; - public static readonly TYPE_P = 351; - public static readonly TYPES_P = 352; - public static readonly UNBOUNDED = 353; - public static readonly UNCOMMITTED = 354; - public static readonly UNENCRYPTED = 355; - public static readonly UNKNOWN = 356; - public static readonly UNLISTEN = 357; - public static readonly UNLOGGED = 358; - public static readonly UNTIL = 359; - public static readonly UPDATE = 360; - public static readonly VACUUM = 361; - public static readonly VALID = 362; - public static readonly VALIDATE = 363; - public static readonly VALIDATOR = 364; - public static readonly VARYING = 365; - public static readonly VERSION_P = 366; - public static readonly VIEW = 367; - public static readonly VOLATILE = 368; - public static readonly WHITESPACE_P = 369; - public static readonly WITHOUT = 370; - public static readonly WORK = 371; - public static readonly WRAPPER = 372; - public static readonly WRITE = 373; - public static readonly XML_P = 374; - public static readonly YEAR_P = 375; - public static readonly YES_P = 376; - public static readonly ZONE = 377; - public static readonly BETWEEN = 378; - public static readonly BIGINT = 379; - public static readonly BIT = 380; - public static readonly BOOLEAN_P = 381; - public static readonly CHAR_P = 382; - public static readonly CHARACTER = 383; - public static readonly COALESCE = 384; - public static readonly DEC = 385; - public static readonly DECIMAL_P = 386; - public static readonly EXISTS = 387; - public static readonly EXTRACT = 388; - public static readonly FLOAT_P = 389; - public static readonly GREATEST = 390; - public static readonly INOUT = 391; - public static readonly INT_P = 392; - public static readonly INTEGER = 393; - public static readonly INTERVAL = 394; - public static readonly LEAST = 395; - public static readonly NATIONAL = 396; - public static readonly NCHAR = 397; - public static readonly NONE = 398; - public static readonly NULLIF = 399; - public static readonly NUMERIC = 400; - public static readonly OVERLAY = 401; - public static readonly POSITION = 402; - public static readonly PRECISION = 403; - public static readonly REAL = 404; - public static readonly ROW = 405; - public static readonly SETOF = 406; - public static readonly SMALLINT = 407; - public static readonly SUBSTRING = 408; - public static readonly TIME = 409; - public static readonly TIMESTAMP = 410; - public static readonly TREAT = 411; - public static readonly TRIM = 412; - public static readonly VALUES = 413; - public static readonly VARCHAR = 414; - public static readonly XMLATTRIBUTES = 415; - public static readonly XMLCONCAT = 416; - public static readonly XMLELEMENT = 417; - public static readonly XMLEXISTS = 418; - public static readonly XMLFOREST = 419; - public static readonly XMLPARSE = 420; - public static readonly XMLPI = 421; - public static readonly XMLROOT = 422; - public static readonly XMLSERIALIZE = 423; - public static readonly CALL = 424; - public static readonly CURRENT_P = 425; - public static readonly ATTACH = 426; - public static readonly DETACH = 427; - public static readonly EXPRESSION = 428; - public static readonly GENERATED = 429; - public static readonly LOGGED = 430; - public static readonly STORED = 431; - public static readonly INCLUDE = 432; - public static readonly ROUTINE = 433; - public static readonly TRANSFORM = 434; - public static readonly IMPORT_P = 435; - public static readonly POLICY = 436; - public static readonly METHOD = 437; - public static readonly REFERENCING = 438; - public static readonly NEW = 439; - public static readonly OLD = 440; - public static readonly VALUE_P = 441; - public static readonly SUBSCRIPTION = 442; - public static readonly PUBLICATION = 443; - public static readonly OUT_P = 444; - public static readonly END_P = 445; - public static readonly ROUTINES = 446; - public static readonly SCHEMAS = 447; - public static readonly PROCEDURES = 448; - public static readonly INPUT_P = 449; - public static readonly SUPPORT = 450; - public static readonly PARALLEL = 451; - public static readonly SQL_P = 452; - public static readonly DEPENDS = 453; - public static readonly OVERRIDING = 454; - public static readonly CONFLICT = 455; - public static readonly SKIP_P = 456; - public static readonly LOCKED = 457; - public static readonly TIES = 458; - public static readonly ROLLUP = 459; - public static readonly CUBE = 460; - public static readonly GROUPING = 461; - public static readonly SETS = 462; - public static readonly TABLESAMPLE = 463; - public static readonly ORDINALITY = 464; - public static readonly XMLTABLE = 465; - public static readonly COLUMNS = 466; - public static readonly XMLNAMESPACES = 467; - public static readonly ROWTYPE = 468; - public static readonly NORMALIZED = 469; - public static readonly WITHIN = 470; - public static readonly FILTER = 471; - public static readonly GROUPS = 472; - public static readonly OTHERS = 473; - public static readonly NFC = 474; - public static readonly NFD = 475; - public static readonly NFKC = 476; - public static readonly NFKD = 477; - public static readonly UESCAPE = 478; - public static readonly VIEWS = 479; - public static readonly NORMALIZE = 480; - public static readonly DUMP = 481; - public static readonly PRINT_STRICT_PARAMS = 482; - public static readonly VARIABLE_CONFLICT = 483; - public static readonly ERROR = 484; - public static readonly USE_VARIABLE = 485; - public static readonly USE_COLUMN = 486; - public static readonly ALIAS = 487; - public static readonly CONSTANT = 488; - public static readonly PERFORM = 489; - public static readonly GET = 490; - public static readonly DIAGNOSTICS = 491; - public static readonly STACKED = 492; - public static readonly ELSIF = 493; - public static readonly WHILE = 494; - public static readonly REVERSE = 495; - public static readonly FOREACH = 496; - public static readonly SLICE = 497; - public static readonly EXIT = 498; - public static readonly RETURN = 499; - public static readonly QUERY = 500; - public static readonly RAISE = 501; - public static readonly SQLSTATE = 502; - public static readonly DEBUG = 503; - public static readonly LOG = 504; - public static readonly INFO = 505; - public static readonly NOTICE = 506; - public static readonly WARNING = 507; - public static readonly EXCEPTION = 508; - public static readonly ASSERT = 509; - public static readonly LOOP = 510; - public static readonly OPEN = 511; - public static readonly Identifier = 512; - public static readonly QuotedIdentifier = 513; - public static readonly UnterminatedQuotedIdentifier = 514; - public static readonly InvalidQuotedIdentifier = 515; - public static readonly InvalidUnterminatedQuotedIdentifier = 516; - public static readonly UnicodeQuotedIdentifier = 517; - public static readonly UnterminatedUnicodeQuotedIdentifier = 518; - public static readonly InvalidUnicodeQuotedIdentifier = 519; - public static readonly InvalidUnterminatedUnicodeQuotedIdentifier = 520; - public static readonly StringConstant = 521; - public static readonly UnterminatedStringConstant = 522; - public static readonly UnicodeEscapeStringConstant = 523; - public static readonly UnterminatedUnicodeEscapeStringConstant = 524; - public static readonly BeginDollarStringConstant = 525; - public static readonly BinaryStringConstant = 526; - public static readonly UnterminatedBinaryStringConstant = 527; - public static readonly InvalidBinaryStringConstant = 528; - public static readonly InvalidUnterminatedBinaryStringConstant = 529; - public static readonly HexadecimalStringConstant = 530; - public static readonly UnterminatedHexadecimalStringConstant = 531; - public static readonly InvalidHexadecimalStringConstant = 532; - public static readonly InvalidUnterminatedHexadecimalStringConstant = 533; - public static readonly Integral = 534; - public static readonly NumericFail = 535; - public static readonly Numeric = 536; - public static readonly PLSQLVARIABLENAME = 537; - public static readonly PLSQLIDENTIFIER = 538; - public static readonly Whitespace = 539; - public static readonly Newline = 540; - public static readonly LineComment = 541; - public static readonly BlockComment = 542; - public static readonly UnterminatedBlockComment = 543; - public static readonly MetaCommand = 544; - public static readonly EndMetaCommand = 545; - public static readonly ErrorCharacter = 546; - public static readonly EscapeStringConstant = 547; - public static readonly UnterminatedEscapeStringConstant = 548; - public static readonly InvalidEscapeStringConstant = 549; - public static readonly InvalidUnterminatedEscapeStringConstant = 550; - public static readonly DollarText = 551; - public static readonly EndDollarStringConstant = 552; - public static readonly AfterEscapeStringConstantWithNewlineMode_Continued = 553; + public static readonly KW_ALL = 30; + public static readonly KW_ANALYSE = 31; + public static readonly KW_ANALYZE = 32; + public static readonly KW_AND = 33; + public static readonly KW_ANY = 34; + public static readonly KW_ARRAY = 35; + public static readonly KW_AS = 36; + public static readonly KW_ASC = 37; + public static readonly KW_ASYMMETRIC = 38; + public static readonly KW_BOTH = 39; + public static readonly KW_CASE = 40; + public static readonly KW_CAST = 41; + public static readonly KW_CHECK = 42; + public static readonly KW_COLLATE = 43; + public static readonly KW_COLUMN = 44; + public static readonly KW_CONSTRAINT = 45; + public static readonly KW_CREATE = 46; + public static readonly KW_CURRENT_CATALOG = 47; + public static readonly KW_CURRENT_DATE = 48; + public static readonly KW_CURRENT_ROLE = 49; + public static readonly KW_CURRENT_TIME = 50; + public static readonly KW_CURRENT_TIMESTAMP = 51; + public static readonly KW_CURRENT_USER = 52; + public static readonly KW_DEFAULT = 53; + public static readonly KW_DEFERRABLE = 54; + public static readonly KW_DESC = 55; + public static readonly KW_DISTINCT = 56; + public static readonly KW_DO = 57; + public static readonly KW_ELSE = 58; + public static readonly KW_EXCEPT = 59; + public static readonly KW_FALSE = 60; + public static readonly KW_FETCH = 61; + public static readonly KW_FOR = 62; + public static readonly KW_FOREIGN = 63; + public static readonly KW_FROM = 64; + public static readonly KW_GRANT = 65; + public static readonly KW_GROUP = 66; + public static readonly KW_HAVING = 67; + public static readonly KW_IN = 68; + public static readonly KW_INITIALLY = 69; + public static readonly KW_INTERSECT = 70; + public static readonly KW_INTO = 71; + public static readonly KW_LATERAL = 72; + public static readonly KW_LEADING = 73; + public static readonly KW_LIMIT = 74; + public static readonly KW_LOCALTIME = 75; + public static readonly KW_LOCALTIMESTAMP = 76; + public static readonly KW_NOT = 77; + public static readonly KW_NULL = 78; + public static readonly KW_OFFSET = 79; + public static readonly KW_ON = 80; + public static readonly KW_ONLY = 81; + public static readonly KW_OR = 82; + public static readonly KW_ORDER = 83; + public static readonly KW_PLACING = 84; + public static readonly KW_PRIMARY = 85; + public static readonly KW_REFERENCES = 86; + public static readonly KW_RETURNING = 87; + public static readonly KW_SELECT = 88; + public static readonly KW_SESSION_USER = 89; + public static readonly KW_SOME = 90; + public static readonly KW_SYMMETRIC = 91; + public static readonly KW_TABLE = 92; + public static readonly KW_THEN = 93; + public static readonly KW_TO = 94; + public static readonly KW_TRAILING = 95; + public static readonly KW_TRUE = 96; + public static readonly KW_UNION = 97; + public static readonly KW_UNIQUE = 98; + public static readonly KW_USER = 99; + public static readonly KW_USING = 100; + public static readonly KW_VARIADIC = 101; + public static readonly KW_WHEN = 102; + public static readonly KW_WHERE = 103; + public static readonly KW_WINDOW = 104; + public static readonly KW_WITH = 105; + public static readonly KW_AUTHORIZATION = 106; + public static readonly KW_BINARY = 107; + public static readonly KW_COLLATION = 108; + public static readonly KW_CONCURRENTLY = 109; + public static readonly KW_CROSS = 110; + public static readonly KW_CURRENT_SCHEMA = 111; + public static readonly KW_FREEZE = 112; + public static readonly KW_FULL = 113; + public static readonly KW_ILIKE = 114; + public static readonly KW_INNER = 115; + public static readonly KW_IS = 116; + public static readonly KW_ISNULL = 117; + public static readonly KW_JOIN = 118; + public static readonly KW_LEFT = 119; + public static readonly KW_LIKE = 120; + public static readonly KW_NATURAL = 121; + public static readonly KW_NOTNULL = 122; + public static readonly KW_OUTER = 123; + public static readonly KW_OVER = 124; + public static readonly KW_OVERLAPS = 125; + public static readonly KW_RIGHT = 126; + public static readonly KW_SIMILAR = 127; + public static readonly KW_VERBOSE = 128; + public static readonly KW_ABORT = 129; + public static readonly KW_ABSOLUTE = 130; + public static readonly KW_ACCESS = 131; + public static readonly KW_ACTION = 132; + public static readonly KW_ADD = 133; + public static readonly KW_ADMIN = 134; + public static readonly KW_AFTER = 135; + public static readonly KW_AGGREGATE = 136; + public static readonly KW_ALSO = 137; + public static readonly KW_ALTER = 138; + public static readonly KW_ALWAYS = 139; + public static readonly KW_ASSERTION = 140; + public static readonly KW_ASSIGNMENT = 141; + public static readonly KW_AT = 142; + public static readonly KW_ATTRIBUTE = 143; + public static readonly KW_BACKWARD = 144; + public static readonly KW_BEFORE = 145; + public static readonly KW_BEGIN = 146; + public static readonly KW_BY = 147; + public static readonly KW_CACHE = 148; + public static readonly KW_CALLED = 149; + public static readonly KW_CASCADE = 150; + public static readonly KW_CASCADED = 151; + public static readonly KW_CATALOG = 152; + public static readonly KW_CHAIN = 153; + public static readonly KW_CHARACTERISTICS = 154; + public static readonly KW_CHECKPOINT = 155; + public static readonly KW_CLASS = 156; + public static readonly KW_CLOSE = 157; + public static readonly KW_CLUSTER = 158; + public static readonly KW_COMMENT = 159; + public static readonly KW_COMMENTS = 160; + public static readonly KW_COMMIT = 161; + public static readonly KW_COMMITTED = 162; + public static readonly KW_CONFIGURATION = 163; + public static readonly KW_CONNECTION = 164; + public static readonly KW_CONSTRAINTS = 165; + public static readonly KW_CONTENT = 166; + public static readonly KW_CONTINUE = 167; + public static readonly KW_CONVERSION = 168; + public static readonly KW_COPY = 169; + public static readonly KW_COST = 170; + public static readonly KW_CSV = 171; + public static readonly KW_CURSOR = 172; + public static readonly KW_CYCLE = 173; + public static readonly KW_DATA = 174; + public static readonly KW_DATABASE = 175; + public static readonly KW_DAY = 176; + public static readonly KW_DEALLOCATE = 177; + public static readonly KW_DECLARE = 178; + public static readonly KW_DEFAULTS = 179; + public static readonly KW_DEFERRED = 180; + public static readonly KW_DEFINER = 181; + public static readonly KW_DELETE = 182; + public static readonly KW_DELIMITER = 183; + public static readonly KW_DELIMITERS = 184; + public static readonly KW_DICTIONARY = 185; + public static readonly KW_DISABLE = 186; + public static readonly KW_DISCARD = 187; + public static readonly KW_DOCUMENT = 188; + public static readonly KW_DOMAIN = 189; + public static readonly KW_DOUBLE = 190; + public static readonly KW_DROP = 191; + public static readonly KW_EACH = 192; + public static readonly KW_ENABLE = 193; + public static readonly KW_ENCODING = 194; + public static readonly KW_ENCRYPTED = 195; + public static readonly KW_ENUM = 196; + public static readonly KW_ESCAPE = 197; + public static readonly KW_EVENT = 198; + public static readonly KW_EXCLUDE = 199; + public static readonly KW_EXCLUDING = 200; + public static readonly KW_EXCLUSIVE = 201; + public static readonly KW_EXECUTE = 202; + public static readonly KW_EXPLAIN = 203; + public static readonly KW_EXTENSION = 204; + public static readonly KW_EXTERNAL = 205; + public static readonly KW_FAMILY = 206; + public static readonly KW_FIRST = 207; + public static readonly KW_FOLLOWING = 208; + public static readonly KW_FORCE = 209; + public static readonly KW_FORWARD = 210; + public static readonly KW_FUNCTION = 211; + public static readonly KW_FUNCTIONS = 212; + public static readonly KW_GLOBAL = 213; + public static readonly KW_GRANTED = 214; + public static readonly KW_HANDLER = 215; + public static readonly KW_HEADER = 216; + public static readonly KW_HOLD = 217; + public static readonly KW_HOUR = 218; + public static readonly KW_IDENTITY = 219; + public static readonly KW_IF = 220; + public static readonly KW_IMMEDIATE = 221; + public static readonly KW_IMMUTABLE = 222; + public static readonly KW_IMPLICIT = 223; + public static readonly KW_INCLUDING = 224; + public static readonly KW_INCREMENT = 225; + public static readonly KW_INDEX = 226; + public static readonly KW_INDEXES = 227; + public static readonly KW_INHERIT = 228; + public static readonly KW_NOINHERIT = 229; + public static readonly KW_SUPERUSER = 230; + public static readonly KW_NOSUPERUSER = 231; + public static readonly KW_CREATEDB = 232; + public static readonly KW_NOCREATEDB = 233; + public static readonly KW_CREATEROLE = 234; + public static readonly KW_NOCREATEROLE = 235; + public static readonly KW_CREATEUSER = 236; + public static readonly KW_NOCREATEUSER = 237; + public static readonly KW_INHERITS = 238; + public static readonly KW_INLINE = 239; + public static readonly KW_INSENSITIVE = 240; + public static readonly KW_INSERT = 241; + public static readonly KW_INSTEAD = 242; + public static readonly KW_INVOKER = 243; + public static readonly KW_ISOLATION = 244; + public static readonly KW_KEY = 245; + public static readonly KW_LABEL = 246; + public static readonly KW_LANGUAGE = 247; + public static readonly KW_LARGE = 248; + public static readonly KW_LAST = 249; + public static readonly KW_LEAKPROOF = 250; + public static readonly KW_LEVEL = 251; + public static readonly KW_LISTEN = 252; + public static readonly KW_LOAD = 253; + public static readonly KW_LOCAL = 254; + public static readonly KW_LOCATION = 255; + public static readonly KW_LOCK = 256; + public static readonly KW_MAPPING = 257; + public static readonly KW_MATCH = 258; + public static readonly KW_MATERIALIZED = 259; + public static readonly KW_MAXVALUE = 260; + public static readonly KW_MINUTE = 261; + public static readonly KW_MINVALUE = 262; + public static readonly KW_MODE = 263; + public static readonly KW_MONTH = 264; + public static readonly KW_MOVE = 265; + public static readonly KW_NAME = 266; + public static readonly KW_NAMES = 267; + public static readonly KW_NEXT = 268; + public static readonly KW_NO = 269; + public static readonly KW_NOTHING = 270; + public static readonly KW_NOTIFY = 271; + public static readonly KW_NOWAIT = 272; + public static readonly KW_NULLS = 273; + public static readonly KW_OBJECT = 274; + public static readonly KW_OF = 275; + public static readonly KW_OFF = 276; + public static readonly KW_OIDS = 277; + public static readonly KW_OPERATOR = 278; + public static readonly KW_OPTION = 279; + public static readonly KW_OPTIONS = 280; + public static readonly KW_OWNED = 281; + public static readonly KW_OWNER = 282; + public static readonly KW_PARSER = 283; + public static readonly KW_PARTIAL = 284; + public static readonly KW_PARTITION = 285; + public static readonly KW_PASSING = 286; + public static readonly KW_PASSWORD = 287; + public static readonly KW_PLANS = 288; + public static readonly KW_PRECEDING = 289; + public static readonly KW_PREPARE = 290; + public static readonly KW_PREPARED = 291; + public static readonly KW_PRESERVE = 292; + public static readonly KW_PRIOR = 293; + public static readonly KW_PRIVILEGES = 294; + public static readonly KW_PROCEDURAL = 295; + public static readonly KW_PROCEDURE = 296; + public static readonly KW_PROGRAM = 297; + public static readonly KW_QUOTE = 298; + public static readonly KW_RANGE = 299; + public static readonly KW_READ = 300; + public static readonly KW_REASSIGN = 301; + public static readonly KW_RECHECK = 302; + public static readonly KW_RECURSIVE = 303; + public static readonly KW_REF = 304; + public static readonly KW_REFRESH = 305; + public static readonly KW_REINDEX = 306; + public static readonly KW_RELATIVE = 307; + public static readonly KW_RELEASE = 308; + public static readonly KW_RENAME = 309; + public static readonly KW_REPEATABLE = 310; + public static readonly KW_REPLACE = 311; + public static readonly KW_REPLICA = 312; + public static readonly KW_RESET = 313; + public static readonly KW_RESTART = 314; + public static readonly KW_RESTRICT = 315; + public static readonly KW_RETURNS = 316; + public static readonly KW_REVOKE = 317; + public static readonly KW_ROLE = 318; + public static readonly KW_ROLLBACK = 319; + public static readonly KW_ROWS = 320; + public static readonly KW_RULE = 321; + public static readonly KW_SAVEPOINT = 322; + public static readonly KW_SCHEMA = 323; + public static readonly KW_SCROLL = 324; + public static readonly KW_SEARCH = 325; + public static readonly KW_SECOND = 326; + public static readonly KW_SECURITY = 327; + public static readonly KW_SEQUENCE = 328; + public static readonly KW_SEQUENCES = 329; + public static readonly KW_SERIALIZABLE = 330; + public static readonly KW_SERVER = 331; + public static readonly KW_SESSION = 332; + public static readonly KW_SET = 333; + public static readonly KW_SHARE = 334; + public static readonly KW_SHOW = 335; + public static readonly KW_SIMPLE = 336; + public static readonly KW_SNAPSHOT = 337; + public static readonly KW_STABLE = 338; + public static readonly KW_STANDALONE = 339; + public static readonly KW_START = 340; + public static readonly KW_STATEMENT = 341; + public static readonly KW_STATISTICS = 342; + public static readonly KW_STDIN = 343; + public static readonly KW_STDOUT = 344; + public static readonly KW_STORAGE = 345; + public static readonly KW_STRICT = 346; + public static readonly KW_STRIP = 347; + public static readonly KW_SYSID = 348; + public static readonly KW_SYSTEM = 349; + public static readonly KW_TABLES = 350; + public static readonly KW_TABLESPACE = 351; + public static readonly KW_TEMP = 352; + public static readonly KW_TEMPLATE = 353; + public static readonly KW_TEMPORARY = 354; + public static readonly KW_TEXT = 355; + public static readonly KW_TRANSACTION = 356; + public static readonly KW_TRIGGER = 357; + public static readonly KW_TRUNCATE = 358; + public static readonly KW_TRUSTED = 359; + public static readonly KW_TYPE = 360; + public static readonly KW_TYPES = 361; + public static readonly KW_UNBOUNDED = 362; + public static readonly KW_UNCOMMITTED = 363; + public static readonly KW_UNENCRYPTED = 364; + public static readonly KW_UNKNOWN = 365; + public static readonly KW_UNLISTEN = 366; + public static readonly KW_UNLOGGED = 367; + public static readonly KW_UNTIL = 368; + public static readonly KW_UPDATE = 369; + public static readonly KW_VACUUM = 370; + public static readonly KW_VALID = 371; + public static readonly KW_VALIDATE = 372; + public static readonly KW_VALIDATOR = 373; + public static readonly KW_VARYING = 374; + public static readonly KW_VERSION = 375; + public static readonly KW_VIEW = 376; + public static readonly KW_VOLATILE = 377; + public static readonly KW_WHITESPACE = 378; + public static readonly KW_WITHOUT = 379; + public static readonly KW_WORK = 380; + public static readonly KW_WRAPPER = 381; + public static readonly KW_WRITE = 382; + public static readonly KW_XML = 383; + public static readonly KW_YEAR = 384; + public static readonly KW_YES = 385; + public static readonly KW_ZONE = 386; + public static readonly KW_BETWEEN = 387; + public static readonly KW_BIGINT = 388; + public static readonly KW_BIT = 389; + public static readonly KW_BOOLEAN = 390; + public static readonly KW_CHAR = 391; + public static readonly KW_CHARACTER = 392; + public static readonly KW_COALESCE = 393; + public static readonly KW_DEC = 394; + public static readonly KW_DECIMAL = 395; + public static readonly KW_EXISTS = 396; + public static readonly KW_EXTRACT = 397; + public static readonly KW_FLOAT = 398; + public static readonly KW_GREATEST = 399; + public static readonly KW_INOUT = 400; + public static readonly KW_INT = 401; + public static readonly KW_INTEGER = 402; + public static readonly KW_INTERVAL = 403; + public static readonly KW_LEAST = 404; + public static readonly KW_NATIONAL = 405; + public static readonly KW_NCHAR = 406; + public static readonly KW_NONE = 407; + public static readonly KW_NULLIF = 408; + public static readonly KW_NUMERIC = 409; + public static readonly KW_OVERLAY = 410; + public static readonly KW_POSITION = 411; + public static readonly KW_PRECISION = 412; + public static readonly KW_REAL = 413; + public static readonly KW_ROW = 414; + public static readonly KW_SETOF = 415; + public static readonly KW_SMALLINT = 416; + public static readonly KW_SUBSTRING = 417; + public static readonly KW_TIME = 418; + public static readonly KW_TIMESTAMP = 419; + public static readonly KW_TREAT = 420; + public static readonly KW_TRIM = 421; + public static readonly KW_VALUES = 422; + public static readonly KW_VARCHAR = 423; + public static readonly KW_XMLATTRIBUTES = 424; + public static readonly KW_XMLCONCAT = 425; + public static readonly KW_XMLELEMENT = 426; + public static readonly KW_XMLEXISTS = 427; + public static readonly KW_XMLFOREST = 428; + public static readonly KW_XMLPARSE = 429; + public static readonly KW_XMLPI = 430; + public static readonly KW_XMLROOT = 431; + public static readonly KW_XMLSERIALIZE = 432; + public static readonly KW_CALL = 433; + public static readonly KW_CURRENT = 434; + public static readonly KW_ATTACH = 435; + public static readonly KW_DETACH = 436; + public static readonly KW_EXPRESSION = 437; + public static readonly KW_GENERATED = 438; + public static readonly KW_LOGGED = 439; + public static readonly KW_STORED = 440; + public static readonly KW_INCLUDE = 441; + public static readonly KW_ROUTINE = 442; + public static readonly KW_TRANSFORM = 443; + public static readonly KW_IMPORT = 444; + public static readonly KW_POLICY = 445; + public static readonly KW_METHOD = 446; + public static readonly KW_REFERENCING = 447; + public static readonly KW_NEW = 448; + public static readonly KW_OLD = 449; + public static readonly KW_VALUE = 450; + public static readonly KW_SUBSCRIPTION = 451; + public static readonly KW_PUBLICATION = 452; + public static readonly KW_OUT = 453; + public static readonly KW_END = 454; + public static readonly KW_ROUTINES = 455; + public static readonly KW_SCHEMAS = 456; + public static readonly KW_PROCEDURES = 457; + public static readonly KW_INPUT = 458; + public static readonly KW_SUPPORT = 459; + public static readonly KW_PARALLEL = 460; + public static readonly KW_SQL = 461; + public static readonly KW_DEPENDS = 462; + public static readonly KW_OVERRIDING = 463; + public static readonly KW_CONFLICT = 464; + public static readonly KW_SKIP = 465; + public static readonly KW_LOCKED = 466; + public static readonly KW_TIES = 467; + public static readonly KW_ROLLUP = 468; + public static readonly KW_CUBE = 469; + public static readonly KW_GROUPING = 470; + public static readonly KW_SETS = 471; + public static readonly KW_TABLESAMPLE = 472; + public static readonly KW_ORDINALITY = 473; + public static readonly KW_XMLTABLE = 474; + public static readonly KW_COLUMNS = 475; + public static readonly KW_XMLNAMESPACES = 476; + public static readonly KW_ROWTYPE = 477; + public static readonly KW_NORMALIZED = 478; + public static readonly KW_WITHIN = 479; + public static readonly KW_FILTER = 480; + public static readonly KW_GROUPS = 481; + public static readonly KW_OTHERS = 482; + public static readonly KW_NFC = 483; + public static readonly KW_NFD = 484; + public static readonly KW_NFKC = 485; + public static readonly KW_NFKD = 486; + public static readonly KW_UESCAPE = 487; + public static readonly KW_VIEWS = 488; + public static readonly KW_NORMALIZE = 489; + public static readonly KW_DUMP = 490; + public static readonly KW_PRINT_STRICT_PARAMS = 491; + public static readonly KW_VARIABLE_CONFLICT = 492; + public static readonly KW_ERROR = 493; + public static readonly KW_USE_VARIABLE = 494; + public static readonly KW_USE_COLUMN = 495; + public static readonly KW_ALIAS = 496; + public static readonly KW_CONSTANT = 497; + public static readonly KW_PERFORM = 498; + public static readonly KW_GET = 499; + public static readonly KW_DIAGNOSTICS = 500; + public static readonly KW_STACKED = 501; + public static readonly KW_ELSIF = 502; + public static readonly KW_WHILE = 503; + public static readonly KW_REVERSE = 504; + public static readonly KW_FOREACH = 505; + public static readonly KW_SLICE = 506; + public static readonly KW_EXIT = 507; + public static readonly KW_RETURN = 508; + public static readonly KW_QUERY = 509; + public static readonly KW_RAISE = 510; + public static readonly KW_SQLSTATE = 511; + public static readonly KW_DEBUG = 512; + public static readonly KW_LOG = 513; + public static readonly KW_INFO = 514; + public static readonly KW_NOTICE = 515; + public static readonly KW_WARNING = 516; + public static readonly KW_EXCEPTION = 517; + public static readonly KW_ASSERT = 518; + public static readonly KW_LOOP = 519; + public static readonly KW_OPEN = 520; + public static readonly KW_PEFERENCES = 521; + public static readonly KW_USAGE = 522; + public static readonly KW_CONNECT = 523; + public static readonly KW_PUBLIC = 524; + public static readonly Identifier = 525; + public static readonly QuotedIdentifier = 526; + public static readonly UnterminatedQuotedIdentifier = 527; + public static readonly InvalidQuotedIdentifier = 528; + public static readonly InvalidUnterminatedQuotedIdentifier = 529; + public static readonly UnicodeQuotedIdentifier = 530; + public static readonly UnterminatedUnicodeQuotedIdentifier = 531; + public static readonly InvalidUnicodeQuotedIdentifier = 532; + public static readonly InvalidUnterminatedUnicodeQuotedIdentifier = 533; + public static readonly StringConstant = 534; + public static readonly UnterminatedStringConstant = 535; + public static readonly UnicodeEscapeStringConstant = 536; + public static readonly UnterminatedUnicodeEscapeStringConstant = 537; + public static readonly BeginDollarStringConstant = 538; + public static readonly BinaryStringConstant = 539; + public static readonly UnterminatedBinaryStringConstant = 540; + public static readonly InvalidBinaryStringConstant = 541; + public static readonly InvalidUnterminatedBinaryStringConstant = 542; + public static readonly HexadecimalStringConstant = 543; + public static readonly UnterminatedHexadecimalStringConstant = 544; + public static readonly InvalidHexadecimalStringConstant = 545; + public static readonly InvalidUnterminatedHexadecimalStringConstant = 546; + public static readonly Integral = 547; + public static readonly NumericFail = 548; + public static readonly Numeric = 549; + public static readonly PLSQLVARIABLENAME = 550; + public static readonly PLSQLIDENTIFIER = 551; + public static readonly Whitespace = 552; + public static readonly Newline = 553; + public static readonly LineComment = 554; + public static readonly BlockComment = 555; + public static readonly UnterminatedBlockComment = 556; + public static readonly MetaCommand = 557; + public static readonly EndMetaCommand = 558; + public static readonly ErrorCharacter = 559; + public static readonly EscapeStringConstant = 560; + public static readonly UnterminatedEscapeStringConstant = 561; + public static readonly InvalidEscapeStringConstant = 562; + public static readonly InvalidUnterminatedEscapeStringConstant = 563; + public static readonly DollarText = 564; + public static readonly EndDollarStringConstant = 565; + public static readonly AfterEscapeStringConstantWithNewlineMode_Continued = 566; public static readonly RULE_program = 0; public static readonly RULE_plsqlroot = 1; public static readonly RULE_stmtmulti = 2; @@ -671,722 +681,735 @@ export class PostgreSQLParser extends PostgreSQLParserBase { public static readonly RULE_copy_generic_opt_arg_list_item = 84; public static readonly RULE_createstmt = 85; public static readonly RULE_opttemp = 86; - public static readonly RULE_opttableelementlist = 87; - public static readonly RULE_opttypedtableelementlist = 88; - public static readonly RULE_tableelementlist = 89; - public static readonly RULE_typedtableelementlist = 90; - public static readonly RULE_tableelement = 91; - public static readonly RULE_typedtableelement = 92; - public static readonly RULE_columnDef = 93; - public static readonly RULE_columnOptions = 94; - public static readonly RULE_colquallist = 95; - public static readonly RULE_colconstraint = 96; - public static readonly RULE_colconstraintelem = 97; - public static readonly RULE_generated_when = 98; - public static readonly RULE_constraintattr = 99; - public static readonly RULE_tablelikeclause = 100; - public static readonly RULE_tablelikeoptionlist = 101; - public static readonly RULE_tablelikeoption = 102; - public static readonly RULE_tableconstraint = 103; - public static readonly RULE_constraintelem = 104; - public static readonly RULE_opt_no_inherit = 105; - public static readonly RULE_opt_column_list = 106; - public static readonly RULE_columnlist = 107; - public static readonly RULE_columnElem = 108; - public static readonly RULE_opt_c_include = 109; - public static readonly RULE_key_match = 110; - public static readonly RULE_exclusionconstraintlist = 111; - public static readonly RULE_exclusionconstraintelem = 112; - public static readonly RULE_exclusionwhereclause = 113; - public static readonly RULE_key_actions = 114; - public static readonly RULE_key_update = 115; - public static readonly RULE_key_delete = 116; - public static readonly RULE_key_action = 117; - public static readonly RULE_optinherit = 118; - public static readonly RULE_optpartitionspec = 119; - public static readonly RULE_partitionspec = 120; - public static readonly RULE_part_params = 121; - public static readonly RULE_part_elem = 122; - public static readonly RULE_table_access_method_clause = 123; - public static readonly RULE_optwith = 124; - public static readonly RULE_oncommitoption = 125; - public static readonly RULE_opttablespace = 126; - public static readonly RULE_optconstablespace = 127; - public static readonly RULE_existingindex = 128; - public static readonly RULE_createstatsstmt = 129; - public static readonly RULE_alterstatsstmt = 130; - public static readonly RULE_createasstmt = 131; - public static readonly RULE_create_as_target = 132; - public static readonly RULE_opt_with_data = 133; - public static readonly RULE_creatematviewstmt = 134; - public static readonly RULE_create_mv_target = 135; - public static readonly RULE_optnolog = 136; - public static readonly RULE_refreshmatviewstmt = 137; - public static readonly RULE_createseqstmt = 138; - public static readonly RULE_alterseqstmt = 139; - public static readonly RULE_optseqoptlist = 140; - public static readonly RULE_optparenthesizedseqoptlist = 141; - public static readonly RULE_seqoptlist = 142; - public static readonly RULE_seqoptelem = 143; - public static readonly RULE_opt_by = 144; - public static readonly RULE_numericonly = 145; - public static readonly RULE_numericonly_list = 146; - public static readonly RULE_createplangstmt = 147; - public static readonly RULE_opt_trusted = 148; - public static readonly RULE_handler_name = 149; - public static readonly RULE_opt_inline_handler = 150; - public static readonly RULE_validator_clause = 151; - public static readonly RULE_opt_validator = 152; - public static readonly RULE_opt_procedural = 153; - public static readonly RULE_createtablespacestmt = 154; - public static readonly RULE_opttablespaceowner = 155; - public static readonly RULE_droptablespacestmt = 156; - public static readonly RULE_createextensionstmt = 157; - public static readonly RULE_create_extension_opt_list = 158; - public static readonly RULE_create_extension_opt_item = 159; - public static readonly RULE_alterextensionstmt = 160; - public static readonly RULE_alter_extension_opt_list = 161; - public static readonly RULE_alter_extension_opt_item = 162; - public static readonly RULE_alterextensioncontentsstmt = 163; - public static readonly RULE_createfdwstmt = 164; - public static readonly RULE_fdw_option = 165; - public static readonly RULE_fdw_options = 166; - public static readonly RULE_opt_fdw_options = 167; - public static readonly RULE_alterfdwstmt = 168; - public static readonly RULE_create_generic_options = 169; - public static readonly RULE_generic_option_list = 170; - public static readonly RULE_alter_generic_options = 171; - public static readonly RULE_alter_generic_option_list = 172; - public static readonly RULE_alter_generic_option_elem = 173; - public static readonly RULE_generic_option_elem = 174; - public static readonly RULE_generic_option_name = 175; - public static readonly RULE_generic_option_arg = 176; - public static readonly RULE_createforeignserverstmt = 177; - public static readonly RULE_opt_type = 178; - public static readonly RULE_foreign_server_version = 179; - public static readonly RULE_opt_foreign_server_version = 180; - public static readonly RULE_alterforeignserverstmt = 181; - public static readonly RULE_createforeigntablestmt = 182; - public static readonly RULE_importforeignschemastmt = 183; - public static readonly RULE_import_qualification_type = 184; - public static readonly RULE_import_qualification = 185; - public static readonly RULE_createusermappingstmt = 186; - public static readonly RULE_auth_ident = 187; - public static readonly RULE_dropusermappingstmt = 188; - public static readonly RULE_alterusermappingstmt = 189; - public static readonly RULE_createpolicystmt = 190; - public static readonly RULE_alterpolicystmt = 191; - public static readonly RULE_rowsecurityoptionalexpr = 192; - public static readonly RULE_rowsecurityoptionalwithcheck = 193; - public static readonly RULE_rowsecuritydefaulttorole = 194; - public static readonly RULE_rowsecurityoptionaltorole = 195; - public static readonly RULE_rowsecuritydefaultpermissive = 196; - public static readonly RULE_rowsecuritydefaultforcmd = 197; - public static readonly RULE_row_security_cmd = 198; - public static readonly RULE_createamstmt = 199; - public static readonly RULE_am_type = 200; - public static readonly RULE_createtrigstmt = 201; - public static readonly RULE_triggeractiontime = 202; - public static readonly RULE_triggerevents = 203; - public static readonly RULE_triggeroneevent = 204; - public static readonly RULE_triggerreferencing = 205; - public static readonly RULE_triggertransitions = 206; - public static readonly RULE_triggertransition = 207; - public static readonly RULE_transitionoldornew = 208; - public static readonly RULE_transitionrowortable = 209; - public static readonly RULE_transitionrelname = 210; - public static readonly RULE_triggerforspec = 211; - public static readonly RULE_triggerforopteach = 212; - public static readonly RULE_triggerfortype = 213; - public static readonly RULE_triggerwhen = 214; - public static readonly RULE_function_or_procedure = 215; - public static readonly RULE_triggerfuncargs = 216; - public static readonly RULE_triggerfuncarg = 217; - public static readonly RULE_optconstrfromtable = 218; - public static readonly RULE_constraintattributespec = 219; - public static readonly RULE_constraintattributeElem = 220; - public static readonly RULE_createeventtrigstmt = 221; - public static readonly RULE_event_trigger_when_list = 222; - public static readonly RULE_event_trigger_when_item = 223; - public static readonly RULE_event_trigger_value_list = 224; - public static readonly RULE_altereventtrigstmt = 225; - public static readonly RULE_enable_trigger = 226; - public static readonly RULE_createassertionstmt = 227; - public static readonly RULE_definestmt = 228; - public static readonly RULE_definition = 229; - public static readonly RULE_def_list = 230; - public static readonly RULE_def_elem = 231; - public static readonly RULE_def_arg = 232; - public static readonly RULE_old_aggr_definition = 233; - public static readonly RULE_old_aggr_list = 234; - public static readonly RULE_old_aggr_elem = 235; - public static readonly RULE_opt_enum_val_list = 236; - public static readonly RULE_enum_val_list = 237; - public static readonly RULE_alterenumstmt = 238; - public static readonly RULE_opt_if_not_exists = 239; - public static readonly RULE_createopclassstmt = 240; - public static readonly RULE_opclass_item_list = 241; - public static readonly RULE_opclass_item = 242; - public static readonly RULE_opt_default = 243; - public static readonly RULE_opt_opfamily = 244; - public static readonly RULE_opclass_purpose = 245; - public static readonly RULE_opt_recheck = 246; - public static readonly RULE_createopfamilystmt = 247; - public static readonly RULE_alteropfamilystmt = 248; - public static readonly RULE_opclass_drop_list = 249; - public static readonly RULE_opclass_drop = 250; - public static readonly RULE_dropopclassstmt = 251; - public static readonly RULE_dropopfamilystmt = 252; - public static readonly RULE_dropownedstmt = 253; - public static readonly RULE_reassignownedstmt = 254; - public static readonly RULE_dropstmt = 255; - public static readonly RULE_object_type_any_name = 256; - public static readonly RULE_object_type_name = 257; - public static readonly RULE_drop_type_name = 258; - public static readonly RULE_object_type_name_on_any_name = 259; - public static readonly RULE_any_name_list = 260; - public static readonly RULE_any_name = 261; - public static readonly RULE_attrs = 262; - public static readonly RULE_type_name_list = 263; - public static readonly RULE_truncatestmt = 264; - public static readonly RULE_opt_restart_seqs = 265; - public static readonly RULE_commentstmt = 266; - public static readonly RULE_comment_text = 267; - public static readonly RULE_seclabelstmt = 268; - public static readonly RULE_opt_provider = 269; - public static readonly RULE_security_label = 270; - public static readonly RULE_fetchstmt = 271; - public static readonly RULE_fetch_args = 272; - public static readonly RULE_from_in = 273; - public static readonly RULE_opt_from_in = 274; - public static readonly RULE_grantstmt = 275; - public static readonly RULE_revokestmt = 276; - public static readonly RULE_privileges = 277; - public static readonly RULE_privilege_list = 278; - public static readonly RULE_privilege = 279; - public static readonly RULE_privilege_target = 280; - public static readonly RULE_grantee_list = 281; - public static readonly RULE_grantee = 282; - public static readonly RULE_opt_grant_grant_option = 283; - public static readonly RULE_grantrolestmt = 284; - public static readonly RULE_revokerolestmt = 285; - public static readonly RULE_opt_grant_admin_option = 286; - public static readonly RULE_opt_granted_by = 287; - public static readonly RULE_alterdefaultprivilegesstmt = 288; - public static readonly RULE_defacloptionlist = 289; - public static readonly RULE_defacloption = 290; - public static readonly RULE_defaclaction = 291; - public static readonly RULE_defacl_privilege_target = 292; - public static readonly RULE_indexstmt = 293; - public static readonly RULE_opt_unique = 294; - public static readonly RULE_opt_concurrently = 295; - public static readonly RULE_opt_index_name = 296; - public static readonly RULE_access_method_clause = 297; - public static readonly RULE_index_params = 298; - public static readonly RULE_index_elem_options = 299; - public static readonly RULE_index_elem = 300; - public static readonly RULE_opt_include = 301; - public static readonly RULE_index_including_params = 302; - public static readonly RULE_opt_collate = 303; - public static readonly RULE_opt_class = 304; - public static readonly RULE_opt_asc_desc = 305; - public static readonly RULE_opt_nulls_order = 306; - public static readonly RULE_createfunctionstmt = 307; - public static readonly RULE_opt_or_replace = 308; - public static readonly RULE_func_args = 309; - public static readonly RULE_func_args_list = 310; - public static readonly RULE_function_with_argtypes_list = 311; - public static readonly RULE_function_with_argtypes = 312; - public static readonly RULE_func_args_with_defaults = 313; - public static readonly RULE_func_args_with_defaults_list = 314; - public static readonly RULE_func_arg = 315; - public static readonly RULE_arg_class = 316; - public static readonly RULE_param_name = 317; - public static readonly RULE_func_return = 318; - public static readonly RULE_func_type = 319; - public static readonly RULE_func_arg_with_default = 320; - public static readonly RULE_aggr_arg = 321; - public static readonly RULE_aggr_args = 322; - public static readonly RULE_aggr_args_list = 323; - public static readonly RULE_aggregate_with_argtypes = 324; - public static readonly RULE_aggregate_with_argtypes_list = 325; - public static readonly RULE_createfunc_opt_list = 326; - public static readonly RULE_common_func_opt_item = 327; - public static readonly RULE_createfunc_opt_item = 328; - public static readonly RULE_func_as = 329; - public static readonly RULE_transform_type_list = 330; - public static readonly RULE_opt_definition = 331; - public static readonly RULE_table_func_column = 332; - public static readonly RULE_table_func_column_list = 333; - public static readonly RULE_alterfunctionstmt = 334; - public static readonly RULE_alterfunc_opt_list = 335; - public static readonly RULE_opt_restrict = 336; - public static readonly RULE_removefuncstmt = 337; - public static readonly RULE_removeaggrstmt = 338; - public static readonly RULE_removeoperstmt = 339; - public static readonly RULE_oper_argtypes = 340; - public static readonly RULE_any_operator = 341; - public static readonly RULE_operator_with_argtypes_list = 342; - public static readonly RULE_operator_with_argtypes = 343; - public static readonly RULE_dostmt = 344; - public static readonly RULE_dostmt_opt_list = 345; - public static readonly RULE_dostmt_opt_item = 346; - public static readonly RULE_createcaststmt = 347; - public static readonly RULE_cast_context = 348; - public static readonly RULE_dropcaststmt = 349; - public static readonly RULE_opt_if_exists = 350; - public static readonly RULE_createtransformstmt = 351; - public static readonly RULE_transform_element_list = 352; - public static readonly RULE_droptransformstmt = 353; - public static readonly RULE_reindexstmt = 354; - public static readonly RULE_reindex_target_type = 355; - public static readonly RULE_reindex_target_multitable = 356; - public static readonly RULE_reindex_option_list = 357; - public static readonly RULE_reindex_option_elem = 358; - public static readonly RULE_altertblspcstmt = 359; - public static readonly RULE_renamestmt = 360; - public static readonly RULE_opt_column = 361; - public static readonly RULE_opt_set_data = 362; - public static readonly RULE_alterobjectdependsstmt = 363; - public static readonly RULE_opt_no = 364; - public static readonly RULE_alterobjectschemastmt = 365; - public static readonly RULE_alteroperatorstmt = 366; - public static readonly RULE_operator_def_list = 367; - public static readonly RULE_operator_def_elem = 368; - public static readonly RULE_operator_def_arg = 369; - public static readonly RULE_altertypestmt = 370; - public static readonly RULE_alterownerstmt = 371; - public static readonly RULE_createpublicationstmt = 372; - public static readonly RULE_opt_publication_for_tables = 373; - public static readonly RULE_publication_for_tables = 374; - public static readonly RULE_alterpublicationstmt = 375; - public static readonly RULE_createsubscriptionstmt = 376; - public static readonly RULE_publication_name_list = 377; - public static readonly RULE_publication_name_item = 378; - public static readonly RULE_altersubscriptionstmt = 379; - public static readonly RULE_dropsubscriptionstmt = 380; - public static readonly RULE_rulestmt = 381; - public static readonly RULE_ruleactionlist = 382; - public static readonly RULE_ruleactionmulti = 383; - public static readonly RULE_ruleactionstmt = 384; - public static readonly RULE_ruleactionstmtOrEmpty = 385; - public static readonly RULE_event = 386; - public static readonly RULE_opt_instead = 387; - public static readonly RULE_notifystmt = 388; - public static readonly RULE_notify_payload = 389; - public static readonly RULE_listenstmt = 390; - public static readonly RULE_unlistenstmt = 391; - public static readonly RULE_transactionstmt = 392; - public static readonly RULE_opt_transaction = 393; - public static readonly RULE_transaction_mode_item = 394; - public static readonly RULE_transaction_mode_list = 395; - public static readonly RULE_transaction_mode_list_or_empty = 396; - public static readonly RULE_opt_transaction_chain = 397; - public static readonly RULE_viewstmt = 398; - public static readonly RULE_opt_check_option = 399; - public static readonly RULE_loadstmt = 400; - public static readonly RULE_createdbstmt = 401; - public static readonly RULE_createdb_opt_list = 402; - public static readonly RULE_createdb_opt_items = 403; - public static readonly RULE_createdb_opt_item = 404; - public static readonly RULE_createdb_opt_name = 405; - public static readonly RULE_opt_equal = 406; - public static readonly RULE_alterdatabasestmt = 407; - public static readonly RULE_alterdatabasesetstmt = 408; - public static readonly RULE_dropdbstmt = 409; - public static readonly RULE_drop_option_list = 410; - public static readonly RULE_drop_option = 411; - public static readonly RULE_altercollationstmt = 412; - public static readonly RULE_altersystemstmt = 413; - public static readonly RULE_createdomainstmt = 414; - public static readonly RULE_alterdomainstmt = 415; - public static readonly RULE_opt_as = 416; - public static readonly RULE_altertsdictionarystmt = 417; - public static readonly RULE_altertsconfigurationstmt = 418; - public static readonly RULE_any_with = 419; - public static readonly RULE_createconversionstmt = 420; - public static readonly RULE_clusterstmt = 421; - public static readonly RULE_cluster_index_specification = 422; - public static readonly RULE_vacuumstmt = 423; - public static readonly RULE_analyzestmt = 424; - public static readonly RULE_vac_analyze_option_list = 425; - public static readonly RULE_analyze_keyword = 426; - public static readonly RULE_vac_analyze_option_elem = 427; - public static readonly RULE_vac_analyze_option_name = 428; - public static readonly RULE_vac_analyze_option_arg = 429; - public static readonly RULE_opt_analyze = 430; - public static readonly RULE_opt_verbose = 431; - public static readonly RULE_opt_full = 432; - public static readonly RULE_opt_freeze = 433; - public static readonly RULE_opt_name_list = 434; - public static readonly RULE_vacuum_relation = 435; - public static readonly RULE_vacuum_relation_list = 436; - public static readonly RULE_opt_vacuum_relation_list = 437; - public static readonly RULE_explainstmt = 438; - public static readonly RULE_explainablestmt = 439; - public static readonly RULE_explain_option_list = 440; - public static readonly RULE_explain_option_elem = 441; - public static readonly RULE_explain_option_name = 442; - public static readonly RULE_explain_option_arg = 443; - public static readonly RULE_preparestmt = 444; - public static readonly RULE_prep_type_clause = 445; - public static readonly RULE_preparablestmt = 446; - public static readonly RULE_executestmt = 447; - public static readonly RULE_execute_param_clause = 448; - public static readonly RULE_deallocatestmt = 449; - public static readonly RULE_insertstmt = 450; - public static readonly RULE_insert_target = 451; - public static readonly RULE_insert_rest = 452; - public static readonly RULE_override_kind = 453; - public static readonly RULE_insert_column_list = 454; - public static readonly RULE_insert_column_item = 455; - public static readonly RULE_opt_on_conflict = 456; - public static readonly RULE_opt_conf_expr = 457; - public static readonly RULE_returning_clause = 458; - public static readonly RULE_deletestmt = 459; - public static readonly RULE_using_clause = 460; - public static readonly RULE_lockstmt = 461; - public static readonly RULE_opt_lock = 462; - public static readonly RULE_lock_type = 463; - public static readonly RULE_opt_nowait = 464; - public static readonly RULE_opt_nowait_or_skip = 465; - public static readonly RULE_updatestmt = 466; - public static readonly RULE_set_clause_list = 467; - public static readonly RULE_set_clause = 468; - public static readonly RULE_set_target = 469; - public static readonly RULE_set_target_list = 470; - public static readonly RULE_declarecursorstmt = 471; - public static readonly RULE_cursor_name = 472; - public static readonly RULE_cursor_options = 473; - public static readonly RULE_opt_hold = 474; - public static readonly RULE_selectstmt = 475; - public static readonly RULE_select_with_parens = 476; - public static readonly RULE_select_no_parens = 477; - public static readonly RULE_select_clause = 478; - public static readonly RULE_simple_select = 479; - public static readonly RULE_set_operator = 480; - public static readonly RULE_set_operator_with_all_or_distinct = 481; - public static readonly RULE_with_clause = 482; - public static readonly RULE_cte_list = 483; - public static readonly RULE_common_table_expr = 484; - public static readonly RULE_opt_materialized = 485; - public static readonly RULE_opt_with_clause = 486; - public static readonly RULE_into_clause = 487; - public static readonly RULE_opt_strict = 488; - public static readonly RULE_opttempTableName = 489; - public static readonly RULE_opt_table = 490; - public static readonly RULE_all_or_distinct = 491; - public static readonly RULE_distinct_clause = 492; - public static readonly RULE_opt_all_clause = 493; - public static readonly RULE_opt_sort_clause = 494; - public static readonly RULE_sort_clause = 495; - public static readonly RULE_sortby_list = 496; - public static readonly RULE_sortby = 497; - public static readonly RULE_select_limit = 498; - public static readonly RULE_opt_select_limit = 499; - public static readonly RULE_limit_clause = 500; - public static readonly RULE_offset_clause = 501; - public static readonly RULE_select_limit_value = 502; - public static readonly RULE_select_offset_value = 503; - public static readonly RULE_select_fetch_first_value = 504; - public static readonly RULE_i_or_f_const = 505; - public static readonly RULE_row_or_rows = 506; - public static readonly RULE_first_or_next = 507; - public static readonly RULE_group_clause = 508; - public static readonly RULE_group_by_list = 509; - public static readonly RULE_group_by_item = 510; - public static readonly RULE_empty_grouping_set = 511; - public static readonly RULE_rollup_clause = 512; - public static readonly RULE_cube_clause = 513; - public static readonly RULE_grouping_sets_clause = 514; - public static readonly RULE_having_clause = 515; - public static readonly RULE_for_locking_clause = 516; - public static readonly RULE_opt_for_locking_clause = 517; - public static readonly RULE_for_locking_items = 518; - public static readonly RULE_for_locking_item = 519; - public static readonly RULE_for_locking_strength = 520; - public static readonly RULE_locked_rels_list = 521; - public static readonly RULE_values_clause = 522; - public static readonly RULE_from_clause = 523; - public static readonly RULE_from_list = 524; - public static readonly RULE_table_ref = 525; - public static readonly RULE_alias_clause = 526; - public static readonly RULE_opt_alias_clause = 527; - public static readonly RULE_func_alias_clause = 528; - public static readonly RULE_join_type = 529; - public static readonly RULE_join_qual = 530; - public static readonly RULE_relation_expr = 531; - public static readonly RULE_relation_expr_list = 532; - public static readonly RULE_relation_expr_opt_alias = 533; - public static readonly RULE_tablesample_clause = 534; - public static readonly RULE_opt_repeatable_clause = 535; - public static readonly RULE_func_table = 536; - public static readonly RULE_rowsfrom_item = 537; - public static readonly RULE_rowsfrom_list = 538; - public static readonly RULE_opt_col_def_list = 539; - public static readonly RULE_opt_ordinality = 540; - public static readonly RULE_where_clause = 541; - public static readonly RULE_where_or_current_clause = 542; - public static readonly RULE_opttablefuncelementlist = 543; - public static readonly RULE_tablefuncelementlist = 544; - public static readonly RULE_tablefuncelement = 545; - public static readonly RULE_xmltable = 546; - public static readonly RULE_xmltable_column_list = 547; - public static readonly RULE_xmltable_column_el = 548; - public static readonly RULE_xmltable_column_option_list = 549; - public static readonly RULE_xmltable_column_option_el = 550; - public static readonly RULE_xml_namespace_list = 551; - public static readonly RULE_xml_namespace_el = 552; - public static readonly RULE_typename = 553; - public static readonly RULE_opt_array_bounds = 554; - public static readonly RULE_simpletypename = 555; - public static readonly RULE_consttypename = 556; - public static readonly RULE_generictype = 557; - public static readonly RULE_opt_type_modifiers = 558; - public static readonly RULE_numeric = 559; - public static readonly RULE_opt_float = 560; - public static readonly RULE_bit = 561; - public static readonly RULE_constbit = 562; - public static readonly RULE_bitwithlength = 563; - public static readonly RULE_bitwithoutlength = 564; - public static readonly RULE_character = 565; - public static readonly RULE_constcharacter = 566; - public static readonly RULE_character_c = 567; - public static readonly RULE_opt_varying = 568; - public static readonly RULE_constdatetime = 569; - public static readonly RULE_constinterval = 570; - public static readonly RULE_opt_timezone = 571; - public static readonly RULE_opt_interval = 572; - public static readonly RULE_interval_second = 573; - public static readonly RULE_opt_escape = 574; - public static readonly RULE_a_expr = 575; - public static readonly RULE_a_expr_qual = 576; - public static readonly RULE_a_expr_lessless = 577; - public static readonly RULE_a_expr_or = 578; - public static readonly RULE_a_expr_and = 579; - public static readonly RULE_a_expr_in = 580; - public static readonly RULE_a_expr_unary_not = 581; - public static readonly RULE_a_expr_isnull = 582; - public static readonly RULE_a_expr_is_not = 583; - public static readonly RULE_a_expr_compare = 584; - public static readonly RULE_a_expr_like = 585; - public static readonly RULE_a_expr_qual_op = 586; - public static readonly RULE_a_expr_unary_qualop = 587; - public static readonly RULE_a_expr_add = 588; - public static readonly RULE_a_expr_mul = 589; - public static readonly RULE_a_expr_caret = 590; - public static readonly RULE_a_expr_unary_sign = 591; - public static readonly RULE_a_expr_at_time_zone = 592; - public static readonly RULE_a_expr_collate = 593; - public static readonly RULE_a_expr_typecast = 594; - public static readonly RULE_b_expr = 595; - public static readonly RULE_c_expr = 596; - public static readonly RULE_plsqlvariablename = 597; - public static readonly RULE_func_application = 598; - public static readonly RULE_func_expr = 599; - public static readonly RULE_func_expr_windowless = 600; - public static readonly RULE_func_expr_common_subexpr = 601; - public static readonly RULE_xml_root_version = 602; - public static readonly RULE_opt_xml_root_standalone = 603; - public static readonly RULE_xml_attributes = 604; - public static readonly RULE_xml_attribute_list = 605; - public static readonly RULE_xml_attribute_el = 606; - public static readonly RULE_document_or_content = 607; - public static readonly RULE_xml_whitespace_option = 608; - public static readonly RULE_xmlexists_argument = 609; - public static readonly RULE_xml_passing_mech = 610; - public static readonly RULE_within_group_clause = 611; - public static readonly RULE_filter_clause = 612; - public static readonly RULE_window_clause = 613; - public static readonly RULE_window_definition_list = 614; - public static readonly RULE_window_definition = 615; - public static readonly RULE_over_clause = 616; - public static readonly RULE_window_specification = 617; - public static readonly RULE_opt_existing_window_name = 618; - public static readonly RULE_opt_partition_clause = 619; - public static readonly RULE_opt_frame_clause = 620; - public static readonly RULE_frame_extent = 621; - public static readonly RULE_frame_bound = 622; - public static readonly RULE_opt_window_exclusion_clause = 623; - public static readonly RULE_row = 624; - public static readonly RULE_explicit_row = 625; - public static readonly RULE_implicit_row = 626; - public static readonly RULE_sub_type = 627; - public static readonly RULE_all_op = 628; - public static readonly RULE_mathop = 629; - public static readonly RULE_qual_op = 630; - public static readonly RULE_qual_all_op = 631; - public static readonly RULE_subquery_Op = 632; - public static readonly RULE_expr_list = 633; - public static readonly RULE_func_arg_list = 634; - public static readonly RULE_func_arg_expr = 635; - public static readonly RULE_type_list = 636; - public static readonly RULE_array_expr = 637; - public static readonly RULE_array_expr_list = 638; - public static readonly RULE_extract_list = 639; - public static readonly RULE_extract_arg = 640; - public static readonly RULE_unicode_normal_form = 641; - public static readonly RULE_overlay_list = 642; - public static readonly RULE_position_list = 643; - public static readonly RULE_substr_list = 644; - public static readonly RULE_trim_list = 645; - public static readonly RULE_in_expr = 646; - public static readonly RULE_case_expr = 647; - public static readonly RULE_when_clause_list = 648; - public static readonly RULE_when_clause = 649; - public static readonly RULE_case_default = 650; - public static readonly RULE_case_arg = 651; - public static readonly RULE_columnref = 652; - public static readonly RULE_indirection_el = 653; - public static readonly RULE_opt_slice_bound = 654; - public static readonly RULE_indirection = 655; - public static readonly RULE_opt_indirection = 656; - public static readonly RULE_opt_target_list = 657; - public static readonly RULE_target_list = 658; - public static readonly RULE_target_el = 659; - public static readonly RULE_qualified_name_list = 660; - public static readonly RULE_qualified_name = 661; - public static readonly RULE_name_list = 662; - public static readonly RULE_name = 663; - public static readonly RULE_attr_name = 664; - public static readonly RULE_file_name = 665; - public static readonly RULE_func_name = 666; - public static readonly RULE_aexprconst = 667; - public static readonly RULE_xconst = 668; - public static readonly RULE_bconst = 669; - public static readonly RULE_fconst = 670; - public static readonly RULE_iconst = 671; - public static readonly RULE_sconst = 672; - public static readonly RULE_anysconst = 673; - public static readonly RULE_opt_uescape = 674; - public static readonly RULE_signediconst = 675; - public static readonly RULE_roleid = 676; - public static readonly RULE_rolespec = 677; - public static readonly RULE_role_list = 678; - public static readonly RULE_colid = 679; - public static readonly RULE_type_function_name = 680; - public static readonly RULE_nonreservedword = 681; - public static readonly RULE_collabel = 682; - public static readonly RULE_identifier = 683; - public static readonly RULE_plsqlidentifier = 684; - public static readonly RULE_unreserved_keyword = 685; - public static readonly RULE_col_name_keyword = 686; - public static readonly RULE_type_func_name_keyword = 687; - public static readonly RULE_reserved_keyword = 688; - public static readonly RULE_pl_function = 689; - public static readonly RULE_comp_options = 690; - public static readonly RULE_comp_option = 691; - public static readonly RULE_sharp = 692; - public static readonly RULE_option_value = 693; - public static readonly RULE_opt_semi = 694; - public static readonly RULE_pl_block = 695; - public static readonly RULE_decl_sect = 696; - public static readonly RULE_decl_start = 697; - public static readonly RULE_decl_stmts = 698; - public static readonly RULE_label_decl = 699; - public static readonly RULE_decl_stmt = 700; - public static readonly RULE_decl_statement = 701; - public static readonly RULE_opt_scrollable = 702; - public static readonly RULE_decl_cursor_query = 703; - public static readonly RULE_decl_cursor_args = 704; - public static readonly RULE_decl_cursor_arglist = 705; - public static readonly RULE_decl_cursor_arg = 706; - public static readonly RULE_decl_is_for = 707; - public static readonly RULE_decl_aliasitem = 708; - public static readonly RULE_decl_varname = 709; - public static readonly RULE_decl_const = 710; - public static readonly RULE_decl_datatype = 711; - public static readonly RULE_decl_collate = 712; - public static readonly RULE_decl_notnull = 713; - public static readonly RULE_decl_defval = 714; - public static readonly RULE_decl_defkey = 715; - public static readonly RULE_assign_operator = 716; - public static readonly RULE_proc_sect = 717; - public static readonly RULE_proc_stmt = 718; - public static readonly RULE_stmt_perform = 719; - public static readonly RULE_stmt_call = 720; - public static readonly RULE_opt_expr_list = 721; - public static readonly RULE_stmt_assign = 722; - public static readonly RULE_stmt_getdiag = 723; - public static readonly RULE_getdiag_area_opt = 724; - public static readonly RULE_getdiag_list = 725; - public static readonly RULE_getdiag_list_item = 726; - public static readonly RULE_getdiag_item = 727; - public static readonly RULE_getdiag_target = 728; - public static readonly RULE_assign_var = 729; - public static readonly RULE_stmt_if = 730; - public static readonly RULE_stmt_elsifs = 731; - public static readonly RULE_stmt_else = 732; - public static readonly RULE_stmt_case = 733; - public static readonly RULE_opt_expr_until_when = 734; - public static readonly RULE_case_when_list = 735; - public static readonly RULE_case_when = 736; - public static readonly RULE_opt_case_else = 737; - public static readonly RULE_stmt_loop = 738; - public static readonly RULE_stmt_while = 739; - public static readonly RULE_stmt_for = 740; - public static readonly RULE_for_control = 741; - public static readonly RULE_opt_for_using_expression = 742; - public static readonly RULE_opt_cursor_parameters = 743; - public static readonly RULE_opt_reverse = 744; - public static readonly RULE_opt_by_expression = 745; - public static readonly RULE_for_variable = 746; - public static readonly RULE_stmt_foreach_a = 747; - public static readonly RULE_foreach_slice = 748; - public static readonly RULE_stmt_exit = 749; - public static readonly RULE_exit_type = 750; - public static readonly RULE_stmt_return = 751; - public static readonly RULE_opt_return_result = 752; - public static readonly RULE_stmt_raise = 753; - public static readonly RULE_opt_stmt_raise_level = 754; - public static readonly RULE_opt_raise_list = 755; - public static readonly RULE_opt_raise_using = 756; - public static readonly RULE_opt_raise_using_elem = 757; - public static readonly RULE_opt_raise_using_elem_list = 758; - public static readonly RULE_stmt_assert = 759; - public static readonly RULE_opt_stmt_assert_message = 760; - public static readonly RULE_loop_body = 761; - public static readonly RULE_stmt_execsql = 762; - public static readonly RULE_stmt_dynexecute = 763; - public static readonly RULE_opt_execute_using = 764; - public static readonly RULE_opt_execute_using_list = 765; - public static readonly RULE_opt_execute_into = 766; - public static readonly RULE_stmt_open = 767; - public static readonly RULE_opt_open_bound_list_item = 768; - public static readonly RULE_opt_open_bound_list = 769; - public static readonly RULE_opt_open_using = 770; - public static readonly RULE_opt_scroll_option = 771; - public static readonly RULE_opt_scroll_option_no = 772; - public static readonly RULE_stmt_fetch = 773; - public static readonly RULE_into_target = 774; - public static readonly RULE_opt_cursor_from = 775; - public static readonly RULE_opt_fetch_direction = 776; - public static readonly RULE_stmt_move = 777; - public static readonly RULE_stmt_close = 778; - public static readonly RULE_stmt_null = 779; - public static readonly RULE_stmt_commit = 780; - public static readonly RULE_stmt_rollback = 781; - public static readonly RULE_plsql_opt_transaction_chain = 782; - public static readonly RULE_stmt_set = 783; - public static readonly RULE_cursor_variable = 784; - public static readonly RULE_exception_sect = 785; - public static readonly RULE_proc_exceptions = 786; - public static readonly RULE_proc_exception = 787; - public static readonly RULE_proc_conditions = 788; - public static readonly RULE_proc_condition = 789; - public static readonly RULE_opt_block_label = 790; - public static readonly RULE_opt_loop_label = 791; - public static readonly RULE_opt_label = 792; - public static readonly RULE_opt_exitcond = 793; - public static readonly RULE_any_identifier = 794; - public static readonly RULE_plsql_unreserved_keyword = 795; - public static readonly RULE_sql_expression = 796; - public static readonly RULE_expr_until_then = 797; - public static readonly RULE_expr_until_semi = 798; - public static readonly RULE_expr_until_rightbracket = 799; - public static readonly RULE_expr_until_loop = 800; - public static readonly RULE_make_execsql_stmt = 801; - public static readonly RULE_opt_returning_clause_into = 802; + public static readonly RULE_table_column_list = 87; + public static readonly RULE_opttableelementlist = 88; + public static readonly RULE_opttypedtableelementlist = 89; + public static readonly RULE_tableelementlist = 90; + public static readonly RULE_typedtableelementlist = 91; + public static readonly RULE_tableelement = 92; + public static readonly RULE_typedtableelement = 93; + public static readonly RULE_columnDef = 94; + public static readonly RULE_columnOptions = 95; + public static readonly RULE_colquallist = 96; + public static readonly RULE_colconstraint = 97; + public static readonly RULE_colconstraintelem = 98; + public static readonly RULE_generated_when = 99; + public static readonly RULE_deferrable_trigger = 100; + public static readonly RULE_initially_trigger = 101; + public static readonly RULE_tablelikeclause = 102; + public static readonly RULE_tablelikeoptionlist = 103; + public static readonly RULE_tablelikeoption = 104; + public static readonly RULE_tableconstraint = 105; + public static readonly RULE_constraintelem = 106; + public static readonly RULE_opt_no_inherit = 107; + public static readonly RULE_opt_column_list = 108; + public static readonly RULE_columnlist = 109; + public static readonly RULE_columnElem = 110; + public static readonly RULE_opt_c_include = 111; + public static readonly RULE_key_match = 112; + public static readonly RULE_exclusionconstraintlist = 113; + public static readonly RULE_exclusionconstraintelem = 114; + public static readonly RULE_exclusionwhereclause = 115; + public static readonly RULE_key_actions = 116; + public static readonly RULE_key_update = 117; + public static readonly RULE_key_delete = 118; + public static readonly RULE_key_action = 119; + public static readonly RULE_optinherit = 120; + public static readonly RULE_optpartitionspec = 121; + public static readonly RULE_partitionspec = 122; + public static readonly RULE_part_params = 123; + public static readonly RULE_part_elem = 124; + public static readonly RULE_table_access_method_clause = 125; + public static readonly RULE_optwith = 126; + public static readonly RULE_oncommitoption = 127; + public static readonly RULE_opttablespace = 128; + public static readonly RULE_optconstablespace = 129; + public static readonly RULE_existingindex = 130; + public static readonly RULE_createstatsstmt = 131; + public static readonly RULE_alterstatsstmt = 132; + public static readonly RULE_createasstmt = 133; + public static readonly RULE_create_as_target = 134; + public static readonly RULE_opt_with_data = 135; + public static readonly RULE_creatematviewstmt = 136; + public static readonly RULE_create_mv_target = 137; + public static readonly RULE_optnolog = 138; + public static readonly RULE_refreshmatviewstmt = 139; + public static readonly RULE_createseqstmt = 140; + public static readonly RULE_alterseqstmt = 141; + public static readonly RULE_optseqoptlist = 142; + public static readonly RULE_optparenthesizedseqoptlist = 143; + public static readonly RULE_seqoptlist = 144; + public static readonly RULE_seqoptelem = 145; + public static readonly RULE_opt_by = 146; + public static readonly RULE_numericonly = 147; + public static readonly RULE_numericonly_list = 148; + public static readonly RULE_createplangstmt = 149; + public static readonly RULE_opt_trusted = 150; + public static readonly RULE_handler_name = 151; + public static readonly RULE_opt_inline_handler = 152; + public static readonly RULE_validator_clause = 153; + public static readonly RULE_opt_validator = 154; + public static readonly RULE_opt_procedural = 155; + public static readonly RULE_createtablespacestmt = 156; + public static readonly RULE_opttablespaceowner = 157; + public static readonly RULE_droptablespacestmt = 158; + public static readonly RULE_createextensionstmt = 159; + public static readonly RULE_create_extension_opt_list = 160; + public static readonly RULE_create_extension_opt_item = 161; + public static readonly RULE_alterextensionstmt = 162; + public static readonly RULE_alter_extension_opt_list = 163; + public static readonly RULE_alter_extension_opt_item = 164; + public static readonly RULE_alterextensioncontentsstmt = 165; + public static readonly RULE_createfdwstmt = 166; + public static readonly RULE_fdw_option = 167; + public static readonly RULE_fdw_options = 168; + public static readonly RULE_opt_fdw_options = 169; + public static readonly RULE_alterfdwstmt = 170; + public static readonly RULE_create_generic_options = 171; + public static readonly RULE_generic_option_list = 172; + public static readonly RULE_alter_generic_options = 173; + public static readonly RULE_alter_generic_option_list = 174; + public static readonly RULE_alter_generic_option_elem = 175; + public static readonly RULE_generic_option_elem = 176; + public static readonly RULE_generic_option_name = 177; + public static readonly RULE_generic_option_arg = 178; + public static readonly RULE_createforeignserverstmt = 179; + public static readonly RULE_opt_type = 180; + public static readonly RULE_foreign_server_version = 181; + public static readonly RULE_opt_foreign_server_version = 182; + public static readonly RULE_alterforeignserverstmt = 183; + public static readonly RULE_createforeigntablestmt = 184; + public static readonly RULE_importforeignschemastmt = 185; + public static readonly RULE_import_qualification_type = 186; + public static readonly RULE_import_qualification = 187; + public static readonly RULE_createusermappingstmt = 188; + public static readonly RULE_auth_ident = 189; + public static readonly RULE_dropusermappingstmt = 190; + public static readonly RULE_alterusermappingstmt = 191; + public static readonly RULE_createpolicystmt = 192; + public static readonly RULE_alterpolicystmt = 193; + public static readonly RULE_rowsecurityoptionalexpr = 194; + public static readonly RULE_rowsecurityoptionalwithcheck = 195; + public static readonly RULE_rowsecuritydefaulttorole = 196; + public static readonly RULE_rowsecurityoptionaltorole = 197; + public static readonly RULE_rowsecuritydefaultpermissive = 198; + public static readonly RULE_rowsecuritydefaultforcmd = 199; + public static readonly RULE_row_security_cmd = 200; + public static readonly RULE_createamstmt = 201; + public static readonly RULE_am_type = 202; + public static readonly RULE_createtrigstmt = 203; + public static readonly RULE_triggeractiontime = 204; + public static readonly RULE_foreachrow = 205; + public static readonly RULE_roworstatment = 206; + public static readonly RULE_triggerevents = 207; + public static readonly RULE_triggeroneevent = 208; + public static readonly RULE_triggerreferencing = 209; + public static readonly RULE_triggertransitions = 210; + public static readonly RULE_triggertransition = 211; + public static readonly RULE_transitionoldornew = 212; + public static readonly RULE_transitionrowortable = 213; + public static readonly RULE_transitionrelname = 214; + public static readonly RULE_triggerforspec = 215; + public static readonly RULE_triggerforopteach = 216; + public static readonly RULE_triggerfortype = 217; + public static readonly RULE_triggerwhen = 218; + public static readonly RULE_function_or_procedure = 219; + public static readonly RULE_triggerfuncargs = 220; + public static readonly RULE_triggerfuncarg = 221; + public static readonly RULE_optconstrfromtable = 222; + public static readonly RULE_constraintattributespec = 223; + public static readonly RULE_constraintattributeElem = 224; + public static readonly RULE_createeventtrigstmt = 225; + public static readonly RULE_event_trigger_when_list = 226; + public static readonly RULE_event_trigger_when_item = 227; + public static readonly RULE_event_trigger_value_list = 228; + public static readonly RULE_altereventtrigstmt = 229; + public static readonly RULE_enable_trigger = 230; + public static readonly RULE_createassertionstmt = 231; + public static readonly RULE_definestmt = 232; + public static readonly RULE_definition = 233; + public static readonly RULE_def_list = 234; + public static readonly RULE_def_elem = 235; + public static readonly RULE_def_arg = 236; + public static readonly RULE_old_aggr_definition = 237; + public static readonly RULE_old_aggr_list = 238; + public static readonly RULE_old_aggr_elem = 239; + public static readonly RULE_opt_enum_val_list = 240; + public static readonly RULE_enum_val_list = 241; + public static readonly RULE_alterenumstmt = 242; + public static readonly RULE_opt_if_not_exists = 243; + public static readonly RULE_createopclassstmt = 244; + public static readonly RULE_opclass_item_list = 245; + public static readonly RULE_opclass_item = 246; + public static readonly RULE_opt_default = 247; + public static readonly RULE_opt_opfamily = 248; + public static readonly RULE_opclass_purpose = 249; + public static readonly RULE_opt_recheck = 250; + public static readonly RULE_createopfamilystmt = 251; + public static readonly RULE_alteropfamilystmt = 252; + public static readonly RULE_opclass_drop_list = 253; + public static readonly RULE_opclass_drop = 254; + public static readonly RULE_dropopclassstmt = 255; + public static readonly RULE_dropopfamilystmt = 256; + public static readonly RULE_dropownedstmt = 257; + public static readonly RULE_reassignownedstmt = 258; + public static readonly RULE_dropstmt = 259; + public static readonly RULE_object_type_any_name = 260; + public static readonly RULE_object_type_name = 261; + public static readonly RULE_drop_type_name = 262; + public static readonly RULE_object_type_name_on_any_name = 263; + public static readonly RULE_any_name_list = 264; + public static readonly RULE_any_name = 265; + public static readonly RULE_attrs = 266; + public static readonly RULE_type_name_list = 267; + public static readonly RULE_truncatestmt = 268; + public static readonly RULE_opt_restart_seqs = 269; + public static readonly RULE_commentstmt = 270; + public static readonly RULE_comment_text = 271; + public static readonly RULE_seclabelstmt = 272; + public static readonly RULE_opt_provider = 273; + public static readonly RULE_security_label = 274; + public static readonly RULE_fetchstmt = 275; + public static readonly RULE_fetch_args = 276; + public static readonly RULE_from_in = 277; + public static readonly RULE_opt_from_in = 278; + public static readonly RULE_grantstmt = 279; + public static readonly RULE_revokestmt = 280; + public static readonly RULE_privileges = 281; + public static readonly RULE_beforeprivilegeselectlist = 282; + public static readonly RULE_beforeprivilegeselect = 283; + public static readonly RULE_privilege_list = 284; + public static readonly RULE_privilege = 285; + public static readonly RULE_privilege_target = 286; + public static readonly RULE_grantee_list = 287; + public static readonly RULE_grantee = 288; + public static readonly RULE_opt_grant_grant_option = 289; + public static readonly RULE_grantrolestmt = 290; + public static readonly RULE_revokerolestmt = 291; + public static readonly RULE_opt_grant_admin_option = 292; + public static readonly RULE_opt_granted_by = 293; + public static readonly RULE_alterdefaultprivilegesstmt = 294; + public static readonly RULE_defacloptionlist = 295; + public static readonly RULE_defacloption = 296; + public static readonly RULE_defaclaction = 297; + public static readonly RULE_defacl_privilege_target = 298; + public static readonly RULE_indexstmt = 299; + public static readonly RULE_opt_unique = 300; + public static readonly RULE_opt_concurrently = 301; + public static readonly RULE_opt_index_name = 302; + public static readonly RULE_access_method_clause = 303; + public static readonly RULE_index_params = 304; + public static readonly RULE_index_elem_options = 305; + public static readonly RULE_index_elem = 306; + public static readonly RULE_opt_include = 307; + public static readonly RULE_index_including_params = 308; + public static readonly RULE_opt_collate = 309; + public static readonly RULE_opt_class = 310; + public static readonly RULE_opt_asc_desc = 311; + public static readonly RULE_opt_nulls_order = 312; + public static readonly RULE_createfunctionstmt = 313; + public static readonly RULE_attrilist = 314; + public static readonly RULE_opt_or_replace = 315; + public static readonly RULE_func_args = 316; + public static readonly RULE_func_args_list = 317; + public static readonly RULE_function_with_argtypes_list = 318; + public static readonly RULE_function_with_argtypes = 319; + public static readonly RULE_func_args_with_defaults = 320; + public static readonly RULE_func_args_with_defaults_list = 321; + public static readonly RULE_func_arg = 322; + public static readonly RULE_arg_class = 323; + public static readonly RULE_param_name = 324; + public static readonly RULE_func_return = 325; + public static readonly RULE_func_type = 326; + public static readonly RULE_func_arg_with_default = 327; + public static readonly RULE_aggr_arg = 328; + public static readonly RULE_aggr_args = 329; + public static readonly RULE_aggr_args_list = 330; + public static readonly RULE_aggregate_with_argtypes = 331; + public static readonly RULE_aggregate_with_argtypes_list = 332; + public static readonly RULE_createfunc_opt_list = 333; + public static readonly RULE_common_func_opt_item = 334; + public static readonly RULE_createfunc_opt_item = 335; + public static readonly RULE_func_as = 336; + public static readonly RULE_transform_type_list = 337; + public static readonly RULE_opt_definition = 338; + public static readonly RULE_table_func_column = 339; + public static readonly RULE_table_func_column_list = 340; + public static readonly RULE_alterfunctionstmt = 341; + public static readonly RULE_alterfunc_opt_list = 342; + public static readonly RULE_opt_restrict = 343; + public static readonly RULE_removefuncstmt = 344; + public static readonly RULE_removeaggrstmt = 345; + public static readonly RULE_removeoperstmt = 346; + public static readonly RULE_oper_argtypes = 347; + public static readonly RULE_any_operator = 348; + public static readonly RULE_operator_with_argtypes_list = 349; + public static readonly RULE_operator_with_argtypes = 350; + public static readonly RULE_dostmt = 351; + public static readonly RULE_dostmt_opt_list = 352; + public static readonly RULE_dostmt_opt_item = 353; + public static readonly RULE_createcaststmt = 354; + public static readonly RULE_cast_context = 355; + public static readonly RULE_dropcaststmt = 356; + public static readonly RULE_opt_if_exists = 357; + public static readonly RULE_createtransformstmt = 358; + public static readonly RULE_transform_element_list = 359; + public static readonly RULE_droptransformstmt = 360; + public static readonly RULE_reindexstmt = 361; + public static readonly RULE_reindex_target_type = 362; + public static readonly RULE_reindex_target_multitable = 363; + public static readonly RULE_reindex_option_list = 364; + public static readonly RULE_reindex_option_elem = 365; + public static readonly RULE_altertblspcstmt = 366; + public static readonly RULE_renamestmt = 367; + public static readonly RULE_opt_column = 368; + public static readonly RULE_opt_set_data = 369; + public static readonly RULE_alterobjectdependsstmt = 370; + public static readonly RULE_opt_no = 371; + public static readonly RULE_alterobjectschemastmt = 372; + public static readonly RULE_alteroperatorstmt = 373; + public static readonly RULE_operator_def_list = 374; + public static readonly RULE_operator_def_elem = 375; + public static readonly RULE_operator_def_arg = 376; + public static readonly RULE_altertypestmt = 377; + public static readonly RULE_alterownerstmt = 378; + public static readonly RULE_createpublicationstmt = 379; + public static readonly RULE_opt_publication_for_tables = 380; + public static readonly RULE_publication_for_tables = 381; + public static readonly RULE_alterpublicationstmt = 382; + public static readonly RULE_createsubscriptionstmt = 383; + public static readonly RULE_publication_name_list = 384; + public static readonly RULE_publication_name_item = 385; + public static readonly RULE_altersubscriptionstmt = 386; + public static readonly RULE_dropsubscriptionstmt = 387; + public static readonly RULE_rulestmt = 388; + public static readonly RULE_ruleactionlist = 389; + public static readonly RULE_ruleactionmulti = 390; + public static readonly RULE_ruleactionstmt = 391; + public static readonly RULE_ruleactionstmtOrEmpty = 392; + public static readonly RULE_event = 393; + public static readonly RULE_opt_instead = 394; + public static readonly RULE_notifystmt = 395; + public static readonly RULE_notify_payload = 396; + public static readonly RULE_listenstmt = 397; + public static readonly RULE_unlistenstmt = 398; + public static readonly RULE_transactionstmt = 399; + public static readonly RULE_opt_transaction = 400; + public static readonly RULE_transaction_mode_item = 401; + public static readonly RULE_transaction_mode_list = 402; + public static readonly RULE_transaction_mode_list_or_empty = 403; + public static readonly RULE_opt_transaction_chain = 404; + public static readonly RULE_viewstmt = 405; + public static readonly RULE_opt_check_option = 406; + public static readonly RULE_loadstmt = 407; + public static readonly RULE_createdbstmt = 408; + public static readonly RULE_createdb_opt_list = 409; + public static readonly RULE_createdb_opt_items = 410; + public static readonly RULE_createdb_opt_item = 411; + public static readonly RULE_createdb_opt_name = 412; + public static readonly RULE_opt_equal = 413; + public static readonly RULE_alterdatabasestmt = 414; + public static readonly RULE_alterdatabasesetstmt = 415; + public static readonly RULE_dropdbstmt = 416; + public static readonly RULE_drop_option_list = 417; + public static readonly RULE_drop_option = 418; + public static readonly RULE_altercollationstmt = 419; + public static readonly RULE_altersystemstmt = 420; + public static readonly RULE_createdomainstmt = 421; + public static readonly RULE_alterdomainstmt = 422; + public static readonly RULE_opt_as = 423; + public static readonly RULE_altertsdictionarystmt = 424; + public static readonly RULE_altertsconfigurationstmt = 425; + public static readonly RULE_any_with = 426; + public static readonly RULE_createconversionstmt = 427; + public static readonly RULE_clusterstmt = 428; + public static readonly RULE_cluster_index_specification = 429; + public static readonly RULE_vacuumstmt = 430; + public static readonly RULE_analyzestmt = 431; + public static readonly RULE_vac_analyze_option_list = 432; + public static readonly RULE_analyze_keyword = 433; + public static readonly RULE_vac_analyze_option_elem = 434; + public static readonly RULE_vac_analyze_option_name = 435; + public static readonly RULE_vac_analyze_option_arg = 436; + public static readonly RULE_opt_analyze = 437; + public static readonly RULE_opt_verbose = 438; + public static readonly RULE_opt_full = 439; + public static readonly RULE_opt_freeze = 440; + public static readonly RULE_opt_name_list = 441; + public static readonly RULE_vacuum_relation = 442; + public static readonly RULE_vacuum_relation_list = 443; + public static readonly RULE_opt_vacuum_relation_list = 444; + public static readonly RULE_explainstmt = 445; + public static readonly RULE_explainablestmt = 446; + public static readonly RULE_explain_option_list = 447; + public static readonly RULE_explain_option_elem = 448; + public static readonly RULE_explain_option_name = 449; + public static readonly RULE_explain_option_arg = 450; + public static readonly RULE_preparestmt = 451; + public static readonly RULE_prep_type_clause = 452; + public static readonly RULE_preparablestmt = 453; + public static readonly RULE_executestmt = 454; + public static readonly RULE_execute_param_clause = 455; + public static readonly RULE_deallocatestmt = 456; + public static readonly RULE_insertstmt = 457; + public static readonly RULE_insert_target = 458; + public static readonly RULE_insert_rest = 459; + public static readonly RULE_override_kind = 460; + public static readonly RULE_insert_column_list = 461; + public static readonly RULE_insert_column_item = 462; + public static readonly RULE_opt_on_conflict = 463; + public static readonly RULE_opt_conf_expr = 464; + public static readonly RULE_returning_clause = 465; + public static readonly RULE_deletestmt = 466; + public static readonly RULE_using_clause = 467; + public static readonly RULE_lockstmt = 468; + public static readonly RULE_opt_lock = 469; + public static readonly RULE_lock_type = 470; + public static readonly RULE_opt_nowait = 471; + public static readonly RULE_opt_nowait_or_skip = 472; + public static readonly RULE_updatestmt = 473; + public static readonly RULE_set_clause_list = 474; + public static readonly RULE_set_clause = 475; + public static readonly RULE_set_target = 476; + public static readonly RULE_set_target_list = 477; + public static readonly RULE_declarecursorstmt = 478; + public static readonly RULE_cursor_name = 479; + public static readonly RULE_cursor_options = 480; + public static readonly RULE_opt_hold = 481; + public static readonly RULE_selectstmt = 482; + public static readonly RULE_select_with_parens = 483; + public static readonly RULE_select_no_parens = 484; + public static readonly RULE_select_clause = 485; + public static readonly RULE_simple_select = 486; + public static readonly RULE_set_operator = 487; + public static readonly RULE_set_operator_with_all_or_distinct = 488; + public static readonly RULE_with_clause = 489; + public static readonly RULE_cte_list = 490; + public static readonly RULE_common_table_expr = 491; + public static readonly RULE_opt_materialized = 492; + public static readonly RULE_opt_with_clause = 493; + public static readonly RULE_into_clause = 494; + public static readonly RULE_opt_strict = 495; + public static readonly RULE_opttempTableName = 496; + public static readonly RULE_opt_table = 497; + public static readonly RULE_all_or_distinct = 498; + public static readonly RULE_distinct_clause = 499; + public static readonly RULE_opt_all_clause = 500; + public static readonly RULE_opt_sort_clause = 501; + public static readonly RULE_sort_clause = 502; + public static readonly RULE_sortby_list = 503; + public static readonly RULE_sortby = 504; + public static readonly RULE_select_limit = 505; + public static readonly RULE_opt_select_limit = 506; + public static readonly RULE_limit_clause = 507; + public static readonly RULE_offset_clause = 508; + public static readonly RULE_select_limit_value = 509; + public static readonly RULE_select_offset_value = 510; + public static readonly RULE_select_fetch_first_value = 511; + public static readonly RULE_i_or_f_const = 512; + public static readonly RULE_row_or_rows = 513; + public static readonly RULE_first_or_next = 514; + public static readonly RULE_group_clause = 515; + public static readonly RULE_group_by_list = 516; + public static readonly RULE_group_by_item = 517; + public static readonly RULE_empty_grouping_set = 518; + public static readonly RULE_rollup_clause = 519; + public static readonly RULE_cube_clause = 520; + public static readonly RULE_grouping_sets_clause = 521; + public static readonly RULE_having_clause = 522; + public static readonly RULE_for_locking_clause = 523; + public static readonly RULE_opt_for_locking_clause = 524; + public static readonly RULE_for_locking_items = 525; + public static readonly RULE_for_locking_item = 526; + public static readonly RULE_for_locking_strength = 527; + public static readonly RULE_locked_rels_list = 528; + public static readonly RULE_values_clause = 529; + public static readonly RULE_from_clause = 530; + public static readonly RULE_from_list = 531; + public static readonly RULE_table_ref = 532; + public static readonly RULE_alias_clause = 533; + public static readonly RULE_opt_alias_clause = 534; + public static readonly RULE_func_alias_clause = 535; + public static readonly RULE_join_type = 536; + public static readonly RULE_join_qual = 537; + public static readonly RULE_relation_expr = 538; + public static readonly RULE_relation_expr_list = 539; + public static readonly RULE_relation_expr_opt_alias = 540; + public static readonly RULE_tablesample_clause = 541; + public static readonly RULE_opt_repeatable_clause = 542; + public static readonly RULE_func_table = 543; + public static readonly RULE_rowsfrom_item = 544; + public static readonly RULE_rowsfrom_list = 545; + public static readonly RULE_opt_col_def_list = 546; + public static readonly RULE_opt_ordinality = 547; + public static readonly RULE_where_clause = 548; + public static readonly RULE_where_or_current_clause = 549; + public static readonly RULE_opttablefuncelementlist = 550; + public static readonly RULE_tablefuncelementlist = 551; + public static readonly RULE_tablefuncelement = 552; + public static readonly RULE_xmltable = 553; + public static readonly RULE_xmltable_column_list = 554; + public static readonly RULE_xmltable_column_el = 555; + public static readonly RULE_xmltable_column_option_list = 556; + public static readonly RULE_xmltable_column_option_el = 557; + public static readonly RULE_xml_namespace_list = 558; + public static readonly RULE_xml_namespace_el = 559; + public static readonly RULE_typename = 560; + public static readonly RULE_opt_array_bounds = 561; + public static readonly RULE_simpletypename = 562; + public static readonly RULE_consttypename = 563; + public static readonly RULE_generictype = 564; + public static readonly RULE_opt_type_modifiers = 565; + public static readonly RULE_numeric = 566; + public static readonly RULE_opt_float = 567; + public static readonly RULE_bit = 568; + public static readonly RULE_constbit = 569; + public static readonly RULE_bitwithlength = 570; + public static readonly RULE_bitwithoutlength = 571; + public static readonly RULE_character = 572; + public static readonly RULE_constcharacter = 573; + public static readonly RULE_character_c = 574; + public static readonly RULE_opt_varying = 575; + public static readonly RULE_constdatetime = 576; + public static readonly RULE_constinterval = 577; + public static readonly RULE_opt_timezone = 578; + public static readonly RULE_opt_interval = 579; + public static readonly RULE_interval_second = 580; + public static readonly RULE_opt_escape = 581; + public static readonly RULE_a_expr = 582; + public static readonly RULE_a_expr_qual = 583; + public static readonly RULE_a_expr_lessless = 584; + public static readonly RULE_a_expr_or = 585; + public static readonly RULE_a_expr_and = 586; + public static readonly RULE_a_expr_in = 587; + public static readonly RULE_a_expr_unary_not = 588; + public static readonly RULE_a_expr_isnull = 589; + public static readonly RULE_a_expr_is_not = 590; + public static readonly RULE_a_expr_compare = 591; + public static readonly RULE_a_expr_like = 592; + public static readonly RULE_a_expr_qual_op = 593; + public static readonly RULE_a_expr_unary_qualop = 594; + public static readonly RULE_a_expr_add = 595; + public static readonly RULE_a_expr_mul = 596; + public static readonly RULE_a_expr_caret = 597; + public static readonly RULE_a_expr_unary_sign = 598; + public static readonly RULE_a_expr_at_time_zone = 599; + public static readonly RULE_a_expr_collate = 600; + public static readonly RULE_a_expr_typecast = 601; + public static readonly RULE_b_expr = 602; + public static readonly RULE_c_expr = 603; + public static readonly RULE_plsqlvariablename = 604; + public static readonly RULE_func_application = 605; + public static readonly RULE_func_expr = 606; + public static readonly RULE_func_expr_windowless = 607; + public static readonly RULE_func_expr_common_subexpr = 608; + public static readonly RULE_xml_root_version = 609; + public static readonly RULE_opt_xml_root_standalone = 610; + public static readonly RULE_xml_attributes = 611; + public static readonly RULE_xml_attribute_list = 612; + public static readonly RULE_xml_attribute_el = 613; + public static readonly RULE_document_or_content = 614; + public static readonly RULE_xml_whitespace_option = 615; + public static readonly RULE_xmlexists_argument = 616; + public static readonly RULE_xml_passing_mech = 617; + public static readonly RULE_within_group_clause = 618; + public static readonly RULE_filter_clause = 619; + public static readonly RULE_window_clause = 620; + public static readonly RULE_window_definition_list = 621; + public static readonly RULE_window_definition = 622; + public static readonly RULE_over_clause = 623; + public static readonly RULE_window_specification = 624; + public static readonly RULE_opt_existing_window_name = 625; + public static readonly RULE_opt_partition_clause = 626; + public static readonly RULE_opt_frame_clause = 627; + public static readonly RULE_frame_extent = 628; + public static readonly RULE_frame_bound = 629; + public static readonly RULE_opt_window_exclusion_clause = 630; + public static readonly RULE_row = 631; + public static readonly RULE_explicit_row = 632; + public static readonly RULE_implicit_row = 633; + public static readonly RULE_sub_type = 634; + public static readonly RULE_all_op = 635; + public static readonly RULE_mathop = 636; + public static readonly RULE_qual_op = 637; + public static readonly RULE_qual_all_op = 638; + public static readonly RULE_subquery_Op = 639; + public static readonly RULE_expr_list = 640; + public static readonly RULE_func_arg_list = 641; + public static readonly RULE_func_arg_expr = 642; + public static readonly RULE_type_list = 643; + public static readonly RULE_array_expr = 644; + public static readonly RULE_array_expr_list = 645; + public static readonly RULE_extract_list = 646; + public static readonly RULE_extract_arg = 647; + public static readonly RULE_unicode_normal_form = 648; + public static readonly RULE_overlay_list = 649; + public static readonly RULE_position_list = 650; + public static readonly RULE_substr_list = 651; + public static readonly RULE_trim_list = 652; + public static readonly RULE_in_expr = 653; + public static readonly RULE_case_expr = 654; + public static readonly RULE_when_clause_list = 655; + public static readonly RULE_when_clause = 656; + public static readonly RULE_case_default = 657; + public static readonly RULE_case_arg = 658; + public static readonly RULE_columnref = 659; + public static readonly RULE_indirection_el = 660; + public static readonly RULE_opt_slice_bound = 661; + public static readonly RULE_indirection = 662; + public static readonly RULE_opt_indirection = 663; + public static readonly RULE_opt_target_list = 664; + public static readonly RULE_target_list = 665; + public static readonly RULE_target_el = 666; + public static readonly RULE_qualified_name_list = 667; + public static readonly RULE_table_qualified_name = 668; + public static readonly RULE_qualified_name = 669; + public static readonly RULE_name_list = 670; + public static readonly RULE_name = 671; + public static readonly RULE_attr_name = 672; + public static readonly RULE_file_name = 673; + public static readonly RULE_func_name = 674; + public static readonly RULE_aexprconst = 675; + public static readonly RULE_xconst = 676; + public static readonly RULE_bconst = 677; + public static readonly RULE_fconst = 678; + public static readonly RULE_iconst = 679; + public static readonly RULE_sconst = 680; + public static readonly RULE_anysconst = 681; + public static readonly RULE_opt_uescape = 682; + public static readonly RULE_signediconst = 683; + public static readonly RULE_groupname = 684; + public static readonly RULE_roleid = 685; + public static readonly RULE_rolespec = 686; + public static readonly RULE_role_list = 687; + public static readonly RULE_colid = 688; + public static readonly RULE_index_method_choices = 689; + public static readonly RULE_exclude_element = 690; + public static readonly RULE_index_paramenters = 691; + public static readonly RULE_wherePredicate = 692; + public static readonly RULE_type_function_name = 693; + public static readonly RULE_nonreservedword = 694; + public static readonly RULE_collabel = 695; + public static readonly RULE_identifier = 696; + public static readonly RULE_plsqlidentifier = 697; + public static readonly RULE_unreserved_keyword = 698; + public static readonly RULE_col_name_keyword = 699; + public static readonly RULE_type_func_name_keyword = 700; + public static readonly RULE_reserved_keyword = 701; + public static readonly RULE_pl_function = 702; + public static readonly RULE_comp_options = 703; + public static readonly RULE_comp_option = 704; + public static readonly RULE_sharp = 705; + public static readonly RULE_option_value = 706; + public static readonly RULE_opt_semi = 707; + public static readonly RULE_pl_block = 708; + public static readonly RULE_decl_sect = 709; + public static readonly RULE_decl_start = 710; + public static readonly RULE_decl_stmts = 711; + public static readonly RULE_label_decl = 712; + public static readonly RULE_decl_stmt = 713; + public static readonly RULE_decl_statement = 714; + public static readonly RULE_opt_scrollable = 715; + public static readonly RULE_decl_cursor_query = 716; + public static readonly RULE_decl_cursor_args = 717; + public static readonly RULE_decl_cursor_arglist = 718; + public static readonly RULE_decl_cursor_arg = 719; + public static readonly RULE_decl_is_for = 720; + public static readonly RULE_decl_aliasitem = 721; + public static readonly RULE_decl_varname = 722; + public static readonly RULE_decl_const = 723; + public static readonly RULE_decl_datatype = 724; + public static readonly RULE_decl_collate = 725; + public static readonly RULE_decl_notnull = 726; + public static readonly RULE_decl_defval = 727; + public static readonly RULE_decl_defkey = 728; + public static readonly RULE_assign_operator = 729; + public static readonly RULE_proc_sect = 730; + public static readonly RULE_proc_stmt = 731; + public static readonly RULE_stmt_perform = 732; + public static readonly RULE_stmt_call = 733; + public static readonly RULE_opt_expr_list = 734; + public static readonly RULE_stmt_assign = 735; + public static readonly RULE_stmt_getdiag = 736; + public static readonly RULE_getdiag_area_opt = 737; + public static readonly RULE_getdiag_list = 738; + public static readonly RULE_getdiag_list_item = 739; + public static readonly RULE_getdiag_item = 740; + public static readonly RULE_getdiag_target = 741; + public static readonly RULE_assign_var = 742; + public static readonly RULE_stmt_if = 743; + public static readonly RULE_stmt_elsifs = 744; + public static readonly RULE_stmt_else = 745; + public static readonly RULE_stmt_case = 746; + public static readonly RULE_opt_expr_until_when = 747; + public static readonly RULE_case_when_list = 748; + public static readonly RULE_case_when = 749; + public static readonly RULE_opt_case_else = 750; + public static readonly RULE_stmt_loop = 751; + public static readonly RULE_stmt_while = 752; + public static readonly RULE_stmt_for = 753; + public static readonly RULE_for_control = 754; + public static readonly RULE_opt_for_using_expression = 755; + public static readonly RULE_opt_cursor_parameters = 756; + public static readonly RULE_opt_reverse = 757; + public static readonly RULE_opt_by_expression = 758; + public static readonly RULE_for_variable = 759; + public static readonly RULE_stmt_foreach_a = 760; + public static readonly RULE_foreach_slice = 761; + public static readonly RULE_stmt_exit = 762; + public static readonly RULE_exit_type = 763; + public static readonly RULE_stmt_return = 764; + public static readonly RULE_opt_return_result = 765; + public static readonly RULE_stmt_raise = 766; + public static readonly RULE_opt_stmt_raise_level = 767; + public static readonly RULE_opt_raise_list = 768; + public static readonly RULE_opt_raise_using = 769; + public static readonly RULE_opt_raise_using_elem = 770; + public static readonly RULE_opt_raise_using_elem_list = 771; + public static readonly RULE_stmt_assert = 772; + public static readonly RULE_opt_stmt_assert_message = 773; + public static readonly RULE_loop_body = 774; + public static readonly RULE_stmt_execsql = 775; + public static readonly RULE_stmt_dynexecute = 776; + public static readonly RULE_opt_execute_using = 777; + public static readonly RULE_opt_execute_using_list = 778; + public static readonly RULE_opt_execute_into = 779; + public static readonly RULE_stmt_open = 780; + public static readonly RULE_opt_open_bound_list_item = 781; + public static readonly RULE_opt_open_bound_list = 782; + public static readonly RULE_opt_open_using = 783; + public static readonly RULE_opt_scroll_option = 784; + public static readonly RULE_opt_scroll_option_no = 785; + public static readonly RULE_stmt_fetch = 786; + public static readonly RULE_into_target = 787; + public static readonly RULE_opt_cursor_from = 788; + public static readonly RULE_opt_fetch_direction = 789; + public static readonly RULE_stmt_move = 790; + public static readonly RULE_stmt_close = 791; + public static readonly RULE_stmt_null = 792; + public static readonly RULE_stmt_commit = 793; + public static readonly RULE_stmt_rollback = 794; + public static readonly RULE_plsql_opt_transaction_chain = 795; + public static readonly RULE_stmt_set = 796; + public static readonly RULE_cursor_variable = 797; + public static readonly RULE_exception_sect = 798; + public static readonly RULE_proc_exceptions = 799; + public static readonly RULE_proc_exception = 800; + public static readonly RULE_proc_conditions = 801; + public static readonly RULE_proc_condition = 802; + public static readonly RULE_opt_block_label = 803; + public static readonly RULE_opt_loop_label = 804; + public static readonly RULE_opt_label = 805; + public static readonly RULE_opt_exitcond = 806; + public static readonly RULE_any_identifier = 807; + public static readonly RULE_plsql_unreserved_keyword = 808; + public static readonly RULE_sql_expression = 809; + public static readonly RULE_expr_until_then = 810; + public static readonly RULE_expr_until_semi = 811; + public static readonly RULE_expr_until_rightbracket = 812; + public static readonly RULE_expr_until_loop = 813; + public static readonly RULE_make_execsql_stmt = 814; + public static readonly RULE_opt_returning_clause_into = 815; // tslint:disable:no-trailing-whitespace public static readonly ruleNames: string[] = [ "program", "plsqlroot", "stmtmulti", "stmt", "plsqlconsolecommand", "callstmt", @@ -1409,13 +1432,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { "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", + "opttemp", "table_column_list", "opttableelementlist", "opttypedtableelementlist", + "tableelementlist", "typedtableelementlist", "tableelement", "typedtableelement", + "columnDef", "columnOptions", "colquallist", "colconstraint", "colconstraintelem", + "generated_when", "deferrable_trigger", "initially_trigger", "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", @@ -1438,33 +1461,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { "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", + "createamstmt", "am_type", "createtrigstmt", "triggeractiontime", "foreachrow", + "roworstatment", "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", "beforeprivilegeselectlist", + "beforeprivilegeselect", "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", + "attrilist", "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", @@ -1546,22 +1569,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { "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", + "table_qualified_name", "qualified_name", "name_list", "name", "attr_name", + "file_name", "func_name", "aexprconst", "xconst", "bconst", "fconst", + "iconst", "sconst", "anysconst", "opt_uescape", "signediconst", "groupname", + "roleid", "rolespec", "role_list", "colid", "index_method_choices", "exclude_element", + "index_paramenters", "wherePredicate", "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", @@ -1615,8 +1639,10 @@ export class PostgreSQLParser extends PostgreSQLParserBase { "'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'", + "'INCLUDING'", "'INCREMENT'", "'INDEX'", "'INDEXES'", "'INHERIT'", "'NOINHERIT'", + "'SUPERUSER'", "'NOSUPERUSER'", "'CREATEDB'", "'NOCREATEDB'", "'CREATEROLE'", + "'NOCREATEROLE'", "'CREATEUSER'", "'NOCREATEUSER'", "'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'", @@ -1662,102 +1688,122 @@ export class PostgreSQLParser extends PostgreSQLParserBase { "'CONSTANT'", "'PERFORM'", "'GET'", "'DIAGNOSTICS'", "'STACKED'", "'ELSIF'", "'WHILE'", "'REVERSE'", "'FOREACH'", "'SLICE'", "'EXIT'", "'RETURN'", "'QUERY'", "'RAISE'", "'SQLSTATE'", "'DEBUG'", "'LOG'", "'INFO'", "'NOTICE'", - "'WARNING'", "'EXCEPTION'", "'ASSERT'", "'LOOP'", "'OPEN'", undefined, + "'WARNING'", "'EXCEPTION'", "'ASSERT'", "'LOOP'", "'OPEN'", "'PEFERENCES'", + "'USAGE'", "'CONNECT'", "'PUBLIC'", undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined, - undefined, undefined, undefined, undefined, "'\\''", undefined, undefined, - undefined, undefined, undefined, undefined, undefined, "'''", + undefined, "'\\''", undefined, undefined, undefined, undefined, undefined, + undefined, undefined, "'''", ]; private static readonly _SYMBOLIC_NAMES: Array = [ undefined, "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", + "PERCENT", "PARAM", "Operator", "KW_ALL", "KW_ANALYSE", "KW_ANALYZE", + "KW_AND", "KW_ANY", "KW_ARRAY", "KW_AS", "KW_ASC", "KW_ASYMMETRIC", "KW_BOTH", + "KW_CASE", "KW_CAST", "KW_CHECK", "KW_COLLATE", "KW_COLUMN", "KW_CONSTRAINT", + "KW_CREATE", "KW_CURRENT_CATALOG", "KW_CURRENT_DATE", "KW_CURRENT_ROLE", + "KW_CURRENT_TIME", "KW_CURRENT_TIMESTAMP", "KW_CURRENT_USER", "KW_DEFAULT", + "KW_DEFERRABLE", "KW_DESC", "KW_DISTINCT", "KW_DO", "KW_ELSE", "KW_EXCEPT", + "KW_FALSE", "KW_FETCH", "KW_FOR", "KW_FOREIGN", "KW_FROM", "KW_GRANT", + "KW_GROUP", "KW_HAVING", "KW_IN", "KW_INITIALLY", "KW_INTERSECT", "KW_INTO", + "KW_LATERAL", "KW_LEADING", "KW_LIMIT", "KW_LOCALTIME", "KW_LOCALTIMESTAMP", + "KW_NOT", "KW_NULL", "KW_OFFSET", "KW_ON", "KW_ONLY", "KW_OR", "KW_ORDER", + "KW_PLACING", "KW_PRIMARY", "KW_REFERENCES", "KW_RETURNING", "KW_SELECT", + "KW_SESSION_USER", "KW_SOME", "KW_SYMMETRIC", "KW_TABLE", "KW_THEN", "KW_TO", + "KW_TRAILING", "KW_TRUE", "KW_UNION", "KW_UNIQUE", "KW_USER", "KW_USING", + "KW_VARIADIC", "KW_WHEN", "KW_WHERE", "KW_WINDOW", "KW_WITH", "KW_AUTHORIZATION", + "KW_BINARY", "KW_COLLATION", "KW_CONCURRENTLY", "KW_CROSS", "KW_CURRENT_SCHEMA", + "KW_FREEZE", "KW_FULL", "KW_ILIKE", "KW_INNER", "KW_IS", "KW_ISNULL", + "KW_JOIN", "KW_LEFT", "KW_LIKE", "KW_NATURAL", "KW_NOTNULL", "KW_OUTER", + "KW_OVER", "KW_OVERLAPS", "KW_RIGHT", "KW_SIMILAR", "KW_VERBOSE", "KW_ABORT", + "KW_ABSOLUTE", "KW_ACCESS", "KW_ACTION", "KW_ADD", "KW_ADMIN", "KW_AFTER", + "KW_AGGREGATE", "KW_ALSO", "KW_ALTER", "KW_ALWAYS", "KW_ASSERTION", "KW_ASSIGNMENT", + "KW_AT", "KW_ATTRIBUTE", "KW_BACKWARD", "KW_BEFORE", "KW_BEGIN", "KW_BY", + "KW_CACHE", "KW_CALLED", "KW_CASCADE", "KW_CASCADED", "KW_CATALOG", "KW_CHAIN", + "KW_CHARACTERISTICS", "KW_CHECKPOINT", "KW_CLASS", "KW_CLOSE", "KW_CLUSTER", + "KW_COMMENT", "KW_COMMENTS", "KW_COMMIT", "KW_COMMITTED", "KW_CONFIGURATION", + "KW_CONNECTION", "KW_CONSTRAINTS", "KW_CONTENT", "KW_CONTINUE", "KW_CONVERSION", + "KW_COPY", "KW_COST", "KW_CSV", "KW_CURSOR", "KW_CYCLE", "KW_DATA", "KW_DATABASE", + "KW_DAY", "KW_DEALLOCATE", "KW_DECLARE", "KW_DEFAULTS", "KW_DEFERRED", + "KW_DEFINER", "KW_DELETE", "KW_DELIMITER", "KW_DELIMITERS", "KW_DICTIONARY", + "KW_DISABLE", "KW_DISCARD", "KW_DOCUMENT", "KW_DOMAIN", "KW_DOUBLE", "KW_DROP", + "KW_EACH", "KW_ENABLE", "KW_ENCODING", "KW_ENCRYPTED", "KW_ENUM", "KW_ESCAPE", + "KW_EVENT", "KW_EXCLUDE", "KW_EXCLUDING", "KW_EXCLUSIVE", "KW_EXECUTE", + "KW_EXPLAIN", "KW_EXTENSION", "KW_EXTERNAL", "KW_FAMILY", "KW_FIRST", + "KW_FOLLOWING", "KW_FORCE", "KW_FORWARD", "KW_FUNCTION", "KW_FUNCTIONS", + "KW_GLOBAL", "KW_GRANTED", "KW_HANDLER", "KW_HEADER", "KW_HOLD", "KW_HOUR", + "KW_IDENTITY", "KW_IF", "KW_IMMEDIATE", "KW_IMMUTABLE", "KW_IMPLICIT", + "KW_INCLUDING", "KW_INCREMENT", "KW_INDEX", "KW_INDEXES", "KW_INHERIT", + "KW_NOINHERIT", "KW_SUPERUSER", "KW_NOSUPERUSER", "KW_CREATEDB", "KW_NOCREATEDB", + "KW_CREATEROLE", "KW_NOCREATEROLE", "KW_CREATEUSER", "KW_NOCREATEUSER", + "KW_INHERITS", "KW_INLINE", "KW_INSENSITIVE", "KW_INSERT", "KW_INSTEAD", + "KW_INVOKER", "KW_ISOLATION", "KW_KEY", "KW_LABEL", "KW_LANGUAGE", "KW_LARGE", + "KW_LAST", "KW_LEAKPROOF", "KW_LEVEL", "KW_LISTEN", "KW_LOAD", "KW_LOCAL", + "KW_LOCATION", "KW_LOCK", "KW_MAPPING", "KW_MATCH", "KW_MATERIALIZED", + "KW_MAXVALUE", "KW_MINUTE", "KW_MINVALUE", "KW_MODE", "KW_MONTH", "KW_MOVE", + "KW_NAME", "KW_NAMES", "KW_NEXT", "KW_NO", "KW_NOTHING", "KW_NOTIFY", + "KW_NOWAIT", "KW_NULLS", "KW_OBJECT", "KW_OF", "KW_OFF", "KW_OIDS", "KW_OPERATOR", + "KW_OPTION", "KW_OPTIONS", "KW_OWNED", "KW_OWNER", "KW_PARSER", "KW_PARTIAL", + "KW_PARTITION", "KW_PASSING", "KW_PASSWORD", "KW_PLANS", "KW_PRECEDING", + "KW_PREPARE", "KW_PREPARED", "KW_PRESERVE", "KW_PRIOR", "KW_PRIVILEGES", + "KW_PROCEDURAL", "KW_PROCEDURE", "KW_PROGRAM", "KW_QUOTE", "KW_RANGE", + "KW_READ", "KW_REASSIGN", "KW_RECHECK", "KW_RECURSIVE", "KW_REF", "KW_REFRESH", + "KW_REINDEX", "KW_RELATIVE", "KW_RELEASE", "KW_RENAME", "KW_REPEATABLE", + "KW_REPLACE", "KW_REPLICA", "KW_RESET", "KW_RESTART", "KW_RESTRICT", "KW_RETURNS", + "KW_REVOKE", "KW_ROLE", "KW_ROLLBACK", "KW_ROWS", "KW_RULE", "KW_SAVEPOINT", + "KW_SCHEMA", "KW_SCROLL", "KW_SEARCH", "KW_SECOND", "KW_SECURITY", "KW_SEQUENCE", + "KW_SEQUENCES", "KW_SERIALIZABLE", "KW_SERVER", "KW_SESSION", "KW_SET", + "KW_SHARE", "KW_SHOW", "KW_SIMPLE", "KW_SNAPSHOT", "KW_STABLE", "KW_STANDALONE", + "KW_START", "KW_STATEMENT", "KW_STATISTICS", "KW_STDIN", "KW_STDOUT", + "KW_STORAGE", "KW_STRICT", "KW_STRIP", "KW_SYSID", "KW_SYSTEM", "KW_TABLES", + "KW_TABLESPACE", "KW_TEMP", "KW_TEMPLATE", "KW_TEMPORARY", "KW_TEXT", + "KW_TRANSACTION", "KW_TRIGGER", "KW_TRUNCATE", "KW_TRUSTED", "KW_TYPE", + "KW_TYPES", "KW_UNBOUNDED", "KW_UNCOMMITTED", "KW_UNENCRYPTED", "KW_UNKNOWN", + "KW_UNLISTEN", "KW_UNLOGGED", "KW_UNTIL", "KW_UPDATE", "KW_VACUUM", "KW_VALID", + "KW_VALIDATE", "KW_VALIDATOR", "KW_VARYING", "KW_VERSION", "KW_VIEW", + "KW_VOLATILE", "KW_WHITESPACE", "KW_WITHOUT", "KW_WORK", "KW_WRAPPER", + "KW_WRITE", "KW_XML", "KW_YEAR", "KW_YES", "KW_ZONE", "KW_BETWEEN", "KW_BIGINT", + "KW_BIT", "KW_BOOLEAN", "KW_CHAR", "KW_CHARACTER", "KW_COALESCE", "KW_DEC", + "KW_DECIMAL", "KW_EXISTS", "KW_EXTRACT", "KW_FLOAT", "KW_GREATEST", "KW_INOUT", + "KW_INT", "KW_INTEGER", "KW_INTERVAL", "KW_LEAST", "KW_NATIONAL", "KW_NCHAR", + "KW_NONE", "KW_NULLIF", "KW_NUMERIC", "KW_OVERLAY", "KW_POSITION", "KW_PRECISION", + "KW_REAL", "KW_ROW", "KW_SETOF", "KW_SMALLINT", "KW_SUBSTRING", "KW_TIME", + "KW_TIMESTAMP", "KW_TREAT", "KW_TRIM", "KW_VALUES", "KW_VARCHAR", "KW_XMLATTRIBUTES", + "KW_XMLCONCAT", "KW_XMLELEMENT", "KW_XMLEXISTS", "KW_XMLFOREST", "KW_XMLPARSE", + "KW_XMLPI", "KW_XMLROOT", "KW_XMLSERIALIZE", "KW_CALL", "KW_CURRENT", + "KW_ATTACH", "KW_DETACH", "KW_EXPRESSION", "KW_GENERATED", "KW_LOGGED", + "KW_STORED", "KW_INCLUDE", "KW_ROUTINE", "KW_TRANSFORM", "KW_IMPORT", + "KW_POLICY", "KW_METHOD", "KW_REFERENCING", "KW_NEW", "KW_OLD", "KW_VALUE", + "KW_SUBSCRIPTION", "KW_PUBLICATION", "KW_OUT", "KW_END", "KW_ROUTINES", + "KW_SCHEMAS", "KW_PROCEDURES", "KW_INPUT", "KW_SUPPORT", "KW_PARALLEL", + "KW_SQL", "KW_DEPENDS", "KW_OVERRIDING", "KW_CONFLICT", "KW_SKIP", "KW_LOCKED", + "KW_TIES", "KW_ROLLUP", "KW_CUBE", "KW_GROUPING", "KW_SETS", "KW_TABLESAMPLE", + "KW_ORDINALITY", "KW_XMLTABLE", "KW_COLUMNS", "KW_XMLNAMESPACES", "KW_ROWTYPE", + "KW_NORMALIZED", "KW_WITHIN", "KW_FILTER", "KW_GROUPS", "KW_OTHERS", "KW_NFC", + "KW_NFD", "KW_NFKC", "KW_NFKD", "KW_UESCAPE", "KW_VIEWS", "KW_NORMALIZE", + "KW_DUMP", "KW_PRINT_STRICT_PARAMS", "KW_VARIABLE_CONFLICT", "KW_ERROR", + "KW_USE_VARIABLE", "KW_USE_COLUMN", "KW_ALIAS", "KW_CONSTANT", "KW_PERFORM", + "KW_GET", "KW_DIAGNOSTICS", "KW_STACKED", "KW_ELSIF", "KW_WHILE", "KW_REVERSE", + "KW_FOREACH", "KW_SLICE", "KW_EXIT", "KW_RETURN", "KW_QUERY", "KW_RAISE", + "KW_SQLSTATE", "KW_DEBUG", "KW_LOG", "KW_INFO", "KW_NOTICE", "KW_WARNING", + "KW_EXCEPTION", "KW_ASSERT", "KW_LOOP", "KW_OPEN", "KW_PEFERENCES", "KW_USAGE", + "KW_CONNECT", "KW_PUBLIC", "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", "DollarText", "EndDollarStringConstant", "AfterEscapeStringConstantWithNewlineMode_Continued", ]; public static readonly VOCABULARY: Vocabulary = new VocabularyImpl(PostgreSQLParser._LITERAL_NAMES, PostgreSQLParser._SYMBOLIC_NAMES, []); @@ -1793,7 +1839,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1606; + this.state = 1632; this.stmtmulti(); } } @@ -1818,7 +1864,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1608; + this.state = 1634; this.pl_function(); } } @@ -1844,27 +1890,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1616; + this.state = 1642; 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) { + while (_la === PostgreSQLParser.OPEN_PAREN || _la === PostgreSQLParser.KW_ANALYSE || ((((_la - 32)) & ~0x1F) === 0 && ((1 << (_la - 32)) & ((1 << (PostgreSQLParser.KW_ANALYZE - 32)) | (1 << (PostgreSQLParser.KW_CREATE - 32)) | (1 << (PostgreSQLParser.KW_DO - 32)) | (1 << (PostgreSQLParser.KW_FETCH - 32)))) !== 0) || ((((_la - 65)) & ~0x1F) === 0 && ((1 << (_la - 65)) & ((1 << (PostgreSQLParser.KW_GRANT - 65)) | (1 << (PostgreSQLParser.KW_SELECT - 65)) | (1 << (PostgreSQLParser.KW_TABLE - 65)))) !== 0) || _la === PostgreSQLParser.KW_WITH || _la === PostgreSQLParser.KW_ABORT || ((((_la - 138)) & ~0x1F) === 0 && ((1 << (_la - 138)) & ((1 << (PostgreSQLParser.KW_ALTER - 138)) | (1 << (PostgreSQLParser.KW_BEGIN - 138)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 138)) | (1 << (PostgreSQLParser.KW_CLOSE - 138)) | (1 << (PostgreSQLParser.KW_CLUSTER - 138)) | (1 << (PostgreSQLParser.KW_COMMENT - 138)) | (1 << (PostgreSQLParser.KW_COMMIT - 138)) | (1 << (PostgreSQLParser.KW_COPY - 138)))) !== 0) || ((((_la - 177)) & ~0x1F) === 0 && ((1 << (_la - 177)) & ((1 << (PostgreSQLParser.KW_DEALLOCATE - 177)) | (1 << (PostgreSQLParser.KW_DECLARE - 177)) | (1 << (PostgreSQLParser.KW_DELETE - 177)) | (1 << (PostgreSQLParser.KW_DISCARD - 177)) | (1 << (PostgreSQLParser.KW_DROP - 177)) | (1 << (PostgreSQLParser.KW_EXECUTE - 177)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 177)))) !== 0) || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & ((1 << (PostgreSQLParser.KW_INSERT - 241)) | (1 << (PostgreSQLParser.KW_LISTEN - 241)) | (1 << (PostgreSQLParser.KW_LOAD - 241)) | (1 << (PostgreSQLParser.KW_LOCK - 241)) | (1 << (PostgreSQLParser.KW_MOVE - 241)) | (1 << (PostgreSQLParser.KW_NOTIFY - 241)))) !== 0) || ((((_la - 290)) & ~0x1F) === 0 && ((1 << (_la - 290)) & ((1 << (PostgreSQLParser.KW_PREPARE - 290)) | (1 << (PostgreSQLParser.KW_REASSIGN - 290)) | (1 << (PostgreSQLParser.KW_REFRESH - 290)) | (1 << (PostgreSQLParser.KW_REINDEX - 290)) | (1 << (PostgreSQLParser.KW_RELEASE - 290)) | (1 << (PostgreSQLParser.KW_RESET - 290)) | (1 << (PostgreSQLParser.KW_REVOKE - 290)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 290)))) !== 0) || ((((_la - 322)) & ~0x1F) === 0 && ((1 << (_la - 322)) & ((1 << (PostgreSQLParser.KW_SAVEPOINT - 322)) | (1 << (PostgreSQLParser.KW_SECURITY - 322)) | (1 << (PostgreSQLParser.KW_SET - 322)) | (1 << (PostgreSQLParser.KW_SHOW - 322)) | (1 << (PostgreSQLParser.KW_START - 322)))) !== 0) || ((((_la - 358)) & ~0x1F) === 0 && ((1 << (_la - 358)) & ((1 << (PostgreSQLParser.KW_TRUNCATE - 358)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 358)) | (1 << (PostgreSQLParser.KW_UPDATE - 358)) | (1 << (PostgreSQLParser.KW_VACUUM - 358)))) !== 0) || ((((_la - 422)) & ~0x1F) === 0 && ((1 << (_la - 422)) & ((1 << (PostgreSQLParser.KW_VALUES - 422)) | (1 << (PostgreSQLParser.KW_CALL - 422)) | (1 << (PostgreSQLParser.KW_IMPORT - 422)))) !== 0) || _la === PostgreSQLParser.KW_END || _la === PostgreSQLParser.MetaCommand) { { { - this.state = 1610; + this.state = 1636; this.stmt(); - this.state = 1612; + this.state = 1638; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.SEMI) { { - this.state = 1611; + this.state = 1637; this.match(PostgreSQLParser.SEMI); } } } } - this.state = 1618; + this.state = 1644; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -1889,13 +1935,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: StmtContext = new StmtContext(this._ctx, this.state); this.enterRule(_localctx, 6, PostgreSQLParser.RULE_stmt); try { - this.state = 1743; + this.state = 1769; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 2, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 1619; + this.state = 1645; this.altereventtrigstmt(); } break; @@ -1903,7 +1949,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 1620; + this.state = 1646; this.altercollationstmt(); } break; @@ -1911,7 +1957,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 1621; + this.state = 1647; this.alterdatabasestmt(); } break; @@ -1919,7 +1965,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 1622; + this.state = 1648; this.alterdatabasesetstmt(); } break; @@ -1927,7 +1973,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 1623; + this.state = 1649; this.alterdefaultprivilegesstmt(); } break; @@ -1935,7 +1981,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 1624; + this.state = 1650; this.alterdomainstmt(); } break; @@ -1943,7 +1989,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 1625; + this.state = 1651; this.alterenumstmt(); } break; @@ -1951,7 +1997,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 1626; + this.state = 1652; this.alterextensionstmt(); } break; @@ -1959,7 +2005,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 1627; + this.state = 1653; this.alterextensioncontentsstmt(); } break; @@ -1967,7 +2013,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 1628; + this.state = 1654; this.alterfdwstmt(); } break; @@ -1975,7 +2021,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 1629; + this.state = 1655; this.alterforeignserverstmt(); } break; @@ -1983,7 +2029,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 1630; + this.state = 1656; this.alterfunctionstmt(); } break; @@ -1991,7 +2037,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 1631; + this.state = 1657; this.altergroupstmt(); } break; @@ -1999,7 +2045,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 1632; + this.state = 1658; this.alterobjectdependsstmt(); } break; @@ -2007,7 +2053,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 1633; + this.state = 1659; this.alterobjectschemastmt(); } break; @@ -2015,7 +2061,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 1634; + this.state = 1660; this.alterownerstmt(); } break; @@ -2023,7 +2069,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 1635; + this.state = 1661; this.alteroperatorstmt(); } break; @@ -2031,7 +2077,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 18: this.enterOuterAlt(_localctx, 18); { - this.state = 1636; + this.state = 1662; this.altertypestmt(); } break; @@ -2039,7 +2085,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 19: this.enterOuterAlt(_localctx, 19); { - this.state = 1637; + this.state = 1663; this.alterpolicystmt(); } break; @@ -2047,7 +2093,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 20: this.enterOuterAlt(_localctx, 20); { - this.state = 1638; + this.state = 1664; this.alterseqstmt(); } break; @@ -2055,7 +2101,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 21: this.enterOuterAlt(_localctx, 21); { - this.state = 1639; + this.state = 1665; this.altersystemstmt(); } break; @@ -2063,7 +2109,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 22: this.enterOuterAlt(_localctx, 22); { - this.state = 1640; + this.state = 1666; this.altertablestmt(); } break; @@ -2071,7 +2117,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 23: this.enterOuterAlt(_localctx, 23); { - this.state = 1641; + this.state = 1667; this.altertblspcstmt(); } break; @@ -2079,7 +2125,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 24: this.enterOuterAlt(_localctx, 24); { - this.state = 1642; + this.state = 1668; this.altercompositetypestmt(); } break; @@ -2087,7 +2133,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 25: this.enterOuterAlt(_localctx, 25); { - this.state = 1643; + this.state = 1669; this.alterpublicationstmt(); } break; @@ -2095,7 +2141,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 26: this.enterOuterAlt(_localctx, 26); { - this.state = 1644; + this.state = 1670; this.alterrolesetstmt(); } break; @@ -2103,7 +2149,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 27: this.enterOuterAlt(_localctx, 27); { - this.state = 1645; + this.state = 1671; this.alterrolestmt(); } break; @@ -2111,7 +2157,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 28: this.enterOuterAlt(_localctx, 28); { - this.state = 1646; + this.state = 1672; this.altersubscriptionstmt(); } break; @@ -2119,7 +2165,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 29: this.enterOuterAlt(_localctx, 29); { - this.state = 1647; + this.state = 1673; this.alterstatsstmt(); } break; @@ -2127,7 +2173,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 30: this.enterOuterAlt(_localctx, 30); { - this.state = 1648; + this.state = 1674; this.altertsconfigurationstmt(); } break; @@ -2135,7 +2181,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 31: this.enterOuterAlt(_localctx, 31); { - this.state = 1649; + this.state = 1675; this.altertsdictionarystmt(); } break; @@ -2143,7 +2189,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 32: this.enterOuterAlt(_localctx, 32); { - this.state = 1650; + this.state = 1676; this.alterusermappingstmt(); } break; @@ -2151,7 +2197,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 33: this.enterOuterAlt(_localctx, 33); { - this.state = 1651; + this.state = 1677; this.analyzestmt(); } break; @@ -2159,7 +2205,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 34: this.enterOuterAlt(_localctx, 34); { - this.state = 1652; + this.state = 1678; this.callstmt(); } break; @@ -2167,7 +2213,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 35: this.enterOuterAlt(_localctx, 35); { - this.state = 1653; + this.state = 1679; this.checkpointstmt(); } break; @@ -2175,7 +2221,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 36: this.enterOuterAlt(_localctx, 36); { - this.state = 1654; + this.state = 1680; this.closeportalstmt(); } break; @@ -2183,7 +2229,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 37: this.enterOuterAlt(_localctx, 37); { - this.state = 1655; + this.state = 1681; this.clusterstmt(); } break; @@ -2191,7 +2237,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 38: this.enterOuterAlt(_localctx, 38); { - this.state = 1656; + this.state = 1682; this.commentstmt(); } break; @@ -2199,7 +2245,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 39: this.enterOuterAlt(_localctx, 39); { - this.state = 1657; + this.state = 1683; this.constraintssetstmt(); } break; @@ -2207,7 +2253,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 40: this.enterOuterAlt(_localctx, 40); { - this.state = 1658; + this.state = 1684; this.copystmt(); } break; @@ -2215,7 +2261,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 41: this.enterOuterAlt(_localctx, 41); { - this.state = 1659; + this.state = 1685; this.createamstmt(); } break; @@ -2223,7 +2269,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 42: this.enterOuterAlt(_localctx, 42); { - this.state = 1660; + this.state = 1686; this.createasstmt(); } break; @@ -2231,7 +2277,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 43: this.enterOuterAlt(_localctx, 43); { - this.state = 1661; + this.state = 1687; this.createassertionstmt(); } break; @@ -2239,7 +2285,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 44: this.enterOuterAlt(_localctx, 44); { - this.state = 1662; + this.state = 1688; this.createcaststmt(); } break; @@ -2247,7 +2293,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 45: this.enterOuterAlt(_localctx, 45); { - this.state = 1663; + this.state = 1689; this.createconversionstmt(); } break; @@ -2255,7 +2301,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 46: this.enterOuterAlt(_localctx, 46); { - this.state = 1664; + this.state = 1690; this.createdomainstmt(); } break; @@ -2263,7 +2309,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 47: this.enterOuterAlt(_localctx, 47); { - this.state = 1665; + this.state = 1691; this.createextensionstmt(); } break; @@ -2271,7 +2317,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 48: this.enterOuterAlt(_localctx, 48); { - this.state = 1666; + this.state = 1692; this.createfdwstmt(); } break; @@ -2279,7 +2325,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 49: this.enterOuterAlt(_localctx, 49); { - this.state = 1667; + this.state = 1693; this.createforeignserverstmt(); } break; @@ -2287,7 +2333,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 50: this.enterOuterAlt(_localctx, 50); { - this.state = 1668; + this.state = 1694; this.createforeigntablestmt(); } break; @@ -2295,7 +2341,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 51: this.enterOuterAlt(_localctx, 51); { - this.state = 1669; + this.state = 1695; this.createfunctionstmt(); } break; @@ -2303,7 +2349,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 52: this.enterOuterAlt(_localctx, 52); { - this.state = 1670; + this.state = 1696; this.creategroupstmt(); } break; @@ -2311,7 +2357,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 53: this.enterOuterAlt(_localctx, 53); { - this.state = 1671; + this.state = 1697; this.creatematviewstmt(); } break; @@ -2319,7 +2365,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 54: this.enterOuterAlt(_localctx, 54); { - this.state = 1672; + this.state = 1698; this.createopclassstmt(); } break; @@ -2327,7 +2373,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 55: this.enterOuterAlt(_localctx, 55); { - this.state = 1673; + this.state = 1699; this.createopfamilystmt(); } break; @@ -2335,7 +2381,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 56: this.enterOuterAlt(_localctx, 56); { - this.state = 1674; + this.state = 1700; this.createpublicationstmt(); } break; @@ -2343,7 +2389,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 57: this.enterOuterAlt(_localctx, 57); { - this.state = 1675; + this.state = 1701; this.alteropfamilystmt(); } break; @@ -2351,7 +2397,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 58: this.enterOuterAlt(_localctx, 58); { - this.state = 1676; + this.state = 1702; this.createpolicystmt(); } break; @@ -2359,7 +2405,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 59: this.enterOuterAlt(_localctx, 59); { - this.state = 1677; + this.state = 1703; this.createplangstmt(); } break; @@ -2367,7 +2413,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 60: this.enterOuterAlt(_localctx, 60); { - this.state = 1678; + this.state = 1704; this.createschemastmt(); } break; @@ -2375,7 +2421,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 61: this.enterOuterAlt(_localctx, 61); { - this.state = 1679; + this.state = 1705; this.createseqstmt(); } break; @@ -2383,7 +2429,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 62: this.enterOuterAlt(_localctx, 62); { - this.state = 1680; + this.state = 1706; this.createstmt(); } break; @@ -2391,7 +2437,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 63: this.enterOuterAlt(_localctx, 63); { - this.state = 1681; + this.state = 1707; this.createsubscriptionstmt(); } break; @@ -2399,7 +2445,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 64: this.enterOuterAlt(_localctx, 64); { - this.state = 1682; + this.state = 1708; this.createstatsstmt(); } break; @@ -2407,7 +2453,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 65: this.enterOuterAlt(_localctx, 65); { - this.state = 1683; + this.state = 1709; this.createtablespacestmt(); } break; @@ -2415,7 +2461,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 66: this.enterOuterAlt(_localctx, 66); { - this.state = 1684; + this.state = 1710; this.createtransformstmt(); } break; @@ -2423,7 +2469,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 67: this.enterOuterAlt(_localctx, 67); { - this.state = 1685; + this.state = 1711; this.createtrigstmt(); } break; @@ -2431,7 +2477,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 68: this.enterOuterAlt(_localctx, 68); { - this.state = 1686; + this.state = 1712; this.createeventtrigstmt(); } break; @@ -2439,7 +2485,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 69: this.enterOuterAlt(_localctx, 69); { - this.state = 1687; + this.state = 1713; this.createrolestmt(); } break; @@ -2447,7 +2493,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 70: this.enterOuterAlt(_localctx, 70); { - this.state = 1688; + this.state = 1714; this.createuserstmt(); } break; @@ -2455,7 +2501,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 71: this.enterOuterAlt(_localctx, 71); { - this.state = 1689; + this.state = 1715; this.createusermappingstmt(); } break; @@ -2463,7 +2509,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 72: this.enterOuterAlt(_localctx, 72); { - this.state = 1690; + this.state = 1716; this.createdbstmt(); } break; @@ -2471,7 +2517,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 73: this.enterOuterAlt(_localctx, 73); { - this.state = 1691; + this.state = 1717; this.deallocatestmt(); } break; @@ -2479,7 +2525,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 74: this.enterOuterAlt(_localctx, 74); { - this.state = 1692; + this.state = 1718; this.declarecursorstmt(); } break; @@ -2487,7 +2533,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 75: this.enterOuterAlt(_localctx, 75); { - this.state = 1693; + this.state = 1719; this.definestmt(); } break; @@ -2495,7 +2541,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 76: this.enterOuterAlt(_localctx, 76); { - this.state = 1694; + this.state = 1720; this.deletestmt(); } break; @@ -2503,7 +2549,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 77: this.enterOuterAlt(_localctx, 77); { - this.state = 1695; + this.state = 1721; this.discardstmt(); } break; @@ -2511,7 +2557,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 78: this.enterOuterAlt(_localctx, 78); { - this.state = 1696; + this.state = 1722; this.dostmt(); } break; @@ -2519,7 +2565,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 79: this.enterOuterAlt(_localctx, 79); { - this.state = 1697; + this.state = 1723; this.dropcaststmt(); } break; @@ -2527,7 +2573,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 80: this.enterOuterAlt(_localctx, 80); { - this.state = 1698; + this.state = 1724; this.dropopclassstmt(); } break; @@ -2535,7 +2581,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 81: this.enterOuterAlt(_localctx, 81); { - this.state = 1699; + this.state = 1725; this.dropopfamilystmt(); } break; @@ -2543,7 +2589,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 82: this.enterOuterAlt(_localctx, 82); { - this.state = 1700; + this.state = 1726; this.dropownedstmt(); } break; @@ -2551,7 +2597,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 83: this.enterOuterAlt(_localctx, 83); { - this.state = 1701; + this.state = 1727; this.dropstmt(); } break; @@ -2559,7 +2605,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 84: this.enterOuterAlt(_localctx, 84); { - this.state = 1702; + this.state = 1728; this.dropsubscriptionstmt(); } break; @@ -2567,7 +2613,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 85: this.enterOuterAlt(_localctx, 85); { - this.state = 1703; + this.state = 1729; this.droptablespacestmt(); } break; @@ -2575,7 +2621,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 86: this.enterOuterAlt(_localctx, 86); { - this.state = 1704; + this.state = 1730; this.droptransformstmt(); } break; @@ -2583,7 +2629,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 87: this.enterOuterAlt(_localctx, 87); { - this.state = 1705; + this.state = 1731; this.droprolestmt(); } break; @@ -2591,7 +2637,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 88: this.enterOuterAlt(_localctx, 88); { - this.state = 1706; + this.state = 1732; this.dropusermappingstmt(); } break; @@ -2599,7 +2645,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 89: this.enterOuterAlt(_localctx, 89); { - this.state = 1707; + this.state = 1733; this.dropdbstmt(); } break; @@ -2607,7 +2653,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 90: this.enterOuterAlt(_localctx, 90); { - this.state = 1708; + this.state = 1734; this.executestmt(); } break; @@ -2615,7 +2661,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 91: this.enterOuterAlt(_localctx, 91); { - this.state = 1709; + this.state = 1735; this.explainstmt(); } break; @@ -2623,7 +2669,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 92: this.enterOuterAlt(_localctx, 92); { - this.state = 1710; + this.state = 1736; this.fetchstmt(); } break; @@ -2631,7 +2677,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 93: this.enterOuterAlt(_localctx, 93); { - this.state = 1711; + this.state = 1737; this.grantstmt(); } break; @@ -2639,7 +2685,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 94: this.enterOuterAlt(_localctx, 94); { - this.state = 1712; + this.state = 1738; this.grantrolestmt(); } break; @@ -2647,7 +2693,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 95: this.enterOuterAlt(_localctx, 95); { - this.state = 1713; + this.state = 1739; this.importforeignschemastmt(); } break; @@ -2655,7 +2701,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 96: this.enterOuterAlt(_localctx, 96); { - this.state = 1714; + this.state = 1740; this.indexstmt(); } break; @@ -2663,7 +2709,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 97: this.enterOuterAlt(_localctx, 97); { - this.state = 1715; + this.state = 1741; this.insertstmt(); } break; @@ -2671,7 +2717,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 98: this.enterOuterAlt(_localctx, 98); { - this.state = 1716; + this.state = 1742; this.listenstmt(); } break; @@ -2679,7 +2725,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 99: this.enterOuterAlt(_localctx, 99); { - this.state = 1717; + this.state = 1743; this.refreshmatviewstmt(); } break; @@ -2687,7 +2733,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 100: this.enterOuterAlt(_localctx, 100); { - this.state = 1718; + this.state = 1744; this.loadstmt(); } break; @@ -2695,7 +2741,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 101: this.enterOuterAlt(_localctx, 101); { - this.state = 1719; + this.state = 1745; this.lockstmt(); } break; @@ -2703,7 +2749,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 102: this.enterOuterAlt(_localctx, 102); { - this.state = 1720; + this.state = 1746; this.notifystmt(); } break; @@ -2711,7 +2757,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 103: this.enterOuterAlt(_localctx, 103); { - this.state = 1721; + this.state = 1747; this.preparestmt(); } break; @@ -2719,7 +2765,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 104: this.enterOuterAlt(_localctx, 104); { - this.state = 1722; + this.state = 1748; this.reassignownedstmt(); } break; @@ -2727,7 +2773,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 105: this.enterOuterAlt(_localctx, 105); { - this.state = 1723; + this.state = 1749; this.reindexstmt(); } break; @@ -2735,7 +2781,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 106: this.enterOuterAlt(_localctx, 106); { - this.state = 1724; + this.state = 1750; this.removeaggrstmt(); } break; @@ -2743,7 +2789,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 107: this.enterOuterAlt(_localctx, 107); { - this.state = 1725; + this.state = 1751; this.removefuncstmt(); } break; @@ -2751,7 +2797,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 108: this.enterOuterAlt(_localctx, 108); { - this.state = 1726; + this.state = 1752; this.removeoperstmt(); } break; @@ -2759,7 +2805,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 109: this.enterOuterAlt(_localctx, 109); { - this.state = 1727; + this.state = 1753; this.renamestmt(); } break; @@ -2767,7 +2813,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 110: this.enterOuterAlt(_localctx, 110); { - this.state = 1728; + this.state = 1754; this.revokestmt(); } break; @@ -2775,7 +2821,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 111: this.enterOuterAlt(_localctx, 111); { - this.state = 1729; + this.state = 1755; this.revokerolestmt(); } break; @@ -2783,7 +2829,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 112: this.enterOuterAlt(_localctx, 112); { - this.state = 1730; + this.state = 1756; this.rulestmt(); } break; @@ -2791,7 +2837,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 113: this.enterOuterAlt(_localctx, 113); { - this.state = 1731; + this.state = 1757; this.seclabelstmt(); } break; @@ -2799,7 +2845,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 114: this.enterOuterAlt(_localctx, 114); { - this.state = 1732; + this.state = 1758; this.selectstmt(); } break; @@ -2807,7 +2853,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 115: this.enterOuterAlt(_localctx, 115); { - this.state = 1733; + this.state = 1759; this.transactionstmt(); } break; @@ -2815,7 +2861,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 116: this.enterOuterAlt(_localctx, 116); { - this.state = 1734; + this.state = 1760; this.truncatestmt(); } break; @@ -2823,7 +2869,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 117: this.enterOuterAlt(_localctx, 117); { - this.state = 1735; + this.state = 1761; this.unlistenstmt(); } break; @@ -2831,7 +2877,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 118: this.enterOuterAlt(_localctx, 118); { - this.state = 1736; + this.state = 1762; this.updatestmt(); } break; @@ -2839,7 +2885,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 119: this.enterOuterAlt(_localctx, 119); { - this.state = 1737; + this.state = 1763; this.vacuumstmt(); } break; @@ -2847,7 +2893,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 120: this.enterOuterAlt(_localctx, 120); { - this.state = 1738; + this.state = 1764; this.variableresetstmt(); } break; @@ -2855,7 +2901,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 121: this.enterOuterAlt(_localctx, 121); { - this.state = 1739; + this.state = 1765; this.variablesetstmt(); } break; @@ -2863,7 +2909,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 122: this.enterOuterAlt(_localctx, 122); { - this.state = 1740; + this.state = 1766; this.variableshowstmt(); } break; @@ -2871,7 +2917,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 123: this.enterOuterAlt(_localctx, 123); { - this.state = 1741; + this.state = 1767; this.viewstmt(); } break; @@ -2879,7 +2925,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 124: this.enterOuterAlt(_localctx, 124); { - this.state = 1742; + this.state = 1768; this.plsqlconsolecommand(); } break; @@ -2907,14 +2953,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1745; + this.state = 1771; this.match(PostgreSQLParser.MetaCommand); - this.state = 1747; + this.state = 1773; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.EndMetaCommand) { { - this.state = 1746; + this.state = 1772; this.match(PostgreSQLParser.EndMetaCommand); } } @@ -2942,9 +2988,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1749; - this.match(PostgreSQLParser.CALL); - this.state = 1750; + this.state = 1775; + this.match(PostgreSQLParser.KW_CALL); + this.state = 1776; this.func_application(); } } @@ -2969,23 +3015,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1752; - this.match(PostgreSQLParser.CREATE); - this.state = 1753; - this.match(PostgreSQLParser.ROLE); - this.state = 1754; + this.state = 1778; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 1779; + this.match(PostgreSQLParser.KW_ROLE); + this.state = 1780; this.roleid(); - this.state = 1756; + this.state = 1782; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 4, this._ctx) ) { case 1: { - this.state = 1755; + this.state = 1781; this.opt_with(); } break; } - this.state = 1758; + this.state = 1784; this.optrolelist(); } } @@ -3010,8 +3056,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1760; - this.match(PostgreSQLParser.WITH); + this.state = 1786; + this.match(PostgreSQLParser.KW_WITH); } } catch (re) { @@ -3036,19 +3082,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 1765; + this.state = 1791; this._errHandler.sync(this); _alt = this.interpreter.adaptivePredict(this._input, 5, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 1762; + this.state = 1788; this.createoptroleelem(); } } } - this.state = 1767; + this.state = 1793; this._errHandler.sync(this); _alt = this.interpreter.adaptivePredict(this._input, 5, this._ctx); } @@ -3076,19 +3122,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 1771; + this.state = 1797; this._errHandler.sync(this); _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 1768; + this.state = 1794; this.alteroptroleelem(); } } } - this.state = 1773; + this.state = 1799; this._errHandler.sync(this); _alt = this.interpreter.adaptivePredict(this._input, 6, this._ctx); } @@ -3114,15 +3160,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 20, PostgreSQLParser.RULE_alteroptroleelem); let _la: number; try { - this.state = 1792; + this.state = 1822; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.PASSWORD: + case PostgreSQLParser.KW_PASSWORD: this.enterOuterAlt(_localctx, 1); { - this.state = 1774; - this.match(PostgreSQLParser.PASSWORD); - this.state = 1777; + this.state = 1800; + this.match(PostgreSQLParser.KW_PASSWORD); + this.state = 1803; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: @@ -3130,14 +3176,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.BeginDollarStringConstant: case PostgreSQLParser.EscapeStringConstant: { - this.state = 1775; + this.state = 1801; this.sconst(); } break; - case PostgreSQLParser.NULL_P: + case PostgreSQLParser.KW_NULL: { - this.state = 1776; - this.match(PostgreSQLParser.NULL_P); + this.state = 1802; + this.match(PostgreSQLParser.KW_NULL); } break; default: @@ -3145,13 +3191,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.ENCRYPTED: - case PostgreSQLParser.UNENCRYPTED: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_UNENCRYPTED: this.enterOuterAlt(_localctx, 2); { - this.state = 1779; + this.state = 1805; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ENCRYPTED || _la === PostgreSQLParser.UNENCRYPTED)) { + if (!(_la === PostgreSQLParser.KW_ENCRYPTED || _la === PostgreSQLParser.KW_UNENCRYPTED)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -3161,123 +3207,206 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 1780; - this.match(PostgreSQLParser.PASSWORD); - this.state = 1781; + this.state = 1806; + this.match(PostgreSQLParser.KW_PASSWORD); + this.state = 1807; this.sconst(); } break; - case PostgreSQLParser.INHERIT: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_NOINHERIT: this.enterOuterAlt(_localctx, 3); { - this.state = 1782; - this.match(PostgreSQLParser.INHERIT); + this.state = 1808; + _la = this._input.LA(1); + if (!(_la === PostgreSQLParser.KW_INHERIT || _la === PostgreSQLParser.KW_NOINHERIT)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } } break; - case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.KW_CREATEUSER: + case PostgreSQLParser.KW_NOCREATEUSER: this.enterOuterAlt(_localctx, 4); { - this.state = 1783; - this.match(PostgreSQLParser.CONNECTION); - this.state = 1784; - this.match(PostgreSQLParser.LIMIT); - this.state = 1785; + this.state = 1809; + _la = this._input.LA(1); + if (!(_la === PostgreSQLParser.KW_CREATEUSER || _la === PostgreSQLParser.KW_NOCREATEUSER)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + break; + case PostgreSQLParser.KW_CREATEROLE: + case PostgreSQLParser.KW_NOCREATEROLE: + this.enterOuterAlt(_localctx, 5); + { + this.state = 1810; + _la = this._input.LA(1); + if (!(_la === PostgreSQLParser.KW_CREATEROLE || _la === PostgreSQLParser.KW_NOCREATEROLE)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + break; + case PostgreSQLParser.KW_CREATEDB: + case PostgreSQLParser.KW_NOCREATEDB: + this.enterOuterAlt(_localctx, 6); + { + this.state = 1811; + _la = this._input.LA(1); + if (!(_la === PostgreSQLParser.KW_CREATEDB || _la === PostgreSQLParser.KW_NOCREATEDB)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + break; + case PostgreSQLParser.KW_SUPERUSER: + case PostgreSQLParser.KW_NOSUPERUSER: + this.enterOuterAlt(_localctx, 7); + { + this.state = 1812; + _la = this._input.LA(1); + if (!(_la === PostgreSQLParser.KW_SUPERUSER || _la === PostgreSQLParser.KW_NOSUPERUSER)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + break; + case PostgreSQLParser.KW_CONNECTION: + this.enterOuterAlt(_localctx, 8); + { + this.state = 1813; + this.match(PostgreSQLParser.KW_CONNECTION); + this.state = 1814; + this.match(PostgreSQLParser.KW_LIMIT); + this.state = 1815; this.signediconst(); } break; - case PostgreSQLParser.VALID: - this.enterOuterAlt(_localctx, 5); + case PostgreSQLParser.KW_VALID: + this.enterOuterAlt(_localctx, 9); { - this.state = 1786; - this.match(PostgreSQLParser.VALID); - this.state = 1787; - this.match(PostgreSQLParser.UNTIL); - this.state = 1788; + this.state = 1816; + this.match(PostgreSQLParser.KW_VALID); + this.state = 1817; + this.match(PostgreSQLParser.KW_UNTIL); + this.state = 1818; this.sconst(); } break; - case PostgreSQLParser.USER: - this.enterOuterAlt(_localctx, 6); + case PostgreSQLParser.KW_USER: + this.enterOuterAlt(_localctx, 10); { - this.state = 1789; - this.match(PostgreSQLParser.USER); - this.state = 1790; + this.state = 1819; + this.match(PostgreSQLParser.KW_USER); + this.state = 1820; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: case PostgreSQLParser.PLSQLVARIABLENAME: case PostgreSQLParser.PLSQLIDENTIFIER: - this.enterOuterAlt(_localctx, 7); + this.enterOuterAlt(_localctx, 11); { - this.state = 1791; + this.state = 1821; this.identifier(); } break; @@ -3305,81 +3434,90 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 22, PostgreSQLParser.RULE_createoptroleelem); let _la: number; try { - this.state = 1804; + this.state = 1834; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_NOINHERIT: + case PostgreSQLParser.KW_SUPERUSER: + case PostgreSQLParser.KW_NOSUPERUSER: + case PostgreSQLParser.KW_CREATEDB: + case PostgreSQLParser.KW_NOCREATEDB: + case PostgreSQLParser.KW_CREATEROLE: + case PostgreSQLParser.KW_NOCREATEROLE: + case PostgreSQLParser.KW_CREATEUSER: + case PostgreSQLParser.KW_NOCREATEUSER: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -3387,45 +3525,45 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 1794; + this.state = 1824; this.alteroptroleelem(); } break; - case PostgreSQLParser.SYSID: + case PostgreSQLParser.KW_SYSID: this.enterOuterAlt(_localctx, 2); { - this.state = 1795; - this.match(PostgreSQLParser.SYSID); - this.state = 1796; + this.state = 1825; + this.match(PostgreSQLParser.KW_SYSID); + this.state = 1826; this.iconst(); } break; - case PostgreSQLParser.ADMIN: + case PostgreSQLParser.KW_ADMIN: this.enterOuterAlt(_localctx, 3); { - this.state = 1797; - this.match(PostgreSQLParser.ADMIN); - this.state = 1798; + this.state = 1827; + this.match(PostgreSQLParser.KW_ADMIN); + this.state = 1828; this.role_list(); } break; - case PostgreSQLParser.ROLE: + case PostgreSQLParser.KW_ROLE: this.enterOuterAlt(_localctx, 4); { - this.state = 1799; - this.match(PostgreSQLParser.ROLE); - this.state = 1800; + this.state = 1829; + this.match(PostgreSQLParser.KW_ROLE); + this.state = 1830; this.role_list(); } break; - case PostgreSQLParser.IN_P: + case PostgreSQLParser.KW_IN: this.enterOuterAlt(_localctx, 5); { - this.state = 1801; - this.match(PostgreSQLParser.IN_P); - this.state = 1802; + this.state = 1831; + this.match(PostgreSQLParser.KW_IN); + this.state = 1832; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.GROUP_P || _la === PostgreSQLParser.ROLE)) { + if (!(_la === PostgreSQLParser.KW_GROUP || _la === PostgreSQLParser.KW_ROLE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -3435,7 +3573,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 1803; + this.state = 1833; this.role_list(); } break; @@ -3464,23 +3602,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1806; - this.match(PostgreSQLParser.CREATE); - this.state = 1807; - this.match(PostgreSQLParser.USER); - this.state = 1808; + this.state = 1836; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 1837; + this.match(PostgreSQLParser.KW_USER); + this.state = 1838; this.roleid(); - this.state = 1810; + this.state = 1840; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 10, this._ctx) ) { case 1: { - this.state = 1809; + this.state = 1839; this.opt_with(); } break; } - this.state = 1812; + this.state = 1842; this.optrolelist(); } } @@ -3506,11 +3644,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1814; - this.match(PostgreSQLParser.ALTER); - this.state = 1815; + this.state = 1844; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 1845; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.USER || _la === PostgreSQLParser.ROLE)) { + if (!(_la === PostgreSQLParser.KW_USER || _la === PostgreSQLParser.KW_ROLE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -3520,19 +3658,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 1816; + this.state = 1846; this.rolespec(); - this.state = 1818; + this.state = 1848; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 11, this._ctx) ) { case 1: { - this.state = 1817; + this.state = 1847; this.opt_with(); } break; } - this.state = 1820; + this.state = 1850; this.alteroptrolelist(); } } @@ -3555,24 +3693,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Opt_in_databaseContext = new Opt_in_databaseContext(this._ctx, this.state); this.enterRule(_localctx, 28, PostgreSQLParser.RULE_opt_in_database); try { - this.state = 1826; + this.state = 1856; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.RESET: - case PostgreSQLParser.SET: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_SET: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.IN_P: + case PostgreSQLParser.KW_IN: this.enterOuterAlt(_localctx, 2); { - this.state = 1823; - this.match(PostgreSQLParser.IN_P); - this.state = 1824; - this.match(PostgreSQLParser.DATABASE); - this.state = 1825; + this.state = 1853; + this.match(PostgreSQLParser.KW_IN); + this.state = 1854; + this.match(PostgreSQLParser.KW_DATABASE); + this.state = 1855; this.name(); } break; @@ -3602,11 +3740,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1828; - this.match(PostgreSQLParser.ALTER); - this.state = 1829; + this.state = 1858; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 1859; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.USER || _la === PostgreSQLParser.ROLE)) { + if (!(_la === PostgreSQLParser.KW_USER || _la === PostgreSQLParser.KW_ROLE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -3616,21 +3754,445 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 1831; + this.state = 1862; this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.ALL) { + switch (this._input.LA(1)) { + case PostgreSQLParser.KW_ALL: { - this.state = 1830; - this.match(PostgreSQLParser.ALL); + this.state = 1860; + this.match(PostgreSQLParser.KW_ALL); } + break; + case PostgreSQLParser.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: + case PostgreSQLParser.KW_PUBLIC: + case PostgreSQLParser.Identifier: + case PostgreSQLParser.QuotedIdentifier: + case PostgreSQLParser.UnicodeQuotedIdentifier: + case PostgreSQLParser.PLSQLVARIABLENAME: + case PostgreSQLParser.PLSQLIDENTIFIER: + { + this.state = 1861; + this.rolespec(); + } + break; + default: + throw new NoViableAltException(this); } - - this.state = 1833; - this.rolespec(); - this.state = 1834; + this.state = 1864; this.opt_in_database(); - this.state = 1835; + this.state = 1865; this.setresetclause(); } } @@ -3656,11 +4218,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1837; - this.match(PostgreSQLParser.DROP); - this.state = 1838; + this.state = 1867; + this.match(PostgreSQLParser.KW_DROP); + this.state = 1868; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.GROUP_P || _la === PostgreSQLParser.USER || _la === PostgreSQLParser.ROLE)) { + if (!(_la === PostgreSQLParser.KW_GROUP || _la === PostgreSQLParser.KW_USER || _la === PostgreSQLParser.KW_ROLE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -3670,19 +4232,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 1841; + this.state = 1871; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 14, this._ctx) ) { case 1: { - this.state = 1839; - this.match(PostgreSQLParser.IF_P); - this.state = 1840; - this.match(PostgreSQLParser.EXISTS); + this.state = 1869; + this.match(PostgreSQLParser.KW_IF); + this.state = 1870; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 1843; + this.state = 1873; this.role_list(); } } @@ -3707,23 +4269,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1845; - this.match(PostgreSQLParser.CREATE); - this.state = 1846; - this.match(PostgreSQLParser.GROUP_P); - this.state = 1847; - this.roleid(); - this.state = 1849; + this.state = 1875; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 1876; + this.match(PostgreSQLParser.KW_GROUP); + this.state = 1877; + this.groupname(); + this.state = 1879; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 15, this._ctx) ) { case 1: { - this.state = 1848; + this.state = 1878; this.opt_with(); } break; } - this.state = 1851; + this.state = 1881; this.optrolelist(); } } @@ -3748,17 +4310,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1853; - this.match(PostgreSQLParser.ALTER); - this.state = 1854; - this.match(PostgreSQLParser.GROUP_P); - this.state = 1855; + this.state = 1883; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 1884; + this.match(PostgreSQLParser.KW_GROUP); + this.state = 1885; this.rolespec(); - this.state = 1856; + this.state = 1886; this.add_drop(); - this.state = 1857; - this.match(PostgreSQLParser.USER); - this.state = 1858; + this.state = 1887; + this.match(PostgreSQLParser.KW_USER); + this.state = 1888; this.role_list(); } } @@ -3784,9 +4346,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1860; + this.state = 1890; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ADD_P || _la === PostgreSQLParser.DROP)) { + if (!(_la === PostgreSQLParser.KW_ADD || _la === PostgreSQLParser.KW_DROP)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -3820,54 +4382,54 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1862; - this.match(PostgreSQLParser.CREATE); - this.state = 1863; - this.match(PostgreSQLParser.SCHEMA); - this.state = 1867; + this.state = 1892; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 1893; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 1897; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 16, this._ctx) ) { case 1: { - this.state = 1864; - this.match(PostgreSQLParser.IF_P); - this.state = 1865; - this.match(PostgreSQLParser.NOT); - this.state = 1866; - this.match(PostgreSQLParser.EXISTS); + this.state = 1894; + this.match(PostgreSQLParser.KW_IF); + this.state = 1895; + this.match(PostgreSQLParser.KW_NOT); + this.state = 1896; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 1875; + this.state = 1905; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 18, this._ctx) ) { case 1: { - this.state = 1870; + this.state = 1900; 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)) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.KW_OVER - 124)) | (1 << (PostgreSQLParser.KW_ABORT - 124)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 124)) | (1 << (PostgreSQLParser.KW_ACCESS - 124)) | (1 << (PostgreSQLParser.KW_ACTION - 124)) | (1 << (PostgreSQLParser.KW_ADD - 124)) | (1 << (PostgreSQLParser.KW_ADMIN - 124)) | (1 << (PostgreSQLParser.KW_AFTER - 124)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 124)) | (1 << (PostgreSQLParser.KW_ALSO - 124)) | (1 << (PostgreSQLParser.KW_ALTER - 124)) | (1 << (PostgreSQLParser.KW_ALWAYS - 124)) | (1 << (PostgreSQLParser.KW_ASSERTION - 124)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.KW_AT - 124)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.KW_BACKWARD - 124)) | (1 << (PostgreSQLParser.KW_BEFORE - 124)) | (1 << (PostgreSQLParser.KW_BEGIN - 124)) | (1 << (PostgreSQLParser.KW_BY - 124)) | (1 << (PostgreSQLParser.KW_CACHE - 124)) | (1 << (PostgreSQLParser.KW_CALLED - 124)) | (1 << (PostgreSQLParser.KW_CASCADE - 124)) | (1 << (PostgreSQLParser.KW_CASCADED - 124)) | (1 << (PostgreSQLParser.KW_CATALOG - 124)) | (1 << (PostgreSQLParser.KW_CHAIN - 124)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.KW_CLASS - 156)) | (1 << (PostgreSQLParser.KW_CLOSE - 156)) | (1 << (PostgreSQLParser.KW_CLUSTER - 156)) | (1 << (PostgreSQLParser.KW_COMMENT - 156)) | (1 << (PostgreSQLParser.KW_COMMENTS - 156)) | (1 << (PostgreSQLParser.KW_COMMIT - 156)) | (1 << (PostgreSQLParser.KW_COMMITTED - 156)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 156)) | (1 << (PostgreSQLParser.KW_CONNECTION - 156)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.KW_CONTENT - 156)) | (1 << (PostgreSQLParser.KW_CONTINUE - 156)) | (1 << (PostgreSQLParser.KW_CONVERSION - 156)) | (1 << (PostgreSQLParser.KW_COPY - 156)) | (1 << (PostgreSQLParser.KW_COST - 156)) | (1 << (PostgreSQLParser.KW_CSV - 156)) | (1 << (PostgreSQLParser.KW_CURSOR - 156)) | (1 << (PostgreSQLParser.KW_CYCLE - 156)) | (1 << (PostgreSQLParser.KW_DATA - 156)) | (1 << (PostgreSQLParser.KW_DATABASE - 156)) | (1 << (PostgreSQLParser.KW_DAY - 156)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 156)) | (1 << (PostgreSQLParser.KW_DECLARE - 156)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 156)) | (1 << (PostgreSQLParser.KW_DEFERRED - 156)) | (1 << (PostgreSQLParser.KW_DEFINER - 156)) | (1 << (PostgreSQLParser.KW_DELETE - 156)) | (1 << (PostgreSQLParser.KW_DELIMITER - 156)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 156)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 156)) | (1 << (PostgreSQLParser.KW_DISABLE - 156)) | (1 << (PostgreSQLParser.KW_DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.KW_DOCUMENT - 188)) | (1 << (PostgreSQLParser.KW_DOMAIN - 188)) | (1 << (PostgreSQLParser.KW_DOUBLE - 188)) | (1 << (PostgreSQLParser.KW_DROP - 188)) | (1 << (PostgreSQLParser.KW_EACH - 188)) | (1 << (PostgreSQLParser.KW_ENABLE - 188)) | (1 << (PostgreSQLParser.KW_ENCODING - 188)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 188)) | (1 << (PostgreSQLParser.KW_ENUM - 188)) | (1 << (PostgreSQLParser.KW_ESCAPE - 188)) | (1 << (PostgreSQLParser.KW_EVENT - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 188)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.KW_EXECUTE - 188)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 188)) | (1 << (PostgreSQLParser.KW_EXTENSION - 188)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 188)) | (1 << (PostgreSQLParser.KW_FAMILY - 188)) | (1 << (PostgreSQLParser.KW_FIRST - 188)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 188)) | (1 << (PostgreSQLParser.KW_FORCE - 188)) | (1 << (PostgreSQLParser.KW_FORWARD - 188)) | (1 << (PostgreSQLParser.KW_FUNCTION - 188)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 188)) | (1 << (PostgreSQLParser.KW_GLOBAL - 188)) | (1 << (PostgreSQLParser.KW_GRANTED - 188)) | (1 << (PostgreSQLParser.KW_HANDLER - 188)) | (1 << (PostgreSQLParser.KW_HEADER - 188)) | (1 << (PostgreSQLParser.KW_HOLD - 188)) | (1 << (PostgreSQLParser.KW_HOUR - 188)) | (1 << (PostgreSQLParser.KW_IDENTITY - 188)))) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.KW_IF - 220)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 220)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 220)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 220)) | (1 << (PostgreSQLParser.KW_INCLUDING - 220)) | (1 << (PostgreSQLParser.KW_INCREMENT - 220)) | (1 << (PostgreSQLParser.KW_INDEX - 220)) | (1 << (PostgreSQLParser.KW_INDEXES - 220)) | (1 << (PostgreSQLParser.KW_INHERIT - 220)) | (1 << (PostgreSQLParser.KW_INHERITS - 220)) | (1 << (PostgreSQLParser.KW_INLINE - 220)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 220)) | (1 << (PostgreSQLParser.KW_INSERT - 220)) | (1 << (PostgreSQLParser.KW_INSTEAD - 220)) | (1 << (PostgreSQLParser.KW_INVOKER - 220)) | (1 << (PostgreSQLParser.KW_ISOLATION - 220)) | (1 << (PostgreSQLParser.KW_KEY - 220)) | (1 << (PostgreSQLParser.KW_LABEL - 220)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 220)) | (1 << (PostgreSQLParser.KW_LARGE - 220)) | (1 << (PostgreSQLParser.KW_LAST - 220)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 220)) | (1 << (PostgreSQLParser.KW_LEVEL - 220)))) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.KW_LISTEN - 252)) | (1 << (PostgreSQLParser.KW_LOAD - 252)) | (1 << (PostgreSQLParser.KW_LOCAL - 252)) | (1 << (PostgreSQLParser.KW_LOCATION - 252)) | (1 << (PostgreSQLParser.KW_LOCK - 252)) | (1 << (PostgreSQLParser.KW_MAPPING - 252)) | (1 << (PostgreSQLParser.KW_MATCH - 252)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 252)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 252)) | (1 << (PostgreSQLParser.KW_MINUTE - 252)) | (1 << (PostgreSQLParser.KW_MINVALUE - 252)) | (1 << (PostgreSQLParser.KW_MODE - 252)) | (1 << (PostgreSQLParser.KW_MONTH - 252)) | (1 << (PostgreSQLParser.KW_MOVE - 252)) | (1 << (PostgreSQLParser.KW_NAME - 252)) | (1 << (PostgreSQLParser.KW_NAMES - 252)) | (1 << (PostgreSQLParser.KW_NEXT - 252)) | (1 << (PostgreSQLParser.KW_NO - 252)) | (1 << (PostgreSQLParser.KW_NOTHING - 252)) | (1 << (PostgreSQLParser.KW_NOTIFY - 252)) | (1 << (PostgreSQLParser.KW_NOWAIT - 252)) | (1 << (PostgreSQLParser.KW_NULLS - 252)) | (1 << (PostgreSQLParser.KW_OBJECT - 252)) | (1 << (PostgreSQLParser.KW_OF - 252)) | (1 << (PostgreSQLParser.KW_OFF - 252)) | (1 << (PostgreSQLParser.KW_OIDS - 252)) | (1 << (PostgreSQLParser.KW_OPERATOR - 252)) | (1 << (PostgreSQLParser.KW_OPTION - 252)) | (1 << (PostgreSQLParser.KW_OPTIONS - 252)) | (1 << (PostgreSQLParser.KW_OWNED - 252)) | (1 << (PostgreSQLParser.KW_OWNER - 252)) | (1 << (PostgreSQLParser.KW_PARSER - 252)))) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.KW_PARTIAL - 284)) | (1 << (PostgreSQLParser.KW_PARTITION - 284)) | (1 << (PostgreSQLParser.KW_PASSING - 284)) | (1 << (PostgreSQLParser.KW_PASSWORD - 284)) | (1 << (PostgreSQLParser.KW_PLANS - 284)) | (1 << (PostgreSQLParser.KW_PRECEDING - 284)) | (1 << (PostgreSQLParser.KW_PREPARE - 284)) | (1 << (PostgreSQLParser.KW_PREPARED - 284)) | (1 << (PostgreSQLParser.KW_PRESERVE - 284)) | (1 << (PostgreSQLParser.KW_PRIOR - 284)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 284)) | (1 << (PostgreSQLParser.KW_PROGRAM - 284)) | (1 << (PostgreSQLParser.KW_QUOTE - 284)) | (1 << (PostgreSQLParser.KW_RANGE - 284)) | (1 << (PostgreSQLParser.KW_READ - 284)) | (1 << (PostgreSQLParser.KW_REASSIGN - 284)) | (1 << (PostgreSQLParser.KW_RECHECK - 284)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 284)) | (1 << (PostgreSQLParser.KW_REF - 284)) | (1 << (PostgreSQLParser.KW_REFRESH - 284)) | (1 << (PostgreSQLParser.KW_REINDEX - 284)) | (1 << (PostgreSQLParser.KW_RELATIVE - 284)) | (1 << (PostgreSQLParser.KW_RELEASE - 284)) | (1 << (PostgreSQLParser.KW_RENAME - 284)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 284)) | (1 << (PostgreSQLParser.KW_REPLACE - 284)) | (1 << (PostgreSQLParser.KW_REPLICA - 284)) | (1 << (PostgreSQLParser.KW_RESET - 284)) | (1 << (PostgreSQLParser.KW_RESTART - 284)) | (1 << (PostgreSQLParser.KW_RESTRICT - 284)))) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.KW_RETURNS - 316)) | (1 << (PostgreSQLParser.KW_REVOKE - 316)) | (1 << (PostgreSQLParser.KW_ROLE - 316)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 316)) | (1 << (PostgreSQLParser.KW_ROWS - 316)) | (1 << (PostgreSQLParser.KW_RULE - 316)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 316)) | (1 << (PostgreSQLParser.KW_SCHEMA - 316)) | (1 << (PostgreSQLParser.KW_SCROLL - 316)) | (1 << (PostgreSQLParser.KW_SEARCH - 316)) | (1 << (PostgreSQLParser.KW_SECOND - 316)) | (1 << (PostgreSQLParser.KW_SECURITY - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 316)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.KW_SERVER - 316)) | (1 << (PostgreSQLParser.KW_SESSION - 316)) | (1 << (PostgreSQLParser.KW_SET - 316)) | (1 << (PostgreSQLParser.KW_SHARE - 316)) | (1 << (PostgreSQLParser.KW_SHOW - 316)) | (1 << (PostgreSQLParser.KW_SIMPLE - 316)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 316)) | (1 << (PostgreSQLParser.KW_STABLE - 316)) | (1 << (PostgreSQLParser.KW_STANDALONE - 316)) | (1 << (PostgreSQLParser.KW_START - 316)) | (1 << (PostgreSQLParser.KW_STATEMENT - 316)) | (1 << (PostgreSQLParser.KW_STATISTICS - 316)) | (1 << (PostgreSQLParser.KW_STDIN - 316)) | (1 << (PostgreSQLParser.KW_STDOUT - 316)) | (1 << (PostgreSQLParser.KW_STORAGE - 316)) | (1 << (PostgreSQLParser.KW_STRICT - 316)) | (1 << (PostgreSQLParser.KW_STRIP - 316)))) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.KW_SYSID - 348)) | (1 << (PostgreSQLParser.KW_SYSTEM - 348)) | (1 << (PostgreSQLParser.KW_TABLES - 348)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 348)) | (1 << (PostgreSQLParser.KW_TEMP - 348)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 348)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 348)) | (1 << (PostgreSQLParser.KW_TEXT - 348)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 348)) | (1 << (PostgreSQLParser.KW_TRIGGER - 348)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 348)) | (1 << (PostgreSQLParser.KW_TRUSTED - 348)) | (1 << (PostgreSQLParser.KW_TYPE - 348)) | (1 << (PostgreSQLParser.KW_TYPES - 348)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 348)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 348)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 348)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 348)) | (1 << (PostgreSQLParser.KW_UNTIL - 348)) | (1 << (PostgreSQLParser.KW_UPDATE - 348)) | (1 << (PostgreSQLParser.KW_VACUUM - 348)) | (1 << (PostgreSQLParser.KW_VALID - 348)) | (1 << (PostgreSQLParser.KW_VALIDATE - 348)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 348)) | (1 << (PostgreSQLParser.KW_VARYING - 348)) | (1 << (PostgreSQLParser.KW_VERSION - 348)) | (1 << (PostgreSQLParser.KW_VIEW - 348)) | (1 << (PostgreSQLParser.KW_VOLATILE - 348)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 348)) | (1 << (PostgreSQLParser.KW_WITHOUT - 348)))) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.KW_WORK - 380)) | (1 << (PostgreSQLParser.KW_WRAPPER - 380)) | (1 << (PostgreSQLParser.KW_WRITE - 380)) | (1 << (PostgreSQLParser.KW_XML - 380)) | (1 << (PostgreSQLParser.KW_YEAR - 380)) | (1 << (PostgreSQLParser.KW_YES - 380)) | (1 << (PostgreSQLParser.KW_ZONE - 380)) | (1 << (PostgreSQLParser.KW_BETWEEN - 380)) | (1 << (PostgreSQLParser.KW_BIGINT - 380)) | (1 << (PostgreSQLParser.KW_BIT - 380)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 380)) | (1 << (PostgreSQLParser.KW_CHAR - 380)) | (1 << (PostgreSQLParser.KW_CHARACTER - 380)) | (1 << (PostgreSQLParser.KW_COALESCE - 380)) | (1 << (PostgreSQLParser.KW_DEC - 380)) | (1 << (PostgreSQLParser.KW_DECIMAL - 380)) | (1 << (PostgreSQLParser.KW_EXISTS - 380)) | (1 << (PostgreSQLParser.KW_EXTRACT - 380)) | (1 << (PostgreSQLParser.KW_FLOAT - 380)) | (1 << (PostgreSQLParser.KW_GREATEST - 380)) | (1 << (PostgreSQLParser.KW_INOUT - 380)) | (1 << (PostgreSQLParser.KW_INT - 380)) | (1 << (PostgreSQLParser.KW_INTEGER - 380)) | (1 << (PostgreSQLParser.KW_INTERVAL - 380)) | (1 << (PostgreSQLParser.KW_LEAST - 380)) | (1 << (PostgreSQLParser.KW_NATIONAL - 380)) | (1 << (PostgreSQLParser.KW_NCHAR - 380)) | (1 << (PostgreSQLParser.KW_NONE - 380)) | (1 << (PostgreSQLParser.KW_NULLIF - 380)) | (1 << (PostgreSQLParser.KW_NUMERIC - 380)) | (1 << (PostgreSQLParser.KW_OVERLAY - 380)) | (1 << (PostgreSQLParser.KW_POSITION - 380)))) !== 0) || ((((_la - 412)) & ~0x1F) === 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.KW_PRECISION - 412)) | (1 << (PostgreSQLParser.KW_REAL - 412)) | (1 << (PostgreSQLParser.KW_ROW - 412)) | (1 << (PostgreSQLParser.KW_SETOF - 412)) | (1 << (PostgreSQLParser.KW_SMALLINT - 412)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 412)) | (1 << (PostgreSQLParser.KW_TIME - 412)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 412)) | (1 << (PostgreSQLParser.KW_TREAT - 412)) | (1 << (PostgreSQLParser.KW_TRIM - 412)) | (1 << (PostgreSQLParser.KW_VALUES - 412)) | (1 << (PostgreSQLParser.KW_VARCHAR - 412)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 412)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 412)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 412)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 412)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 412)) | (1 << (PostgreSQLParser.KW_XMLPI - 412)) | (1 << (PostgreSQLParser.KW_XMLROOT - 412)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.KW_CALL - 412)) | (1 << (PostgreSQLParser.KW_CURRENT - 412)) | (1 << (PostgreSQLParser.KW_ATTACH - 412)) | (1 << (PostgreSQLParser.KW_DETACH - 412)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 412)) | (1 << (PostgreSQLParser.KW_GENERATED - 412)) | (1 << (PostgreSQLParser.KW_LOGGED - 412)) | (1 << (PostgreSQLParser.KW_STORED - 412)) | (1 << (PostgreSQLParser.KW_INCLUDE - 412)) | (1 << (PostgreSQLParser.KW_ROUTINE - 412)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 412)))) !== 0) || ((((_la - 444)) & ~0x1F) === 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.KW_IMPORT - 444)) | (1 << (PostgreSQLParser.KW_POLICY - 444)) | (1 << (PostgreSQLParser.KW_METHOD - 444)) | (1 << (PostgreSQLParser.KW_REFERENCING - 444)) | (1 << (PostgreSQLParser.KW_NEW - 444)) | (1 << (PostgreSQLParser.KW_OLD - 444)) | (1 << (PostgreSQLParser.KW_VALUE - 444)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 444)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 444)) | (1 << (PostgreSQLParser.KW_OUT - 444)) | (1 << (PostgreSQLParser.KW_ROUTINES - 444)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 444)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 444)) | (1 << (PostgreSQLParser.KW_INPUT - 444)) | (1 << (PostgreSQLParser.KW_SUPPORT - 444)) | (1 << (PostgreSQLParser.KW_PARALLEL - 444)) | (1 << (PostgreSQLParser.KW_SQL - 444)) | (1 << (PostgreSQLParser.KW_DEPENDS - 444)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 444)) | (1 << (PostgreSQLParser.KW_CONFLICT - 444)) | (1 << (PostgreSQLParser.KW_SKIP - 444)) | (1 << (PostgreSQLParser.KW_LOCKED - 444)) | (1 << (PostgreSQLParser.KW_TIES - 444)) | (1 << (PostgreSQLParser.KW_ROLLUP - 444)) | (1 << (PostgreSQLParser.KW_CUBE - 444)) | (1 << (PostgreSQLParser.KW_GROUPING - 444)) | (1 << (PostgreSQLParser.KW_SETS - 444)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 444)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 444)) | (1 << (PostgreSQLParser.KW_COLUMNS - 444)))) !== 0) || ((((_la - 476)) & ~0x1F) === 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.KW_XMLNAMESPACES - 476)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 476)) | (1 << (PostgreSQLParser.KW_WITHIN - 476)) | (1 << (PostgreSQLParser.KW_FILTER - 476)) | (1 << (PostgreSQLParser.KW_GROUPS - 476)) | (1 << (PostgreSQLParser.KW_OTHERS - 476)) | (1 << (PostgreSQLParser.KW_NFC - 476)) | (1 << (PostgreSQLParser.KW_NFD - 476)) | (1 << (PostgreSQLParser.KW_NFKC - 476)) | (1 << (PostgreSQLParser.KW_NFKD - 476)) | (1 << (PostgreSQLParser.KW_UESCAPE - 476)) | (1 << (PostgreSQLParser.KW_VIEWS - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 476)) | (1 << (PostgreSQLParser.KW_DUMP - 476)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.KW_ERROR - 476)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 476)) | (1 << (PostgreSQLParser.KW_ALIAS - 476)) | (1 << (PostgreSQLParser.KW_CONSTANT - 476)) | (1 << (PostgreSQLParser.KW_PERFORM - 476)) | (1 << (PostgreSQLParser.KW_GET - 476)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.KW_STACKED - 476)) | (1 << (PostgreSQLParser.KW_ELSIF - 476)) | (1 << (PostgreSQLParser.KW_REVERSE - 476)) | (1 << (PostgreSQLParser.KW_SLICE - 476)) | (1 << (PostgreSQLParser.KW_EXIT - 476)))) !== 0) || ((((_la - 508)) & ~0x1F) === 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.KW_RETURN - 508)) | (1 << (PostgreSQLParser.KW_QUERY - 508)) | (1 << (PostgreSQLParser.KW_RAISE - 508)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 508)) | (1 << (PostgreSQLParser.KW_DEBUG - 508)) | (1 << (PostgreSQLParser.KW_LOG - 508)) | (1 << (PostgreSQLParser.KW_INFO - 508)) | (1 << (PostgreSQLParser.KW_NOTICE - 508)) | (1 << (PostgreSQLParser.KW_WARNING - 508)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 508)) | (1 << (PostgreSQLParser.KW_ASSERT - 508)) | (1 << (PostgreSQLParser.KW_OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 1869; + this.state = 1899; this.optschemaname(); } } - this.state = 1872; - this.match(PostgreSQLParser.AUTHORIZATION); - this.state = 1873; + this.state = 1902; + this.match(PostgreSQLParser.KW_AUTHORIZATION); + this.state = 1903; this.rolespec(); } break; case 2: { - this.state = 1874; + this.state = 1904; this.colid(); } break; } - this.state = 1877; + this.state = 1907; this.optschemaeltlist(); } } @@ -3892,7 +4454,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1879; + this.state = 1909; this.colid(); } } @@ -3918,19 +4480,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 1884; + this.state = 1914; this._errHandler.sync(this); _alt = this.interpreter.adaptivePredict(this._input, 19, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 1881; + this.state = 1911; this.schema_stmt(); } } } - this.state = 1886; + this.state = 1916; this._errHandler.sync(this); _alt = this.interpreter.adaptivePredict(this._input, 19, this._ctx); } @@ -3955,13 +4517,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Schema_stmtContext = new Schema_stmtContext(this._ctx, this.state); this.enterRule(_localctx, 46, PostgreSQLParser.RULE_schema_stmt); try { - this.state = 1893; + this.state = 1923; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 20, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 1887; + this.state = 1917; this.createstmt(); } break; @@ -3969,7 +4531,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 1888; + this.state = 1918; this.indexstmt(); } break; @@ -3977,7 +4539,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 1889; + this.state = 1919; this.createseqstmt(); } break; @@ -3985,7 +4547,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 1890; + this.state = 1920; this.createtrigstmt(); } break; @@ -3993,7 +4555,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 1891; + this.state = 1921; this.grantstmt(); } break; @@ -4001,7 +4563,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 1892; + this.state = 1922; this.viewstmt(); } break; @@ -4029,16 +4591,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1895; - this.match(PostgreSQLParser.SET); - this.state = 1897; + this.state = 1925; + this.match(PostgreSQLParser.KW_SET); + this.state = 1927; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 21, this._ctx) ) { case 1: { - this.state = 1896; + this.state = 1926; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.LOCAL || _la === PostgreSQLParser.SESSION)) { + if (!(_la === PostgreSQLParser.KW_LOCAL || _la === PostgreSQLParser.KW_SESSION)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -4051,7 +4613,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } break; } - this.state = 1899; + this.state = 1929; this.set_rest(); } } @@ -4074,15 +4636,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Set_restContext = new Set_restContext(this._ctx, this.state); this.enterRule(_localctx, 50, PostgreSQLParser.RULE_set_rest); try { - this.state = 1909; + this.state = 1939; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 22, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 1901; - this.match(PostgreSQLParser.TRANSACTION); - this.state = 1902; + this.state = 1931; + this.match(PostgreSQLParser.KW_TRANSACTION); + this.state = 1932; this.transaction_mode_list(); } break; @@ -4090,15 +4652,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { 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.state = 1933; + this.match(PostgreSQLParser.KW_SESSION); + this.state = 1934; + this.match(PostgreSQLParser.KW_CHARACTERISTICS); + this.state = 1935; + this.match(PostgreSQLParser.KW_AS); + this.state = 1936; + this.match(PostgreSQLParser.KW_TRANSACTION); + this.state = 1937; this.transaction_mode_list(); } break; @@ -4106,7 +4668,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 1908; + this.state = 1938; this.set_rest_more(); } break; @@ -4134,11 +4696,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1911; + this.state = 1941; this.var_name(); - this.state = 1912; + this.state = 1942; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.EQUAL || _la === PostgreSQLParser.TO)) { + if (!(_la === PostgreSQLParser.EQUAL || _la === PostgreSQLParser.KW_TO)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -4148,7 +4710,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 1913; + this.state = 1943; this.var_list(); } } @@ -4172,13 +4734,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 54, PostgreSQLParser.RULE_set_rest_more); let _la: number; try { - this.state = 1942; + this.state = 1972; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 24, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 1915; + this.state = 1945; this.generic_set(); } break; @@ -4186,23 +4748,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 1916; + this.state = 1946; this.var_name(); - this.state = 1917; - this.match(PostgreSQLParser.FROM); - this.state = 1918; - this.match(PostgreSQLParser.CURRENT_P); + this.state = 1947; + this.match(PostgreSQLParser.KW_FROM); + this.state = 1948; + this.match(PostgreSQLParser.KW_CURRENT); } 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.state = 1950; + this.match(PostgreSQLParser.KW_TIME); + this.state = 1951; + this.match(PostgreSQLParser.KW_ZONE); + this.state = 1952; this.zone_value(); } break; @@ -4210,9 +4772,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 1923; - this.match(PostgreSQLParser.CATALOG); - this.state = 1924; + this.state = 1953; + this.match(PostgreSQLParser.KW_CATALOG); + this.state = 1954; this.sconst(); } break; @@ -4220,9 +4782,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 1925; - this.match(PostgreSQLParser.SCHEMA); - this.state = 1926; + this.state = 1955; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 1956; this.sconst(); } break; @@ -4230,14 +4792,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 1927; - this.match(PostgreSQLParser.NAMES); - this.state = 1929; + this.state = 1957; + this.match(PostgreSQLParser.KW_NAMES); + this.state = 1959; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.DEFAULT || ((((_la - 521)) & ~0x1F) === 0 && ((1 << (_la - 521)) & ((1 << (PostgreSQLParser.StringConstant - 521)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 521)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 521)) | (1 << (PostgreSQLParser.EscapeStringConstant - 521)))) !== 0)) { + if (_la === PostgreSQLParser.KW_DEFAULT || ((((_la - 534)) & ~0x1F) === 0 && ((1 << (_la - 534)) & ((1 << (PostgreSQLParser.StringConstant - 534)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 534)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 534)) | (1 << (PostgreSQLParser.EscapeStringConstant - 534)))) !== 0)) { { - this.state = 1928; + this.state = 1958; this.opt_encoding(); } } @@ -4248,9 +4810,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 1931; - this.match(PostgreSQLParser.ROLE); - this.state = 1932; + this.state = 1961; + this.match(PostgreSQLParser.KW_ROLE); + this.state = 1962; this.nonreservedword_or_sconst(); } break; @@ -4258,11 +4820,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 1933; - this.match(PostgreSQLParser.SESSION); - this.state = 1934; - this.match(PostgreSQLParser.AUTHORIZATION); - this.state = 1935; + this.state = 1963; + this.match(PostgreSQLParser.KW_SESSION); + this.state = 1964; + this.match(PostgreSQLParser.KW_AUTHORIZATION); + this.state = 1965; this.nonreservedword_or_sconst(); } break; @@ -4270,11 +4832,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 1936; - this.match(PostgreSQLParser.XML_P); - this.state = 1937; - this.match(PostgreSQLParser.OPTION); - this.state = 1938; + this.state = 1966; + this.match(PostgreSQLParser.KW_XML); + this.state = 1967; + this.match(PostgreSQLParser.KW_OPTION); + this.state = 1968; this.document_or_content(); } break; @@ -4282,11 +4844,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 1939; - this.match(PostgreSQLParser.TRANSACTION); - this.state = 1940; - this.match(PostgreSQLParser.SNAPSHOT); - this.state = 1941; + this.state = 1969; + this.match(PostgreSQLParser.KW_TRANSACTION); + this.state = 1970; + this.match(PostgreSQLParser.KW_SNAPSHOT); + this.state = 1971; this.sconst(); } break; @@ -4314,21 +4876,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1944; + this.state = 1974; this.colid(); - this.state = 1949; + this.state = 1979; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.DOT) { { { - this.state = 1945; + this.state = 1975; this.match(PostgreSQLParser.DOT); - this.state = 1946; + this.state = 1976; this.colid(); } } - this.state = 1951; + this.state = 1981; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -4356,21 +4918,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 1952; + this.state = 1982; this.var_value(); - this.state = 1957; + this.state = 1987; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 1953; + this.state = 1983; this.match(PostgreSQLParser.COMMA); - this.state = 1954; + this.state = 1984; this.var_value(); } } - this.state = 1959; + this.state = 1989; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -4395,423 +4957,423 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Var_valueContext = new Var_valueContext(this._ctx, this.state); this.enterRule(_localctx, 60, PostgreSQLParser.RULE_var_value); try { - this.state = 1962; + this.state = 1992; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_ON: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -4823,7 +5385,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 1960; + this.state = 1990; this.opt_boolean_or_string(); } break; @@ -4833,7 +5395,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.Numeric: this.enterOuterAlt(_localctx, 2); { - this.state = 1961; + this.state = 1991; this.numericonly(); } break; @@ -4861,17 +5423,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 62, PostgreSQLParser.RULE_iso_level); let _la: number; try { - this.state = 1969; + this.state = 1999; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.READ: + case PostgreSQLParser.KW_READ: this.enterOuterAlt(_localctx, 1); { - this.state = 1964; - this.match(PostgreSQLParser.READ); - this.state = 1965; + this.state = 1994; + this.match(PostgreSQLParser.KW_READ); + this.state = 1995; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.COMMITTED || _la === PostgreSQLParser.UNCOMMITTED)) { + if (!(_la === PostgreSQLParser.KW_COMMITTED || _la === PostgreSQLParser.KW_UNCOMMITTED)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -4883,20 +5445,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.REPEATABLE: + case PostgreSQLParser.KW_REPEATABLE: this.enterOuterAlt(_localctx, 2); { - this.state = 1966; - this.match(PostgreSQLParser.REPEATABLE); - this.state = 1967; - this.match(PostgreSQLParser.READ); + this.state = 1996; + this.match(PostgreSQLParser.KW_REPEATABLE); + this.state = 1997; + this.match(PostgreSQLParser.KW_READ); } break; - case PostgreSQLParser.SERIALIZABLE: + case PostgreSQLParser.KW_SERIALIZABLE: this.enterOuterAlt(_localctx, 3); { - this.state = 1968; - this.match(PostgreSQLParser.SERIALIZABLE); + this.state = 1998; + this.match(PostgreSQLParser.KW_SERIALIZABLE); } break; default: @@ -4922,441 +5484,441 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Opt_boolean_or_stringContext = new Opt_boolean_or_stringContext(this._ctx, this.state); this.enterRule(_localctx, 64, PostgreSQLParser.RULE_opt_boolean_or_string); try { - this.state = 1975; + this.state = 2005; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.KW_TRUE: this.enterOuterAlt(_localctx, 1); { - this.state = 1971; - this.match(PostgreSQLParser.TRUE_P); + this.state = 2001; + this.match(PostgreSQLParser.KW_TRUE); } break; - case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.KW_FALSE: this.enterOuterAlt(_localctx, 2); { - this.state = 1972; - this.match(PostgreSQLParser.FALSE_P); + this.state = 2002; + this.match(PostgreSQLParser.KW_FALSE); } break; - case PostgreSQLParser.ON: + case PostgreSQLParser.KW_ON: this.enterOuterAlt(_localctx, 3); { - this.state = 1973; - this.match(PostgreSQLParser.ON); + this.state = 2003; + this.match(PostgreSQLParser.KW_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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -5368,7 +5930,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 4); { - this.state = 1974; + this.state = 2004; this.nonreservedword_or_sconst(); } break; @@ -5396,13 +5958,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 66, PostgreSQLParser.RULE_zone_value); let _la: number; try { - this.state = 1993; + this.state = 2023; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 31, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 1977; + this.state = 2007; this.sconst(); } break; @@ -5410,7 +5972,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 1978; + this.state = 2008; this.identifier(); } break; @@ -5418,16 +5980,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 1979; + this.state = 2009; this.constinterval(); - this.state = 1980; + this.state = 2010; this.sconst(); - this.state = 1982; + this.state = 2012; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.DAY_P || _la === PostgreSQLParser.HOUR_P || _la === PostgreSQLParser.MINUTE_P || _la === PostgreSQLParser.MONTH_P || _la === PostgreSQLParser.SECOND_P || _la === PostgreSQLParser.YEAR_P) { + if (_la === PostgreSQLParser.KW_DAY || _la === PostgreSQLParser.KW_HOUR || _la === PostgreSQLParser.KW_MINUTE || _la === PostgreSQLParser.KW_MONTH || _la === PostgreSQLParser.KW_SECOND || _la === PostgreSQLParser.KW_YEAR) { { - this.state = 1981; + this.state = 2011; this.opt_interval(); } } @@ -5438,15 +6000,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 1984; + this.state = 2014; this.constinterval(); - this.state = 1985; + this.state = 2015; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 1986; + this.state = 2016; this.iconst(); - this.state = 1987; + this.state = 2017; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 1988; + this.state = 2018; this.sconst(); } break; @@ -5454,7 +6016,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 1990; + this.state = 2020; this.numericonly(); } break; @@ -5462,16 +6024,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 1991; - this.match(PostgreSQLParser.DEFAULT); + this.state = 2021; + this.match(PostgreSQLParser.KW_DEFAULT); } break; case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 1992; - this.match(PostgreSQLParser.LOCAL); + this.state = 2022; + this.match(PostgreSQLParser.KW_LOCAL); } break; } @@ -5495,7 +6057,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Opt_encodingContext = new Opt_encodingContext(this._ctx, this.state); this.enterRule(_localctx, 68, PostgreSQLParser.RULE_opt_encoding); try { - this.state = 1997; + this.state = 2027; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: @@ -5504,15 +6066,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 1995; + this.state = 2025; this.sconst(); } break; - case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.KW_DEFAULT: this.enterOuterAlt(_localctx, 2); { - this.state = 1996; - this.match(PostgreSQLParser.DEFAULT); + this.state = 2026; + this.match(PostgreSQLParser.KW_DEFAULT); } break; default: @@ -5538,420 +6100,420 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Nonreservedword_or_sconstContext = new Nonreservedword_or_sconstContext(this._ctx, this.state); this.enterRule(_localctx, 70, PostgreSQLParser.RULE_nonreservedword_or_sconst); try { - this.state = 2001; + this.state = 2031; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -5959,7 +6521,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 1999; + this.state = 2029; this.nonreservedword(); } break; @@ -5969,7 +6531,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 2); { - this.state = 2000; + this.state = 2030; this.sconst(); } break; @@ -5998,9 +6560,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2003; - this.match(PostgreSQLParser.RESET); - this.state = 2004; + this.state = 2033; + this.match(PostgreSQLParser.KW_RESET); + this.state = 2034; this.reset_rest(); } } @@ -6023,13 +6585,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Reset_restContext = new Reset_restContext(this._ctx, this.state); this.enterRule(_localctx, 74, PostgreSQLParser.RULE_reset_rest); try { - this.state = 2014; + this.state = 2044; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 34, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2006; + this.state = 2036; this.generic_reset(); } break; @@ -6037,32 +6599,32 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2007; - this.match(PostgreSQLParser.TIME); - this.state = 2008; - this.match(PostgreSQLParser.ZONE); + this.state = 2037; + this.match(PostgreSQLParser.KW_TIME); + this.state = 2038; + this.match(PostgreSQLParser.KW_ZONE); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 2009; - this.match(PostgreSQLParser.TRANSACTION); - this.state = 2010; - this.match(PostgreSQLParser.ISOLATION); - this.state = 2011; - this.match(PostgreSQLParser.LEVEL); + this.state = 2039; + this.match(PostgreSQLParser.KW_TRANSACTION); + this.state = 2040; + this.match(PostgreSQLParser.KW_ISOLATION); + this.state = 2041; + this.match(PostgreSQLParser.KW_LEVEL); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 2012; - this.match(PostgreSQLParser.SESSION); - this.state = 2013; - this.match(PostgreSQLParser.AUTHORIZATION); + this.state = 2042; + this.match(PostgreSQLParser.KW_SESSION); + this.state = 2043; + this.match(PostgreSQLParser.KW_AUTHORIZATION); } break; } @@ -6086,399 +6648,399 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Generic_resetContext = new Generic_resetContext(this._ctx, this.state); this.enterRule(_localctx, 76, PostgreSQLParser.RULE_generic_reset); try { - this.state = 2018; + this.state = 2048; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -6486,15 +7048,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 2016; + this.state = 2046; this.var_name(); } break; - case PostgreSQLParser.ALL: + case PostgreSQLParser.KW_ALL: this.enterOuterAlt(_localctx, 2); { - this.state = 2017; - this.match(PostgreSQLParser.ALL); + this.state = 2047; + this.match(PostgreSQLParser.KW_ALL); } break; default: @@ -6520,22 +7082,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: SetresetclauseContext = new SetresetclauseContext(this._ctx, this.state); this.enterRule(_localctx, 78, PostgreSQLParser.RULE_setresetclause); try { - this.state = 2023; + this.state = 2053; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.SET: + case PostgreSQLParser.KW_SET: this.enterOuterAlt(_localctx, 1); { - this.state = 2020; - this.match(PostgreSQLParser.SET); - this.state = 2021; + this.state = 2050; + this.match(PostgreSQLParser.KW_SET); + this.state = 2051; this.set_rest(); } break; - case PostgreSQLParser.RESET: + case PostgreSQLParser.KW_RESET: this.enterOuterAlt(_localctx, 2); { - this.state = 2022; + this.state = 2052; this.variableresetstmt(); } break; @@ -6562,22 +7124,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: FunctionsetresetclauseContext = new FunctionsetresetclauseContext(this._ctx, this.state); this.enterRule(_localctx, 80, PostgreSQLParser.RULE_functionsetresetclause); try { - this.state = 2028; + this.state = 2058; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.SET: + case PostgreSQLParser.KW_SET: this.enterOuterAlt(_localctx, 1); { - this.state = 2025; - this.match(PostgreSQLParser.SET); - this.state = 2026; + this.state = 2055; + this.match(PostgreSQLParser.KW_SET); + this.state = 2056; this.set_rest_more(); } break; - case PostgreSQLParser.RESET: + case PostgreSQLParser.KW_RESET: this.enterOuterAlt(_localctx, 2); { - this.state = 2027; + this.state = 2057; this.variableresetstmt(); } break; @@ -6606,51 +7168,51 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2030; - this.match(PostgreSQLParser.SHOW); - this.state = 2040; + this.state = 2060; + this.match(PostgreSQLParser.KW_SHOW); + this.state = 2070; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 38, this._ctx) ) { case 1: { - this.state = 2031; + this.state = 2061; this.var_name(); } break; case 2: { - this.state = 2032; - this.match(PostgreSQLParser.TIME); - this.state = 2033; - this.match(PostgreSQLParser.ZONE); + this.state = 2062; + this.match(PostgreSQLParser.KW_TIME); + this.state = 2063; + this.match(PostgreSQLParser.KW_ZONE); } break; case 3: { - this.state = 2034; - this.match(PostgreSQLParser.TRANSACTION); - this.state = 2035; - this.match(PostgreSQLParser.ISOLATION); - this.state = 2036; - this.match(PostgreSQLParser.LEVEL); + this.state = 2064; + this.match(PostgreSQLParser.KW_TRANSACTION); + this.state = 2065; + this.match(PostgreSQLParser.KW_ISOLATION); + this.state = 2066; + this.match(PostgreSQLParser.KW_LEVEL); } break; case 4: { - this.state = 2037; - this.match(PostgreSQLParser.SESSION); - this.state = 2038; - this.match(PostgreSQLParser.AUTHORIZATION); + this.state = 2067; + this.match(PostgreSQLParser.KW_SESSION); + this.state = 2068; + this.match(PostgreSQLParser.KW_AUTHORIZATION); } break; case 5: { - this.state = 2039; - this.match(PostgreSQLParser.ALL); + this.state = 2069; + this.match(PostgreSQLParser.KW_ALL); } break; } @@ -6677,13 +7239,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2042; - this.match(PostgreSQLParser.SET); - this.state = 2043; - this.match(PostgreSQLParser.CONSTRAINTS); - this.state = 2044; + this.state = 2072; + this.match(PostgreSQLParser.KW_SET); + this.state = 2073; + this.match(PostgreSQLParser.KW_CONSTRAINTS); + this.state = 2074; this.constraints_set_list(); - this.state = 2045; + this.state = 2075; this.constraints_set_mode(); } } @@ -6706,406 +7268,406 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Constraints_set_listContext = new Constraints_set_listContext(this._ctx, this.state); this.enterRule(_localctx, 86, PostgreSQLParser.RULE_constraints_set_list); try { - this.state = 2049; + this.state = 2079; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.ALL: + case PostgreSQLParser.KW_ALL: this.enterOuterAlt(_localctx, 1); { - this.state = 2047; - this.match(PostgreSQLParser.ALL); + this.state = 2077; + this.match(PostgreSQLParser.KW_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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -7113,7 +7675,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 2); { - this.state = 2048; + this.state = 2078; this.qualified_name_list(); } break; @@ -7143,9 +7705,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2051; + this.state = 2081; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.DEFERRED || _la === PostgreSQLParser.IMMEDIATE)) { + if (!(_la === PostgreSQLParser.KW_DEFERRED || _la === PostgreSQLParser.KW_IMMEDIATE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -7178,8 +7740,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2053; - this.match(PostgreSQLParser.CHECKPOINT); + this.state = 2083; + this.match(PostgreSQLParser.KW_CHECKPOINT); } } catch (re) { @@ -7204,11 +7766,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2055; - this.match(PostgreSQLParser.DISCARD); - this.state = 2056; + this.state = 2085; + this.match(PostgreSQLParser.KW_DISCARD); + this.state = 2086; _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))) { + if (!(_la === PostgreSQLParser.KW_ALL || _la === PostgreSQLParser.KW_PLANS || ((((_la - 329)) & ~0x1F) === 0 && ((1 << (_la - 329)) & ((1 << (PostgreSQLParser.KW_SEQUENCES - 329)) | (1 << (PostgreSQLParser.KW_TEMP - 329)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 329)))) !== 0))) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -7240,59 +7802,59 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 94, PostgreSQLParser.RULE_altertablestmt); let _la: number; try { - this.state = 2170; + this.state = 2200; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 54, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2058; - this.match(PostgreSQLParser.ALTER); - this.state = 2059; - this.match(PostgreSQLParser.TABLE); - this.state = 2062; + this.state = 2088; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2089; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 2092; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 40, this._ctx) ) { case 1: { - this.state = 2060; - this.match(PostgreSQLParser.IF_P); - this.state = 2061; - this.match(PostgreSQLParser.EXISTS); + this.state = 2090; + this.match(PostgreSQLParser.KW_IF); + this.state = 2091; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 2064; + this.state = 2094; this.relation_expr(); - this.state = 2067; + this.state = 2097; 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: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_VALIDATE: { - this.state = 2065; + this.state = 2095; this.alter_table_cmds(); } break; - case PostgreSQLParser.ATTACH: - case PostgreSQLParser.DETACH: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: { - this.state = 2066; + this.state = 2096; this.partition_cmd(); } break; @@ -7305,44 +7867,44 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2069; - this.match(PostgreSQLParser.ALTER); - this.state = 2070; - this.match(PostgreSQLParser.TABLE); - this.state = 2071; - this.match(PostgreSQLParser.ALL); - this.state = 2072; - this.match(PostgreSQLParser.IN_P); - this.state = 2073; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 2074; + this.state = 2099; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2100; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 2101; + this.match(PostgreSQLParser.KW_ALL); + this.state = 2102; + this.match(PostgreSQLParser.KW_IN); + this.state = 2103; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 2104; this.name(); - this.state = 2078; + this.state = 2108; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OWNED) { + if (_la === PostgreSQLParser.KW_OWNED) { { - this.state = 2075; - this.match(PostgreSQLParser.OWNED); - this.state = 2076; - this.match(PostgreSQLParser.BY); - this.state = 2077; + this.state = 2105; + this.match(PostgreSQLParser.KW_OWNED); + this.state = 2106; + this.match(PostgreSQLParser.KW_BY); + this.state = 2107; this.role_list(); } } - this.state = 2080; - this.match(PostgreSQLParser.SET); - this.state = 2081; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 2082; + this.state = 2110; + this.match(PostgreSQLParser.KW_SET); + this.state = 2111; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 2112; this.name(); - this.state = 2084; + this.state = 2114; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOWAIT) { + if (_la === PostgreSQLParser.KW_NOWAIT) { { - this.state = 2083; + this.state = 2113; this.opt_nowait(); } } @@ -7353,52 +7915,52 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 2086; - this.match(PostgreSQLParser.ALTER); - this.state = 2087; - this.match(PostgreSQLParser.INDEX); - this.state = 2090; + this.state = 2116; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2117; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 2120; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 44, this._ctx) ) { case 1: { - this.state = 2088; - this.match(PostgreSQLParser.IF_P); - this.state = 2089; - this.match(PostgreSQLParser.EXISTS); + this.state = 2118; + this.match(PostgreSQLParser.KW_IF); + this.state = 2119; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 2092; + this.state = 2122; this.qualified_name(); - this.state = 2095; + this.state = 2125; 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: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_VALIDATE: { - this.state = 2093; + this.state = 2123; this.alter_table_cmds(); } break; - case PostgreSQLParser.ATTACH: + case PostgreSQLParser.KW_ATTACH: { - this.state = 2094; + this.state = 2124; this.index_partition_cmd(); } break; @@ -7411,44 +7973,44 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 2097; - this.match(PostgreSQLParser.ALTER); - this.state = 2098; - this.match(PostgreSQLParser.INDEX); - this.state = 2099; - this.match(PostgreSQLParser.ALL); - this.state = 2100; - this.match(PostgreSQLParser.IN_P); - this.state = 2101; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 2102; + this.state = 2127; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2128; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 2129; + this.match(PostgreSQLParser.KW_ALL); + this.state = 2130; + this.match(PostgreSQLParser.KW_IN); + this.state = 2131; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 2132; this.name(); - this.state = 2106; + this.state = 2136; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OWNED) { + if (_la === PostgreSQLParser.KW_OWNED) { { - this.state = 2103; - this.match(PostgreSQLParser.OWNED); - this.state = 2104; - this.match(PostgreSQLParser.BY); - this.state = 2105; + this.state = 2133; + this.match(PostgreSQLParser.KW_OWNED); + this.state = 2134; + this.match(PostgreSQLParser.KW_BY); + this.state = 2135; this.role_list(); } } - this.state = 2108; - this.match(PostgreSQLParser.SET); - this.state = 2109; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 2110; + this.state = 2138; + this.match(PostgreSQLParser.KW_SET); + this.state = 2139; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 2140; this.name(); - this.state = 2112; + this.state = 2142; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOWAIT) { + if (_la === PostgreSQLParser.KW_NOWAIT) { { - this.state = 2111; + this.state = 2141; this.opt_nowait(); } } @@ -7459,25 +8021,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 2114; - this.match(PostgreSQLParser.ALTER); - this.state = 2115; - this.match(PostgreSQLParser.SEQUENCE); - this.state = 2118; + this.state = 2144; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2145; + this.match(PostgreSQLParser.KW_SEQUENCE); + this.state = 2148; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 48, this._ctx) ) { case 1: { - this.state = 2116; - this.match(PostgreSQLParser.IF_P); - this.state = 2117; - this.match(PostgreSQLParser.EXISTS); + this.state = 2146; + this.match(PostgreSQLParser.KW_IF); + this.state = 2147; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 2120; + this.state = 2150; this.qualified_name(); - this.state = 2121; + this.state = 2151; this.alter_table_cmds(); } break; @@ -7485,25 +8047,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 2123; - this.match(PostgreSQLParser.ALTER); - this.state = 2124; - this.match(PostgreSQLParser.VIEW); - this.state = 2127; + this.state = 2153; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2154; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 2157; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 49, this._ctx) ) { case 1: { - this.state = 2125; - this.match(PostgreSQLParser.IF_P); - this.state = 2126; - this.match(PostgreSQLParser.EXISTS); + this.state = 2155; + this.match(PostgreSQLParser.KW_IF); + this.state = 2156; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 2129; + this.state = 2159; this.qualified_name(); - this.state = 2130; + this.state = 2160; this.alter_table_cmds(); } break; @@ -7511,27 +8073,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 2132; - this.match(PostgreSQLParser.ALTER); - this.state = 2133; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 2134; - this.match(PostgreSQLParser.VIEW); - this.state = 2137; + this.state = 2162; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2163; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 2164; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 2167; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 50, this._ctx) ) { case 1: { - this.state = 2135; - this.match(PostgreSQLParser.IF_P); - this.state = 2136; - this.match(PostgreSQLParser.EXISTS); + this.state = 2165; + this.match(PostgreSQLParser.KW_IF); + this.state = 2166; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 2139; + this.state = 2169; this.qualified_name(); - this.state = 2140; + this.state = 2170; this.alter_table_cmds(); } break; @@ -7539,46 +8101,46 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 2142; - this.match(PostgreSQLParser.ALTER); - this.state = 2143; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 2144; - this.match(PostgreSQLParser.VIEW); - this.state = 2145; - this.match(PostgreSQLParser.ALL); - this.state = 2146; - this.match(PostgreSQLParser.IN_P); - this.state = 2147; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 2148; + this.state = 2172; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2173; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 2174; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 2175; + this.match(PostgreSQLParser.KW_ALL); + this.state = 2176; + this.match(PostgreSQLParser.KW_IN); + this.state = 2177; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 2178; this.name(); - this.state = 2152; + this.state = 2182; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OWNED) { + if (_la === PostgreSQLParser.KW_OWNED) { { - this.state = 2149; - this.match(PostgreSQLParser.OWNED); - this.state = 2150; - this.match(PostgreSQLParser.BY); - this.state = 2151; + this.state = 2179; + this.match(PostgreSQLParser.KW_OWNED); + this.state = 2180; + this.match(PostgreSQLParser.KW_BY); + this.state = 2181; this.role_list(); } } - this.state = 2154; - this.match(PostgreSQLParser.SET); - this.state = 2155; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 2156; + this.state = 2184; + this.match(PostgreSQLParser.KW_SET); + this.state = 2185; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 2186; this.name(); - this.state = 2158; + this.state = 2188; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOWAIT) { + if (_la === PostgreSQLParser.KW_NOWAIT) { { - this.state = 2157; + this.state = 2187; this.opt_nowait(); } } @@ -7589,27 +8151,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 2160; - this.match(PostgreSQLParser.ALTER); - this.state = 2161; - this.match(PostgreSQLParser.FOREIGN); - this.state = 2162; - this.match(PostgreSQLParser.TABLE); - this.state = 2165; + this.state = 2190; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2191; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 2192; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 2195; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 53, this._ctx) ) { case 1: { - this.state = 2163; - this.match(PostgreSQLParser.IF_P); - this.state = 2164; - this.match(PostgreSQLParser.EXISTS); + this.state = 2193; + this.match(PostgreSQLParser.KW_IF); + this.state = 2194; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 2167; + this.state = 2197; this.relation_expr(); - this.state = 2168; + this.state = 2198; this.alter_table_cmds(); } break; @@ -7637,21 +8199,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2172; + this.state = 2202; this.alter_table_cmd(); - this.state = 2177; + this.state = 2207; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 2173; + this.state = 2203; this.match(PostgreSQLParser.COMMA); - this.state = 2174; + this.state = 2204; this.alter_table_cmd(); } } - this.state = 2179; + this.state = 2209; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -7676,30 +8238,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Partition_cmdContext = new Partition_cmdContext(this._ctx, this.state); this.enterRule(_localctx, 98, PostgreSQLParser.RULE_partition_cmd); try { - this.state = 2188; + this.state = 2218; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.ATTACH: + case PostgreSQLParser.KW_ATTACH: this.enterOuterAlt(_localctx, 1); { - this.state = 2180; - this.match(PostgreSQLParser.ATTACH); - this.state = 2181; - this.match(PostgreSQLParser.PARTITION); - this.state = 2182; + this.state = 2210; + this.match(PostgreSQLParser.KW_ATTACH); + this.state = 2211; + this.match(PostgreSQLParser.KW_PARTITION); + this.state = 2212; this.qualified_name(); - this.state = 2183; + this.state = 2213; this.partitionboundspec(); } break; - case PostgreSQLParser.DETACH: + case PostgreSQLParser.KW_DETACH: this.enterOuterAlt(_localctx, 2); { - this.state = 2185; - this.match(PostgreSQLParser.DETACH); - this.state = 2186; - this.match(PostgreSQLParser.PARTITION); - this.state = 2187; + this.state = 2215; + this.match(PostgreSQLParser.KW_DETACH); + this.state = 2216; + this.match(PostgreSQLParser.KW_PARTITION); + this.state = 2217; this.qualified_name(); } break; @@ -7728,11 +8290,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2190; - this.match(PostgreSQLParser.ATTACH); - this.state = 2191; - this.match(PostgreSQLParser.PARTITION); - this.state = 2192; + this.state = 2220; + this.match(PostgreSQLParser.KW_ATTACH); + this.state = 2221; + this.match(PostgreSQLParser.KW_PARTITION); + this.state = 2222; this.qualified_name(); } } @@ -7756,15 +8318,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 102, PostgreSQLParser.RULE_alter_table_cmd); let _la: number; try { - this.state = 2492; + this.state = 2522; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 83, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2194; - this.match(PostgreSQLParser.ADD_P); - this.state = 2195; + this.state = 2224; + this.match(PostgreSQLParser.KW_ADD); + this.state = 2225; this.columnDef(); } break; @@ -7772,15 +8334,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2196; - this.match(PostgreSQLParser.ADD_P); - this.state = 2197; - this.match(PostgreSQLParser.IF_P); - this.state = 2198; - this.match(PostgreSQLParser.NOT); - this.state = 2199; - this.match(PostgreSQLParser.EXISTS); - this.state = 2200; + this.state = 2226; + this.match(PostgreSQLParser.KW_ADD); + this.state = 2227; + this.match(PostgreSQLParser.KW_IF); + this.state = 2228; + this.match(PostgreSQLParser.KW_NOT); + this.state = 2229; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 2230; this.columnDef(); } break; @@ -7788,11 +8350,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 2201; - this.match(PostgreSQLParser.ADD_P); - this.state = 2202; - this.match(PostgreSQLParser.COLUMN); - this.state = 2203; + this.state = 2231; + this.match(PostgreSQLParser.KW_ADD); + this.state = 2232; + this.match(PostgreSQLParser.KW_COLUMN); + this.state = 2233; this.columnDef(); } break; @@ -7800,17 +8362,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 2204; - this.match(PostgreSQLParser.ADD_P); - this.state = 2205; - this.match(PostgreSQLParser.COLUMN); - this.state = 2206; - this.match(PostgreSQLParser.IF_P); - this.state = 2207; - this.match(PostgreSQLParser.NOT); - this.state = 2208; - this.match(PostgreSQLParser.EXISTS); - this.state = 2209; + this.state = 2234; + this.match(PostgreSQLParser.KW_ADD); + this.state = 2235; + this.match(PostgreSQLParser.KW_COLUMN); + this.state = 2236; + this.match(PostgreSQLParser.KW_IF); + this.state = 2237; + this.match(PostgreSQLParser.KW_NOT); + this.state = 2238; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 2239; this.columnDef(); } break; @@ -7818,21 +8380,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 2210; - this.match(PostgreSQLParser.ALTER); - this.state = 2212; + this.state = 2240; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2242; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 57, this._ctx) ) { case 1: { - this.state = 2211; + this.state = 2241; this.opt_column(); } break; } - this.state = 2214; + this.state = 2244; this.colid(); - this.state = 2215; + this.state = 2245; this.alter_column_default(); } break; @@ -7840,129 +8402,129 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 2217; - this.match(PostgreSQLParser.ALTER); - this.state = 2219; + this.state = 2247; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2249; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 58, this._ctx) ) { case 1: { - this.state = 2218; + this.state = 2248; this.opt_column(); } break; } - this.state = 2221; + this.state = 2251; this.colid(); - this.state = 2222; - this.match(PostgreSQLParser.DROP); - this.state = 2223; - this.match(PostgreSQLParser.NOT); - this.state = 2224; - this.match(PostgreSQLParser.NULL_P); + this.state = 2252; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2253; + this.match(PostgreSQLParser.KW_NOT); + this.state = 2254; + this.match(PostgreSQLParser.KW_NULL); } break; case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 2226; - this.match(PostgreSQLParser.ALTER); - this.state = 2228; + this.state = 2256; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2258; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 59, this._ctx) ) { case 1: { - this.state = 2227; + this.state = 2257; this.opt_column(); } break; } - this.state = 2230; + this.state = 2260; this.colid(); - this.state = 2231; - this.match(PostgreSQLParser.SET); - this.state = 2232; - this.match(PostgreSQLParser.NOT); - this.state = 2233; - this.match(PostgreSQLParser.NULL_P); + this.state = 2261; + this.match(PostgreSQLParser.KW_SET); + this.state = 2262; + this.match(PostgreSQLParser.KW_NOT); + this.state = 2263; + this.match(PostgreSQLParser.KW_NULL); } break; case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 2235; - this.match(PostgreSQLParser.ALTER); - this.state = 2237; + this.state = 2265; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2267; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 60, this._ctx) ) { case 1: { - this.state = 2236; + this.state = 2266; this.opt_column(); } break; } - this.state = 2239; + this.state = 2269; this.colid(); - this.state = 2240; - this.match(PostgreSQLParser.DROP); - this.state = 2241; - this.match(PostgreSQLParser.EXPRESSION); + this.state = 2270; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2271; + this.match(PostgreSQLParser.KW_EXPRESSION); } break; case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 2243; - this.match(PostgreSQLParser.ALTER); - this.state = 2245; + this.state = 2273; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2275; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 61, this._ctx) ) { case 1: { - this.state = 2244; + this.state = 2274; this.opt_column(); } break; } - this.state = 2247; + this.state = 2277; this.colid(); - this.state = 2248; - this.match(PostgreSQLParser.DROP); - this.state = 2249; - this.match(PostgreSQLParser.EXPRESSION); - this.state = 2250; - this.match(PostgreSQLParser.IF_P); - this.state = 2251; - this.match(PostgreSQLParser.EXISTS); + this.state = 2278; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2279; + this.match(PostgreSQLParser.KW_EXPRESSION); + this.state = 2280; + this.match(PostgreSQLParser.KW_IF); + this.state = 2281; + this.match(PostgreSQLParser.KW_EXISTS); } break; case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 2253; - this.match(PostgreSQLParser.ALTER); - this.state = 2255; + this.state = 2283; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2285; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 62, this._ctx) ) { case 1: { - this.state = 2254; + this.state = 2284; this.opt_column(); } break; } - this.state = 2257; + this.state = 2287; this.colid(); - this.state = 2258; - this.match(PostgreSQLParser.SET); - this.state = 2259; - this.match(PostgreSQLParser.STATISTICS); - this.state = 2260; + this.state = 2288; + this.match(PostgreSQLParser.KW_SET); + this.state = 2289; + this.match(PostgreSQLParser.KW_STATISTICS); + this.state = 2290; this.signediconst(); } break; @@ -7970,25 +8532,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 2262; - this.match(PostgreSQLParser.ALTER); - this.state = 2264; + this.state = 2292; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2294; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.COLUMN) { + if (_la === PostgreSQLParser.KW_COLUMN) { { - this.state = 2263; + this.state = 2293; this.opt_column(); } } - this.state = 2266; + this.state = 2296; this.iconst(); - this.state = 2267; - this.match(PostgreSQLParser.SET); - this.state = 2268; - this.match(PostgreSQLParser.STATISTICS); - this.state = 2269; + this.state = 2297; + this.match(PostgreSQLParser.KW_SET); + this.state = 2298; + this.match(PostgreSQLParser.KW_STATISTICS); + this.state = 2299; this.signediconst(); } break; @@ -7996,23 +8558,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 2271; - this.match(PostgreSQLParser.ALTER); - this.state = 2273; + this.state = 2301; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2303; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 64, this._ctx) ) { case 1: { - this.state = 2272; + this.state = 2302; this.opt_column(); } break; } - this.state = 2275; + this.state = 2305; this.colid(); - this.state = 2276; - this.match(PostgreSQLParser.SET); - this.state = 2277; + this.state = 2306; + this.match(PostgreSQLParser.KW_SET); + this.state = 2307; this.reloptions(); } break; @@ -8020,101 +8582,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 2279; - this.match(PostgreSQLParser.ALTER); - this.state = 2281; - this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 65, this._ctx) ) { - case 1: - { - this.state = 2280; - this.opt_column(); - } - break; - } - this.state = 2283; - this.colid(); - this.state = 2284; - this.match(PostgreSQLParser.RESET); - this.state = 2285; - this.reloptions(); - } - break; - - case 14: - this.enterOuterAlt(_localctx, 14); - { - this.state = 2287; - this.match(PostgreSQLParser.ALTER); - this.state = 2289; - this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 66, this._ctx) ) { - case 1: - { - this.state = 2288; - this.opt_column(); - } - break; - } - this.state = 2291; - this.colid(); - this.state = 2292; - this.match(PostgreSQLParser.SET); - this.state = 2293; - this.match(PostgreSQLParser.STORAGE); - this.state = 2294; - this.colid(); - } - break; - - case 15: - this.enterOuterAlt(_localctx, 15); - { - this.state = 2296; - this.match(PostgreSQLParser.ALTER); - this.state = 2298; - this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 67, this._ctx) ) { - case 1: - { - this.state = 2297; - this.opt_column(); - } - break; - } - this.state = 2300; - this.colid(); - this.state = 2301; - this.match(PostgreSQLParser.ADD_P); - this.state = 2302; - this.match(PostgreSQLParser.GENERATED); - this.state = 2303; - this.generated_when(); - this.state = 2304; - this.match(PostgreSQLParser.AS); - this.state = 2305; - this.match(PostgreSQLParser.IDENTITY_P); - this.state = 2307; - this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 68, this._ctx) ) { - case 1: - { - this.state = 2306; - this.optparenthesizedseqoptlist(); - } - break; - } - } - break; - - case 16: - this.enterOuterAlt(_localctx, 16); - { this.state = 2309; - this.match(PostgreSQLParser.ALTER); + this.match(PostgreSQLParser.KW_ALTER); this.state = 2311; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 69, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 65, this._ctx) ) { case 1: { this.state = 2310; @@ -8125,6 +8597,96 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.state = 2313; this.colid(); this.state = 2314; + this.match(PostgreSQLParser.KW_RESET); + this.state = 2315; + this.reloptions(); + } + break; + + case 14: + this.enterOuterAlt(_localctx, 14); + { + this.state = 2317; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2319; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 66, this._ctx) ) { + case 1: + { + this.state = 2318; + this.opt_column(); + } + break; + } + this.state = 2321; + this.colid(); + this.state = 2322; + this.match(PostgreSQLParser.KW_SET); + this.state = 2323; + this.match(PostgreSQLParser.KW_STORAGE); + this.state = 2324; + this.colid(); + } + break; + + case 15: + this.enterOuterAlt(_localctx, 15); + { + this.state = 2326; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2328; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 67, this._ctx) ) { + case 1: + { + this.state = 2327; + this.opt_column(); + } + break; + } + this.state = 2330; + this.colid(); + this.state = 2331; + this.match(PostgreSQLParser.KW_ADD); + this.state = 2332; + this.match(PostgreSQLParser.KW_GENERATED); + this.state = 2333; + this.generated_when(); + this.state = 2334; + this.match(PostgreSQLParser.KW_AS); + this.state = 2335; + this.match(PostgreSQLParser.KW_IDENTITY); + this.state = 2337; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 68, this._ctx) ) { + case 1: + { + this.state = 2336; + this.optparenthesizedseqoptlist(); + } + break; + } + } + break; + + case 16: + this.enterOuterAlt(_localctx, 16); + { + this.state = 2339; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2341; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 69, this._ctx) ) { + case 1: + { + this.state = 2340; + this.opt_column(); + } + break; + } + this.state = 2343; + this.colid(); + this.state = 2344; this.alter_identity_column_option_list(); } break; @@ -8132,82 +8694,82 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 2316; - this.match(PostgreSQLParser.ALTER); - this.state = 2318; + this.state = 2346; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2348; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 70, this._ctx) ) { case 1: { - this.state = 2317; + this.state = 2347; this.opt_column(); } break; } - this.state = 2320; + this.state = 2350; this.colid(); - this.state = 2321; - this.match(PostgreSQLParser.DROP); - this.state = 2322; - this.match(PostgreSQLParser.IDENTITY_P); + this.state = 2351; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2352; + this.match(PostgreSQLParser.KW_IDENTITY); } break; case 18: this.enterOuterAlt(_localctx, 18); { - this.state = 2324; - this.match(PostgreSQLParser.ALTER); - this.state = 2326; + this.state = 2354; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2356; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 71, this._ctx) ) { case 1: { - this.state = 2325; + this.state = 2355; this.opt_column(); } break; } - this.state = 2328; + this.state = 2358; this.colid(); - this.state = 2329; - this.match(PostgreSQLParser.DROP); - this.state = 2330; - this.match(PostgreSQLParser.IDENTITY_P); - this.state = 2331; - this.match(PostgreSQLParser.IF_P); - this.state = 2332; - this.match(PostgreSQLParser.EXISTS); + this.state = 2359; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2360; + this.match(PostgreSQLParser.KW_IDENTITY); + this.state = 2361; + this.match(PostgreSQLParser.KW_IF); + this.state = 2362; + this.match(PostgreSQLParser.KW_EXISTS); } break; case 19: this.enterOuterAlt(_localctx, 19); { - this.state = 2334; - this.match(PostgreSQLParser.DROP); - this.state = 2336; + this.state = 2364; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2366; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.COLUMN) { + if (_la === PostgreSQLParser.KW_COLUMN) { { - this.state = 2335; + this.state = 2365; this.opt_column(); } } - this.state = 2338; - this.match(PostgreSQLParser.IF_P); - this.state = 2339; - this.match(PostgreSQLParser.EXISTS); - this.state = 2340; + this.state = 2368; + this.match(PostgreSQLParser.KW_IF); + this.state = 2369; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 2370; this.colid(); - this.state = 2342; + this.state = 2372; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 2341; + this.state = 2371; this.opt_drop_behavior(); } } @@ -8218,26 +8780,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 20: this.enterOuterAlt(_localctx, 20); { - this.state = 2344; - this.match(PostgreSQLParser.DROP); - this.state = 2346; + this.state = 2374; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2376; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 74, this._ctx) ) { case 1: { - this.state = 2345; + this.state = 2375; this.opt_column(); } break; } - this.state = 2348; + this.state = 2378; this.colid(); - this.state = 2350; + this.state = 2380; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 2349; + this.state = 2379; this.opt_drop_behavior(); } } @@ -8248,50 +8810,50 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 21: this.enterOuterAlt(_localctx, 21); { - this.state = 2352; - this.match(PostgreSQLParser.ALTER); - this.state = 2354; + this.state = 2382; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2384; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 76, this._ctx) ) { case 1: { - this.state = 2353; + this.state = 2383; this.opt_column(); } break; } - this.state = 2356; + this.state = 2386; this.colid(); - this.state = 2358; + this.state = 2388; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.SET) { + if (_la === PostgreSQLParser.KW_SET) { { - this.state = 2357; + this.state = 2387; this.opt_set_data(); } } - this.state = 2360; - this.match(PostgreSQLParser.TYPE_P); - this.state = 2361; + this.state = 2390; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 2391; this.typename(); - this.state = 2363; + this.state = 2393; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.COLLATE) { + if (_la === PostgreSQLParser.KW_COLLATE) { { - this.state = 2362; + this.state = 2392; this.opt_collate_clause(); } } - this.state = 2366; + this.state = 2396; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 2365; + this.state = 2395; this.alter_using(); } } @@ -8302,21 +8864,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 22: this.enterOuterAlt(_localctx, 22); { - this.state = 2368; - this.match(PostgreSQLParser.ALTER); - this.state = 2370; + this.state = 2398; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2400; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 80, this._ctx) ) { case 1: { - this.state = 2369; + this.state = 2399; this.opt_column(); } break; } - this.state = 2372; + this.state = 2402; this.colid(); - this.state = 2373; + this.state = 2403; this.alter_generic_options(); } break; @@ -8324,9 +8886,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 23: this.enterOuterAlt(_localctx, 23); { - this.state = 2375; - this.match(PostgreSQLParser.ADD_P); - this.state = 2376; + this.state = 2405; + this.match(PostgreSQLParser.KW_ADD); + this.state = 2406; this.tableconstraint(); } break; @@ -8334,13 +8896,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 24: this.enterOuterAlt(_localctx, 24); { - this.state = 2377; - this.match(PostgreSQLParser.ALTER); - this.state = 2378; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 2379; + this.state = 2407; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2408; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 2409; this.name(); - this.state = 2380; + this.state = 2410; this.constraintattributespec(); } break; @@ -8348,11 +8910,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 25: this.enterOuterAlt(_localctx, 25); { - this.state = 2382; - this.match(PostgreSQLParser.VALIDATE); - this.state = 2383; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 2384; + this.state = 2412; + this.match(PostgreSQLParser.KW_VALIDATE); + this.state = 2413; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 2414; this.name(); } break; @@ -8360,22 +8922,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 26: this.enterOuterAlt(_localctx, 26); { - this.state = 2385; - this.match(PostgreSQLParser.DROP); - this.state = 2386; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 2387; - this.match(PostgreSQLParser.IF_P); - this.state = 2388; - this.match(PostgreSQLParser.EXISTS); - this.state = 2389; + this.state = 2415; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2416; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 2417; + this.match(PostgreSQLParser.KW_IF); + this.state = 2418; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 2419; this.name(); - this.state = 2391; + this.state = 2421; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 2390; + this.state = 2420; this.opt_drop_behavior(); } } @@ -8386,18 +8948,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 27: this.enterOuterAlt(_localctx, 27); { - this.state = 2393; - this.match(PostgreSQLParser.DROP); - this.state = 2394; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 2395; + this.state = 2423; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2424; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 2425; this.name(); - this.state = 2397; + this.state = 2427; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 2396; + this.state = 2426; this.opt_drop_behavior(); } } @@ -8408,23 +8970,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 28: this.enterOuterAlt(_localctx, 28); { - this.state = 2399; - this.match(PostgreSQLParser.SET); - this.state = 2400; - this.match(PostgreSQLParser.WITHOUT); - this.state = 2401; - this.match(PostgreSQLParser.OIDS); + this.state = 2429; + this.match(PostgreSQLParser.KW_SET); + this.state = 2430; + this.match(PostgreSQLParser.KW_WITHOUT); + this.state = 2431; + this.match(PostgreSQLParser.KW_OIDS); } break; case 29: this.enterOuterAlt(_localctx, 29); { - this.state = 2402; - this.match(PostgreSQLParser.CLUSTER); - this.state = 2403; - this.match(PostgreSQLParser.ON); - this.state = 2404; + this.state = 2432; + this.match(PostgreSQLParser.KW_CLUSTER); + this.state = 2433; + this.match(PostgreSQLParser.KW_ON); + this.state = 2434; this.name(); } break; @@ -8432,43 +8994,43 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 30: this.enterOuterAlt(_localctx, 30); { - this.state = 2405; - this.match(PostgreSQLParser.SET); - this.state = 2406; - this.match(PostgreSQLParser.WITHOUT); - this.state = 2407; - this.match(PostgreSQLParser.CLUSTER); + this.state = 2435; + this.match(PostgreSQLParser.KW_SET); + this.state = 2436; + this.match(PostgreSQLParser.KW_WITHOUT); + this.state = 2437; + this.match(PostgreSQLParser.KW_CLUSTER); } break; case 31: this.enterOuterAlt(_localctx, 31); { - this.state = 2408; - this.match(PostgreSQLParser.SET); - this.state = 2409; - this.match(PostgreSQLParser.LOGGED); + this.state = 2438; + this.match(PostgreSQLParser.KW_SET); + this.state = 2439; + this.match(PostgreSQLParser.KW_LOGGED); } break; case 32: this.enterOuterAlt(_localctx, 32); { - this.state = 2410; - this.match(PostgreSQLParser.SET); - this.state = 2411; - this.match(PostgreSQLParser.UNLOGGED); + this.state = 2440; + this.match(PostgreSQLParser.KW_SET); + this.state = 2441; + this.match(PostgreSQLParser.KW_UNLOGGED); } break; case 33: this.enterOuterAlt(_localctx, 33); { - this.state = 2412; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 2413; - this.match(PostgreSQLParser.TRIGGER); - this.state = 2414; + this.state = 2442; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 2443; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 2444; this.name(); } break; @@ -8476,13 +9038,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 34: this.enterOuterAlt(_localctx, 34); { - this.state = 2415; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 2416; - this.match(PostgreSQLParser.ALWAYS); - this.state = 2417; - this.match(PostgreSQLParser.TRIGGER); - this.state = 2418; + this.state = 2445; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 2446; + this.match(PostgreSQLParser.KW_ALWAYS); + this.state = 2447; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 2448; this.name(); } break; @@ -8490,13 +9052,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 35: this.enterOuterAlt(_localctx, 35); { - this.state = 2419; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 2420; - this.match(PostgreSQLParser.REPLICA); - this.state = 2421; - this.match(PostgreSQLParser.TRIGGER); - this.state = 2422; + this.state = 2449; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 2450; + this.match(PostgreSQLParser.KW_REPLICA); + this.state = 2451; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 2452; this.name(); } break; @@ -8504,35 +9066,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 36: this.enterOuterAlt(_localctx, 36); { - this.state = 2423; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 2424; - this.match(PostgreSQLParser.TRIGGER); - this.state = 2425; - this.match(PostgreSQLParser.ALL); + this.state = 2453; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 2454; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 2455; + this.match(PostgreSQLParser.KW_ALL); } break; case 37: this.enterOuterAlt(_localctx, 37); { - this.state = 2426; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 2427; - this.match(PostgreSQLParser.TRIGGER); - this.state = 2428; - this.match(PostgreSQLParser.USER); + this.state = 2456; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 2457; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 2458; + this.match(PostgreSQLParser.KW_USER); } break; case 38: this.enterOuterAlt(_localctx, 38); { - this.state = 2429; - this.match(PostgreSQLParser.DISABLE_P); - this.state = 2430; - this.match(PostgreSQLParser.TRIGGER); - this.state = 2431; + this.state = 2459; + this.match(PostgreSQLParser.KW_DISABLE); + this.state = 2460; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 2461; this.name(); } break; @@ -8540,35 +9102,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 39: this.enterOuterAlt(_localctx, 39); { - this.state = 2432; - this.match(PostgreSQLParser.DISABLE_P); - this.state = 2433; - this.match(PostgreSQLParser.TRIGGER); - this.state = 2434; - this.match(PostgreSQLParser.ALL); + this.state = 2462; + this.match(PostgreSQLParser.KW_DISABLE); + this.state = 2463; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 2464; + this.match(PostgreSQLParser.KW_ALL); } break; case 40: this.enterOuterAlt(_localctx, 40); { - this.state = 2435; - this.match(PostgreSQLParser.DISABLE_P); - this.state = 2436; - this.match(PostgreSQLParser.TRIGGER); - this.state = 2437; - this.match(PostgreSQLParser.USER); + this.state = 2465; + this.match(PostgreSQLParser.KW_DISABLE); + this.state = 2466; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 2467; + this.match(PostgreSQLParser.KW_USER); } break; case 41: this.enterOuterAlt(_localctx, 41); { - this.state = 2438; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 2439; - this.match(PostgreSQLParser.RULE); - this.state = 2440; + this.state = 2468; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 2469; + this.match(PostgreSQLParser.KW_RULE); + this.state = 2470; this.name(); } break; @@ -8576,13 +9138,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 42: this.enterOuterAlt(_localctx, 42); { - this.state = 2441; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 2442; - this.match(PostgreSQLParser.ALWAYS); - this.state = 2443; - this.match(PostgreSQLParser.RULE); - this.state = 2444; + this.state = 2471; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 2472; + this.match(PostgreSQLParser.KW_ALWAYS); + this.state = 2473; + this.match(PostgreSQLParser.KW_RULE); + this.state = 2474; this.name(); } break; @@ -8590,13 +9152,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 43: this.enterOuterAlt(_localctx, 43); { - this.state = 2445; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 2446; - this.match(PostgreSQLParser.REPLICA); - this.state = 2447; - this.match(PostgreSQLParser.RULE); - this.state = 2448; + this.state = 2475; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 2476; + this.match(PostgreSQLParser.KW_REPLICA); + this.state = 2477; + this.match(PostgreSQLParser.KW_RULE); + this.state = 2478; this.name(); } break; @@ -8604,11 +9166,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 44: this.enterOuterAlt(_localctx, 44); { - this.state = 2449; - this.match(PostgreSQLParser.DISABLE_P); - this.state = 2450; - this.match(PostgreSQLParser.RULE); - this.state = 2451; + this.state = 2479; + this.match(PostgreSQLParser.KW_DISABLE); + this.state = 2480; + this.match(PostgreSQLParser.KW_RULE); + this.state = 2481; this.name(); } break; @@ -8616,9 +9178,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 45: this.enterOuterAlt(_localctx, 45); { - this.state = 2452; - this.match(PostgreSQLParser.INHERIT); - this.state = 2453; + this.state = 2482; + this.match(PostgreSQLParser.KW_INHERIT); + this.state = 2483; this.qualified_name(); } break; @@ -8626,11 +9188,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 46: this.enterOuterAlt(_localctx, 46); { - this.state = 2454; - this.match(PostgreSQLParser.NO); - this.state = 2455; - this.match(PostgreSQLParser.INHERIT); - this.state = 2456; + this.state = 2484; + this.match(PostgreSQLParser.KW_NO); + this.state = 2485; + this.match(PostgreSQLParser.KW_INHERIT); + this.state = 2486; this.qualified_name(); } break; @@ -8638,9 +9200,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 47: this.enterOuterAlt(_localctx, 47); { - this.state = 2457; - this.match(PostgreSQLParser.OF); - this.state = 2458; + this.state = 2487; + this.match(PostgreSQLParser.KW_OF); + this.state = 2488; this.any_name(); } break; @@ -8648,21 +9210,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 48: this.enterOuterAlt(_localctx, 48); { - this.state = 2459; - this.match(PostgreSQLParser.NOT); - this.state = 2460; - this.match(PostgreSQLParser.OF); + this.state = 2489; + this.match(PostgreSQLParser.KW_NOT); + this.state = 2490; + this.match(PostgreSQLParser.KW_OF); } break; case 49: this.enterOuterAlt(_localctx, 49); { - this.state = 2461; - this.match(PostgreSQLParser.OWNER); - this.state = 2462; - this.match(PostgreSQLParser.TO); - this.state = 2463; + this.state = 2491; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 2492; + this.match(PostgreSQLParser.KW_TO); + this.state = 2493; this.rolespec(); } break; @@ -8670,11 +9232,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 50: this.enterOuterAlt(_localctx, 50); { - this.state = 2464; - this.match(PostgreSQLParser.SET); - this.state = 2465; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 2466; + this.state = 2494; + this.match(PostgreSQLParser.KW_SET); + this.state = 2495; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 2496; this.name(); } break; @@ -8682,9 +9244,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 51: this.enterOuterAlt(_localctx, 51); { - this.state = 2467; - this.match(PostgreSQLParser.SET); - this.state = 2468; + this.state = 2497; + this.match(PostgreSQLParser.KW_SET); + this.state = 2498; this.reloptions(); } break; @@ -8692,9 +9254,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 52: this.enterOuterAlt(_localctx, 52); { - this.state = 2469; - this.match(PostgreSQLParser.RESET); - this.state = 2470; + this.state = 2499; + this.match(PostgreSQLParser.KW_RESET); + this.state = 2500; this.reloptions(); } break; @@ -8702,11 +9264,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 53: this.enterOuterAlt(_localctx, 53); { - this.state = 2471; - this.match(PostgreSQLParser.REPLICA); - this.state = 2472; - this.match(PostgreSQLParser.IDENTITY_P); - this.state = 2473; + this.state = 2501; + this.match(PostgreSQLParser.KW_REPLICA); + this.state = 2502; + this.match(PostgreSQLParser.KW_IDENTITY); + this.state = 2503; this.replica_identity(); } break; @@ -8714,65 +9276,65 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 54: this.enterOuterAlt(_localctx, 54); { - this.state = 2474; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 2475; - this.match(PostgreSQLParser.ROW); - this.state = 2476; - this.match(PostgreSQLParser.LEVEL); - this.state = 2477; - this.match(PostgreSQLParser.SECURITY); + this.state = 2504; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 2505; + this.match(PostgreSQLParser.KW_ROW); + this.state = 2506; + this.match(PostgreSQLParser.KW_LEVEL); + this.state = 2507; + this.match(PostgreSQLParser.KW_SECURITY); } break; case 55: this.enterOuterAlt(_localctx, 55); { - this.state = 2478; - this.match(PostgreSQLParser.DISABLE_P); - this.state = 2479; - this.match(PostgreSQLParser.ROW); - this.state = 2480; - this.match(PostgreSQLParser.LEVEL); - this.state = 2481; - this.match(PostgreSQLParser.SECURITY); + this.state = 2508; + this.match(PostgreSQLParser.KW_DISABLE); + this.state = 2509; + this.match(PostgreSQLParser.KW_ROW); + this.state = 2510; + this.match(PostgreSQLParser.KW_LEVEL); + this.state = 2511; + this.match(PostgreSQLParser.KW_SECURITY); } break; case 56: this.enterOuterAlt(_localctx, 56); { - this.state = 2482; - this.match(PostgreSQLParser.FORCE); - this.state = 2483; - this.match(PostgreSQLParser.ROW); - this.state = 2484; - this.match(PostgreSQLParser.LEVEL); - this.state = 2485; - this.match(PostgreSQLParser.SECURITY); + this.state = 2512; + this.match(PostgreSQLParser.KW_FORCE); + this.state = 2513; + this.match(PostgreSQLParser.KW_ROW); + this.state = 2514; + this.match(PostgreSQLParser.KW_LEVEL); + this.state = 2515; + this.match(PostgreSQLParser.KW_SECURITY); } break; case 57: this.enterOuterAlt(_localctx, 57); { - this.state = 2486; - this.match(PostgreSQLParser.NO); - this.state = 2487; - this.match(PostgreSQLParser.FORCE); - this.state = 2488; - this.match(PostgreSQLParser.ROW); - this.state = 2489; - this.match(PostgreSQLParser.LEVEL); - this.state = 2490; - this.match(PostgreSQLParser.SECURITY); + this.state = 2516; + this.match(PostgreSQLParser.KW_NO); + this.state = 2517; + this.match(PostgreSQLParser.KW_FORCE); + this.state = 2518; + this.match(PostgreSQLParser.KW_ROW); + this.state = 2519; + this.match(PostgreSQLParser.KW_LEVEL); + this.state = 2520; + this.match(PostgreSQLParser.KW_SECURITY); } break; case 58: this.enterOuterAlt(_localctx, 58); { - this.state = 2491; + this.state = 2521; this.alter_generic_options(); } break; @@ -8797,27 +9359,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Alter_column_defaultContext = new Alter_column_defaultContext(this._ctx, this.state); this.enterRule(_localctx, 104, PostgreSQLParser.RULE_alter_column_default); try { - this.state = 2499; + this.state = 2529; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.SET: + case PostgreSQLParser.KW_SET: this.enterOuterAlt(_localctx, 1); { - this.state = 2494; - this.match(PostgreSQLParser.SET); - this.state = 2495; - this.match(PostgreSQLParser.DEFAULT); - this.state = 2496; + this.state = 2524; + this.match(PostgreSQLParser.KW_SET); + this.state = 2525; + this.match(PostgreSQLParser.KW_DEFAULT); + this.state = 2526; this.a_expr(); } break; - case PostgreSQLParser.DROP: + case PostgreSQLParser.KW_DROP: this.enterOuterAlt(_localctx, 2); { - this.state = 2497; - this.match(PostgreSQLParser.DROP); - this.state = 2498; - this.match(PostgreSQLParser.DEFAULT); + this.state = 2527; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2528; + this.match(PostgreSQLParser.KW_DEFAULT); } break; default: @@ -8846,9 +9408,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2501; + this.state = 2531; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT)) { + if (!(_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -8881,9 +9443,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2503; - this.match(PostgreSQLParser.COLLATE); - this.state = 2504; + this.state = 2533; + this.match(PostgreSQLParser.KW_COLLATE); + this.state = 2534; this.any_name(); } } @@ -8908,9 +9470,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2506; - this.match(PostgreSQLParser.USING); - this.state = 2507; + this.state = 2536; + this.match(PostgreSQLParser.KW_USING); + this.state = 2537; this.a_expr(); } } @@ -8933,38 +9495,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Replica_identityContext = new Replica_identityContext(this._ctx, this.state); this.enterRule(_localctx, 112, PostgreSQLParser.RULE_replica_identity); try { - this.state = 2515; + this.state = 2545; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.NOTHING: + case PostgreSQLParser.KW_NOTHING: this.enterOuterAlt(_localctx, 1); { - this.state = 2509; - this.match(PostgreSQLParser.NOTHING); + this.state = 2539; + this.match(PostgreSQLParser.KW_NOTHING); } break; - case PostgreSQLParser.FULL: + case PostgreSQLParser.KW_FULL: this.enterOuterAlt(_localctx, 2); { - this.state = 2510; - this.match(PostgreSQLParser.FULL); + this.state = 2540; + this.match(PostgreSQLParser.KW_FULL); } break; - case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.KW_DEFAULT: this.enterOuterAlt(_localctx, 3); { - this.state = 2511; - this.match(PostgreSQLParser.DEFAULT); + this.state = 2541; + this.match(PostgreSQLParser.KW_DEFAULT); } break; - case PostgreSQLParser.USING: + case PostgreSQLParser.KW_USING: this.enterOuterAlt(_localctx, 4); { - this.state = 2512; - this.match(PostgreSQLParser.USING); - this.state = 2513; - this.match(PostgreSQLParser.INDEX); - this.state = 2514; + this.state = 2542; + this.match(PostgreSQLParser.KW_USING); + this.state = 2543; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 2544; this.name(); } break; @@ -8993,11 +9555,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2517; + this.state = 2547; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2518; + this.state = 2548; this.reloption_list(); - this.state = 2519; + this.state = 2549; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -9022,9 +9584,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2521; - this.match(PostgreSQLParser.WITH); - this.state = 2522; + this.state = 2551; + this.match(PostgreSQLParser.KW_WITH); + this.state = 2552; this.reloptions(); } } @@ -9050,21 +9612,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2524; + this.state = 2554; this.reloption_elem(); - this.state = 2529; + this.state = 2559; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 2525; + this.state = 2555; this.match(PostgreSQLParser.COMMA); - this.state = 2526; + this.state = 2556; this.reloption_elem(); } } - this.state = 2531; + this.state = 2561; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -9092,33 +9654,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2532; + this.state = 2562; this.collabel(); - this.state = 2541; + this.state = 2571; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.EQUAL: { - this.state = 2533; + this.state = 2563; this.match(PostgreSQLParser.EQUAL); - this.state = 2534; + this.state = 2564; this.def_arg(); } break; case PostgreSQLParser.DOT: { - this.state = 2535; + this.state = 2565; this.match(PostgreSQLParser.DOT); - this.state = 2536; + this.state = 2566; this.collabel(); - this.state = 2539; + this.state = 2569; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.EQUAL) { { - this.state = 2537; + this.state = 2567; this.match(PostgreSQLParser.EQUAL); - this.state = 2538; + this.state = 2568; this.def_arg(); } } @@ -9155,7 +9717,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 2544; + this.state = 2574; this._errHandler.sync(this); _alt = 1; do { @@ -9163,7 +9725,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 1: { { - this.state = 2543; + this.state = 2573; this.alter_identity_column_option(); } } @@ -9171,7 +9733,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 2546; + this.state = 2576; this._errHandler.sync(this); _alt = this.interpreter.adaptivePredict(this._input, 89, this._ctx); } while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER); @@ -9197,65 +9759,65 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 124, PostgreSQLParser.RULE_alter_identity_column_option); let _la: number; try { - this.state = 2561; + this.state = 2591; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.RESTART: + case PostgreSQLParser.KW_RESTART: this.enterOuterAlt(_localctx, 1); { - this.state = 2548; - this.match(PostgreSQLParser.RESTART); - this.state = 2553; + this.state = 2578; + this.match(PostgreSQLParser.KW_RESTART); + this.state = 2583; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 91, this._ctx) ) { case 1: { - this.state = 2550; + this.state = 2580; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH) { + if (_la === PostgreSQLParser.KW_WITH) { { - this.state = 2549; + this.state = 2579; this.opt_with(); } } - this.state = 2552; + this.state = 2582; this.numericonly(); } break; } } break; - case PostgreSQLParser.SET: + case PostgreSQLParser.KW_SET: this.enterOuterAlt(_localctx, 2); { - this.state = 2555; - this.match(PostgreSQLParser.SET); - this.state = 2559; + this.state = 2585; + this.match(PostgreSQLParser.KW_SET); + this.state = 2589; 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: + case PostgreSQLParser.KW_AS: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_START: { - this.state = 2556; + this.state = 2586; this.seqoptelem(); } break; - case PostgreSQLParser.GENERATED: + case PostgreSQLParser.KW_GENERATED: { - this.state = 2557; - this.match(PostgreSQLParser.GENERATED); - this.state = 2558; + this.state = 2587; + this.match(PostgreSQLParser.KW_GENERATED); + this.state = 2588; this.generated_when(); } break; @@ -9287,23 +9849,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: PartitionboundspecContext = new PartitionboundspecContext(this._ctx, this.state); this.enterRule(_localctx, 126, PostgreSQLParser.RULE_partitionboundspec); try { - this.state = 2589; + this.state = 2619; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 94, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2563; - this.match(PostgreSQLParser.FOR); - this.state = 2564; - this.match(PostgreSQLParser.VALUES); - this.state = 2565; - this.match(PostgreSQLParser.WITH); - this.state = 2566; + this.state = 2593; + this.match(PostgreSQLParser.KW_FOR); + this.state = 2594; + this.match(PostgreSQLParser.KW_VALUES); + this.state = 2595; + this.match(PostgreSQLParser.KW_WITH); + this.state = 2596; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2567; + this.state = 2597; this.hash_partbound(); - this.state = 2568; + this.state = 2598; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -9311,17 +9873,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2570; - this.match(PostgreSQLParser.FOR); - this.state = 2571; - this.match(PostgreSQLParser.VALUES); - this.state = 2572; - this.match(PostgreSQLParser.IN_P); - this.state = 2573; + this.state = 2600; + this.match(PostgreSQLParser.KW_FOR); + this.state = 2601; + this.match(PostgreSQLParser.KW_VALUES); + this.state = 2602; + this.match(PostgreSQLParser.KW_IN); + this.state = 2603; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2574; + this.state = 2604; this.expr_list(); - this.state = 2575; + this.state = 2605; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -9329,25 +9891,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 2577; - this.match(PostgreSQLParser.FOR); - this.state = 2578; - this.match(PostgreSQLParser.VALUES); - this.state = 2579; - this.match(PostgreSQLParser.FROM); - this.state = 2580; + this.state = 2607; + this.match(PostgreSQLParser.KW_FOR); + this.state = 2608; + this.match(PostgreSQLParser.KW_VALUES); + this.state = 2609; + this.match(PostgreSQLParser.KW_FROM); + this.state = 2610; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2581; + this.state = 2611; this.expr_list(); - this.state = 2582; + this.state = 2612; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 2583; - this.match(PostgreSQLParser.TO); - this.state = 2584; + this.state = 2613; + this.match(PostgreSQLParser.KW_TO); + this.state = 2614; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2585; + this.state = 2615; this.expr_list(); - this.state = 2586; + this.state = 2616; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -9355,8 +9917,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 2588; - this.match(PostgreSQLParser.DEFAULT); + this.state = 2618; + this.match(PostgreSQLParser.KW_DEFAULT); } break; } @@ -9382,9 +9944,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2591; + this.state = 2621; this.nonreservedword(); - this.state = 2592; + this.state = 2622; this.iconst(); } } @@ -9410,21 +9972,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2594; + this.state = 2624; this.hash_partbound_elem(); - this.state = 2599; + this.state = 2629; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 2595; + this.state = 2625; this.match(PostgreSQLParser.COMMA); - this.state = 2596; + this.state = 2626; this.hash_partbound_elem(); } } - this.state = 2601; + this.state = 2631; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -9451,13 +10013,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2602; - this.match(PostgreSQLParser.ALTER); - this.state = 2603; - this.match(PostgreSQLParser.TYPE_P); - this.state = 2604; + this.state = 2632; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2633; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 2634; this.any_name(); - this.state = 2605; + this.state = 2635; this.alter_type_cmds(); } } @@ -9483,21 +10045,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2607; + this.state = 2637; this.alter_type_cmd(); - this.state = 2612; + this.state = 2642; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 2608; + this.state = 2638; this.match(PostgreSQLParser.COMMA); - this.state = 2609; + this.state = 2639; this.alter_type_cmd(); } } - this.state = 2614; + this.state = 2644; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -9523,102 +10085,102 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 136, PostgreSQLParser.RULE_alter_type_cmd); let _la: number; try { - this.state = 2645; + this.state = 2675; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.ADD_P: + case PostgreSQLParser.KW_ADD: this.enterOuterAlt(_localctx, 1); { - this.state = 2615; - this.match(PostgreSQLParser.ADD_P); - this.state = 2616; - this.match(PostgreSQLParser.ATTRIBUTE); - this.state = 2617; + this.state = 2645; + this.match(PostgreSQLParser.KW_ADD); + this.state = 2646; + this.match(PostgreSQLParser.KW_ATTRIBUTE); + this.state = 2647; this.tablefuncelement(); - this.state = 2619; + this.state = 2649; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 2618; + this.state = 2648; this.opt_drop_behavior(); } } } break; - case PostgreSQLParser.DROP: + case PostgreSQLParser.KW_DROP: this.enterOuterAlt(_localctx, 2); { - this.state = 2621; - this.match(PostgreSQLParser.DROP); - this.state = 2622; - this.match(PostgreSQLParser.ATTRIBUTE); - this.state = 2625; + this.state = 2651; + this.match(PostgreSQLParser.KW_DROP); + this.state = 2652; + this.match(PostgreSQLParser.KW_ATTRIBUTE); + this.state = 2655; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 98, this._ctx) ) { case 1: { - this.state = 2623; - this.match(PostgreSQLParser.IF_P); - this.state = 2624; - this.match(PostgreSQLParser.EXISTS); + this.state = 2653; + this.match(PostgreSQLParser.KW_IF); + this.state = 2654; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 2627; + this.state = 2657; this.colid(); - this.state = 2629; + this.state = 2659; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 2628; + this.state = 2658; this.opt_drop_behavior(); } } } break; - case PostgreSQLParser.ALTER: + case PostgreSQLParser.KW_ALTER: this.enterOuterAlt(_localctx, 3); { - this.state = 2631; - this.match(PostgreSQLParser.ALTER); - this.state = 2632; - this.match(PostgreSQLParser.ATTRIBUTE); - this.state = 2633; + this.state = 2661; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 2662; + this.match(PostgreSQLParser.KW_ATTRIBUTE); + this.state = 2663; this.colid(); - this.state = 2635; + this.state = 2665; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.SET) { + if (_la === PostgreSQLParser.KW_SET) { { - this.state = 2634; + this.state = 2664; this.opt_set_data(); } } - this.state = 2637; - this.match(PostgreSQLParser.TYPE_P); - this.state = 2638; + this.state = 2667; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 2668; this.typename(); - this.state = 2640; + this.state = 2670; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.COLLATE) { + if (_la === PostgreSQLParser.KW_COLLATE) { { - this.state = 2639; + this.state = 2669; this.opt_collate_clause(); } } - this.state = 2643; + this.state = 2673; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 2642; + this.state = 2672; this.opt_drop_behavior(); } } @@ -9650,415 +10212,415 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2647; - this.match(PostgreSQLParser.CLOSE); - this.state = 2650; + this.state = 2677; + this.match(PostgreSQLParser.KW_CLOSE); + this.state = 2680; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: case PostgreSQLParser.PLSQLVARIABLENAME: case PostgreSQLParser.PLSQLIDENTIFIER: { - this.state = 2648; + this.state = 2678; this.cursor_name(); } break; - case PostgreSQLParser.ALL: + case PostgreSQLParser.KW_ALL: { - this.state = 2649; - this.match(PostgreSQLParser.ALL); + this.state = 2679; + this.match(PostgreSQLParser.KW_ALL); } break; default: @@ -10086,78 +10648,78 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 140, PostgreSQLParser.RULE_copystmt); let _la: number; try { - this.state = 2689; + this.state = 2719; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 113, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2652; - this.match(PostgreSQLParser.COPY); - this.state = 2654; + this.state = 2682; + this.match(PostgreSQLParser.KW_COPY); + this.state = 2684; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.BINARY) { + if (_la === PostgreSQLParser.KW_BINARY) { { - this.state = 2653; + this.state = 2683; this.opt_binary(); } } - this.state = 2656; + this.state = 2686; this.qualified_name(); - this.state = 2658; + this.state = 2688; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 2657; + this.state = 2687; this.opt_column_list(); } } - this.state = 2660; + this.state = 2690; this.copy_from(); - this.state = 2662; + this.state = 2692; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PROGRAM) { + if (_la === PostgreSQLParser.KW_PROGRAM) { { - this.state = 2661; + this.state = 2691; this.opt_program(); } } - this.state = 2664; + this.state = 2694; this.copy_file_name(); - this.state = 2666; + this.state = 2696; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING || _la === PostgreSQLParser.DELIMITERS) { + if (_la === PostgreSQLParser.KW_USING || _la === PostgreSQLParser.KW_DELIMITERS) { { - this.state = 2665; + this.state = 2695; this.copy_delimiter(); } } - this.state = 2669; + this.state = 2699; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 109, this._ctx) ) { case 1: { - this.state = 2668; + this.state = 2698; this.opt_with(); } break; } - this.state = 2671; + this.state = 2701; this.copy_options(); - this.state = 2673; + this.state = 2703; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 2672; + this.state = 2702; this.where_clause(); } } @@ -10168,39 +10730,39 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2675; - this.match(PostgreSQLParser.COPY); - this.state = 2676; + this.state = 2705; + this.match(PostgreSQLParser.KW_COPY); + this.state = 2706; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2677; + this.state = 2707; this.preparablestmt(); - this.state = 2678; + this.state = 2708; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 2679; - this.match(PostgreSQLParser.TO); - this.state = 2681; + this.state = 2709; + this.match(PostgreSQLParser.KW_TO); + this.state = 2711; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PROGRAM) { + if (_la === PostgreSQLParser.KW_PROGRAM) { { - this.state = 2680; + this.state = 2710; this.opt_program(); } } - this.state = 2683; + this.state = 2713; this.copy_file_name(); - this.state = 2685; + this.state = 2715; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 112, this._ctx) ) { case 1: { - this.state = 2684; + this.state = 2714; this.opt_with(); } break; } - this.state = 2687; + this.state = 2717; this.copy_options(); } break; @@ -10228,9 +10790,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2691; + this.state = 2721; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.TO)) { + if (!(_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_TO)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -10263,8 +10825,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2693; - this.match(PostgreSQLParser.PROGRAM); + this.state = 2723; + this.match(PostgreSQLParser.KW_PROGRAM); } } catch (re) { @@ -10286,7 +10848,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Copy_file_nameContext = new Copy_file_nameContext(this._ctx, this.state); this.enterRule(_localctx, 146, PostgreSQLParser.RULE_copy_file_name); try { - this.state = 2698; + this.state = 2728; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: @@ -10295,22 +10857,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 2695; + this.state = 2725; this.sconst(); } break; - case PostgreSQLParser.STDIN: + case PostgreSQLParser.KW_STDIN: this.enterOuterAlt(_localctx, 2); { - this.state = 2696; - this.match(PostgreSQLParser.STDIN); + this.state = 2726; + this.match(PostgreSQLParser.KW_STDIN); } break; - case PostgreSQLParser.STDOUT: + case PostgreSQLParser.KW_STDOUT: this.enterOuterAlt(_localctx, 3); { - this.state = 2697; - this.match(PostgreSQLParser.STDOUT); + this.state = 2727; + this.match(PostgreSQLParser.KW_STDOUT); } break; default: @@ -10336,13 +10898,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Copy_optionsContext = new Copy_optionsContext(this._ctx, this.state); this.enterRule(_localctx, 148, PostgreSQLParser.RULE_copy_options); try { - this.state = 2705; + this.state = 2735; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 115, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2700; + this.state = 2730; this.copy_opt_list(); } break; @@ -10350,11 +10912,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2701; + this.state = 2731; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2702; + this.state = 2732; this.copy_generic_opt_list(); - this.state = 2703; + this.state = 2733; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -10382,17 +10944,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2710; + this.state = 2740; 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) { + while (_la === PostgreSQLParser.KW_NULL || _la === PostgreSQLParser.KW_BINARY || _la === PostgreSQLParser.KW_FREEZE || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.KW_CSV - 171)) | (1 << (PostgreSQLParser.KW_DELIMITER - 171)) | (1 << (PostgreSQLParser.KW_ENCODING - 171)) | (1 << (PostgreSQLParser.KW_ESCAPE - 171)))) !== 0) || _la === PostgreSQLParser.KW_FORCE || _la === PostgreSQLParser.KW_HEADER || _la === PostgreSQLParser.KW_QUOTE) { { { - this.state = 2707; + this.state = 2737; this.copy_opt_item(); } } - this.state = 2712; + this.state = 2742; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -10418,41 +10980,41 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 152, PostgreSQLParser.RULE_copy_opt_item); let _la: number; try { - this.state = 2752; + this.state = 2782; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 121, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2713; - this.match(PostgreSQLParser.BINARY); + this.state = 2743; + this.match(PostgreSQLParser.KW_BINARY); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2714; - this.match(PostgreSQLParser.FREEZE); + this.state = 2744; + this.match(PostgreSQLParser.KW_FREEZE); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 2715; - this.match(PostgreSQLParser.DELIMITER); - this.state = 2717; + this.state = 2745; + this.match(PostgreSQLParser.KW_DELIMITER); + this.state = 2747; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 2716; + this.state = 2746; this.opt_as(); } } - this.state = 2719; + this.state = 2749; this.sconst(); } break; @@ -10460,19 +11022,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 2720; - this.match(PostgreSQLParser.NULL_P); - this.state = 2722; + this.state = 2750; + this.match(PostgreSQLParser.KW_NULL); + this.state = 2752; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 2721; + this.state = 2751; this.opt_as(); } } - this.state = 2724; + this.state = 2754; this.sconst(); } break; @@ -10480,35 +11042,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 2725; - this.match(PostgreSQLParser.CSV); + this.state = 2755; + this.match(PostgreSQLParser.KW_CSV); } break; case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 2726; - this.match(PostgreSQLParser.HEADER_P); + this.state = 2756; + this.match(PostgreSQLParser.KW_HEADER); } break; case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 2727; - this.match(PostgreSQLParser.QUOTE); - this.state = 2729; + this.state = 2757; + this.match(PostgreSQLParser.KW_QUOTE); + this.state = 2759; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 2728; + this.state = 2758; this.opt_as(); } } - this.state = 2731; + this.state = 2761; this.sconst(); } break; @@ -10516,19 +11078,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 2732; - this.match(PostgreSQLParser.ESCAPE); - this.state = 2734; + this.state = 2762; + this.match(PostgreSQLParser.KW_ESCAPE); + this.state = 2764; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 2733; + this.state = 2763; this.opt_as(); } } - this.state = 2736; + this.state = 2766; this.sconst(); } break; @@ -10536,11 +11098,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 2737; - this.match(PostgreSQLParser.FORCE); - this.state = 2738; - this.match(PostgreSQLParser.QUOTE); - this.state = 2739; + this.state = 2767; + this.match(PostgreSQLParser.KW_FORCE); + this.state = 2768; + this.match(PostgreSQLParser.KW_QUOTE); + this.state = 2769; this.columnlist(); } break; @@ -10548,11 +11110,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 2740; - this.match(PostgreSQLParser.FORCE); - this.state = 2741; - this.match(PostgreSQLParser.QUOTE); - this.state = 2742; + this.state = 2770; + this.match(PostgreSQLParser.KW_FORCE); + this.state = 2771; + this.match(PostgreSQLParser.KW_QUOTE); + this.state = 2772; this.match(PostgreSQLParser.STAR); } break; @@ -10560,13 +11122,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 2743; - this.match(PostgreSQLParser.FORCE); - this.state = 2744; - this.match(PostgreSQLParser.NOT); - this.state = 2745; - this.match(PostgreSQLParser.NULL_P); - this.state = 2746; + this.state = 2773; + this.match(PostgreSQLParser.KW_FORCE); + this.state = 2774; + this.match(PostgreSQLParser.KW_NOT); + this.state = 2775; + this.match(PostgreSQLParser.KW_NULL); + this.state = 2776; this.columnlist(); } break; @@ -10574,11 +11136,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 2747; - this.match(PostgreSQLParser.FORCE); - this.state = 2748; - this.match(PostgreSQLParser.NULL_P); - this.state = 2749; + this.state = 2777; + this.match(PostgreSQLParser.KW_FORCE); + this.state = 2778; + this.match(PostgreSQLParser.KW_NULL); + this.state = 2779; this.columnlist(); } break; @@ -10586,9 +11148,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 2750; - this.match(PostgreSQLParser.ENCODING); - this.state = 2751; + this.state = 2780; + this.match(PostgreSQLParser.KW_ENCODING); + this.state = 2781; this.sconst(); } break; @@ -10615,8 +11177,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2754; - this.match(PostgreSQLParser.BINARY); + this.state = 2784; + this.match(PostgreSQLParser.KW_BINARY); } } catch (re) { @@ -10641,19 +11203,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2757; + this.state = 2787; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 2756; + this.state = 2786; this.opt_using(); } } - this.state = 2759; - this.match(PostgreSQLParser.DELIMITERS); - this.state = 2760; + this.state = 2789; + this.match(PostgreSQLParser.KW_DELIMITERS); + this.state = 2790; this.sconst(); } } @@ -10678,8 +11240,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2762; - this.match(PostgreSQLParser.USING); + this.state = 2792; + this.match(PostgreSQLParser.KW_USING); } } catch (re) { @@ -10704,21 +11266,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2764; + this.state = 2794; this.copy_generic_opt_elem(); - this.state = 2769; + this.state = 2799; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 2765; + this.state = 2795; this.match(PostgreSQLParser.COMMA); - this.state = 2766; + this.state = 2796; this.copy_generic_opt_elem(); } } - this.state = 2771; + this.state = 2801; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -10746,14 +11308,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2772; + this.state = 2802; this.collabel(); - this.state = 2774; + this.state = 2804; this._errHandler.sync(this); _la = this._input.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << PostgreSQLParser.OPEN_PAREN) | (1 << PostgreSQLParser.STAR) | (1 << PostgreSQLParser.PLUS) | (1 << PostgreSQLParser.MINUS))) !== 0) || ((((_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.FALSE_P - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & ((1 << (PostgreSQLParser.ON - 80)) | (1 << (PostgreSQLParser.TABLE - 80)) | (1 << (PostgreSQLParser.TRUE_P - 80)) | (1 << (PostgreSQLParser.AUTHORIZATION - 80)) | (1 << (PostgreSQLParser.BINARY - 80)) | (1 << (PostgreSQLParser.COLLATION - 80)) | (1 << (PostgreSQLParser.CONCURRENTLY - 80)) | (1 << (PostgreSQLParser.CROSS - 80)) | (1 << (PostgreSQLParser.CURRENT_SCHEMA - 80)))) !== 0) || ((((_la - 112)) & ~0x1F) === 0 && ((1 << (_la - 112)) & ((1 << (PostgreSQLParser.FREEZE - 112)) | (1 << (PostgreSQLParser.FULL - 112)) | (1 << (PostgreSQLParser.ILIKE - 112)) | (1 << (PostgreSQLParser.INNER_P - 112)) | (1 << (PostgreSQLParser.IS - 112)) | (1 << (PostgreSQLParser.ISNULL - 112)) | (1 << (PostgreSQLParser.JOIN - 112)) | (1 << (PostgreSQLParser.LEFT - 112)) | (1 << (PostgreSQLParser.LIKE - 112)) | (1 << (PostgreSQLParser.NATURAL - 112)) | (1 << (PostgreSQLParser.NOTNULL - 112)) | (1 << (PostgreSQLParser.OUTER_P - 112)) | (1 << (PostgreSQLParser.OVER - 112)) | (1 << (PostgreSQLParser.OVERLAPS - 112)) | (1 << (PostgreSQLParser.RIGHT - 112)) | (1 << (PostgreSQLParser.SIMILAR - 112)) | (1 << (PostgreSQLParser.VERBOSE - 112)) | (1 << (PostgreSQLParser.ABORT_P - 112)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 112)) | (1 << (PostgreSQLParser.ACCESS - 112)) | (1 << (PostgreSQLParser.ACTION - 112)) | (1 << (PostgreSQLParser.ADD_P - 112)) | (1 << (PostgreSQLParser.ADMIN - 112)) | (1 << (PostgreSQLParser.AFTER - 112)) | (1 << (PostgreSQLParser.AGGREGATE - 112)) | (1 << (PostgreSQLParser.ALSO - 112)) | (1 << (PostgreSQLParser.ALTER - 112)) | (1 << (PostgreSQLParser.ALWAYS - 112)) | (1 << (PostgreSQLParser.ASSERTION - 112)) | (1 << (PostgreSQLParser.ASSIGNMENT - 112)) | (1 << (PostgreSQLParser.AT - 112)) | (1 << (PostgreSQLParser.ATTRIBUTE - 112)))) !== 0) || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & ((1 << (PostgreSQLParser.BACKWARD - 144)) | (1 << (PostgreSQLParser.BEFORE - 144)) | (1 << (PostgreSQLParser.BEGIN_P - 144)) | (1 << (PostgreSQLParser.BY - 144)) | (1 << (PostgreSQLParser.CACHE - 144)) | (1 << (PostgreSQLParser.CALLED - 144)) | (1 << (PostgreSQLParser.CASCADE - 144)) | (1 << (PostgreSQLParser.CASCADED - 144)) | (1 << (PostgreSQLParser.CATALOG - 144)) | (1 << (PostgreSQLParser.CHAIN - 144)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 144)) | (1 << (PostgreSQLParser.CHECKPOINT - 144)) | (1 << (PostgreSQLParser.CLASS - 144)) | (1 << (PostgreSQLParser.CLOSE - 144)) | (1 << (PostgreSQLParser.CLUSTER - 144)) | (1 << (PostgreSQLParser.COMMENT - 144)) | (1 << (PostgreSQLParser.COMMENTS - 144)) | (1 << (PostgreSQLParser.COMMIT - 144)) | (1 << (PostgreSQLParser.COMMITTED - 144)) | (1 << (PostgreSQLParser.CONFIGURATION - 144)) | (1 << (PostgreSQLParser.CONNECTION - 144)) | (1 << (PostgreSQLParser.CONSTRAINTS - 144)) | (1 << (PostgreSQLParser.CONTENT_P - 144)) | (1 << (PostgreSQLParser.CONTINUE_P - 144)) | (1 << (PostgreSQLParser.CONVERSION_P - 144)) | (1 << (PostgreSQLParser.COPY - 144)) | (1 << (PostgreSQLParser.COST - 144)) | (1 << (PostgreSQLParser.CSV - 144)) | (1 << (PostgreSQLParser.CURSOR - 144)) | (1 << (PostgreSQLParser.CYCLE - 144)) | (1 << (PostgreSQLParser.DATA_P - 144)) | (1 << (PostgreSQLParser.DATABASE - 144)))) !== 0) || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (PostgreSQLParser.DAY_P - 176)) | (1 << (PostgreSQLParser.DEALLOCATE - 176)) | (1 << (PostgreSQLParser.DECLARE - 176)) | (1 << (PostgreSQLParser.DEFAULTS - 176)) | (1 << (PostgreSQLParser.DEFERRED - 176)) | (1 << (PostgreSQLParser.DEFINER - 176)) | (1 << (PostgreSQLParser.DELETE_P - 176)) | (1 << (PostgreSQLParser.DELIMITER - 176)) | (1 << (PostgreSQLParser.DELIMITERS - 176)) | (1 << (PostgreSQLParser.DICTIONARY - 176)) | (1 << (PostgreSQLParser.DISABLE_P - 176)) | (1 << (PostgreSQLParser.DISCARD - 176)) | (1 << (PostgreSQLParser.DOCUMENT_P - 176)) | (1 << (PostgreSQLParser.DOMAIN_P - 176)) | (1 << (PostgreSQLParser.DOUBLE_P - 176)) | (1 << (PostgreSQLParser.DROP - 176)) | (1 << (PostgreSQLParser.EACH - 176)) | (1 << (PostgreSQLParser.ENABLE_P - 176)) | (1 << (PostgreSQLParser.ENCODING - 176)) | (1 << (PostgreSQLParser.ENCRYPTED - 176)) | (1 << (PostgreSQLParser.ENUM_P - 176)) | (1 << (PostgreSQLParser.ESCAPE - 176)) | (1 << (PostgreSQLParser.EVENT - 176)) | (1 << (PostgreSQLParser.EXCLUDE - 176)) | (1 << (PostgreSQLParser.EXCLUDING - 176)) | (1 << (PostgreSQLParser.EXCLUSIVE - 176)) | (1 << (PostgreSQLParser.EXECUTE - 176)) | (1 << (PostgreSQLParser.EXPLAIN - 176)) | (1 << (PostgreSQLParser.EXTENSION - 176)) | (1 << (PostgreSQLParser.EXTERNAL - 176)) | (1 << (PostgreSQLParser.FAMILY - 176)) | (1 << (PostgreSQLParser.FIRST_P - 176)))) !== 0) || ((((_la - 208)) & ~0x1F) === 0 && ((1 << (_la - 208)) & ((1 << (PostgreSQLParser.FOLLOWING - 208)) | (1 << (PostgreSQLParser.FORCE - 208)) | (1 << (PostgreSQLParser.FORWARD - 208)) | (1 << (PostgreSQLParser.FUNCTION - 208)) | (1 << (PostgreSQLParser.FUNCTIONS - 208)) | (1 << (PostgreSQLParser.GLOBAL - 208)) | (1 << (PostgreSQLParser.GRANTED - 208)) | (1 << (PostgreSQLParser.HANDLER - 208)) | (1 << (PostgreSQLParser.HEADER_P - 208)) | (1 << (PostgreSQLParser.HOLD - 208)) | (1 << (PostgreSQLParser.HOUR_P - 208)) | (1 << (PostgreSQLParser.IDENTITY_P - 208)) | (1 << (PostgreSQLParser.IF_P - 208)) | (1 << (PostgreSQLParser.IMMEDIATE - 208)) | (1 << (PostgreSQLParser.IMMUTABLE - 208)) | (1 << (PostgreSQLParser.IMPLICIT_P - 208)) | (1 << (PostgreSQLParser.INCLUDING - 208)) | (1 << (PostgreSQLParser.INCREMENT - 208)) | (1 << (PostgreSQLParser.INDEX - 208)) | (1 << (PostgreSQLParser.INDEXES - 208)) | (1 << (PostgreSQLParser.INHERIT - 208)) | (1 << (PostgreSQLParser.INHERITS - 208)) | (1 << (PostgreSQLParser.INLINE_P - 208)) | (1 << (PostgreSQLParser.INSENSITIVE - 208)) | (1 << (PostgreSQLParser.INSERT - 208)) | (1 << (PostgreSQLParser.INSTEAD - 208)) | (1 << (PostgreSQLParser.INVOKER - 208)) | (1 << (PostgreSQLParser.ISOLATION - 208)) | (1 << (PostgreSQLParser.KEY - 208)) | (1 << (PostgreSQLParser.LABEL - 208)) | (1 << (PostgreSQLParser.LANGUAGE - 208)) | (1 << (PostgreSQLParser.LARGE_P - 208)))) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.LAST_P - 240)) | (1 << (PostgreSQLParser.LEAKPROOF - 240)) | (1 << (PostgreSQLParser.LEVEL - 240)) | (1 << (PostgreSQLParser.LISTEN - 240)) | (1 << (PostgreSQLParser.LOAD - 240)) | (1 << (PostgreSQLParser.LOCAL - 240)) | (1 << (PostgreSQLParser.LOCATION - 240)) | (1 << (PostgreSQLParser.LOCK_P - 240)) | (1 << (PostgreSQLParser.MAPPING - 240)) | (1 << (PostgreSQLParser.MATCH - 240)) | (1 << (PostgreSQLParser.MATERIALIZED - 240)) | (1 << (PostgreSQLParser.MAXVALUE - 240)) | (1 << (PostgreSQLParser.MINUTE_P - 240)) | (1 << (PostgreSQLParser.MINVALUE - 240)) | (1 << (PostgreSQLParser.MODE - 240)) | (1 << (PostgreSQLParser.MONTH_P - 240)) | (1 << (PostgreSQLParser.MOVE - 240)) | (1 << (PostgreSQLParser.NAME_P - 240)) | (1 << (PostgreSQLParser.NAMES - 240)) | (1 << (PostgreSQLParser.NEXT - 240)) | (1 << (PostgreSQLParser.NO - 240)) | (1 << (PostgreSQLParser.NOTHING - 240)) | (1 << (PostgreSQLParser.NOTIFY - 240)) | (1 << (PostgreSQLParser.NOWAIT - 240)) | (1 << (PostgreSQLParser.NULLS_P - 240)) | (1 << (PostgreSQLParser.OBJECT_P - 240)) | (1 << (PostgreSQLParser.OF - 240)) | (1 << (PostgreSQLParser.OFF - 240)) | (1 << (PostgreSQLParser.OIDS - 240)) | (1 << (PostgreSQLParser.OPERATOR - 240)) | (1 << (PostgreSQLParser.OPTION - 240)) | (1 << (PostgreSQLParser.OPTIONS - 240)))) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & ((1 << (PostgreSQLParser.OWNED - 272)) | (1 << (PostgreSQLParser.OWNER - 272)) | (1 << (PostgreSQLParser.PARSER - 272)) | (1 << (PostgreSQLParser.PARTIAL - 272)) | (1 << (PostgreSQLParser.PARTITION - 272)) | (1 << (PostgreSQLParser.PASSING - 272)) | (1 << (PostgreSQLParser.PASSWORD - 272)) | (1 << (PostgreSQLParser.PLANS - 272)) | (1 << (PostgreSQLParser.PRECEDING - 272)) | (1 << (PostgreSQLParser.PREPARE - 272)) | (1 << (PostgreSQLParser.PREPARED - 272)) | (1 << (PostgreSQLParser.PRESERVE - 272)) | (1 << (PostgreSQLParser.PRIOR - 272)) | (1 << (PostgreSQLParser.PRIVILEGES - 272)) | (1 << (PostgreSQLParser.PROCEDURAL - 272)) | (1 << (PostgreSQLParser.PROCEDURE - 272)) | (1 << (PostgreSQLParser.PROGRAM - 272)) | (1 << (PostgreSQLParser.QUOTE - 272)) | (1 << (PostgreSQLParser.RANGE - 272)) | (1 << (PostgreSQLParser.READ - 272)) | (1 << (PostgreSQLParser.REASSIGN - 272)) | (1 << (PostgreSQLParser.RECHECK - 272)) | (1 << (PostgreSQLParser.RECURSIVE - 272)) | (1 << (PostgreSQLParser.REF - 272)) | (1 << (PostgreSQLParser.REFRESH - 272)) | (1 << (PostgreSQLParser.REINDEX - 272)) | (1 << (PostgreSQLParser.RELATIVE_P - 272)) | (1 << (PostgreSQLParser.RELEASE - 272)) | (1 << (PostgreSQLParser.RENAME - 272)) | (1 << (PostgreSQLParser.REPEATABLE - 272)) | (1 << (PostgreSQLParser.REPLACE - 272)) | (1 << (PostgreSQLParser.REPLICA - 272)))) !== 0) || ((((_la - 304)) & ~0x1F) === 0 && ((1 << (_la - 304)) & ((1 << (PostgreSQLParser.RESET - 304)) | (1 << (PostgreSQLParser.RESTART - 304)) | (1 << (PostgreSQLParser.RESTRICT - 304)) | (1 << (PostgreSQLParser.RETURNS - 304)) | (1 << (PostgreSQLParser.REVOKE - 304)) | (1 << (PostgreSQLParser.ROLE - 304)) | (1 << (PostgreSQLParser.ROLLBACK - 304)) | (1 << (PostgreSQLParser.ROWS - 304)) | (1 << (PostgreSQLParser.RULE - 304)) | (1 << (PostgreSQLParser.SAVEPOINT - 304)) | (1 << (PostgreSQLParser.SCHEMA - 304)) | (1 << (PostgreSQLParser.SCROLL - 304)) | (1 << (PostgreSQLParser.SEARCH - 304)) | (1 << (PostgreSQLParser.SECOND_P - 304)) | (1 << (PostgreSQLParser.SECURITY - 304)) | (1 << (PostgreSQLParser.SEQUENCE - 304)) | (1 << (PostgreSQLParser.SEQUENCES - 304)) | (1 << (PostgreSQLParser.SERIALIZABLE - 304)) | (1 << (PostgreSQLParser.SERVER - 304)) | (1 << (PostgreSQLParser.SESSION - 304)) | (1 << (PostgreSQLParser.SET - 304)) | (1 << (PostgreSQLParser.SHARE - 304)) | (1 << (PostgreSQLParser.SHOW - 304)) | (1 << (PostgreSQLParser.SIMPLE - 304)) | (1 << (PostgreSQLParser.SNAPSHOT - 304)) | (1 << (PostgreSQLParser.STABLE - 304)) | (1 << (PostgreSQLParser.STANDALONE_P - 304)) | (1 << (PostgreSQLParser.START - 304)) | (1 << (PostgreSQLParser.STATEMENT - 304)) | (1 << (PostgreSQLParser.STATISTICS - 304)) | (1 << (PostgreSQLParser.STDIN - 304)) | (1 << (PostgreSQLParser.STDOUT - 304)))) !== 0) || ((((_la - 336)) & ~0x1F) === 0 && ((1 << (_la - 336)) & ((1 << (PostgreSQLParser.STORAGE - 336)) | (1 << (PostgreSQLParser.STRICT_P - 336)) | (1 << (PostgreSQLParser.STRIP_P - 336)) | (1 << (PostgreSQLParser.SYSID - 336)) | (1 << (PostgreSQLParser.SYSTEM_P - 336)) | (1 << (PostgreSQLParser.TABLES - 336)) | (1 << (PostgreSQLParser.TABLESPACE - 336)) | (1 << (PostgreSQLParser.TEMP - 336)) | (1 << (PostgreSQLParser.TEMPLATE - 336)) | (1 << (PostgreSQLParser.TEMPORARY - 336)) | (1 << (PostgreSQLParser.TEXT_P - 336)) | (1 << (PostgreSQLParser.TRANSACTION - 336)) | (1 << (PostgreSQLParser.TRIGGER - 336)) | (1 << (PostgreSQLParser.TRUNCATE - 336)) | (1 << (PostgreSQLParser.TRUSTED - 336)) | (1 << (PostgreSQLParser.TYPE_P - 336)) | (1 << (PostgreSQLParser.TYPES_P - 336)) | (1 << (PostgreSQLParser.UNBOUNDED - 336)) | (1 << (PostgreSQLParser.UNCOMMITTED - 336)) | (1 << (PostgreSQLParser.UNENCRYPTED - 336)) | (1 << (PostgreSQLParser.UNKNOWN - 336)) | (1 << (PostgreSQLParser.UNLISTEN - 336)) | (1 << (PostgreSQLParser.UNLOGGED - 336)) | (1 << (PostgreSQLParser.UNTIL - 336)) | (1 << (PostgreSQLParser.UPDATE - 336)) | (1 << (PostgreSQLParser.VACUUM - 336)) | (1 << (PostgreSQLParser.VALID - 336)) | (1 << (PostgreSQLParser.VALIDATE - 336)) | (1 << (PostgreSQLParser.VALIDATOR - 336)) | (1 << (PostgreSQLParser.VARYING - 336)) | (1 << (PostgreSQLParser.VERSION_P - 336)) | (1 << (PostgreSQLParser.VIEW - 336)))) !== 0) || ((((_la - 368)) & ~0x1F) === 0 && ((1 << (_la - 368)) & ((1 << (PostgreSQLParser.VOLATILE - 368)) | (1 << (PostgreSQLParser.WHITESPACE_P - 368)) | (1 << (PostgreSQLParser.WITHOUT - 368)) | (1 << (PostgreSQLParser.WORK - 368)) | (1 << (PostgreSQLParser.WRAPPER - 368)) | (1 << (PostgreSQLParser.WRITE - 368)) | (1 << (PostgreSQLParser.XML_P - 368)) | (1 << (PostgreSQLParser.YEAR_P - 368)) | (1 << (PostgreSQLParser.YES_P - 368)) | (1 << (PostgreSQLParser.ZONE - 368)) | (1 << (PostgreSQLParser.BETWEEN - 368)) | (1 << (PostgreSQLParser.BIGINT - 368)) | (1 << (PostgreSQLParser.BIT - 368)) | (1 << (PostgreSQLParser.BOOLEAN_P - 368)) | (1 << (PostgreSQLParser.CHAR_P - 368)) | (1 << (PostgreSQLParser.CHARACTER - 368)) | (1 << (PostgreSQLParser.COALESCE - 368)) | (1 << (PostgreSQLParser.DEC - 368)) | (1 << (PostgreSQLParser.DECIMAL_P - 368)) | (1 << (PostgreSQLParser.EXISTS - 368)) | (1 << (PostgreSQLParser.EXTRACT - 368)) | (1 << (PostgreSQLParser.FLOAT_P - 368)) | (1 << (PostgreSQLParser.GREATEST - 368)) | (1 << (PostgreSQLParser.INOUT - 368)) | (1 << (PostgreSQLParser.INT_P - 368)) | (1 << (PostgreSQLParser.INTEGER - 368)) | (1 << (PostgreSQLParser.INTERVAL - 368)) | (1 << (PostgreSQLParser.LEAST - 368)) | (1 << (PostgreSQLParser.NATIONAL - 368)) | (1 << (PostgreSQLParser.NCHAR - 368)) | (1 << (PostgreSQLParser.NONE - 368)) | (1 << (PostgreSQLParser.NULLIF - 368)))) !== 0) || ((((_la - 400)) & ~0x1F) === 0 && ((1 << (_la - 400)) & ((1 << (PostgreSQLParser.NUMERIC - 400)) | (1 << (PostgreSQLParser.OVERLAY - 400)) | (1 << (PostgreSQLParser.POSITION - 400)) | (1 << (PostgreSQLParser.PRECISION - 400)) | (1 << (PostgreSQLParser.REAL - 400)) | (1 << (PostgreSQLParser.ROW - 400)) | (1 << (PostgreSQLParser.SETOF - 400)) | (1 << (PostgreSQLParser.SMALLINT - 400)) | (1 << (PostgreSQLParser.SUBSTRING - 400)) | (1 << (PostgreSQLParser.TIME - 400)) | (1 << (PostgreSQLParser.TIMESTAMP - 400)) | (1 << (PostgreSQLParser.TREAT - 400)) | (1 << (PostgreSQLParser.TRIM - 400)) | (1 << (PostgreSQLParser.VALUES - 400)) | (1 << (PostgreSQLParser.VARCHAR - 400)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 400)) | (1 << (PostgreSQLParser.XMLCONCAT - 400)) | (1 << (PostgreSQLParser.XMLELEMENT - 400)) | (1 << (PostgreSQLParser.XMLEXISTS - 400)) | (1 << (PostgreSQLParser.XMLFOREST - 400)) | (1 << (PostgreSQLParser.XMLPARSE - 400)) | (1 << (PostgreSQLParser.XMLPI - 400)) | (1 << (PostgreSQLParser.XMLROOT - 400)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 400)) | (1 << (PostgreSQLParser.CALL - 400)) | (1 << (PostgreSQLParser.CURRENT_P - 400)) | (1 << (PostgreSQLParser.ATTACH - 400)) | (1 << (PostgreSQLParser.DETACH - 400)) | (1 << (PostgreSQLParser.EXPRESSION - 400)) | (1 << (PostgreSQLParser.GENERATED - 400)) | (1 << (PostgreSQLParser.LOGGED - 400)) | (1 << (PostgreSQLParser.STORED - 400)))) !== 0) || ((((_la - 432)) & ~0x1F) === 0 && ((1 << (_la - 432)) & ((1 << (PostgreSQLParser.INCLUDE - 432)) | (1 << (PostgreSQLParser.ROUTINE - 432)) | (1 << (PostgreSQLParser.TRANSFORM - 432)) | (1 << (PostgreSQLParser.IMPORT_P - 432)) | (1 << (PostgreSQLParser.POLICY - 432)) | (1 << (PostgreSQLParser.METHOD - 432)) | (1 << (PostgreSQLParser.REFERENCING - 432)) | (1 << (PostgreSQLParser.NEW - 432)) | (1 << (PostgreSQLParser.OLD - 432)) | (1 << (PostgreSQLParser.VALUE_P - 432)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 432)) | (1 << (PostgreSQLParser.PUBLICATION - 432)) | (1 << (PostgreSQLParser.OUT_P - 432)) | (1 << (PostgreSQLParser.ROUTINES - 432)) | (1 << (PostgreSQLParser.SCHEMAS - 432)) | (1 << (PostgreSQLParser.PROCEDURES - 432)) | (1 << (PostgreSQLParser.INPUT_P - 432)) | (1 << (PostgreSQLParser.SUPPORT - 432)) | (1 << (PostgreSQLParser.PARALLEL - 432)) | (1 << (PostgreSQLParser.SQL_P - 432)) | (1 << (PostgreSQLParser.DEPENDS - 432)) | (1 << (PostgreSQLParser.OVERRIDING - 432)) | (1 << (PostgreSQLParser.CONFLICT - 432)) | (1 << (PostgreSQLParser.SKIP_P - 432)) | (1 << (PostgreSQLParser.LOCKED - 432)) | (1 << (PostgreSQLParser.TIES - 432)) | (1 << (PostgreSQLParser.ROLLUP - 432)) | (1 << (PostgreSQLParser.CUBE - 432)) | (1 << (PostgreSQLParser.GROUPING - 432)) | (1 << (PostgreSQLParser.SETS - 432)) | (1 << (PostgreSQLParser.TABLESAMPLE - 432)))) !== 0) || ((((_la - 464)) & ~0x1F) === 0 && ((1 << (_la - 464)) & ((1 << (PostgreSQLParser.ORDINALITY - 464)) | (1 << (PostgreSQLParser.XMLTABLE - 464)) | (1 << (PostgreSQLParser.COLUMNS - 464)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 464)) | (1 << (PostgreSQLParser.ROWTYPE - 464)) | (1 << (PostgreSQLParser.NORMALIZED - 464)) | (1 << (PostgreSQLParser.WITHIN - 464)) | (1 << (PostgreSQLParser.FILTER - 464)) | (1 << (PostgreSQLParser.GROUPS - 464)) | (1 << (PostgreSQLParser.OTHERS - 464)) | (1 << (PostgreSQLParser.NFC - 464)) | (1 << (PostgreSQLParser.NFD - 464)) | (1 << (PostgreSQLParser.NFKC - 464)) | (1 << (PostgreSQLParser.NFKD - 464)) | (1 << (PostgreSQLParser.UESCAPE - 464)) | (1 << (PostgreSQLParser.VIEWS - 464)) | (1 << (PostgreSQLParser.NORMALIZE - 464)) | (1 << (PostgreSQLParser.DUMP - 464)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 464)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 464)) | (1 << (PostgreSQLParser.ERROR - 464)) | (1 << (PostgreSQLParser.USE_VARIABLE - 464)) | (1 << (PostgreSQLParser.USE_COLUMN - 464)) | (1 << (PostgreSQLParser.ALIAS - 464)) | (1 << (PostgreSQLParser.CONSTANT - 464)) | (1 << (PostgreSQLParser.PERFORM - 464)) | (1 << (PostgreSQLParser.GET - 464)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 464)) | (1 << (PostgreSQLParser.STACKED - 464)) | (1 << (PostgreSQLParser.ELSIF - 464)) | (1 << (PostgreSQLParser.REVERSE - 464)))) !== 0) || ((((_la - 497)) & ~0x1F) === 0 && ((1 << (_la - 497)) & ((1 << (PostgreSQLParser.SLICE - 497)) | (1 << (PostgreSQLParser.EXIT - 497)) | (1 << (PostgreSQLParser.RETURN - 497)) | (1 << (PostgreSQLParser.QUERY - 497)) | (1 << (PostgreSQLParser.RAISE - 497)) | (1 << (PostgreSQLParser.SQLSTATE - 497)) | (1 << (PostgreSQLParser.DEBUG - 497)) | (1 << (PostgreSQLParser.LOG - 497)) | (1 << (PostgreSQLParser.INFO - 497)) | (1 << (PostgreSQLParser.NOTICE - 497)) | (1 << (PostgreSQLParser.WARNING - 497)) | (1 << (PostgreSQLParser.EXCEPTION - 497)) | (1 << (PostgreSQLParser.ASSERT - 497)) | (1 << (PostgreSQLParser.OPEN - 497)) | (1 << (PostgreSQLParser.Identifier - 497)) | (1 << (PostgreSQLParser.QuotedIdentifier - 497)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 497)) | (1 << (PostgreSQLParser.StringConstant - 497)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 497)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 497)))) !== 0) || ((((_la - 534)) & ~0x1F) === 0 && ((1 << (_la - 534)) & ((1 << (PostgreSQLParser.Integral - 534)) | (1 << (PostgreSQLParser.Numeric - 534)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 534)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 534)) | (1 << (PostgreSQLParser.EscapeStringConstant - 534)))) !== 0)) { + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << PostgreSQLParser.OPEN_PAREN) | (1 << PostgreSQLParser.STAR) | (1 << PostgreSQLParser.PLUS) | (1 << PostgreSQLParser.MINUS))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & ((1 << (PostgreSQLParser.KW_ON - 80)) | (1 << (PostgreSQLParser.KW_TABLE - 80)) | (1 << (PostgreSQLParser.KW_TRUE - 80)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 80)) | (1 << (PostgreSQLParser.KW_BINARY - 80)) | (1 << (PostgreSQLParser.KW_COLLATION - 80)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 80)) | (1 << (PostgreSQLParser.KW_CROSS - 80)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 80)))) !== 0) || ((((_la - 112)) & ~0x1F) === 0 && ((1 << (_la - 112)) & ((1 << (PostgreSQLParser.KW_FREEZE - 112)) | (1 << (PostgreSQLParser.KW_FULL - 112)) | (1 << (PostgreSQLParser.KW_ILIKE - 112)) | (1 << (PostgreSQLParser.KW_INNER - 112)) | (1 << (PostgreSQLParser.KW_IS - 112)) | (1 << (PostgreSQLParser.KW_ISNULL - 112)) | (1 << (PostgreSQLParser.KW_JOIN - 112)) | (1 << (PostgreSQLParser.KW_LEFT - 112)) | (1 << (PostgreSQLParser.KW_LIKE - 112)) | (1 << (PostgreSQLParser.KW_NATURAL - 112)) | (1 << (PostgreSQLParser.KW_NOTNULL - 112)) | (1 << (PostgreSQLParser.KW_OUTER - 112)) | (1 << (PostgreSQLParser.KW_OVER - 112)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 112)) | (1 << (PostgreSQLParser.KW_RIGHT - 112)) | (1 << (PostgreSQLParser.KW_SIMILAR - 112)) | (1 << (PostgreSQLParser.KW_VERBOSE - 112)) | (1 << (PostgreSQLParser.KW_ABORT - 112)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 112)) | (1 << (PostgreSQLParser.KW_ACCESS - 112)) | (1 << (PostgreSQLParser.KW_ACTION - 112)) | (1 << (PostgreSQLParser.KW_ADD - 112)) | (1 << (PostgreSQLParser.KW_ADMIN - 112)) | (1 << (PostgreSQLParser.KW_AFTER - 112)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 112)) | (1 << (PostgreSQLParser.KW_ALSO - 112)) | (1 << (PostgreSQLParser.KW_ALTER - 112)) | (1 << (PostgreSQLParser.KW_ALWAYS - 112)) | (1 << (PostgreSQLParser.KW_ASSERTION - 112)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 112)) | (1 << (PostgreSQLParser.KW_AT - 112)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 112)))) !== 0) || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & ((1 << (PostgreSQLParser.KW_BACKWARD - 144)) | (1 << (PostgreSQLParser.KW_BEFORE - 144)) | (1 << (PostgreSQLParser.KW_BEGIN - 144)) | (1 << (PostgreSQLParser.KW_BY - 144)) | (1 << (PostgreSQLParser.KW_CACHE - 144)) | (1 << (PostgreSQLParser.KW_CALLED - 144)) | (1 << (PostgreSQLParser.KW_CASCADE - 144)) | (1 << (PostgreSQLParser.KW_CASCADED - 144)) | (1 << (PostgreSQLParser.KW_CATALOG - 144)) | (1 << (PostgreSQLParser.KW_CHAIN - 144)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 144)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 144)) | (1 << (PostgreSQLParser.KW_CLASS - 144)) | (1 << (PostgreSQLParser.KW_CLOSE - 144)) | (1 << (PostgreSQLParser.KW_CLUSTER - 144)) | (1 << (PostgreSQLParser.KW_COMMENT - 144)) | (1 << (PostgreSQLParser.KW_COMMENTS - 144)) | (1 << (PostgreSQLParser.KW_COMMIT - 144)) | (1 << (PostgreSQLParser.KW_COMMITTED - 144)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 144)) | (1 << (PostgreSQLParser.KW_CONNECTION - 144)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 144)) | (1 << (PostgreSQLParser.KW_CONTENT - 144)) | (1 << (PostgreSQLParser.KW_CONTINUE - 144)) | (1 << (PostgreSQLParser.KW_CONVERSION - 144)) | (1 << (PostgreSQLParser.KW_COPY - 144)) | (1 << (PostgreSQLParser.KW_COST - 144)) | (1 << (PostgreSQLParser.KW_CSV - 144)) | (1 << (PostgreSQLParser.KW_CURSOR - 144)) | (1 << (PostgreSQLParser.KW_CYCLE - 144)) | (1 << (PostgreSQLParser.KW_DATA - 144)) | (1 << (PostgreSQLParser.KW_DATABASE - 144)))) !== 0) || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (PostgreSQLParser.KW_DAY - 176)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 176)) | (1 << (PostgreSQLParser.KW_DECLARE - 176)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 176)) | (1 << (PostgreSQLParser.KW_DEFERRED - 176)) | (1 << (PostgreSQLParser.KW_DEFINER - 176)) | (1 << (PostgreSQLParser.KW_DELETE - 176)) | (1 << (PostgreSQLParser.KW_DELIMITER - 176)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 176)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 176)) | (1 << (PostgreSQLParser.KW_DISABLE - 176)) | (1 << (PostgreSQLParser.KW_DISCARD - 176)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 176)) | (1 << (PostgreSQLParser.KW_DOMAIN - 176)) | (1 << (PostgreSQLParser.KW_DOUBLE - 176)) | (1 << (PostgreSQLParser.KW_DROP - 176)) | (1 << (PostgreSQLParser.KW_EACH - 176)) | (1 << (PostgreSQLParser.KW_ENABLE - 176)) | (1 << (PostgreSQLParser.KW_ENCODING - 176)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 176)) | (1 << (PostgreSQLParser.KW_ENUM - 176)) | (1 << (PostgreSQLParser.KW_ESCAPE - 176)) | (1 << (PostgreSQLParser.KW_EVENT - 176)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 176)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 176)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 176)) | (1 << (PostgreSQLParser.KW_EXECUTE - 176)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 176)) | (1 << (PostgreSQLParser.KW_EXTENSION - 176)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 176)) | (1 << (PostgreSQLParser.KW_FAMILY - 176)) | (1 << (PostgreSQLParser.KW_FIRST - 176)))) !== 0) || ((((_la - 208)) & ~0x1F) === 0 && ((1 << (_la - 208)) & ((1 << (PostgreSQLParser.KW_FOLLOWING - 208)) | (1 << (PostgreSQLParser.KW_FORCE - 208)) | (1 << (PostgreSQLParser.KW_FORWARD - 208)) | (1 << (PostgreSQLParser.KW_FUNCTION - 208)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 208)) | (1 << (PostgreSQLParser.KW_GLOBAL - 208)) | (1 << (PostgreSQLParser.KW_GRANTED - 208)) | (1 << (PostgreSQLParser.KW_HANDLER - 208)) | (1 << (PostgreSQLParser.KW_HEADER - 208)) | (1 << (PostgreSQLParser.KW_HOLD - 208)) | (1 << (PostgreSQLParser.KW_HOUR - 208)) | (1 << (PostgreSQLParser.KW_IDENTITY - 208)) | (1 << (PostgreSQLParser.KW_IF - 208)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 208)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 208)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 208)) | (1 << (PostgreSQLParser.KW_INCLUDING - 208)) | (1 << (PostgreSQLParser.KW_INCREMENT - 208)) | (1 << (PostgreSQLParser.KW_INDEX - 208)) | (1 << (PostgreSQLParser.KW_INDEXES - 208)) | (1 << (PostgreSQLParser.KW_INHERIT - 208)) | (1 << (PostgreSQLParser.KW_INHERITS - 208)) | (1 << (PostgreSQLParser.KW_INLINE - 208)))) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.KW_INSENSITIVE - 240)) | (1 << (PostgreSQLParser.KW_INSERT - 240)) | (1 << (PostgreSQLParser.KW_INSTEAD - 240)) | (1 << (PostgreSQLParser.KW_INVOKER - 240)) | (1 << (PostgreSQLParser.KW_ISOLATION - 240)) | (1 << (PostgreSQLParser.KW_KEY - 240)) | (1 << (PostgreSQLParser.KW_LABEL - 240)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 240)) | (1 << (PostgreSQLParser.KW_LARGE - 240)) | (1 << (PostgreSQLParser.KW_LAST - 240)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 240)) | (1 << (PostgreSQLParser.KW_LEVEL - 240)) | (1 << (PostgreSQLParser.KW_LISTEN - 240)) | (1 << (PostgreSQLParser.KW_LOAD - 240)) | (1 << (PostgreSQLParser.KW_LOCAL - 240)) | (1 << (PostgreSQLParser.KW_LOCATION - 240)) | (1 << (PostgreSQLParser.KW_LOCK - 240)) | (1 << (PostgreSQLParser.KW_MAPPING - 240)) | (1 << (PostgreSQLParser.KW_MATCH - 240)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 240)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 240)) | (1 << (PostgreSQLParser.KW_MINUTE - 240)) | (1 << (PostgreSQLParser.KW_MINVALUE - 240)) | (1 << (PostgreSQLParser.KW_MODE - 240)) | (1 << (PostgreSQLParser.KW_MONTH - 240)) | (1 << (PostgreSQLParser.KW_MOVE - 240)) | (1 << (PostgreSQLParser.KW_NAME - 240)) | (1 << (PostgreSQLParser.KW_NAMES - 240)) | (1 << (PostgreSQLParser.KW_NEXT - 240)) | (1 << (PostgreSQLParser.KW_NO - 240)) | (1 << (PostgreSQLParser.KW_NOTHING - 240)) | (1 << (PostgreSQLParser.KW_NOTIFY - 240)))) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & ((1 << (PostgreSQLParser.KW_NOWAIT - 272)) | (1 << (PostgreSQLParser.KW_NULLS - 272)) | (1 << (PostgreSQLParser.KW_OBJECT - 272)) | (1 << (PostgreSQLParser.KW_OF - 272)) | (1 << (PostgreSQLParser.KW_OFF - 272)) | (1 << (PostgreSQLParser.KW_OIDS - 272)) | (1 << (PostgreSQLParser.KW_OPERATOR - 272)) | (1 << (PostgreSQLParser.KW_OPTION - 272)) | (1 << (PostgreSQLParser.KW_OPTIONS - 272)) | (1 << (PostgreSQLParser.KW_OWNED - 272)) | (1 << (PostgreSQLParser.KW_OWNER - 272)) | (1 << (PostgreSQLParser.KW_PARSER - 272)) | (1 << (PostgreSQLParser.KW_PARTIAL - 272)) | (1 << (PostgreSQLParser.KW_PARTITION - 272)) | (1 << (PostgreSQLParser.KW_PASSING - 272)) | (1 << (PostgreSQLParser.KW_PASSWORD - 272)) | (1 << (PostgreSQLParser.KW_PLANS - 272)) | (1 << (PostgreSQLParser.KW_PRECEDING - 272)) | (1 << (PostgreSQLParser.KW_PREPARE - 272)) | (1 << (PostgreSQLParser.KW_PREPARED - 272)) | (1 << (PostgreSQLParser.KW_PRESERVE - 272)) | (1 << (PostgreSQLParser.KW_PRIOR - 272)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 272)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 272)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 272)) | (1 << (PostgreSQLParser.KW_PROGRAM - 272)) | (1 << (PostgreSQLParser.KW_QUOTE - 272)) | (1 << (PostgreSQLParser.KW_RANGE - 272)) | (1 << (PostgreSQLParser.KW_READ - 272)) | (1 << (PostgreSQLParser.KW_REASSIGN - 272)) | (1 << (PostgreSQLParser.KW_RECHECK - 272)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 272)))) !== 0) || ((((_la - 304)) & ~0x1F) === 0 && ((1 << (_la - 304)) & ((1 << (PostgreSQLParser.KW_REF - 304)) | (1 << (PostgreSQLParser.KW_REFRESH - 304)) | (1 << (PostgreSQLParser.KW_REINDEX - 304)) | (1 << (PostgreSQLParser.KW_RELATIVE - 304)) | (1 << (PostgreSQLParser.KW_RELEASE - 304)) | (1 << (PostgreSQLParser.KW_RENAME - 304)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 304)) | (1 << (PostgreSQLParser.KW_REPLACE - 304)) | (1 << (PostgreSQLParser.KW_REPLICA - 304)) | (1 << (PostgreSQLParser.KW_RESET - 304)) | (1 << (PostgreSQLParser.KW_RESTART - 304)) | (1 << (PostgreSQLParser.KW_RESTRICT - 304)) | (1 << (PostgreSQLParser.KW_RETURNS - 304)) | (1 << (PostgreSQLParser.KW_REVOKE - 304)) | (1 << (PostgreSQLParser.KW_ROLE - 304)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 304)) | (1 << (PostgreSQLParser.KW_ROWS - 304)) | (1 << (PostgreSQLParser.KW_RULE - 304)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 304)) | (1 << (PostgreSQLParser.KW_SCHEMA - 304)) | (1 << (PostgreSQLParser.KW_SCROLL - 304)) | (1 << (PostgreSQLParser.KW_SEARCH - 304)) | (1 << (PostgreSQLParser.KW_SECOND - 304)) | (1 << (PostgreSQLParser.KW_SECURITY - 304)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 304)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 304)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 304)) | (1 << (PostgreSQLParser.KW_SERVER - 304)) | (1 << (PostgreSQLParser.KW_SESSION - 304)) | (1 << (PostgreSQLParser.KW_SET - 304)) | (1 << (PostgreSQLParser.KW_SHARE - 304)) | (1 << (PostgreSQLParser.KW_SHOW - 304)))) !== 0) || ((((_la - 336)) & ~0x1F) === 0 && ((1 << (_la - 336)) & ((1 << (PostgreSQLParser.KW_SIMPLE - 336)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 336)) | (1 << (PostgreSQLParser.KW_STABLE - 336)) | (1 << (PostgreSQLParser.KW_STANDALONE - 336)) | (1 << (PostgreSQLParser.KW_START - 336)) | (1 << (PostgreSQLParser.KW_STATEMENT - 336)) | (1 << (PostgreSQLParser.KW_STATISTICS - 336)) | (1 << (PostgreSQLParser.KW_STDIN - 336)) | (1 << (PostgreSQLParser.KW_STDOUT - 336)) | (1 << (PostgreSQLParser.KW_STORAGE - 336)) | (1 << (PostgreSQLParser.KW_STRICT - 336)) | (1 << (PostgreSQLParser.KW_STRIP - 336)) | (1 << (PostgreSQLParser.KW_SYSID - 336)) | (1 << (PostgreSQLParser.KW_SYSTEM - 336)) | (1 << (PostgreSQLParser.KW_TABLES - 336)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 336)) | (1 << (PostgreSQLParser.KW_TEMP - 336)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 336)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 336)) | (1 << (PostgreSQLParser.KW_TEXT - 336)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 336)) | (1 << (PostgreSQLParser.KW_TRIGGER - 336)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 336)) | (1 << (PostgreSQLParser.KW_TRUSTED - 336)) | (1 << (PostgreSQLParser.KW_TYPE - 336)) | (1 << (PostgreSQLParser.KW_TYPES - 336)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 336)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 336)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 336)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 336)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 336)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 336)))) !== 0) || ((((_la - 368)) & ~0x1F) === 0 && ((1 << (_la - 368)) & ((1 << (PostgreSQLParser.KW_UNTIL - 368)) | (1 << (PostgreSQLParser.KW_UPDATE - 368)) | (1 << (PostgreSQLParser.KW_VACUUM - 368)) | (1 << (PostgreSQLParser.KW_VALID - 368)) | (1 << (PostgreSQLParser.KW_VALIDATE - 368)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 368)) | (1 << (PostgreSQLParser.KW_VARYING - 368)) | (1 << (PostgreSQLParser.KW_VERSION - 368)) | (1 << (PostgreSQLParser.KW_VIEW - 368)) | (1 << (PostgreSQLParser.KW_VOLATILE - 368)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 368)) | (1 << (PostgreSQLParser.KW_WITHOUT - 368)) | (1 << (PostgreSQLParser.KW_WORK - 368)) | (1 << (PostgreSQLParser.KW_WRAPPER - 368)) | (1 << (PostgreSQLParser.KW_WRITE - 368)) | (1 << (PostgreSQLParser.KW_XML - 368)) | (1 << (PostgreSQLParser.KW_YEAR - 368)) | (1 << (PostgreSQLParser.KW_YES - 368)) | (1 << (PostgreSQLParser.KW_ZONE - 368)) | (1 << (PostgreSQLParser.KW_BETWEEN - 368)) | (1 << (PostgreSQLParser.KW_BIGINT - 368)) | (1 << (PostgreSQLParser.KW_BIT - 368)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 368)) | (1 << (PostgreSQLParser.KW_CHAR - 368)) | (1 << (PostgreSQLParser.KW_CHARACTER - 368)) | (1 << (PostgreSQLParser.KW_COALESCE - 368)) | (1 << (PostgreSQLParser.KW_DEC - 368)) | (1 << (PostgreSQLParser.KW_DECIMAL - 368)) | (1 << (PostgreSQLParser.KW_EXISTS - 368)) | (1 << (PostgreSQLParser.KW_EXTRACT - 368)) | (1 << (PostgreSQLParser.KW_FLOAT - 368)) | (1 << (PostgreSQLParser.KW_GREATEST - 368)))) !== 0) || ((((_la - 400)) & ~0x1F) === 0 && ((1 << (_la - 400)) & ((1 << (PostgreSQLParser.KW_INOUT - 400)) | (1 << (PostgreSQLParser.KW_INT - 400)) | (1 << (PostgreSQLParser.KW_INTEGER - 400)) | (1 << (PostgreSQLParser.KW_INTERVAL - 400)) | (1 << (PostgreSQLParser.KW_LEAST - 400)) | (1 << (PostgreSQLParser.KW_NATIONAL - 400)) | (1 << (PostgreSQLParser.KW_NCHAR - 400)) | (1 << (PostgreSQLParser.KW_NONE - 400)) | (1 << (PostgreSQLParser.KW_NULLIF - 400)) | (1 << (PostgreSQLParser.KW_NUMERIC - 400)) | (1 << (PostgreSQLParser.KW_OVERLAY - 400)) | (1 << (PostgreSQLParser.KW_POSITION - 400)) | (1 << (PostgreSQLParser.KW_PRECISION - 400)) | (1 << (PostgreSQLParser.KW_REAL - 400)) | (1 << (PostgreSQLParser.KW_ROW - 400)) | (1 << (PostgreSQLParser.KW_SETOF - 400)) | (1 << (PostgreSQLParser.KW_SMALLINT - 400)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 400)) | (1 << (PostgreSQLParser.KW_TIME - 400)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 400)) | (1 << (PostgreSQLParser.KW_TREAT - 400)) | (1 << (PostgreSQLParser.KW_TRIM - 400)) | (1 << (PostgreSQLParser.KW_VALUES - 400)) | (1 << (PostgreSQLParser.KW_VARCHAR - 400)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 400)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 400)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 400)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 400)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 400)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 400)) | (1 << (PostgreSQLParser.KW_XMLPI - 400)) | (1 << (PostgreSQLParser.KW_XMLROOT - 400)))) !== 0) || ((((_la - 432)) & ~0x1F) === 0 && ((1 << (_la - 432)) & ((1 << (PostgreSQLParser.KW_XMLSERIALIZE - 432)) | (1 << (PostgreSQLParser.KW_CALL - 432)) | (1 << (PostgreSQLParser.KW_CURRENT - 432)) | (1 << (PostgreSQLParser.KW_ATTACH - 432)) | (1 << (PostgreSQLParser.KW_DETACH - 432)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 432)) | (1 << (PostgreSQLParser.KW_GENERATED - 432)) | (1 << (PostgreSQLParser.KW_LOGGED - 432)) | (1 << (PostgreSQLParser.KW_STORED - 432)) | (1 << (PostgreSQLParser.KW_INCLUDE - 432)) | (1 << (PostgreSQLParser.KW_ROUTINE - 432)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 432)) | (1 << (PostgreSQLParser.KW_IMPORT - 432)) | (1 << (PostgreSQLParser.KW_POLICY - 432)) | (1 << (PostgreSQLParser.KW_METHOD - 432)) | (1 << (PostgreSQLParser.KW_REFERENCING - 432)) | (1 << (PostgreSQLParser.KW_NEW - 432)) | (1 << (PostgreSQLParser.KW_OLD - 432)) | (1 << (PostgreSQLParser.KW_VALUE - 432)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 432)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 432)) | (1 << (PostgreSQLParser.KW_OUT - 432)) | (1 << (PostgreSQLParser.KW_ROUTINES - 432)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 432)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 432)) | (1 << (PostgreSQLParser.KW_INPUT - 432)) | (1 << (PostgreSQLParser.KW_SUPPORT - 432)) | (1 << (PostgreSQLParser.KW_PARALLEL - 432)) | (1 << (PostgreSQLParser.KW_SQL - 432)) | (1 << (PostgreSQLParser.KW_DEPENDS - 432)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 432)))) !== 0) || ((((_la - 464)) & ~0x1F) === 0 && ((1 << (_la - 464)) & ((1 << (PostgreSQLParser.KW_CONFLICT - 464)) | (1 << (PostgreSQLParser.KW_SKIP - 464)) | (1 << (PostgreSQLParser.KW_LOCKED - 464)) | (1 << (PostgreSQLParser.KW_TIES - 464)) | (1 << (PostgreSQLParser.KW_ROLLUP - 464)) | (1 << (PostgreSQLParser.KW_CUBE - 464)) | (1 << (PostgreSQLParser.KW_GROUPING - 464)) | (1 << (PostgreSQLParser.KW_SETS - 464)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 464)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 464)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 464)) | (1 << (PostgreSQLParser.KW_COLUMNS - 464)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 464)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 464)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 464)) | (1 << (PostgreSQLParser.KW_WITHIN - 464)) | (1 << (PostgreSQLParser.KW_FILTER - 464)) | (1 << (PostgreSQLParser.KW_GROUPS - 464)) | (1 << (PostgreSQLParser.KW_OTHERS - 464)) | (1 << (PostgreSQLParser.KW_NFC - 464)) | (1 << (PostgreSQLParser.KW_NFD - 464)) | (1 << (PostgreSQLParser.KW_NFKC - 464)) | (1 << (PostgreSQLParser.KW_NFKD - 464)) | (1 << (PostgreSQLParser.KW_UESCAPE - 464)) | (1 << (PostgreSQLParser.KW_VIEWS - 464)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 464)) | (1 << (PostgreSQLParser.KW_DUMP - 464)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 464)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 464)) | (1 << (PostgreSQLParser.KW_ERROR - 464)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 464)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 464)))) !== 0) || ((((_la - 496)) & ~0x1F) === 0 && ((1 << (_la - 496)) & ((1 << (PostgreSQLParser.KW_ALIAS - 496)) | (1 << (PostgreSQLParser.KW_CONSTANT - 496)) | (1 << (PostgreSQLParser.KW_PERFORM - 496)) | (1 << (PostgreSQLParser.KW_GET - 496)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 496)) | (1 << (PostgreSQLParser.KW_STACKED - 496)) | (1 << (PostgreSQLParser.KW_ELSIF - 496)) | (1 << (PostgreSQLParser.KW_REVERSE - 496)) | (1 << (PostgreSQLParser.KW_SLICE - 496)) | (1 << (PostgreSQLParser.KW_EXIT - 496)) | (1 << (PostgreSQLParser.KW_RETURN - 496)) | (1 << (PostgreSQLParser.KW_QUERY - 496)) | (1 << (PostgreSQLParser.KW_RAISE - 496)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 496)) | (1 << (PostgreSQLParser.KW_DEBUG - 496)) | (1 << (PostgreSQLParser.KW_LOG - 496)) | (1 << (PostgreSQLParser.KW_INFO - 496)) | (1 << (PostgreSQLParser.KW_NOTICE - 496)) | (1 << (PostgreSQLParser.KW_WARNING - 496)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 496)) | (1 << (PostgreSQLParser.KW_ASSERT - 496)) | (1 << (PostgreSQLParser.KW_OPEN - 496)) | (1 << (PostgreSQLParser.Identifier - 496)) | (1 << (PostgreSQLParser.QuotedIdentifier - 496)))) !== 0) || ((((_la - 530)) & ~0x1F) === 0 && ((1 << (_la - 530)) & ((1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 530)) | (1 << (PostgreSQLParser.StringConstant - 530)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 530)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 530)) | (1 << (PostgreSQLParser.Integral - 530)) | (1 << (PostgreSQLParser.Numeric - 530)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 530)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 530)) | (1 << (PostgreSQLParser.EscapeStringConstant - 530)))) !== 0)) { { - this.state = 2773; + this.state = 2803; this.copy_generic_opt_arg(); } } @@ -10779,423 +11341,423 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _localctx: Copy_generic_opt_argContext = new Copy_generic_opt_argContext(this._ctx, this.state); this.enterRule(_localctx, 164, PostgreSQLParser.RULE_copy_generic_opt_arg); try { - this.state = 2783; + this.state = 2813; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_ON: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -11207,7 +11769,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 2776; + this.state = 2806; this.opt_boolean_or_string(); } break; @@ -11217,25 +11779,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.Numeric: this.enterOuterAlt(_localctx, 2); { - this.state = 2777; + this.state = 2807; this.numericonly(); } break; case PostgreSQLParser.STAR: this.enterOuterAlt(_localctx, 3); { - this.state = 2778; + this.state = 2808; this.match(PostgreSQLParser.STAR); } break; case PostgreSQLParser.OPEN_PAREN: this.enterOuterAlt(_localctx, 4); { - this.state = 2779; + this.state = 2809; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2780; + this.state = 2810; this.copy_generic_opt_arg_list(); - this.state = 2781; + this.state = 2811; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -11265,21 +11827,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2785; + this.state = 2815; this.copy_generic_opt_arg_list_item(); - this.state = 2790; + this.state = 2820; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 2786; + this.state = 2816; this.match(PostgreSQLParser.COMMA); - this.state = 2787; + this.state = 2817; this.copy_generic_opt_arg_list_item(); } } - this.state = 2792; + this.state = 2822; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -11306,7 +11868,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2793; + this.state = 2823; this.opt_boolean_or_string(); } } @@ -11332,251 +11894,251 @@ export class PostgreSQLParser extends PostgreSQLParserBase { try { this.enterOuterAlt(_localctx, 1); { - this.state = 2795; - this.match(PostgreSQLParser.CREATE); - this.state = 2797; + this.state = 2825; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 2827; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GLOBAL || _la === PostgreSQLParser.LOCAL || ((((_la - 343)) & ~0x1F) === 0 && ((1 << (_la - 343)) & ((1 << (PostgreSQLParser.TEMP - 343)) | (1 << (PostgreSQLParser.TEMPORARY - 343)) | (1 << (PostgreSQLParser.UNLOGGED - 343)))) !== 0)) { + if (_la === PostgreSQLParser.KW_GLOBAL || _la === PostgreSQLParser.KW_LOCAL || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & ((1 << (PostgreSQLParser.KW_TEMP - 352)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 352)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 352)))) !== 0)) { { - this.state = 2796; + this.state = 2826; this.opttemp(); } } - this.state = 2799; - this.match(PostgreSQLParser.TABLE); - this.state = 2803; + this.state = 2829; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 2833; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 128, this._ctx) ) { case 1: { - this.state = 2800; - this.match(PostgreSQLParser.IF_P); - this.state = 2801; - this.match(PostgreSQLParser.NOT); - this.state = 2802; - this.match(PostgreSQLParser.EXISTS); + this.state = 2830; + this.match(PostgreSQLParser.KW_IF); + this.state = 2831; + this.match(PostgreSQLParser.KW_NOT); + this.state = 2832; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 2805; - this.qualified_name(); - this.state = 2871; + this.state = 2835; + this.table_qualified_name(); + this.state = 2901; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: { - this.state = 2806; + this.state = 2836; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2808; + this.state = 2838; 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.CHECK - 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)) | (1 << (PostgreSQLParser.FOREIGN - 33)))) !== 0) || ((((_la - 85)) & ~0x1F) === 0 && ((1 << (_la - 85)) & ((1 << (PostgreSQLParser.PRIMARY - 85)) | (1 << (PostgreSQLParser.TABLE - 85)) | (1 << (PostgreSQLParser.UNIQUE - 85)) | (1 << (PostgreSQLParser.IS - 85)))) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & ((1 << (PostgreSQLParser.LIKE - 120)) | (1 << (PostgreSQLParser.OUTER_P - 120)) | (1 << (PostgreSQLParser.OVER - 120)) | (1 << (PostgreSQLParser.ABORT_P - 120)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 120)) | (1 << (PostgreSQLParser.ACCESS - 120)) | (1 << (PostgreSQLParser.ACTION - 120)) | (1 << (PostgreSQLParser.ADD_P - 120)) | (1 << (PostgreSQLParser.ADMIN - 120)) | (1 << (PostgreSQLParser.AFTER - 120)) | (1 << (PostgreSQLParser.AGGREGATE - 120)) | (1 << (PostgreSQLParser.ALSO - 120)) | (1 << (PostgreSQLParser.ALTER - 120)) | (1 << (PostgreSQLParser.ALWAYS - 120)) | (1 << (PostgreSQLParser.ASSERTION - 120)) | (1 << (PostgreSQLParser.ASSIGNMENT - 120)) | (1 << (PostgreSQLParser.AT - 120)) | (1 << (PostgreSQLParser.ATTRIBUTE - 120)) | (1 << (PostgreSQLParser.BACKWARD - 120)) | (1 << (PostgreSQLParser.BEFORE - 120)) | (1 << (PostgreSQLParser.BEGIN_P - 120)) | (1 << (PostgreSQLParser.BY - 120)) | (1 << (PostgreSQLParser.CACHE - 120)) | (1 << (PostgreSQLParser.CALLED - 120)) | (1 << (PostgreSQLParser.CASCADE - 120)) | (1 << (PostgreSQLParser.CASCADED - 120)))) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & ((1 << (PostgreSQLParser.CATALOG - 152)) | (1 << (PostgreSQLParser.CHAIN - 152)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 152)) | (1 << (PostgreSQLParser.CHECKPOINT - 152)) | (1 << (PostgreSQLParser.CLASS - 152)) | (1 << (PostgreSQLParser.CLOSE - 152)) | (1 << (PostgreSQLParser.CLUSTER - 152)) | (1 << (PostgreSQLParser.COMMENT - 152)) | (1 << (PostgreSQLParser.COMMENTS - 152)) | (1 << (PostgreSQLParser.COMMIT - 152)) | (1 << (PostgreSQLParser.COMMITTED - 152)) | (1 << (PostgreSQLParser.CONFIGURATION - 152)) | (1 << (PostgreSQLParser.CONNECTION - 152)) | (1 << (PostgreSQLParser.CONSTRAINTS - 152)) | (1 << (PostgreSQLParser.CONTENT_P - 152)) | (1 << (PostgreSQLParser.CONTINUE_P - 152)) | (1 << (PostgreSQLParser.CONVERSION_P - 152)) | (1 << (PostgreSQLParser.COPY - 152)) | (1 << (PostgreSQLParser.COST - 152)) | (1 << (PostgreSQLParser.CSV - 152)) | (1 << (PostgreSQLParser.CURSOR - 152)) | (1 << (PostgreSQLParser.CYCLE - 152)) | (1 << (PostgreSQLParser.DATA_P - 152)) | (1 << (PostgreSQLParser.DATABASE - 152)) | (1 << (PostgreSQLParser.DAY_P - 152)) | (1 << (PostgreSQLParser.DEALLOCATE - 152)) | (1 << (PostgreSQLParser.DECLARE - 152)) | (1 << (PostgreSQLParser.DEFAULTS - 152)) | (1 << (PostgreSQLParser.DEFERRED - 152)) | (1 << (PostgreSQLParser.DEFINER - 152)) | (1 << (PostgreSQLParser.DELETE_P - 152)) | (1 << (PostgreSQLParser.DELIMITER - 152)))) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & ((1 << (PostgreSQLParser.DELIMITERS - 184)) | (1 << (PostgreSQLParser.DICTIONARY - 184)) | (1 << (PostgreSQLParser.DISABLE_P - 184)) | (1 << (PostgreSQLParser.DISCARD - 184)) | (1 << (PostgreSQLParser.DOCUMENT_P - 184)) | (1 << (PostgreSQLParser.DOMAIN_P - 184)) | (1 << (PostgreSQLParser.DOUBLE_P - 184)) | (1 << (PostgreSQLParser.DROP - 184)) | (1 << (PostgreSQLParser.EACH - 184)) | (1 << (PostgreSQLParser.ENABLE_P - 184)) | (1 << (PostgreSQLParser.ENCODING - 184)) | (1 << (PostgreSQLParser.ENCRYPTED - 184)) | (1 << (PostgreSQLParser.ENUM_P - 184)) | (1 << (PostgreSQLParser.ESCAPE - 184)) | (1 << (PostgreSQLParser.EVENT - 184)) | (1 << (PostgreSQLParser.EXCLUDE - 184)) | (1 << (PostgreSQLParser.EXCLUDING - 184)) | (1 << (PostgreSQLParser.EXCLUSIVE - 184)) | (1 << (PostgreSQLParser.EXECUTE - 184)) | (1 << (PostgreSQLParser.EXPLAIN - 184)) | (1 << (PostgreSQLParser.EXTENSION - 184)) | (1 << (PostgreSQLParser.EXTERNAL - 184)) | (1 << (PostgreSQLParser.FAMILY - 184)) | (1 << (PostgreSQLParser.FIRST_P - 184)) | (1 << (PostgreSQLParser.FOLLOWING - 184)) | (1 << (PostgreSQLParser.FORCE - 184)) | (1 << (PostgreSQLParser.FORWARD - 184)) | (1 << (PostgreSQLParser.FUNCTION - 184)) | (1 << (PostgreSQLParser.FUNCTIONS - 184)) | (1 << (PostgreSQLParser.GLOBAL - 184)) | (1 << (PostgreSQLParser.GRANTED - 184)) | (1 << (PostgreSQLParser.HANDLER - 184)))) !== 0) || ((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & ((1 << (PostgreSQLParser.HEADER_P - 216)) | (1 << (PostgreSQLParser.HOLD - 216)) | (1 << (PostgreSQLParser.HOUR_P - 216)) | (1 << (PostgreSQLParser.IDENTITY_P - 216)) | (1 << (PostgreSQLParser.IF_P - 216)) | (1 << (PostgreSQLParser.IMMEDIATE - 216)) | (1 << (PostgreSQLParser.IMMUTABLE - 216)) | (1 << (PostgreSQLParser.IMPLICIT_P - 216)) | (1 << (PostgreSQLParser.INCLUDING - 216)) | (1 << (PostgreSQLParser.INCREMENT - 216)) | (1 << (PostgreSQLParser.INDEX - 216)) | (1 << (PostgreSQLParser.INDEXES - 216)) | (1 << (PostgreSQLParser.INHERIT - 216)) | (1 << (PostgreSQLParser.INHERITS - 216)) | (1 << (PostgreSQLParser.INLINE_P - 216)) | (1 << (PostgreSQLParser.INSENSITIVE - 216)) | (1 << (PostgreSQLParser.INSERT - 216)) | (1 << (PostgreSQLParser.INSTEAD - 216)) | (1 << (PostgreSQLParser.INVOKER - 216)) | (1 << (PostgreSQLParser.ISOLATION - 216)) | (1 << (PostgreSQLParser.KEY - 216)) | (1 << (PostgreSQLParser.LABEL - 216)) | (1 << (PostgreSQLParser.LANGUAGE - 216)) | (1 << (PostgreSQLParser.LARGE_P - 216)) | (1 << (PostgreSQLParser.LAST_P - 216)) | (1 << (PostgreSQLParser.LEAKPROOF - 216)) | (1 << (PostgreSQLParser.LEVEL - 216)) | (1 << (PostgreSQLParser.LISTEN - 216)) | (1 << (PostgreSQLParser.LOAD - 216)) | (1 << (PostgreSQLParser.LOCAL - 216)) | (1 << (PostgreSQLParser.LOCATION - 216)) | (1 << (PostgreSQLParser.LOCK_P - 216)))) !== 0) || ((((_la - 248)) & ~0x1F) === 0 && ((1 << (_la - 248)) & ((1 << (PostgreSQLParser.MAPPING - 248)) | (1 << (PostgreSQLParser.MATCH - 248)) | (1 << (PostgreSQLParser.MATERIALIZED - 248)) | (1 << (PostgreSQLParser.MAXVALUE - 248)) | (1 << (PostgreSQLParser.MINUTE_P - 248)) | (1 << (PostgreSQLParser.MINVALUE - 248)) | (1 << (PostgreSQLParser.MODE - 248)) | (1 << (PostgreSQLParser.MONTH_P - 248)) | (1 << (PostgreSQLParser.MOVE - 248)) | (1 << (PostgreSQLParser.NAME_P - 248)) | (1 << (PostgreSQLParser.NAMES - 248)) | (1 << (PostgreSQLParser.NEXT - 248)) | (1 << (PostgreSQLParser.NO - 248)) | (1 << (PostgreSQLParser.NOTHING - 248)) | (1 << (PostgreSQLParser.NOTIFY - 248)) | (1 << (PostgreSQLParser.NOWAIT - 248)) | (1 << (PostgreSQLParser.NULLS_P - 248)) | (1 << (PostgreSQLParser.OBJECT_P - 248)) | (1 << (PostgreSQLParser.OF - 248)) | (1 << (PostgreSQLParser.OFF - 248)) | (1 << (PostgreSQLParser.OIDS - 248)) | (1 << (PostgreSQLParser.OPERATOR - 248)) | (1 << (PostgreSQLParser.OPTION - 248)) | (1 << (PostgreSQLParser.OPTIONS - 248)) | (1 << (PostgreSQLParser.OWNED - 248)) | (1 << (PostgreSQLParser.OWNER - 248)) | (1 << (PostgreSQLParser.PARSER - 248)) | (1 << (PostgreSQLParser.PARTIAL - 248)) | (1 << (PostgreSQLParser.PARTITION - 248)) | (1 << (PostgreSQLParser.PASSING - 248)) | (1 << (PostgreSQLParser.PASSWORD - 248)) | (1 << (PostgreSQLParser.PLANS - 248)))) !== 0) || ((((_la - 280)) & ~0x1F) === 0 && ((1 << (_la - 280)) & ((1 << (PostgreSQLParser.PRECEDING - 280)) | (1 << (PostgreSQLParser.PREPARE - 280)) | (1 << (PostgreSQLParser.PREPARED - 280)) | (1 << (PostgreSQLParser.PRESERVE - 280)) | (1 << (PostgreSQLParser.PRIOR - 280)) | (1 << (PostgreSQLParser.PRIVILEGES - 280)) | (1 << (PostgreSQLParser.PROCEDURAL - 280)) | (1 << (PostgreSQLParser.PROCEDURE - 280)) | (1 << (PostgreSQLParser.PROGRAM - 280)) | (1 << (PostgreSQLParser.QUOTE - 280)) | (1 << (PostgreSQLParser.RANGE - 280)) | (1 << (PostgreSQLParser.READ - 280)) | (1 << (PostgreSQLParser.REASSIGN - 280)) | (1 << (PostgreSQLParser.RECHECK - 280)) | (1 << (PostgreSQLParser.RECURSIVE - 280)) | (1 << (PostgreSQLParser.REF - 280)) | (1 << (PostgreSQLParser.REFRESH - 280)) | (1 << (PostgreSQLParser.REINDEX - 280)) | (1 << (PostgreSQLParser.RELATIVE_P - 280)) | (1 << (PostgreSQLParser.RELEASE - 280)) | (1 << (PostgreSQLParser.RENAME - 280)) | (1 << (PostgreSQLParser.REPEATABLE - 280)) | (1 << (PostgreSQLParser.REPLACE - 280)) | (1 << (PostgreSQLParser.REPLICA - 280)) | (1 << (PostgreSQLParser.RESET - 280)) | (1 << (PostgreSQLParser.RESTART - 280)) | (1 << (PostgreSQLParser.RESTRICT - 280)) | (1 << (PostgreSQLParser.RETURNS - 280)) | (1 << (PostgreSQLParser.REVOKE - 280)) | (1 << (PostgreSQLParser.ROLE - 280)) | (1 << (PostgreSQLParser.ROLLBACK - 280)) | (1 << (PostgreSQLParser.ROWS - 280)))) !== 0) || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & ((1 << (PostgreSQLParser.RULE - 312)) | (1 << (PostgreSQLParser.SAVEPOINT - 312)) | (1 << (PostgreSQLParser.SCHEMA - 312)) | (1 << (PostgreSQLParser.SCROLL - 312)) | (1 << (PostgreSQLParser.SEARCH - 312)) | (1 << (PostgreSQLParser.SECOND_P - 312)) | (1 << (PostgreSQLParser.SECURITY - 312)) | (1 << (PostgreSQLParser.SEQUENCE - 312)) | (1 << (PostgreSQLParser.SEQUENCES - 312)) | (1 << (PostgreSQLParser.SERIALIZABLE - 312)) | (1 << (PostgreSQLParser.SERVER - 312)) | (1 << (PostgreSQLParser.SESSION - 312)) | (1 << (PostgreSQLParser.SET - 312)) | (1 << (PostgreSQLParser.SHARE - 312)) | (1 << (PostgreSQLParser.SHOW - 312)) | (1 << (PostgreSQLParser.SIMPLE - 312)) | (1 << (PostgreSQLParser.SNAPSHOT - 312)) | (1 << (PostgreSQLParser.STABLE - 312)) | (1 << (PostgreSQLParser.STANDALONE_P - 312)) | (1 << (PostgreSQLParser.START - 312)) | (1 << (PostgreSQLParser.STATEMENT - 312)) | (1 << (PostgreSQLParser.STATISTICS - 312)) | (1 << (PostgreSQLParser.STDIN - 312)) | (1 << (PostgreSQLParser.STDOUT - 312)) | (1 << (PostgreSQLParser.STORAGE - 312)) | (1 << (PostgreSQLParser.STRICT_P - 312)) | (1 << (PostgreSQLParser.STRIP_P - 312)) | (1 << (PostgreSQLParser.SYSID - 312)) | (1 << (PostgreSQLParser.SYSTEM_P - 312)) | (1 << (PostgreSQLParser.TABLES - 312)) | (1 << (PostgreSQLParser.TABLESPACE - 312)) | (1 << (PostgreSQLParser.TEMP - 312)))) !== 0) || ((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & ((1 << (PostgreSQLParser.TEMPLATE - 344)) | (1 << (PostgreSQLParser.TEMPORARY - 344)) | (1 << (PostgreSQLParser.TEXT_P - 344)) | (1 << (PostgreSQLParser.TRANSACTION - 344)) | (1 << (PostgreSQLParser.TRIGGER - 344)) | (1 << (PostgreSQLParser.TRUNCATE - 344)) | (1 << (PostgreSQLParser.TRUSTED - 344)) | (1 << (PostgreSQLParser.TYPE_P - 344)) | (1 << (PostgreSQLParser.TYPES_P - 344)) | (1 << (PostgreSQLParser.UNBOUNDED - 344)) | (1 << (PostgreSQLParser.UNCOMMITTED - 344)) | (1 << (PostgreSQLParser.UNENCRYPTED - 344)) | (1 << (PostgreSQLParser.UNKNOWN - 344)) | (1 << (PostgreSQLParser.UNLISTEN - 344)) | (1 << (PostgreSQLParser.UNLOGGED - 344)) | (1 << (PostgreSQLParser.UNTIL - 344)) | (1 << (PostgreSQLParser.UPDATE - 344)) | (1 << (PostgreSQLParser.VACUUM - 344)) | (1 << (PostgreSQLParser.VALID - 344)) | (1 << (PostgreSQLParser.VALIDATE - 344)) | (1 << (PostgreSQLParser.VALIDATOR - 344)) | (1 << (PostgreSQLParser.VARYING - 344)) | (1 << (PostgreSQLParser.VERSION_P - 344)) | (1 << (PostgreSQLParser.VIEW - 344)) | (1 << (PostgreSQLParser.VOLATILE - 344)) | (1 << (PostgreSQLParser.WHITESPACE_P - 344)) | (1 << (PostgreSQLParser.WITHOUT - 344)) | (1 << (PostgreSQLParser.WORK - 344)) | (1 << (PostgreSQLParser.WRAPPER - 344)) | (1 << (PostgreSQLParser.WRITE - 344)) | (1 << (PostgreSQLParser.XML_P - 344)) | (1 << (PostgreSQLParser.YEAR_P - 344)))) !== 0) || ((((_la - 376)) & ~0x1F) === 0 && ((1 << (_la - 376)) & ((1 << (PostgreSQLParser.YES_P - 376)) | (1 << (PostgreSQLParser.ZONE - 376)) | (1 << (PostgreSQLParser.BETWEEN - 376)) | (1 << (PostgreSQLParser.BIGINT - 376)) | (1 << (PostgreSQLParser.BIT - 376)) | (1 << (PostgreSQLParser.BOOLEAN_P - 376)) | (1 << (PostgreSQLParser.CHAR_P - 376)) | (1 << (PostgreSQLParser.CHARACTER - 376)) | (1 << (PostgreSQLParser.COALESCE - 376)) | (1 << (PostgreSQLParser.DEC - 376)) | (1 << (PostgreSQLParser.DECIMAL_P - 376)) | (1 << (PostgreSQLParser.EXISTS - 376)) | (1 << (PostgreSQLParser.EXTRACT - 376)) | (1 << (PostgreSQLParser.FLOAT_P - 376)) | (1 << (PostgreSQLParser.GREATEST - 376)) | (1 << (PostgreSQLParser.INOUT - 376)) | (1 << (PostgreSQLParser.INT_P - 376)) | (1 << (PostgreSQLParser.INTEGER - 376)) | (1 << (PostgreSQLParser.INTERVAL - 376)) | (1 << (PostgreSQLParser.LEAST - 376)) | (1 << (PostgreSQLParser.NATIONAL - 376)) | (1 << (PostgreSQLParser.NCHAR - 376)) | (1 << (PostgreSQLParser.NONE - 376)) | (1 << (PostgreSQLParser.NULLIF - 376)) | (1 << (PostgreSQLParser.NUMERIC - 376)) | (1 << (PostgreSQLParser.OVERLAY - 376)) | (1 << (PostgreSQLParser.POSITION - 376)) | (1 << (PostgreSQLParser.PRECISION - 376)) | (1 << (PostgreSQLParser.REAL - 376)) | (1 << (PostgreSQLParser.ROW - 376)) | (1 << (PostgreSQLParser.SETOF - 376)) | (1 << (PostgreSQLParser.SMALLINT - 376)))) !== 0) || ((((_la - 408)) & ~0x1F) === 0 && ((1 << (_la - 408)) & ((1 << (PostgreSQLParser.SUBSTRING - 408)) | (1 << (PostgreSQLParser.TIME - 408)) | (1 << (PostgreSQLParser.TIMESTAMP - 408)) | (1 << (PostgreSQLParser.TREAT - 408)) | (1 << (PostgreSQLParser.TRIM - 408)) | (1 << (PostgreSQLParser.VALUES - 408)) | (1 << (PostgreSQLParser.VARCHAR - 408)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 408)) | (1 << (PostgreSQLParser.XMLCONCAT - 408)) | (1 << (PostgreSQLParser.XMLELEMENT - 408)) | (1 << (PostgreSQLParser.XMLEXISTS - 408)) | (1 << (PostgreSQLParser.XMLFOREST - 408)) | (1 << (PostgreSQLParser.XMLPARSE - 408)) | (1 << (PostgreSQLParser.XMLPI - 408)) | (1 << (PostgreSQLParser.XMLROOT - 408)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 408)) | (1 << (PostgreSQLParser.CALL - 408)) | (1 << (PostgreSQLParser.CURRENT_P - 408)) | (1 << (PostgreSQLParser.ATTACH - 408)) | (1 << (PostgreSQLParser.DETACH - 408)) | (1 << (PostgreSQLParser.EXPRESSION - 408)) | (1 << (PostgreSQLParser.GENERATED - 408)) | (1 << (PostgreSQLParser.LOGGED - 408)) | (1 << (PostgreSQLParser.STORED - 408)) | (1 << (PostgreSQLParser.INCLUDE - 408)) | (1 << (PostgreSQLParser.ROUTINE - 408)) | (1 << (PostgreSQLParser.TRANSFORM - 408)) | (1 << (PostgreSQLParser.IMPORT_P - 408)) | (1 << (PostgreSQLParser.POLICY - 408)) | (1 << (PostgreSQLParser.METHOD - 408)) | (1 << (PostgreSQLParser.REFERENCING - 408)) | (1 << (PostgreSQLParser.NEW - 408)))) !== 0) || ((((_la - 440)) & ~0x1F) === 0 && ((1 << (_la - 440)) & ((1 << (PostgreSQLParser.OLD - 440)) | (1 << (PostgreSQLParser.VALUE_P - 440)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 440)) | (1 << (PostgreSQLParser.PUBLICATION - 440)) | (1 << (PostgreSQLParser.OUT_P - 440)) | (1 << (PostgreSQLParser.ROUTINES - 440)) | (1 << (PostgreSQLParser.SCHEMAS - 440)) | (1 << (PostgreSQLParser.PROCEDURES - 440)) | (1 << (PostgreSQLParser.INPUT_P - 440)) | (1 << (PostgreSQLParser.SUPPORT - 440)) | (1 << (PostgreSQLParser.PARALLEL - 440)) | (1 << (PostgreSQLParser.SQL_P - 440)) | (1 << (PostgreSQLParser.DEPENDS - 440)) | (1 << (PostgreSQLParser.OVERRIDING - 440)) | (1 << (PostgreSQLParser.CONFLICT - 440)) | (1 << (PostgreSQLParser.SKIP_P - 440)) | (1 << (PostgreSQLParser.LOCKED - 440)) | (1 << (PostgreSQLParser.TIES - 440)) | (1 << (PostgreSQLParser.ROLLUP - 440)) | (1 << (PostgreSQLParser.CUBE - 440)) | (1 << (PostgreSQLParser.GROUPING - 440)) | (1 << (PostgreSQLParser.SETS - 440)) | (1 << (PostgreSQLParser.ORDINALITY - 440)) | (1 << (PostgreSQLParser.XMLTABLE - 440)) | (1 << (PostgreSQLParser.COLUMNS - 440)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 440)) | (1 << (PostgreSQLParser.ROWTYPE - 440)) | (1 << (PostgreSQLParser.NORMALIZED - 440)) | (1 << (PostgreSQLParser.WITHIN - 440)) | (1 << (PostgreSQLParser.FILTER - 440)))) !== 0) || ((((_la - 472)) & ~0x1F) === 0 && ((1 << (_la - 472)) & ((1 << (PostgreSQLParser.GROUPS - 472)) | (1 << (PostgreSQLParser.OTHERS - 472)) | (1 << (PostgreSQLParser.NFC - 472)) | (1 << (PostgreSQLParser.NFD - 472)) | (1 << (PostgreSQLParser.NFKC - 472)) | (1 << (PostgreSQLParser.NFKD - 472)) | (1 << (PostgreSQLParser.UESCAPE - 472)) | (1 << (PostgreSQLParser.VIEWS - 472)) | (1 << (PostgreSQLParser.NORMALIZE - 472)) | (1 << (PostgreSQLParser.DUMP - 472)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 472)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 472)) | (1 << (PostgreSQLParser.ERROR - 472)) | (1 << (PostgreSQLParser.USE_VARIABLE - 472)) | (1 << (PostgreSQLParser.USE_COLUMN - 472)) | (1 << (PostgreSQLParser.ALIAS - 472)) | (1 << (PostgreSQLParser.CONSTANT - 472)) | (1 << (PostgreSQLParser.PERFORM - 472)) | (1 << (PostgreSQLParser.GET - 472)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 472)) | (1 << (PostgreSQLParser.STACKED - 472)) | (1 << (PostgreSQLParser.ELSIF - 472)) | (1 << (PostgreSQLParser.REVERSE - 472)) | (1 << (PostgreSQLParser.SLICE - 472)) | (1 << (PostgreSQLParser.EXIT - 472)) | (1 << (PostgreSQLParser.RETURN - 472)) | (1 << (PostgreSQLParser.QUERY - 472)) | (1 << (PostgreSQLParser.RAISE - 472)) | (1 << (PostgreSQLParser.SQLSTATE - 472)) | (1 << (PostgreSQLParser.DEBUG - 472)))) !== 0) || ((((_la - 504)) & ~0x1F) === 0 && ((1 << (_la - 504)) & ((1 << (PostgreSQLParser.LOG - 504)) | (1 << (PostgreSQLParser.INFO - 504)) | (1 << (PostgreSQLParser.NOTICE - 504)) | (1 << (PostgreSQLParser.WARNING - 504)) | (1 << (PostgreSQLParser.EXCEPTION - 504)) | (1 << (PostgreSQLParser.ASSERT - 504)) | (1 << (PostgreSQLParser.OPEN - 504)) | (1 << (PostgreSQLParser.Identifier - 504)) | (1 << (PostgreSQLParser.QuotedIdentifier - 504)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 504)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CHECK - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)) | (1 << (PostgreSQLParser.KW_FOREIGN - 33)))) !== 0) || ((((_la - 85)) & ~0x1F) === 0 && ((1 << (_la - 85)) & ((1 << (PostgreSQLParser.KW_PRIMARY - 85)) | (1 << (PostgreSQLParser.KW_TABLE - 85)) | (1 << (PostgreSQLParser.KW_UNIQUE - 85)) | (1 << (PostgreSQLParser.KW_IS - 85)))) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & ((1 << (PostgreSQLParser.KW_LIKE - 120)) | (1 << (PostgreSQLParser.KW_OUTER - 120)) | (1 << (PostgreSQLParser.KW_OVER - 120)) | (1 << (PostgreSQLParser.KW_ABORT - 120)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 120)) | (1 << (PostgreSQLParser.KW_ACCESS - 120)) | (1 << (PostgreSQLParser.KW_ACTION - 120)) | (1 << (PostgreSQLParser.KW_ADD - 120)) | (1 << (PostgreSQLParser.KW_ADMIN - 120)) | (1 << (PostgreSQLParser.KW_AFTER - 120)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 120)) | (1 << (PostgreSQLParser.KW_ALSO - 120)) | (1 << (PostgreSQLParser.KW_ALTER - 120)) | (1 << (PostgreSQLParser.KW_ALWAYS - 120)) | (1 << (PostgreSQLParser.KW_ASSERTION - 120)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 120)) | (1 << (PostgreSQLParser.KW_AT - 120)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 120)) | (1 << (PostgreSQLParser.KW_BACKWARD - 120)) | (1 << (PostgreSQLParser.KW_BEFORE - 120)) | (1 << (PostgreSQLParser.KW_BEGIN - 120)) | (1 << (PostgreSQLParser.KW_BY - 120)) | (1 << (PostgreSQLParser.KW_CACHE - 120)) | (1 << (PostgreSQLParser.KW_CALLED - 120)) | (1 << (PostgreSQLParser.KW_CASCADE - 120)) | (1 << (PostgreSQLParser.KW_CASCADED - 120)))) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & ((1 << (PostgreSQLParser.KW_CATALOG - 152)) | (1 << (PostgreSQLParser.KW_CHAIN - 152)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 152)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 152)) | (1 << (PostgreSQLParser.KW_CLASS - 152)) | (1 << (PostgreSQLParser.KW_CLOSE - 152)) | (1 << (PostgreSQLParser.KW_CLUSTER - 152)) | (1 << (PostgreSQLParser.KW_COMMENT - 152)) | (1 << (PostgreSQLParser.KW_COMMENTS - 152)) | (1 << (PostgreSQLParser.KW_COMMIT - 152)) | (1 << (PostgreSQLParser.KW_COMMITTED - 152)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 152)) | (1 << (PostgreSQLParser.KW_CONNECTION - 152)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 152)) | (1 << (PostgreSQLParser.KW_CONTENT - 152)) | (1 << (PostgreSQLParser.KW_CONTINUE - 152)) | (1 << (PostgreSQLParser.KW_CONVERSION - 152)) | (1 << (PostgreSQLParser.KW_COPY - 152)) | (1 << (PostgreSQLParser.KW_COST - 152)) | (1 << (PostgreSQLParser.KW_CSV - 152)) | (1 << (PostgreSQLParser.KW_CURSOR - 152)) | (1 << (PostgreSQLParser.KW_CYCLE - 152)) | (1 << (PostgreSQLParser.KW_DATA - 152)) | (1 << (PostgreSQLParser.KW_DATABASE - 152)) | (1 << (PostgreSQLParser.KW_DAY - 152)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 152)) | (1 << (PostgreSQLParser.KW_DECLARE - 152)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 152)) | (1 << (PostgreSQLParser.KW_DEFERRED - 152)) | (1 << (PostgreSQLParser.KW_DEFINER - 152)) | (1 << (PostgreSQLParser.KW_DELETE - 152)) | (1 << (PostgreSQLParser.KW_DELIMITER - 152)))) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & ((1 << (PostgreSQLParser.KW_DELIMITERS - 184)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 184)) | (1 << (PostgreSQLParser.KW_DISABLE - 184)) | (1 << (PostgreSQLParser.KW_DISCARD - 184)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 184)) | (1 << (PostgreSQLParser.KW_DOMAIN - 184)) | (1 << (PostgreSQLParser.KW_DOUBLE - 184)) | (1 << (PostgreSQLParser.KW_DROP - 184)) | (1 << (PostgreSQLParser.KW_EACH - 184)) | (1 << (PostgreSQLParser.KW_ENABLE - 184)) | (1 << (PostgreSQLParser.KW_ENCODING - 184)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 184)) | (1 << (PostgreSQLParser.KW_ENUM - 184)) | (1 << (PostgreSQLParser.KW_ESCAPE - 184)) | (1 << (PostgreSQLParser.KW_EVENT - 184)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 184)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 184)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 184)) | (1 << (PostgreSQLParser.KW_EXECUTE - 184)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 184)) | (1 << (PostgreSQLParser.KW_EXTENSION - 184)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 184)) | (1 << (PostgreSQLParser.KW_FAMILY - 184)) | (1 << (PostgreSQLParser.KW_FIRST - 184)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 184)) | (1 << (PostgreSQLParser.KW_FORCE - 184)) | (1 << (PostgreSQLParser.KW_FORWARD - 184)) | (1 << (PostgreSQLParser.KW_FUNCTION - 184)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 184)) | (1 << (PostgreSQLParser.KW_GLOBAL - 184)) | (1 << (PostgreSQLParser.KW_GRANTED - 184)) | (1 << (PostgreSQLParser.KW_HANDLER - 184)))) !== 0) || ((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & ((1 << (PostgreSQLParser.KW_HEADER - 216)) | (1 << (PostgreSQLParser.KW_HOLD - 216)) | (1 << (PostgreSQLParser.KW_HOUR - 216)) | (1 << (PostgreSQLParser.KW_IDENTITY - 216)) | (1 << (PostgreSQLParser.KW_IF - 216)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 216)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 216)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 216)) | (1 << (PostgreSQLParser.KW_INCLUDING - 216)) | (1 << (PostgreSQLParser.KW_INCREMENT - 216)) | (1 << (PostgreSQLParser.KW_INDEX - 216)) | (1 << (PostgreSQLParser.KW_INDEXES - 216)) | (1 << (PostgreSQLParser.KW_INHERIT - 216)) | (1 << (PostgreSQLParser.KW_INHERITS - 216)) | (1 << (PostgreSQLParser.KW_INLINE - 216)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 216)) | (1 << (PostgreSQLParser.KW_INSERT - 216)) | (1 << (PostgreSQLParser.KW_INSTEAD - 216)) | (1 << (PostgreSQLParser.KW_INVOKER - 216)) | (1 << (PostgreSQLParser.KW_ISOLATION - 216)) | (1 << (PostgreSQLParser.KW_KEY - 216)) | (1 << (PostgreSQLParser.KW_LABEL - 216)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 216)))) !== 0) || ((((_la - 248)) & ~0x1F) === 0 && ((1 << (_la - 248)) & ((1 << (PostgreSQLParser.KW_LARGE - 248)) | (1 << (PostgreSQLParser.KW_LAST - 248)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 248)) | (1 << (PostgreSQLParser.KW_LEVEL - 248)) | (1 << (PostgreSQLParser.KW_LISTEN - 248)) | (1 << (PostgreSQLParser.KW_LOAD - 248)) | (1 << (PostgreSQLParser.KW_LOCAL - 248)) | (1 << (PostgreSQLParser.KW_LOCATION - 248)) | (1 << (PostgreSQLParser.KW_LOCK - 248)) | (1 << (PostgreSQLParser.KW_MAPPING - 248)) | (1 << (PostgreSQLParser.KW_MATCH - 248)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 248)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 248)) | (1 << (PostgreSQLParser.KW_MINUTE - 248)) | (1 << (PostgreSQLParser.KW_MINVALUE - 248)) | (1 << (PostgreSQLParser.KW_MODE - 248)) | (1 << (PostgreSQLParser.KW_MONTH - 248)) | (1 << (PostgreSQLParser.KW_MOVE - 248)) | (1 << (PostgreSQLParser.KW_NAME - 248)) | (1 << (PostgreSQLParser.KW_NAMES - 248)) | (1 << (PostgreSQLParser.KW_NEXT - 248)) | (1 << (PostgreSQLParser.KW_NO - 248)) | (1 << (PostgreSQLParser.KW_NOTHING - 248)) | (1 << (PostgreSQLParser.KW_NOTIFY - 248)) | (1 << (PostgreSQLParser.KW_NOWAIT - 248)) | (1 << (PostgreSQLParser.KW_NULLS - 248)) | (1 << (PostgreSQLParser.KW_OBJECT - 248)) | (1 << (PostgreSQLParser.KW_OF - 248)) | (1 << (PostgreSQLParser.KW_OFF - 248)) | (1 << (PostgreSQLParser.KW_OIDS - 248)) | (1 << (PostgreSQLParser.KW_OPERATOR - 248)) | (1 << (PostgreSQLParser.KW_OPTION - 248)))) !== 0) || ((((_la - 280)) & ~0x1F) === 0 && ((1 << (_la - 280)) & ((1 << (PostgreSQLParser.KW_OPTIONS - 280)) | (1 << (PostgreSQLParser.KW_OWNED - 280)) | (1 << (PostgreSQLParser.KW_OWNER - 280)) | (1 << (PostgreSQLParser.KW_PARSER - 280)) | (1 << (PostgreSQLParser.KW_PARTIAL - 280)) | (1 << (PostgreSQLParser.KW_PARTITION - 280)) | (1 << (PostgreSQLParser.KW_PASSING - 280)) | (1 << (PostgreSQLParser.KW_PASSWORD - 280)) | (1 << (PostgreSQLParser.KW_PLANS - 280)) | (1 << (PostgreSQLParser.KW_PRECEDING - 280)) | (1 << (PostgreSQLParser.KW_PREPARE - 280)) | (1 << (PostgreSQLParser.KW_PREPARED - 280)) | (1 << (PostgreSQLParser.KW_PRESERVE - 280)) | (1 << (PostgreSQLParser.KW_PRIOR - 280)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 280)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 280)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 280)) | (1 << (PostgreSQLParser.KW_PROGRAM - 280)) | (1 << (PostgreSQLParser.KW_QUOTE - 280)) | (1 << (PostgreSQLParser.KW_RANGE - 280)) | (1 << (PostgreSQLParser.KW_READ - 280)) | (1 << (PostgreSQLParser.KW_REASSIGN - 280)) | (1 << (PostgreSQLParser.KW_RECHECK - 280)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 280)) | (1 << (PostgreSQLParser.KW_REF - 280)) | (1 << (PostgreSQLParser.KW_REFRESH - 280)) | (1 << (PostgreSQLParser.KW_REINDEX - 280)) | (1 << (PostgreSQLParser.KW_RELATIVE - 280)) | (1 << (PostgreSQLParser.KW_RELEASE - 280)) | (1 << (PostgreSQLParser.KW_RENAME - 280)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 280)) | (1 << (PostgreSQLParser.KW_REPLACE - 280)))) !== 0) || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & ((1 << (PostgreSQLParser.KW_REPLICA - 312)) | (1 << (PostgreSQLParser.KW_RESET - 312)) | (1 << (PostgreSQLParser.KW_RESTART - 312)) | (1 << (PostgreSQLParser.KW_RESTRICT - 312)) | (1 << (PostgreSQLParser.KW_RETURNS - 312)) | (1 << (PostgreSQLParser.KW_REVOKE - 312)) | (1 << (PostgreSQLParser.KW_ROLE - 312)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 312)) | (1 << (PostgreSQLParser.KW_ROWS - 312)) | (1 << (PostgreSQLParser.KW_RULE - 312)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 312)) | (1 << (PostgreSQLParser.KW_SCHEMA - 312)) | (1 << (PostgreSQLParser.KW_SCROLL - 312)) | (1 << (PostgreSQLParser.KW_SEARCH - 312)) | (1 << (PostgreSQLParser.KW_SECOND - 312)) | (1 << (PostgreSQLParser.KW_SECURITY - 312)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 312)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 312)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 312)) | (1 << (PostgreSQLParser.KW_SERVER - 312)) | (1 << (PostgreSQLParser.KW_SESSION - 312)) | (1 << (PostgreSQLParser.KW_SET - 312)) | (1 << (PostgreSQLParser.KW_SHARE - 312)) | (1 << (PostgreSQLParser.KW_SHOW - 312)) | (1 << (PostgreSQLParser.KW_SIMPLE - 312)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 312)) | (1 << (PostgreSQLParser.KW_STABLE - 312)) | (1 << (PostgreSQLParser.KW_STANDALONE - 312)) | (1 << (PostgreSQLParser.KW_START - 312)) | (1 << (PostgreSQLParser.KW_STATEMENT - 312)) | (1 << (PostgreSQLParser.KW_STATISTICS - 312)) | (1 << (PostgreSQLParser.KW_STDIN - 312)))) !== 0) || ((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & ((1 << (PostgreSQLParser.KW_STDOUT - 344)) | (1 << (PostgreSQLParser.KW_STORAGE - 344)) | (1 << (PostgreSQLParser.KW_STRICT - 344)) | (1 << (PostgreSQLParser.KW_STRIP - 344)) | (1 << (PostgreSQLParser.KW_SYSID - 344)) | (1 << (PostgreSQLParser.KW_SYSTEM - 344)) | (1 << (PostgreSQLParser.KW_TABLES - 344)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 344)) | (1 << (PostgreSQLParser.KW_TEMP - 344)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 344)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 344)) | (1 << (PostgreSQLParser.KW_TEXT - 344)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 344)) | (1 << (PostgreSQLParser.KW_TRIGGER - 344)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 344)) | (1 << (PostgreSQLParser.KW_TRUSTED - 344)) | (1 << (PostgreSQLParser.KW_TYPE - 344)) | (1 << (PostgreSQLParser.KW_TYPES - 344)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 344)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 344)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 344)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 344)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 344)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 344)) | (1 << (PostgreSQLParser.KW_UNTIL - 344)) | (1 << (PostgreSQLParser.KW_UPDATE - 344)) | (1 << (PostgreSQLParser.KW_VACUUM - 344)) | (1 << (PostgreSQLParser.KW_VALID - 344)) | (1 << (PostgreSQLParser.KW_VALIDATE - 344)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 344)) | (1 << (PostgreSQLParser.KW_VARYING - 344)) | (1 << (PostgreSQLParser.KW_VERSION - 344)))) !== 0) || ((((_la - 376)) & ~0x1F) === 0 && ((1 << (_la - 376)) & ((1 << (PostgreSQLParser.KW_VIEW - 376)) | (1 << (PostgreSQLParser.KW_VOLATILE - 376)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 376)) | (1 << (PostgreSQLParser.KW_WITHOUT - 376)) | (1 << (PostgreSQLParser.KW_WORK - 376)) | (1 << (PostgreSQLParser.KW_WRAPPER - 376)) | (1 << (PostgreSQLParser.KW_WRITE - 376)) | (1 << (PostgreSQLParser.KW_XML - 376)) | (1 << (PostgreSQLParser.KW_YEAR - 376)) | (1 << (PostgreSQLParser.KW_YES - 376)) | (1 << (PostgreSQLParser.KW_ZONE - 376)) | (1 << (PostgreSQLParser.KW_BETWEEN - 376)) | (1 << (PostgreSQLParser.KW_BIGINT - 376)) | (1 << (PostgreSQLParser.KW_BIT - 376)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 376)) | (1 << (PostgreSQLParser.KW_CHAR - 376)) | (1 << (PostgreSQLParser.KW_CHARACTER - 376)) | (1 << (PostgreSQLParser.KW_COALESCE - 376)) | (1 << (PostgreSQLParser.KW_DEC - 376)) | (1 << (PostgreSQLParser.KW_DECIMAL - 376)) | (1 << (PostgreSQLParser.KW_EXISTS - 376)) | (1 << (PostgreSQLParser.KW_EXTRACT - 376)) | (1 << (PostgreSQLParser.KW_FLOAT - 376)) | (1 << (PostgreSQLParser.KW_GREATEST - 376)) | (1 << (PostgreSQLParser.KW_INOUT - 376)) | (1 << (PostgreSQLParser.KW_INT - 376)) | (1 << (PostgreSQLParser.KW_INTEGER - 376)) | (1 << (PostgreSQLParser.KW_INTERVAL - 376)) | (1 << (PostgreSQLParser.KW_LEAST - 376)) | (1 << (PostgreSQLParser.KW_NATIONAL - 376)) | (1 << (PostgreSQLParser.KW_NCHAR - 376)) | (1 << (PostgreSQLParser.KW_NONE - 376)))) !== 0) || ((((_la - 408)) & ~0x1F) === 0 && ((1 << (_la - 408)) & ((1 << (PostgreSQLParser.KW_NULLIF - 408)) | (1 << (PostgreSQLParser.KW_NUMERIC - 408)) | (1 << (PostgreSQLParser.KW_OVERLAY - 408)) | (1 << (PostgreSQLParser.KW_POSITION - 408)) | (1 << (PostgreSQLParser.KW_PRECISION - 408)) | (1 << (PostgreSQLParser.KW_REAL - 408)) | (1 << (PostgreSQLParser.KW_ROW - 408)) | (1 << (PostgreSQLParser.KW_SETOF - 408)) | (1 << (PostgreSQLParser.KW_SMALLINT - 408)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 408)) | (1 << (PostgreSQLParser.KW_TIME - 408)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 408)) | (1 << (PostgreSQLParser.KW_TREAT - 408)) | (1 << (PostgreSQLParser.KW_TRIM - 408)) | (1 << (PostgreSQLParser.KW_VALUES - 408)) | (1 << (PostgreSQLParser.KW_VARCHAR - 408)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 408)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 408)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 408)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 408)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 408)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 408)) | (1 << (PostgreSQLParser.KW_XMLPI - 408)) | (1 << (PostgreSQLParser.KW_XMLROOT - 408)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 408)) | (1 << (PostgreSQLParser.KW_CALL - 408)) | (1 << (PostgreSQLParser.KW_CURRENT - 408)) | (1 << (PostgreSQLParser.KW_ATTACH - 408)) | (1 << (PostgreSQLParser.KW_DETACH - 408)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 408)) | (1 << (PostgreSQLParser.KW_GENERATED - 408)) | (1 << (PostgreSQLParser.KW_LOGGED - 408)))) !== 0) || ((((_la - 440)) & ~0x1F) === 0 && ((1 << (_la - 440)) & ((1 << (PostgreSQLParser.KW_STORED - 440)) | (1 << (PostgreSQLParser.KW_INCLUDE - 440)) | (1 << (PostgreSQLParser.KW_ROUTINE - 440)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 440)) | (1 << (PostgreSQLParser.KW_IMPORT - 440)) | (1 << (PostgreSQLParser.KW_POLICY - 440)) | (1 << (PostgreSQLParser.KW_METHOD - 440)) | (1 << (PostgreSQLParser.KW_REFERENCING - 440)) | (1 << (PostgreSQLParser.KW_NEW - 440)) | (1 << (PostgreSQLParser.KW_OLD - 440)) | (1 << (PostgreSQLParser.KW_VALUE - 440)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 440)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 440)) | (1 << (PostgreSQLParser.KW_OUT - 440)) | (1 << (PostgreSQLParser.KW_ROUTINES - 440)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 440)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 440)) | (1 << (PostgreSQLParser.KW_INPUT - 440)) | (1 << (PostgreSQLParser.KW_SUPPORT - 440)) | (1 << (PostgreSQLParser.KW_PARALLEL - 440)) | (1 << (PostgreSQLParser.KW_SQL - 440)) | (1 << (PostgreSQLParser.KW_DEPENDS - 440)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 440)) | (1 << (PostgreSQLParser.KW_CONFLICT - 440)) | (1 << (PostgreSQLParser.KW_SKIP - 440)) | (1 << (PostgreSQLParser.KW_LOCKED - 440)) | (1 << (PostgreSQLParser.KW_TIES - 440)) | (1 << (PostgreSQLParser.KW_ROLLUP - 440)) | (1 << (PostgreSQLParser.KW_CUBE - 440)) | (1 << (PostgreSQLParser.KW_GROUPING - 440)) | (1 << (PostgreSQLParser.KW_SETS - 440)))) !== 0) || ((((_la - 473)) & ~0x1F) === 0 && ((1 << (_la - 473)) & ((1 << (PostgreSQLParser.KW_ORDINALITY - 473)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 473)) | (1 << (PostgreSQLParser.KW_COLUMNS - 473)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 473)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 473)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 473)) | (1 << (PostgreSQLParser.KW_WITHIN - 473)) | (1 << (PostgreSQLParser.KW_FILTER - 473)) | (1 << (PostgreSQLParser.KW_GROUPS - 473)) | (1 << (PostgreSQLParser.KW_OTHERS - 473)) | (1 << (PostgreSQLParser.KW_NFC - 473)) | (1 << (PostgreSQLParser.KW_NFD - 473)) | (1 << (PostgreSQLParser.KW_NFKC - 473)) | (1 << (PostgreSQLParser.KW_NFKD - 473)) | (1 << (PostgreSQLParser.KW_UESCAPE - 473)) | (1 << (PostgreSQLParser.KW_VIEWS - 473)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 473)) | (1 << (PostgreSQLParser.KW_DUMP - 473)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 473)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 473)) | (1 << (PostgreSQLParser.KW_ERROR - 473)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 473)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 473)) | (1 << (PostgreSQLParser.KW_ALIAS - 473)) | (1 << (PostgreSQLParser.KW_CONSTANT - 473)) | (1 << (PostgreSQLParser.KW_PERFORM - 473)) | (1 << (PostgreSQLParser.KW_GET - 473)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 473)) | (1 << (PostgreSQLParser.KW_STACKED - 473)) | (1 << (PostgreSQLParser.KW_ELSIF - 473)) | (1 << (PostgreSQLParser.KW_REVERSE - 473)))) !== 0) || ((((_la - 506)) & ~0x1F) === 0 && ((1 << (_la - 506)) & ((1 << (PostgreSQLParser.KW_SLICE - 506)) | (1 << (PostgreSQLParser.KW_EXIT - 506)) | (1 << (PostgreSQLParser.KW_RETURN - 506)) | (1 << (PostgreSQLParser.KW_QUERY - 506)) | (1 << (PostgreSQLParser.KW_RAISE - 506)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 506)) | (1 << (PostgreSQLParser.KW_DEBUG - 506)) | (1 << (PostgreSQLParser.KW_LOG - 506)) | (1 << (PostgreSQLParser.KW_INFO - 506)) | (1 << (PostgreSQLParser.KW_NOTICE - 506)) | (1 << (PostgreSQLParser.KW_WARNING - 506)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 506)) | (1 << (PostgreSQLParser.KW_ASSERT - 506)) | (1 << (PostgreSQLParser.KW_OPEN - 506)) | (1 << (PostgreSQLParser.Identifier - 506)) | (1 << (PostgreSQLParser.QuotedIdentifier - 506)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 506)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 2807; - this.opttableelementlist(); + this.state = 2837; + this.table_column_list(); } } - this.state = 2810; + this.state = 2840; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 2812; + this.state = 2842; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INHERITS) { + if (_la === PostgreSQLParser.KW_INHERITS) { { - this.state = 2811; + this.state = 2841; this.optinherit(); } } - this.state = 2815; + this.state = 2845; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PARTITION) { + if (_la === PostgreSQLParser.KW_PARTITION) { { - this.state = 2814; + this.state = 2844; this.optpartitionspec(); } } - this.state = 2818; + this.state = 2848; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 2817; + this.state = 2847; this.table_access_method_clause(); } } - this.state = 2821; + this.state = 2851; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 133, this._ctx) ) { case 1: { - this.state = 2820; + this.state = 2850; this.optwith(); } break; } - this.state = 2824; + this.state = 2854; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ON) { + if (_la === PostgreSQLParser.KW_ON) { { - this.state = 2823; + this.state = 2853; this.oncommitoption(); } } - this.state = 2827; + this.state = 2857; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TABLESPACE) { + if (_la === PostgreSQLParser.KW_TABLESPACE) { { - this.state = 2826; + this.state = 2856; this.opttablespace(); } } } break; - case PostgreSQLParser.OF: + case PostgreSQLParser.KW_OF: { - this.state = 2829; - this.match(PostgreSQLParser.OF); - this.state = 2830; + this.state = 2859; + this.match(PostgreSQLParser.KW_OF); + this.state = 2860; this.any_name(); - this.state = 2832; + this.state = 2862; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 136, this._ctx) ) { case 1: { - this.state = 2831; + this.state = 2861; this.opttypedtableelementlist(); } break; } - this.state = 2835; + this.state = 2865; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PARTITION) { + if (_la === PostgreSQLParser.KW_PARTITION) { { - this.state = 2834; + this.state = 2864; this.optpartitionspec(); } } - this.state = 2838; + this.state = 2868; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 2837; + this.state = 2867; this.table_access_method_clause(); } } - this.state = 2841; + this.state = 2871; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 139, this._ctx) ) { case 1: { - this.state = 2840; + this.state = 2870; this.optwith(); } break; } - this.state = 2844; + this.state = 2874; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ON) { + if (_la === PostgreSQLParser.KW_ON) { { - this.state = 2843; + this.state = 2873; this.oncommitoption(); } } - this.state = 2847; + this.state = 2877; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TABLESPACE) { + if (_la === PostgreSQLParser.KW_TABLESPACE) { { - this.state = 2846; + this.state = 2876; this.opttablespace(); } } } break; - case PostgreSQLParser.PARTITION: + case PostgreSQLParser.KW_PARTITION: { - this.state = 2849; - this.match(PostgreSQLParser.PARTITION); - this.state = 2850; - this.match(PostgreSQLParser.OF); - this.state = 2851; + this.state = 2879; + this.match(PostgreSQLParser.KW_PARTITION); + this.state = 2880; + this.match(PostgreSQLParser.KW_OF); + this.state = 2881; this.qualified_name(); - this.state = 2853; + this.state = 2883; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 2852; + this.state = 2882; this.opttypedtableelementlist(); } } - this.state = 2855; + this.state = 2885; this.partitionboundspec(); - this.state = 2857; + this.state = 2887; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PARTITION) { + if (_la === PostgreSQLParser.KW_PARTITION) { { - this.state = 2856; + this.state = 2886; this.optpartitionspec(); } } - this.state = 2860; + this.state = 2890; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 2859; + this.state = 2889; this.table_access_method_clause(); } } - this.state = 2863; + this.state = 2893; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 145, this._ctx) ) { case 1: { - this.state = 2862; + this.state = 2892; this.optwith(); } break; } - this.state = 2866; + this.state = 2896; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ON) { + if (_la === PostgreSQLParser.KW_ON) { { - this.state = 2865; + this.state = 2895; this.oncommitoption(); } } - this.state = 2869; + this.state = 2899; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TABLESPACE) { + if (_la === PostgreSQLParser.KW_TABLESPACE) { { - this.state = 2868; + this.state = 2898; this.opttablespace(); } } @@ -11608,31 +12170,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.enterRule(_localctx, 172, PostgreSQLParser.RULE_opttemp); let _la: number; try { - this.state = 2880; + this.state = 2910; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.TEMPORARY: + case PostgreSQLParser.KW_TEMPORARY: this.enterOuterAlt(_localctx, 1); { - this.state = 2873; - this.match(PostgreSQLParser.TEMPORARY); + this.state = 2903; + this.match(PostgreSQLParser.KW_TEMPORARY); } break; - case PostgreSQLParser.TEMP: + case PostgreSQLParser.KW_TEMP: this.enterOuterAlt(_localctx, 2); { - this.state = 2874; - this.match(PostgreSQLParser.TEMP); + this.state = 2904; + this.match(PostgreSQLParser.KW_TEMP); } break; - case PostgreSQLParser.LOCAL: + case PostgreSQLParser.KW_LOCAL: this.enterOuterAlt(_localctx, 3); { - this.state = 2875; - this.match(PostgreSQLParser.LOCAL); - this.state = 2876; + this.state = 2905; + this.match(PostgreSQLParser.KW_LOCAL); + this.state = 2906; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.TEMP || _la === PostgreSQLParser.TEMPORARY)) { + if (!(_la === PostgreSQLParser.KW_TEMP || _la === PostgreSQLParser.KW_TEMPORARY)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -11644,14 +12206,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.GLOBAL: + case PostgreSQLParser.KW_GLOBAL: this.enterOuterAlt(_localctx, 4); { - this.state = 2877; - this.match(PostgreSQLParser.GLOBAL); - this.state = 2878; + this.state = 2907; + this.match(PostgreSQLParser.KW_GLOBAL); + this.state = 2908; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.TEMP || _la === PostgreSQLParser.TEMPORARY)) { + if (!(_la === PostgreSQLParser.KW_TEMP || _la === PostgreSQLParser.KW_TEMPORARY)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -11663,11 +12225,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.UNLOGGED: + case PostgreSQLParser.KW_UNLOGGED: this.enterOuterAlt(_localctx, 5); { - this.state = 2879; - this.match(PostgreSQLParser.UNLOGGED); + this.state = 2909; + this.match(PostgreSQLParser.KW_UNLOGGED); } break; default: @@ -11689,13 +12251,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { return _localctx; } // @RuleVersion(0) - public opttableelementlist(): OpttableelementlistContext { - let _localctx: OpttableelementlistContext = new OpttableelementlistContext(this._ctx, this.state); - this.enterRule(_localctx, 174, PostgreSQLParser.RULE_opttableelementlist); + public table_column_list(): Table_column_listContext { + let _localctx: Table_column_listContext = new Table_column_listContext(this._ctx, this.state); + this.enterRule(_localctx, 174, PostgreSQLParser.RULE_table_column_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 2882; + this.state = 2912; + this.tableelementlist(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public opttableelementlist(): OpttableelementlistContext { + let _localctx: OpttableelementlistContext = new OpttableelementlistContext(this._ctx, this.state); + this.enterRule(_localctx, 176, PostgreSQLParser.RULE_opttableelementlist); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 2914; this.tableelementlist(); } } @@ -11716,15 +12303,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opttypedtableelementlist(): OpttypedtableelementlistContext { let _localctx: OpttypedtableelementlistContext = new OpttypedtableelementlistContext(this._ctx, this.state); - this.enterRule(_localctx, 176, PostgreSQLParser.RULE_opttypedtableelementlist); + this.enterRule(_localctx, 178, PostgreSQLParser.RULE_opttypedtableelementlist); try { this.enterOuterAlt(_localctx, 1); { - this.state = 2884; + this.state = 2916; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2885; + this.state = 2917; this.typedtableelementlist(); - this.state = 2886; + this.state = 2918; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -11745,26 +12332,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public tableelementlist(): TableelementlistContext { let _localctx: TableelementlistContext = new TableelementlistContext(this._ctx, this.state); - this.enterRule(_localctx, 178, PostgreSQLParser.RULE_tableelementlist); + this.enterRule(_localctx, 180, PostgreSQLParser.RULE_tableelementlist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 2888; + this.state = 2920; this.tableelement(); - this.state = 2893; + this.state = 2925; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 2889; + this.state = 2921; this.match(PostgreSQLParser.COMMA); - this.state = 2890; + this.state = 2922; this.tableelement(); } } - this.state = 2895; + this.state = 2927; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -11787,26 +12374,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public typedtableelementlist(): TypedtableelementlistContext { let _localctx: TypedtableelementlistContext = new TypedtableelementlistContext(this._ctx, this.state); - this.enterRule(_localctx, 180, PostgreSQLParser.RULE_typedtableelementlist); + this.enterRule(_localctx, 182, PostgreSQLParser.RULE_typedtableelementlist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 2896; + this.state = 2928; this.typedtableelement(); - this.state = 2901; + this.state = 2933; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 2897; + this.state = 2929; this.match(PostgreSQLParser.COMMA); - this.state = 2898; + this.state = 2930; this.typedtableelement(); } } - this.state = 2903; + this.state = 2935; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -11829,15 +12416,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public tableelement(): TableelementContext { let _localctx: TableelementContext = new TableelementContext(this._ctx, this.state); - this.enterRule(_localctx, 182, PostgreSQLParser.RULE_tableelement); + this.enterRule(_localctx, 184, PostgreSQLParser.RULE_tableelement); try { - this.state = 2907; + this.state = 2939; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 152, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2904; + this.state = 2936; this.columnDef(); } break; @@ -11845,7 +12432,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2905; + this.state = 2937; this.tablelikeclause(); } break; @@ -11853,7 +12440,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 2906; + this.state = 2938; this.tableconstraint(); } break; @@ -11876,15 +12463,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public typedtableelement(): TypedtableelementContext { let _localctx: TypedtableelementContext = new TypedtableelementContext(this._ctx, this.state); - this.enterRule(_localctx, 184, PostgreSQLParser.RULE_typedtableelement); + this.enterRule(_localctx, 186, PostgreSQLParser.RULE_typedtableelement); try { - this.state = 2911; + this.state = 2943; this._errHandler.sync(this); switch ( this.interpreter.adaptivePredict(this._input, 153, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2909; + this.state = 2941; this.columnOptions(); } break; @@ -11892,7 +12479,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2910; + this.state = 2942; this.tableconstraint(); } break; @@ -11915,26 +12502,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public columnDef(): ColumnDefContext { let _localctx: ColumnDefContext = new ColumnDefContext(this._ctx, this.state); - this.enterRule(_localctx, 186, PostgreSQLParser.RULE_columnDef); + this.enterRule(_localctx, 188, PostgreSQLParser.RULE_columnDef); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 2913; + this.state = 2945; this.colid(); - this.state = 2914; + this.state = 2946; this.typename(); - this.state = 2916; + this.state = 2948; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 2915; + this.state = 2947; this.create_generic_options(); } } - this.state = 2918; + this.state = 2952; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_COLLATE) { + { + this.state = 2950; + this.match(PostgreSQLParser.KW_COLLATE); + this.state = 2951; + this.any_name(); + } + } + + this.state = 2954; this.colquallist(); } } @@ -11955,25 +12554,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public columnOptions(): ColumnOptionsContext { let _localctx: ColumnOptionsContext = new ColumnOptionsContext(this._ctx, this.state); - this.enterRule(_localctx, 188, PostgreSQLParser.RULE_columnOptions); + this.enterRule(_localctx, 190, PostgreSQLParser.RULE_columnOptions); try { this.enterOuterAlt(_localctx, 1); { - this.state = 2920; + this.state = 2956; this.colid(); - this.state = 2923; + this.state = 2959; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 155, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 156, this._ctx) ) { case 1: { - this.state = 2921; - this.match(PostgreSQLParser.WITH); - this.state = 2922; - this.match(PostgreSQLParser.OPTIONS); + this.state = 2957; + this.match(PostgreSQLParser.KW_WITH); + this.state = 2958; + this.match(PostgreSQLParser.KW_OPTIONS); } break; } - this.state = 2925; + this.state = 2961; this.colquallist(); } } @@ -11994,22 +12593,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public colquallist(): ColquallistContext { let _localctx: ColquallistContext = new ColquallistContext(this._ctx, this.state); - this.enterRule(_localctx, 190, PostgreSQLParser.RULE_colquallist); + this.enterRule(_localctx, 192, PostgreSQLParser.RULE_colquallist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 2930; + this.state = 2966; 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) { + while (((((_la - 42)) & ~0x1F) === 0 && ((1 << (_la - 42)) & ((1 << (PostgreSQLParser.KW_CHECK - 42)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 42)) | (1 << (PostgreSQLParser.KW_DEFAULT - 42)))) !== 0) || ((((_la - 77)) & ~0x1F) === 0 && ((1 << (_la - 77)) & ((1 << (PostgreSQLParser.KW_NOT - 77)) | (1 << (PostgreSQLParser.KW_NULL - 77)) | (1 << (PostgreSQLParser.KW_PRIMARY - 77)) | (1 << (PostgreSQLParser.KW_REFERENCES - 77)) | (1 << (PostgreSQLParser.KW_UNIQUE - 77)))) !== 0) || _la === PostgreSQLParser.KW_GENERATED) { { { - this.state = 2927; + this.state = 2963; this.colconstraint(); } } - this.state = 2932; + this.state = 2968; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -12032,46 +12631,77 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public colconstraint(): ColconstraintContext { let _localctx: ColconstraintContext = new ColconstraintContext(this._ctx, this.state); - this.enterRule(_localctx, 192, PostgreSQLParser.RULE_colconstraint); + this.enterRule(_localctx, 194, PostgreSQLParser.RULE_colconstraint); + let _la: number; try { - this.state = 2941; + this.state = 2987; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 157, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 163, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 2933; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 2934; - this.name(); - this.state = 2935; + this.state = 2971; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_CONSTRAINT) { + { + this.state = 2969; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 2970; + this.name(); + } + } + + this.state = 2973; this.colconstraintelem(); + this.state = 2975; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 159, this._ctx) ) { + case 1: + { + this.state = 2974; + this.deferrable_trigger(); + } + break; + } + this.state = 2978; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_INITIALLY) { + { + this.state = 2977; + this.initially_trigger(); + } + } + } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 2937; + this.state = 2980; this.colconstraintelem(); + this.state = 2982; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 161, this._ctx) ) { + case 1: + { + this.state = 2981; + this.deferrable_trigger(); + } + break; } - break; - - case 3: - this.enterOuterAlt(_localctx, 3); - { - this.state = 2938; - this.constraintattr(); + this.state = 2985; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_INITIALLY) { + { + this.state = 2984; + this.initially_trigger(); + } } - break; - case 4: - this.enterOuterAlt(_localctx, 4); - { - this.state = 2939; - this.match(PostgreSQLParser.COLLATE); - this.state = 2940; - this.any_name(); } break; } @@ -12093,138 +12723,138 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public colconstraintelem(): ColconstraintelemContext { let _localctx: ColconstraintelemContext = new ColconstraintelemContext(this._ctx, this.state); - this.enterRule(_localctx, 194, PostgreSQLParser.RULE_colconstraintelem); + this.enterRule(_localctx, 196, PostgreSQLParser.RULE_colconstraintelem); let _la: number; try { - this.state = 2995; + this.state = 3041; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.NOT: + case PostgreSQLParser.KW_NOT: this.enterOuterAlt(_localctx, 1); { - this.state = 2943; - this.match(PostgreSQLParser.NOT); - this.state = 2944; - this.match(PostgreSQLParser.NULL_P); + this.state = 2989; + this.match(PostgreSQLParser.KW_NOT); + this.state = 2990; + this.match(PostgreSQLParser.KW_NULL); } break; - case PostgreSQLParser.NULL_P: + case PostgreSQLParser.KW_NULL: this.enterOuterAlt(_localctx, 2); { - this.state = 2945; - this.match(PostgreSQLParser.NULL_P); + this.state = 2991; + this.match(PostgreSQLParser.KW_NULL); } break; - case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.KW_UNIQUE: this.enterOuterAlt(_localctx, 3); { - this.state = 2946; - this.match(PostgreSQLParser.UNIQUE); - this.state = 2948; + this.state = 2992; + this.match(PostgreSQLParser.KW_UNIQUE); + this.state = 2994; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 158, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 164, this._ctx) ) { case 1: { - this.state = 2947; + this.state = 2993; this.opt_definition(); } break; } - this.state = 2951; + this.state = 2997; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 2950; + this.state = 2996; this.optconstablespace(); } } } break; - case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.KW_PRIMARY: this.enterOuterAlt(_localctx, 4); { - this.state = 2953; - this.match(PostgreSQLParser.PRIMARY); - this.state = 2954; - this.match(PostgreSQLParser.KEY); - this.state = 2956; + this.state = 2999; + this.match(PostgreSQLParser.KW_PRIMARY); + this.state = 3000; + this.match(PostgreSQLParser.KW_KEY); + this.state = 3002; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 160, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 166, this._ctx) ) { case 1: { - this.state = 2955; + this.state = 3001; this.opt_definition(); } break; } - this.state = 2959; + this.state = 3005; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 2958; + this.state = 3004; this.optconstablespace(); } } } break; - case PostgreSQLParser.CHECK: + case PostgreSQLParser.KW_CHECK: this.enterOuterAlt(_localctx, 5); { - this.state = 2961; - this.match(PostgreSQLParser.CHECK); - this.state = 2962; + this.state = 3007; + this.match(PostgreSQLParser.KW_CHECK); + this.state = 3008; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2963; + this.state = 3009; this.a_expr(); - this.state = 2964; + this.state = 3010; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 2966; + this.state = 3012; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 2965; + this.state = 3011; this.opt_no_inherit(); } } } break; - case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.KW_DEFAULT: this.enterOuterAlt(_localctx, 6); { - this.state = 2968; - this.match(PostgreSQLParser.DEFAULT); - this.state = 2969; + this.state = 3014; + this.match(PostgreSQLParser.KW_DEFAULT); + this.state = 3015; this.b_expr(0); } break; - case PostgreSQLParser.GENERATED: + case PostgreSQLParser.KW_GENERATED: this.enterOuterAlt(_localctx, 7); { - this.state = 2970; - this.match(PostgreSQLParser.GENERATED); - this.state = 2971; + this.state = 3016; + this.match(PostgreSQLParser.KW_GENERATED); + this.state = 3017; this.generated_when(); - this.state = 2972; - this.match(PostgreSQLParser.AS); - this.state = 2982; + this.state = 3018; + this.match(PostgreSQLParser.KW_AS); + this.state = 3028; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.IDENTITY_P: + case PostgreSQLParser.KW_IDENTITY: { - this.state = 2973; - this.match(PostgreSQLParser.IDENTITY_P); - this.state = 2975; + this.state = 3019; + this.match(PostgreSQLParser.KW_IDENTITY); + this.state = 3021; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 163, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 169, this._ctx) ) { case 1: { - this.state = 2974; + this.state = 3020; this.optparenthesizedseqoptlist(); } break; @@ -12233,14 +12863,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { break; case PostgreSQLParser.OPEN_PAREN: { - this.state = 2977; + this.state = 3023; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 2978; + this.state = 3024; this.a_expr(); - this.state = 2979; + this.state = 3025; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 2980; - this.match(PostgreSQLParser.STORED); + this.state = 3026; + this.match(PostgreSQLParser.KW_STORED); } break; default: @@ -12248,39 +12878,39 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.REFERENCES: + case PostgreSQLParser.KW_REFERENCES: this.enterOuterAlt(_localctx, 8); { - this.state = 2984; - this.match(PostgreSQLParser.REFERENCES); - this.state = 2985; + this.state = 3030; + this.match(PostgreSQLParser.KW_REFERENCES); + this.state = 3031; this.qualified_name(); - this.state = 2987; + this.state = 3033; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 165, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 171, this._ctx) ) { case 1: { - this.state = 2986; + this.state = 3032; this.opt_column_list(); } break; } - this.state = 2990; + this.state = 3036; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.MATCH) { + if (_la === PostgreSQLParser.KW_MATCH) { { - this.state = 2989; + this.state = 3035; this.key_match(); } } - this.state = 2993; + this.state = 3039; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ON) { + if (_la === PostgreSQLParser.KW_ON) { { - this.state = 2992; + this.state = 3038; this.key_actions(); } } @@ -12308,25 +12938,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public generated_when(): Generated_whenContext { let _localctx: Generated_whenContext = new Generated_whenContext(this._ctx, this.state); - this.enterRule(_localctx, 196, PostgreSQLParser.RULE_generated_when); + this.enterRule(_localctx, 198, PostgreSQLParser.RULE_generated_when); try { - this.state = 3000; + this.state = 3046; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.ALWAYS: + case PostgreSQLParser.KW_ALWAYS: this.enterOuterAlt(_localctx, 1); { - this.state = 2997; - this.match(PostgreSQLParser.ALWAYS); + this.state = 3043; + this.match(PostgreSQLParser.KW_ALWAYS); } break; - case PostgreSQLParser.BY: + case PostgreSQLParser.KW_BY: this.enterOuterAlt(_localctx, 2); { - this.state = 2998; - this.match(PostgreSQLParser.BY); - this.state = 2999; - this.match(PostgreSQLParser.DEFAULT); + this.state = 3044; + this.match(PostgreSQLParser.KW_BY); + this.state = 3045; + this.match(PostgreSQLParser.KW_DEFAULT); } break; default: @@ -12348,47 +12978,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { return _localctx; } // @RuleVersion(0) - public constraintattr(): ConstraintattrContext { - let _localctx: ConstraintattrContext = new ConstraintattrContext(this._ctx, this.state); - this.enterRule(_localctx, 198, PostgreSQLParser.RULE_constraintattr); - let _la: number; + public deferrable_trigger(): Deferrable_triggerContext { + let _localctx: Deferrable_triggerContext = new Deferrable_triggerContext(this._ctx, this.state); + this.enterRule(_localctx, 200, PostgreSQLParser.RULE_deferrable_trigger); try { - this.state = 3007; + this.state = 3051; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.DEFERRABLE: + case PostgreSQLParser.KW_DEFERRABLE: this.enterOuterAlt(_localctx, 1); { - this.state = 3002; - this.match(PostgreSQLParser.DEFERRABLE); + this.state = 3048; + this.match(PostgreSQLParser.KW_DEFERRABLE); } break; - case PostgreSQLParser.NOT: + case PostgreSQLParser.KW_NOT: this.enterOuterAlt(_localctx, 2); { - this.state = 3003; - this.match(PostgreSQLParser.NOT); - this.state = 3004; - this.match(PostgreSQLParser.DEFERRABLE); - } - break; - case PostgreSQLParser.INITIALLY: - this.enterOuterAlt(_localctx, 3); - { - this.state = 3005; - this.match(PostgreSQLParser.INITIALLY); - this.state = 3006; - _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.DEFERRED || _la === PostgreSQLParser.IMMEDIATE)) { - this._errHandler.recoverInline(this); - } else { - if (this._input.LA(1) === Token.EOF) { - this.matchedEOF = true; - } - - this._errHandler.reportMatch(this); - this.consume(); - } + this.state = 3049; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3050; + this.match(PostgreSQLParser.KW_DEFERRABLE); } break; default: @@ -12410,17 +13020,55 @@ export class PostgreSQLParser extends PostgreSQLParserBase { return _localctx; } // @RuleVersion(0) + public initially_trigger(): Initially_triggerContext { + let _localctx: Initially_triggerContext = new Initially_triggerContext(this._ctx, this.state); + this.enterRule(_localctx, 202, PostgreSQLParser.RULE_initially_trigger); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 3053; + this.match(PostgreSQLParser.KW_INITIALLY); + this.state = 3054; + _la = this._input.LA(1); + if (!(_la === PostgreSQLParser.KW_DEFERRED || _la === PostgreSQLParser.KW_IMMEDIATE)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) public tablelikeclause(): TablelikeclauseContext { let _localctx: TablelikeclauseContext = new TablelikeclauseContext(this._ctx, this.state); - this.enterRule(_localctx, 200, PostgreSQLParser.RULE_tablelikeclause); + this.enterRule(_localctx, 204, PostgreSQLParser.RULE_tablelikeclause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3009; - this.match(PostgreSQLParser.LIKE); - this.state = 3010; + this.state = 3056; + this.match(PostgreSQLParser.KW_LIKE); + this.state = 3057; this.qualified_name(); - this.state = 3011; + this.state = 3058; this.tablelikeoptionlist(); } } @@ -12441,20 +13089,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public tablelikeoptionlist(): TablelikeoptionlistContext { let _localctx: TablelikeoptionlistContext = new TablelikeoptionlistContext(this._ctx, this.state); - this.enterRule(_localctx, 202, PostgreSQLParser.RULE_tablelikeoptionlist); + this.enterRule(_localctx, 206, PostgreSQLParser.RULE_tablelikeoptionlist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3017; + this.state = 3064; this._errHandler.sync(this); _la = this._input.LA(1); - while (_la === PostgreSQLParser.EXCLUDING || _la === PostgreSQLParser.INCLUDING) { + while (_la === PostgreSQLParser.KW_EXCLUDING || _la === PostgreSQLParser.KW_INCLUDING) { { { - this.state = 3013; + this.state = 3060; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.EXCLUDING || _la === PostgreSQLParser.INCLUDING)) { + if (!(_la === PostgreSQLParser.KW_EXCLUDING || _la === PostgreSQLParser.KW_INCLUDING)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -12464,11 +13112,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 3014; + this.state = 3061; this.tablelikeoption(); } } - this.state = 3019; + this.state = 3066; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -12491,14 +13139,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public tablelikeoption(): TablelikeoptionContext { let _localctx: TablelikeoptionContext = new TablelikeoptionContext(this._ctx, this.state); - this.enterRule(_localctx, 204, PostgreSQLParser.RULE_tablelikeoption); + this.enterRule(_localctx, 208, PostgreSQLParser.RULE_tablelikeoption); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3020; + this.state = 3067; _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)) { + if (!(_la === PostgreSQLParser.KW_ALL || ((((_la - 160)) & ~0x1F) === 0 && ((1 << (_la - 160)) & ((1 << (PostgreSQLParser.KW_COMMENTS - 160)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 160)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 160)))) !== 0) || _la === PostgreSQLParser.KW_IDENTITY || _la === PostgreSQLParser.KW_INDEXES || _la === PostgreSQLParser.KW_STATISTICS || _la === PostgreSQLParser.KW_STORAGE || _la === PostgreSQLParser.KW_GENERATED)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -12527,30 +13175,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public tableconstraint(): TableconstraintContext { let _localctx: TableconstraintContext = new TableconstraintContext(this._ctx, this.state); - this.enterRule(_localctx, 206, PostgreSQLParser.RULE_tableconstraint); + this.enterRule(_localctx, 210, PostgreSQLParser.RULE_tableconstraint); try { - this.state = 3027; + this.state = 3074; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.CONSTRAINT: + case PostgreSQLParser.KW_CONSTRAINT: this.enterOuterAlt(_localctx, 1); { - this.state = 3022; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 3023; + this.state = 3069; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 3070; this.name(); - this.state = 3024; + this.state = 3071; this.constraintelem(); } break; - case PostgreSQLParser.CHECK: - case PostgreSQLParser.FOREIGN: - case PostgreSQLParser.PRIMARY: - case PostgreSQLParser.UNIQUE: - case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.KW_CHECK: + case PostgreSQLParser.KW_FOREIGN: + case PostgreSQLParser.KW_PRIMARY: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_EXCLUDE: this.enterOuterAlt(_localctx, 2); { - this.state = 3026; + this.state = 3073; this.constraintelem(); } break; @@ -12575,82 +13223,82 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public constraintelem(): ConstraintelemContext { let _localctx: ConstraintelemContext = new ConstraintelemContext(this._ctx, this.state); - this.enterRule(_localctx, 208, PostgreSQLParser.RULE_constraintelem); + this.enterRule(_localctx, 212, PostgreSQLParser.RULE_constraintelem); let _la: number; try { - this.state = 3115; + this.state = 3162; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.CHECK: + case PostgreSQLParser.KW_CHECK: this.enterOuterAlt(_localctx, 1); { - this.state = 3029; - this.match(PostgreSQLParser.CHECK); - this.state = 3030; + this.state = 3076; + this.match(PostgreSQLParser.KW_CHECK); + this.state = 3077; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3031; + this.state = 3078; this.a_expr(); - this.state = 3032; + this.state = 3079; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 3033; + this.state = 3080; this.constraintattributespec(); } break; - case PostgreSQLParser.UNIQUE: + case PostgreSQLParser.KW_UNIQUE: this.enterOuterAlt(_localctx, 2); { - this.state = 3035; - this.match(PostgreSQLParser.UNIQUE); - this.state = 3053; + this.state = 3082; + this.match(PostgreSQLParser.KW_UNIQUE); + this.state = 3100; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: { - this.state = 3036; + this.state = 3083; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3037; + this.state = 3084; this.columnlist(); - this.state = 3038; + this.state = 3085; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 3040; + this.state = 3087; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INCLUDE) { + if (_la === PostgreSQLParser.KW_INCLUDE) { { - this.state = 3039; + this.state = 3086; this.opt_c_include(); } } - this.state = 3043; + this.state = 3090; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 174, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 180, this._ctx) ) { case 1: { - this.state = 3042; + this.state = 3089; this.opt_definition(); } break; } - this.state = 3046; + this.state = 3093; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 3045; + this.state = 3092; this.optconstablespace(); } } - this.state = 3048; + this.state = 3095; this.constraintattributespec(); } break; - case PostgreSQLParser.USING: + case PostgreSQLParser.KW_USING: { - this.state = 3050; + this.state = 3097; this.existingindex(); - this.state = 3051; + this.state = 3098; this.constraintattributespec(); } break; @@ -12659,63 +13307,63 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.PRIMARY: + case PostgreSQLParser.KW_PRIMARY: this.enterOuterAlt(_localctx, 3); { - this.state = 3055; - this.match(PostgreSQLParser.PRIMARY); - this.state = 3056; - this.match(PostgreSQLParser.KEY); - this.state = 3074; + this.state = 3102; + this.match(PostgreSQLParser.KW_PRIMARY); + this.state = 3103; + this.match(PostgreSQLParser.KW_KEY); + this.state = 3121; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: { - this.state = 3057; + this.state = 3104; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3058; + this.state = 3105; this.columnlist(); - this.state = 3059; + this.state = 3106; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 3061; + this.state = 3108; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INCLUDE) { + if (_la === PostgreSQLParser.KW_INCLUDE) { { - this.state = 3060; + this.state = 3107; this.opt_c_include(); } } - this.state = 3064; + this.state = 3111; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 178, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 184, this._ctx) ) { case 1: { - this.state = 3063; + this.state = 3110; this.opt_definition(); } break; } - this.state = 3067; + this.state = 3114; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 3066; + this.state = 3113; this.optconstablespace(); } } - this.state = 3069; + this.state = 3116; this.constraintattributespec(); } break; - case PostgreSQLParser.USING: + case PostgreSQLParser.KW_USING: { - this.state = 3071; + this.state = 3118; this.existingindex(); - this.state = 3072; + this.state = 3119; this.constraintattributespec(); } break; @@ -12724,119 +13372,119 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.EXCLUDE: + case PostgreSQLParser.KW_EXCLUDE: this.enterOuterAlt(_localctx, 4); { - this.state = 3076; - this.match(PostgreSQLParser.EXCLUDE); - this.state = 3078; + this.state = 3123; + this.match(PostgreSQLParser.KW_EXCLUDE); + this.state = 3125; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 3077; + this.state = 3124; this.access_method_clause(); } } - this.state = 3080; + this.state = 3127; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3081; + this.state = 3128; this.exclusionconstraintlist(); - this.state = 3082; + this.state = 3129; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 3084; + this.state = 3131; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INCLUDE) { + if (_la === PostgreSQLParser.KW_INCLUDE) { { - this.state = 3083; + this.state = 3130; this.opt_c_include(); } } - this.state = 3087; + this.state = 3134; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 183, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 189, this._ctx) ) { case 1: { - this.state = 3086; + this.state = 3133; this.opt_definition(); } break; } - this.state = 3090; + this.state = 3137; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 3089; + this.state = 3136; this.optconstablespace(); } } - this.state = 3093; + this.state = 3140; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 3092; + this.state = 3139; this.exclusionwhereclause(); } } - this.state = 3095; + this.state = 3142; this.constraintattributespec(); } break; - case PostgreSQLParser.FOREIGN: + case PostgreSQLParser.KW_FOREIGN: this.enterOuterAlt(_localctx, 5); { - this.state = 3097; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3098; - this.match(PostgreSQLParser.KEY); - this.state = 3099; + this.state = 3144; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3145; + this.match(PostgreSQLParser.KW_KEY); + this.state = 3146; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3100; + this.state = 3147; this.columnlist(); - this.state = 3101; + this.state = 3148; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 3102; - this.match(PostgreSQLParser.REFERENCES); - this.state = 3103; + this.state = 3149; + this.match(PostgreSQLParser.KW_REFERENCES); + this.state = 3150; this.qualified_name(); - this.state = 3105; + this.state = 3152; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 186, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 192, this._ctx) ) { case 1: { - this.state = 3104; + this.state = 3151; this.opt_column_list(); } break; } - this.state = 3108; + this.state = 3155; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.MATCH) { + if (_la === PostgreSQLParser.KW_MATCH) { { - this.state = 3107; + this.state = 3154; this.key_match(); } } - this.state = 3111; + this.state = 3158; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ON) { + if (_la === PostgreSQLParser.KW_ON) { { - this.state = 3110; + this.state = 3157; this.key_actions(); } } - this.state = 3113; + this.state = 3160; this.constraintattributespec(); } break; @@ -12861,14 +13509,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_no_inherit(): Opt_no_inheritContext { let _localctx: Opt_no_inheritContext = new Opt_no_inheritContext(this._ctx, this.state); - this.enterRule(_localctx, 210, PostgreSQLParser.RULE_opt_no_inherit); + this.enterRule(_localctx, 214, PostgreSQLParser.RULE_opt_no_inherit); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3117; - this.match(PostgreSQLParser.NO); - this.state = 3118; - this.match(PostgreSQLParser.INHERIT); + this.state = 3164; + this.match(PostgreSQLParser.KW_NO); + this.state = 3165; + this.match(PostgreSQLParser.KW_INHERIT); } } catch (re) { @@ -12888,15 +13536,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_column_list(): Opt_column_listContext { let _localctx: Opt_column_listContext = new Opt_column_listContext(this._ctx, this.state); - this.enterRule(_localctx, 212, PostgreSQLParser.RULE_opt_column_list); + this.enterRule(_localctx, 216, PostgreSQLParser.RULE_opt_column_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3120; + this.state = 3167; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3121; + this.state = 3168; this.columnlist(); - this.state = 3122; + this.state = 3169; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -12917,26 +13565,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public columnlist(): ColumnlistContext { let _localctx: ColumnlistContext = new ColumnlistContext(this._ctx, this.state); - this.enterRule(_localctx, 214, PostgreSQLParser.RULE_columnlist); + this.enterRule(_localctx, 218, PostgreSQLParser.RULE_columnlist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3124; + this.state = 3171; this.columnElem(); - this.state = 3129; + this.state = 3176; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 3125; + this.state = 3172; this.match(PostgreSQLParser.COMMA); - this.state = 3126; + this.state = 3173; this.columnElem(); } } - this.state = 3131; + this.state = 3178; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -12959,11 +13607,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public columnElem(): ColumnElemContext { let _localctx: ColumnElemContext = new ColumnElemContext(this._ctx, this.state); - this.enterRule(_localctx, 216, PostgreSQLParser.RULE_columnElem); + this.enterRule(_localctx, 220, PostgreSQLParser.RULE_columnElem); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3132; + this.state = 3179; this.colid(); } } @@ -12984,17 +13632,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_c_include(): Opt_c_includeContext { let _localctx: Opt_c_includeContext = new Opt_c_includeContext(this._ctx, this.state); - this.enterRule(_localctx, 218, PostgreSQLParser.RULE_opt_c_include); + this.enterRule(_localctx, 222, PostgreSQLParser.RULE_opt_c_include); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3134; - this.match(PostgreSQLParser.INCLUDE); - this.state = 3135; + this.state = 3181; + this.match(PostgreSQLParser.KW_INCLUDE); + this.state = 3182; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3136; + this.state = 3183; this.columnlist(); - this.state = 3137; + this.state = 3184; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -13015,16 +13663,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public key_match(): Key_matchContext { let _localctx: Key_matchContext = new Key_matchContext(this._ctx, this.state); - this.enterRule(_localctx, 220, PostgreSQLParser.RULE_key_match); + this.enterRule(_localctx, 224, PostgreSQLParser.RULE_key_match); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3139; - this.match(PostgreSQLParser.MATCH); - this.state = 3140; + this.state = 3186; + this.match(PostgreSQLParser.KW_MATCH); + this.state = 3187; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FULL || _la === PostgreSQLParser.PARTIAL || _la === PostgreSQLParser.SIMPLE)) { + if (!(_la === PostgreSQLParser.KW_FULL || _la === PostgreSQLParser.KW_PARTIAL || _la === PostgreSQLParser.KW_SIMPLE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -13053,26 +13701,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public exclusionconstraintlist(): ExclusionconstraintlistContext { let _localctx: ExclusionconstraintlistContext = new ExclusionconstraintlistContext(this._ctx, this.state); - this.enterRule(_localctx, 222, PostgreSQLParser.RULE_exclusionconstraintlist); + this.enterRule(_localctx, 226, PostgreSQLParser.RULE_exclusionconstraintlist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3142; + this.state = 3189; this.exclusionconstraintelem(); - this.state = 3147; + this.state = 3194; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 3143; + this.state = 3190; this.match(PostgreSQLParser.COMMA); - this.state = 3144; + this.state = 3191; this.exclusionconstraintelem(); } } - this.state = 3149; + this.state = 3196; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -13095,33 +13743,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public exclusionconstraintelem(): ExclusionconstraintelemContext { let _localctx: ExclusionconstraintelemContext = new ExclusionconstraintelemContext(this._ctx, this.state); - this.enterRule(_localctx, 224, PostgreSQLParser.RULE_exclusionconstraintelem); + this.enterRule(_localctx, 228, PostgreSQLParser.RULE_exclusionconstraintelem); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3150; + this.state = 3197; this.index_elem(); - this.state = 3151; - this.match(PostgreSQLParser.WITH); - this.state = 3158; + this.state = 3198; + this.match(PostgreSQLParser.KW_WITH); + this.state = 3205; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 192, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 198, this._ctx) ) { case 1: { - this.state = 3152; + this.state = 3199; this.any_operator(); } break; case 2: { - this.state = 3153; - this.match(PostgreSQLParser.OPERATOR); - this.state = 3154; + this.state = 3200; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 3201; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3155; + this.state = 3202; this.any_operator(); - this.state = 3156; + this.state = 3203; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -13145,17 +13793,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public exclusionwhereclause(): ExclusionwhereclauseContext { let _localctx: ExclusionwhereclauseContext = new ExclusionwhereclauseContext(this._ctx, this.state); - this.enterRule(_localctx, 226, PostgreSQLParser.RULE_exclusionwhereclause); + this.enterRule(_localctx, 230, PostgreSQLParser.RULE_exclusionwhereclause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3160; - this.match(PostgreSQLParser.WHERE); - this.state = 3161; + this.state = 3207; + this.match(PostgreSQLParser.KW_WHERE); + this.state = 3208; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3162; + this.state = 3209; this.a_expr(); - this.state = 3163; + this.state = 3210; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -13176,15 +13824,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public key_actions(): Key_actionsContext { let _localctx: Key_actionsContext = new Key_actionsContext(this._ctx, this.state); - this.enterRule(_localctx, 228, PostgreSQLParser.RULE_key_actions); + this.enterRule(_localctx, 232, PostgreSQLParser.RULE_key_actions); try { - this.state = 3173; + this.state = 3220; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 193, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 199, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3165; + this.state = 3212; this.key_update(); } break; @@ -13192,7 +13840,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3166; + this.state = 3213; this.key_delete(); } break; @@ -13200,9 +13848,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 3167; + this.state = 3214; this.key_update(); - this.state = 3168; + this.state = 3215; this.key_delete(); } break; @@ -13210,9 +13858,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 3170; + this.state = 3217; this.key_delete(); - this.state = 3171; + this.state = 3218; this.key_update(); } break; @@ -13235,15 +13883,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public key_update(): Key_updateContext { let _localctx: Key_updateContext = new Key_updateContext(this._ctx, this.state); - this.enterRule(_localctx, 230, PostgreSQLParser.RULE_key_update); + this.enterRule(_localctx, 234, PostgreSQLParser.RULE_key_update); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3175; - this.match(PostgreSQLParser.ON); - this.state = 3176; - this.match(PostgreSQLParser.UPDATE); - this.state = 3177; + this.state = 3222; + this.match(PostgreSQLParser.KW_ON); + this.state = 3223; + this.match(PostgreSQLParser.KW_UPDATE); + this.state = 3224; this.key_action(); } } @@ -13264,15 +13912,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public key_delete(): Key_deleteContext { let _localctx: Key_deleteContext = new Key_deleteContext(this._ctx, this.state); - this.enterRule(_localctx, 232, PostgreSQLParser.RULE_key_delete); + this.enterRule(_localctx, 236, PostgreSQLParser.RULE_key_delete); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3179; - this.match(PostgreSQLParser.ON); - this.state = 3180; - this.match(PostgreSQLParser.DELETE_P); - this.state = 3181; + this.state = 3226; + this.match(PostgreSQLParser.KW_ON); + this.state = 3227; + this.match(PostgreSQLParser.KW_DELETE); + this.state = 3228; this.key_action(); } } @@ -13293,43 +13941,43 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public key_action(): Key_actionContext { let _localctx: Key_actionContext = new Key_actionContext(this._ctx, this.state); - this.enterRule(_localctx, 234, PostgreSQLParser.RULE_key_action); + this.enterRule(_localctx, 238, PostgreSQLParser.RULE_key_action); let _la: number; try { - this.state = 3189; + this.state = 3236; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.NO: + case PostgreSQLParser.KW_NO: this.enterOuterAlt(_localctx, 1); { - this.state = 3183; - this.match(PostgreSQLParser.NO); - this.state = 3184; - this.match(PostgreSQLParser.ACTION); + this.state = 3230; + this.match(PostgreSQLParser.KW_NO); + this.state = 3231; + this.match(PostgreSQLParser.KW_ACTION); } break; - case PostgreSQLParser.RESTRICT: + case PostgreSQLParser.KW_RESTRICT: this.enterOuterAlt(_localctx, 2); { - this.state = 3185; - this.match(PostgreSQLParser.RESTRICT); + this.state = 3232; + this.match(PostgreSQLParser.KW_RESTRICT); } break; - case PostgreSQLParser.CASCADE: + case PostgreSQLParser.KW_CASCADE: this.enterOuterAlt(_localctx, 3); { - this.state = 3186; - this.match(PostgreSQLParser.CASCADE); + this.state = 3233; + this.match(PostgreSQLParser.KW_CASCADE); } break; - case PostgreSQLParser.SET: + case PostgreSQLParser.KW_SET: this.enterOuterAlt(_localctx, 4); { - this.state = 3187; - this.match(PostgreSQLParser.SET); - this.state = 3188; + this.state = 3234; + this.match(PostgreSQLParser.KW_SET); + this.state = 3235; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.DEFAULT || _la === PostgreSQLParser.NULL_P)) { + if (!(_la === PostgreSQLParser.KW_DEFAULT || _la === PostgreSQLParser.KW_NULL)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -13362,17 +14010,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public optinherit(): OptinheritContext { let _localctx: OptinheritContext = new OptinheritContext(this._ctx, this.state); - this.enterRule(_localctx, 236, PostgreSQLParser.RULE_optinherit); + this.enterRule(_localctx, 240, PostgreSQLParser.RULE_optinherit); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3191; - this.match(PostgreSQLParser.INHERITS); - this.state = 3192; + this.state = 3238; + this.match(PostgreSQLParser.KW_INHERITS); + this.state = 3239; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3193; + this.state = 3240; this.qualified_name_list(); - this.state = 3194; + this.state = 3241; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -13393,11 +14041,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public optpartitionspec(): OptpartitionspecContext { let _localctx: OptpartitionspecContext = new OptpartitionspecContext(this._ctx, this.state); - this.enterRule(_localctx, 238, PostgreSQLParser.RULE_optpartitionspec); + this.enterRule(_localctx, 242, PostgreSQLParser.RULE_optpartitionspec); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3196; + this.state = 3243; this.partitionspec(); } } @@ -13418,21 +14066,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public partitionspec(): PartitionspecContext { let _localctx: PartitionspecContext = new PartitionspecContext(this._ctx, this.state); - this.enterRule(_localctx, 240, PostgreSQLParser.RULE_partitionspec); + this.enterRule(_localctx, 244, PostgreSQLParser.RULE_partitionspec); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3198; - this.match(PostgreSQLParser.PARTITION); - this.state = 3199; - this.match(PostgreSQLParser.BY); - this.state = 3200; + this.state = 3245; + this.match(PostgreSQLParser.KW_PARTITION); + this.state = 3246; + this.match(PostgreSQLParser.KW_BY); + this.state = 3247; this.colid(); - this.state = 3201; + this.state = 3248; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3202; + this.state = 3249; this.part_params(); - this.state = 3203; + this.state = 3250; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -13453,26 +14101,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public part_params(): Part_paramsContext { let _localctx: Part_paramsContext = new Part_paramsContext(this._ctx, this.state); - this.enterRule(_localctx, 242, PostgreSQLParser.RULE_part_params); + this.enterRule(_localctx, 246, PostgreSQLParser.RULE_part_params); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3205; + this.state = 3252; this.part_elem(); - this.state = 3210; + this.state = 3257; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 3206; + this.state = 3253; this.match(PostgreSQLParser.COMMA); - this.state = 3207; + this.state = 3254; this.part_elem(); } } - this.state = 3212; + this.state = 3259; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -13495,33 +14143,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public part_elem(): Part_elemContext { let _localctx: Part_elemContext = new Part_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 244, PostgreSQLParser.RULE_part_elem); + this.enterRule(_localctx, 248, PostgreSQLParser.RULE_part_elem); let _la: number; try { - this.state = 3236; + this.state = 3283; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 202, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 208, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3213; + this.state = 3260; this.colid(); - this.state = 3215; + this.state = 3262; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 196, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 202, this._ctx) ) { case 1: { - this.state = 3214; + this.state = 3261; this.opt_collate(); } break; } - this.state = 3218; + this.state = 3265; 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)) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.KW_OVER - 124)) | (1 << (PostgreSQLParser.KW_ABORT - 124)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 124)) | (1 << (PostgreSQLParser.KW_ACCESS - 124)) | (1 << (PostgreSQLParser.KW_ACTION - 124)) | (1 << (PostgreSQLParser.KW_ADD - 124)) | (1 << (PostgreSQLParser.KW_ADMIN - 124)) | (1 << (PostgreSQLParser.KW_AFTER - 124)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 124)) | (1 << (PostgreSQLParser.KW_ALSO - 124)) | (1 << (PostgreSQLParser.KW_ALTER - 124)) | (1 << (PostgreSQLParser.KW_ALWAYS - 124)) | (1 << (PostgreSQLParser.KW_ASSERTION - 124)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.KW_AT - 124)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.KW_BACKWARD - 124)) | (1 << (PostgreSQLParser.KW_BEFORE - 124)) | (1 << (PostgreSQLParser.KW_BEGIN - 124)) | (1 << (PostgreSQLParser.KW_BY - 124)) | (1 << (PostgreSQLParser.KW_CACHE - 124)) | (1 << (PostgreSQLParser.KW_CALLED - 124)) | (1 << (PostgreSQLParser.KW_CASCADE - 124)) | (1 << (PostgreSQLParser.KW_CASCADED - 124)) | (1 << (PostgreSQLParser.KW_CATALOG - 124)) | (1 << (PostgreSQLParser.KW_CHAIN - 124)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.KW_CLASS - 156)) | (1 << (PostgreSQLParser.KW_CLOSE - 156)) | (1 << (PostgreSQLParser.KW_CLUSTER - 156)) | (1 << (PostgreSQLParser.KW_COMMENT - 156)) | (1 << (PostgreSQLParser.KW_COMMENTS - 156)) | (1 << (PostgreSQLParser.KW_COMMIT - 156)) | (1 << (PostgreSQLParser.KW_COMMITTED - 156)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 156)) | (1 << (PostgreSQLParser.KW_CONNECTION - 156)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.KW_CONTENT - 156)) | (1 << (PostgreSQLParser.KW_CONTINUE - 156)) | (1 << (PostgreSQLParser.KW_CONVERSION - 156)) | (1 << (PostgreSQLParser.KW_COPY - 156)) | (1 << (PostgreSQLParser.KW_COST - 156)) | (1 << (PostgreSQLParser.KW_CSV - 156)) | (1 << (PostgreSQLParser.KW_CURSOR - 156)) | (1 << (PostgreSQLParser.KW_CYCLE - 156)) | (1 << (PostgreSQLParser.KW_DATA - 156)) | (1 << (PostgreSQLParser.KW_DATABASE - 156)) | (1 << (PostgreSQLParser.KW_DAY - 156)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 156)) | (1 << (PostgreSQLParser.KW_DECLARE - 156)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 156)) | (1 << (PostgreSQLParser.KW_DEFERRED - 156)) | (1 << (PostgreSQLParser.KW_DEFINER - 156)) | (1 << (PostgreSQLParser.KW_DELETE - 156)) | (1 << (PostgreSQLParser.KW_DELIMITER - 156)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 156)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 156)) | (1 << (PostgreSQLParser.KW_DISABLE - 156)) | (1 << (PostgreSQLParser.KW_DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.KW_DOCUMENT - 188)) | (1 << (PostgreSQLParser.KW_DOMAIN - 188)) | (1 << (PostgreSQLParser.KW_DOUBLE - 188)) | (1 << (PostgreSQLParser.KW_DROP - 188)) | (1 << (PostgreSQLParser.KW_EACH - 188)) | (1 << (PostgreSQLParser.KW_ENABLE - 188)) | (1 << (PostgreSQLParser.KW_ENCODING - 188)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 188)) | (1 << (PostgreSQLParser.KW_ENUM - 188)) | (1 << (PostgreSQLParser.KW_ESCAPE - 188)) | (1 << (PostgreSQLParser.KW_EVENT - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 188)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.KW_EXECUTE - 188)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 188)) | (1 << (PostgreSQLParser.KW_EXTENSION - 188)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 188)) | (1 << (PostgreSQLParser.KW_FAMILY - 188)) | (1 << (PostgreSQLParser.KW_FIRST - 188)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 188)) | (1 << (PostgreSQLParser.KW_FORCE - 188)) | (1 << (PostgreSQLParser.KW_FORWARD - 188)) | (1 << (PostgreSQLParser.KW_FUNCTION - 188)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 188)) | (1 << (PostgreSQLParser.KW_GLOBAL - 188)) | (1 << (PostgreSQLParser.KW_GRANTED - 188)) | (1 << (PostgreSQLParser.KW_HANDLER - 188)) | (1 << (PostgreSQLParser.KW_HEADER - 188)) | (1 << (PostgreSQLParser.KW_HOLD - 188)) | (1 << (PostgreSQLParser.KW_HOUR - 188)) | (1 << (PostgreSQLParser.KW_IDENTITY - 188)))) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.KW_IF - 220)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 220)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 220)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 220)) | (1 << (PostgreSQLParser.KW_INCLUDING - 220)) | (1 << (PostgreSQLParser.KW_INCREMENT - 220)) | (1 << (PostgreSQLParser.KW_INDEX - 220)) | (1 << (PostgreSQLParser.KW_INDEXES - 220)) | (1 << (PostgreSQLParser.KW_INHERIT - 220)) | (1 << (PostgreSQLParser.KW_INHERITS - 220)) | (1 << (PostgreSQLParser.KW_INLINE - 220)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 220)) | (1 << (PostgreSQLParser.KW_INSERT - 220)) | (1 << (PostgreSQLParser.KW_INSTEAD - 220)) | (1 << (PostgreSQLParser.KW_INVOKER - 220)) | (1 << (PostgreSQLParser.KW_ISOLATION - 220)) | (1 << (PostgreSQLParser.KW_KEY - 220)) | (1 << (PostgreSQLParser.KW_LABEL - 220)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 220)) | (1 << (PostgreSQLParser.KW_LARGE - 220)) | (1 << (PostgreSQLParser.KW_LAST - 220)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 220)) | (1 << (PostgreSQLParser.KW_LEVEL - 220)))) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.KW_LISTEN - 252)) | (1 << (PostgreSQLParser.KW_LOAD - 252)) | (1 << (PostgreSQLParser.KW_LOCAL - 252)) | (1 << (PostgreSQLParser.KW_LOCATION - 252)) | (1 << (PostgreSQLParser.KW_LOCK - 252)) | (1 << (PostgreSQLParser.KW_MAPPING - 252)) | (1 << (PostgreSQLParser.KW_MATCH - 252)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 252)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 252)) | (1 << (PostgreSQLParser.KW_MINUTE - 252)) | (1 << (PostgreSQLParser.KW_MINVALUE - 252)) | (1 << (PostgreSQLParser.KW_MODE - 252)) | (1 << (PostgreSQLParser.KW_MONTH - 252)) | (1 << (PostgreSQLParser.KW_MOVE - 252)) | (1 << (PostgreSQLParser.KW_NAME - 252)) | (1 << (PostgreSQLParser.KW_NAMES - 252)) | (1 << (PostgreSQLParser.KW_NEXT - 252)) | (1 << (PostgreSQLParser.KW_NO - 252)) | (1 << (PostgreSQLParser.KW_NOTHING - 252)) | (1 << (PostgreSQLParser.KW_NOTIFY - 252)) | (1 << (PostgreSQLParser.KW_NOWAIT - 252)) | (1 << (PostgreSQLParser.KW_NULLS - 252)) | (1 << (PostgreSQLParser.KW_OBJECT - 252)) | (1 << (PostgreSQLParser.KW_OF - 252)) | (1 << (PostgreSQLParser.KW_OFF - 252)) | (1 << (PostgreSQLParser.KW_OIDS - 252)) | (1 << (PostgreSQLParser.KW_OPERATOR - 252)) | (1 << (PostgreSQLParser.KW_OPTION - 252)) | (1 << (PostgreSQLParser.KW_OPTIONS - 252)) | (1 << (PostgreSQLParser.KW_OWNED - 252)) | (1 << (PostgreSQLParser.KW_OWNER - 252)) | (1 << (PostgreSQLParser.KW_PARSER - 252)))) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.KW_PARTIAL - 284)) | (1 << (PostgreSQLParser.KW_PARTITION - 284)) | (1 << (PostgreSQLParser.KW_PASSING - 284)) | (1 << (PostgreSQLParser.KW_PASSWORD - 284)) | (1 << (PostgreSQLParser.KW_PLANS - 284)) | (1 << (PostgreSQLParser.KW_PRECEDING - 284)) | (1 << (PostgreSQLParser.KW_PREPARE - 284)) | (1 << (PostgreSQLParser.KW_PREPARED - 284)) | (1 << (PostgreSQLParser.KW_PRESERVE - 284)) | (1 << (PostgreSQLParser.KW_PRIOR - 284)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 284)) | (1 << (PostgreSQLParser.KW_PROGRAM - 284)) | (1 << (PostgreSQLParser.KW_QUOTE - 284)) | (1 << (PostgreSQLParser.KW_RANGE - 284)) | (1 << (PostgreSQLParser.KW_READ - 284)) | (1 << (PostgreSQLParser.KW_REASSIGN - 284)) | (1 << (PostgreSQLParser.KW_RECHECK - 284)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 284)) | (1 << (PostgreSQLParser.KW_REF - 284)) | (1 << (PostgreSQLParser.KW_REFRESH - 284)) | (1 << (PostgreSQLParser.KW_REINDEX - 284)) | (1 << (PostgreSQLParser.KW_RELATIVE - 284)) | (1 << (PostgreSQLParser.KW_RELEASE - 284)) | (1 << (PostgreSQLParser.KW_RENAME - 284)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 284)) | (1 << (PostgreSQLParser.KW_REPLACE - 284)) | (1 << (PostgreSQLParser.KW_REPLICA - 284)) | (1 << (PostgreSQLParser.KW_RESET - 284)) | (1 << (PostgreSQLParser.KW_RESTART - 284)) | (1 << (PostgreSQLParser.KW_RESTRICT - 284)))) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.KW_RETURNS - 316)) | (1 << (PostgreSQLParser.KW_REVOKE - 316)) | (1 << (PostgreSQLParser.KW_ROLE - 316)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 316)) | (1 << (PostgreSQLParser.KW_ROWS - 316)) | (1 << (PostgreSQLParser.KW_RULE - 316)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 316)) | (1 << (PostgreSQLParser.KW_SCHEMA - 316)) | (1 << (PostgreSQLParser.KW_SCROLL - 316)) | (1 << (PostgreSQLParser.KW_SEARCH - 316)) | (1 << (PostgreSQLParser.KW_SECOND - 316)) | (1 << (PostgreSQLParser.KW_SECURITY - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 316)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.KW_SERVER - 316)) | (1 << (PostgreSQLParser.KW_SESSION - 316)) | (1 << (PostgreSQLParser.KW_SET - 316)) | (1 << (PostgreSQLParser.KW_SHARE - 316)) | (1 << (PostgreSQLParser.KW_SHOW - 316)) | (1 << (PostgreSQLParser.KW_SIMPLE - 316)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 316)) | (1 << (PostgreSQLParser.KW_STABLE - 316)) | (1 << (PostgreSQLParser.KW_STANDALONE - 316)) | (1 << (PostgreSQLParser.KW_START - 316)) | (1 << (PostgreSQLParser.KW_STATEMENT - 316)) | (1 << (PostgreSQLParser.KW_STATISTICS - 316)) | (1 << (PostgreSQLParser.KW_STDIN - 316)) | (1 << (PostgreSQLParser.KW_STDOUT - 316)) | (1 << (PostgreSQLParser.KW_STORAGE - 316)) | (1 << (PostgreSQLParser.KW_STRICT - 316)) | (1 << (PostgreSQLParser.KW_STRIP - 316)))) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.KW_SYSID - 348)) | (1 << (PostgreSQLParser.KW_SYSTEM - 348)) | (1 << (PostgreSQLParser.KW_TABLES - 348)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 348)) | (1 << (PostgreSQLParser.KW_TEMP - 348)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 348)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 348)) | (1 << (PostgreSQLParser.KW_TEXT - 348)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 348)) | (1 << (PostgreSQLParser.KW_TRIGGER - 348)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 348)) | (1 << (PostgreSQLParser.KW_TRUSTED - 348)) | (1 << (PostgreSQLParser.KW_TYPE - 348)) | (1 << (PostgreSQLParser.KW_TYPES - 348)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 348)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 348)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 348)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 348)) | (1 << (PostgreSQLParser.KW_UNTIL - 348)) | (1 << (PostgreSQLParser.KW_UPDATE - 348)) | (1 << (PostgreSQLParser.KW_VACUUM - 348)) | (1 << (PostgreSQLParser.KW_VALID - 348)) | (1 << (PostgreSQLParser.KW_VALIDATE - 348)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 348)) | (1 << (PostgreSQLParser.KW_VARYING - 348)) | (1 << (PostgreSQLParser.KW_VERSION - 348)) | (1 << (PostgreSQLParser.KW_VIEW - 348)) | (1 << (PostgreSQLParser.KW_VOLATILE - 348)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 348)) | (1 << (PostgreSQLParser.KW_WITHOUT - 348)))) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.KW_WORK - 380)) | (1 << (PostgreSQLParser.KW_WRAPPER - 380)) | (1 << (PostgreSQLParser.KW_WRITE - 380)) | (1 << (PostgreSQLParser.KW_XML - 380)) | (1 << (PostgreSQLParser.KW_YEAR - 380)) | (1 << (PostgreSQLParser.KW_YES - 380)) | (1 << (PostgreSQLParser.KW_ZONE - 380)) | (1 << (PostgreSQLParser.KW_BETWEEN - 380)) | (1 << (PostgreSQLParser.KW_BIGINT - 380)) | (1 << (PostgreSQLParser.KW_BIT - 380)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 380)) | (1 << (PostgreSQLParser.KW_CHAR - 380)) | (1 << (PostgreSQLParser.KW_CHARACTER - 380)) | (1 << (PostgreSQLParser.KW_COALESCE - 380)) | (1 << (PostgreSQLParser.KW_DEC - 380)) | (1 << (PostgreSQLParser.KW_DECIMAL - 380)) | (1 << (PostgreSQLParser.KW_EXISTS - 380)) | (1 << (PostgreSQLParser.KW_EXTRACT - 380)) | (1 << (PostgreSQLParser.KW_FLOAT - 380)) | (1 << (PostgreSQLParser.KW_GREATEST - 380)) | (1 << (PostgreSQLParser.KW_INOUT - 380)) | (1 << (PostgreSQLParser.KW_INT - 380)) | (1 << (PostgreSQLParser.KW_INTEGER - 380)) | (1 << (PostgreSQLParser.KW_INTERVAL - 380)) | (1 << (PostgreSQLParser.KW_LEAST - 380)) | (1 << (PostgreSQLParser.KW_NATIONAL - 380)) | (1 << (PostgreSQLParser.KW_NCHAR - 380)) | (1 << (PostgreSQLParser.KW_NONE - 380)) | (1 << (PostgreSQLParser.KW_NULLIF - 380)) | (1 << (PostgreSQLParser.KW_NUMERIC - 380)) | (1 << (PostgreSQLParser.KW_OVERLAY - 380)) | (1 << (PostgreSQLParser.KW_POSITION - 380)))) !== 0) || ((((_la - 412)) & ~0x1F) === 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.KW_PRECISION - 412)) | (1 << (PostgreSQLParser.KW_REAL - 412)) | (1 << (PostgreSQLParser.KW_ROW - 412)) | (1 << (PostgreSQLParser.KW_SETOF - 412)) | (1 << (PostgreSQLParser.KW_SMALLINT - 412)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 412)) | (1 << (PostgreSQLParser.KW_TIME - 412)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 412)) | (1 << (PostgreSQLParser.KW_TREAT - 412)) | (1 << (PostgreSQLParser.KW_TRIM - 412)) | (1 << (PostgreSQLParser.KW_VALUES - 412)) | (1 << (PostgreSQLParser.KW_VARCHAR - 412)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 412)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 412)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 412)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 412)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 412)) | (1 << (PostgreSQLParser.KW_XMLPI - 412)) | (1 << (PostgreSQLParser.KW_XMLROOT - 412)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.KW_CALL - 412)) | (1 << (PostgreSQLParser.KW_CURRENT - 412)) | (1 << (PostgreSQLParser.KW_ATTACH - 412)) | (1 << (PostgreSQLParser.KW_DETACH - 412)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 412)) | (1 << (PostgreSQLParser.KW_GENERATED - 412)) | (1 << (PostgreSQLParser.KW_LOGGED - 412)) | (1 << (PostgreSQLParser.KW_STORED - 412)) | (1 << (PostgreSQLParser.KW_INCLUDE - 412)) | (1 << (PostgreSQLParser.KW_ROUTINE - 412)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 412)))) !== 0) || ((((_la - 444)) & ~0x1F) === 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.KW_IMPORT - 444)) | (1 << (PostgreSQLParser.KW_POLICY - 444)) | (1 << (PostgreSQLParser.KW_METHOD - 444)) | (1 << (PostgreSQLParser.KW_REFERENCING - 444)) | (1 << (PostgreSQLParser.KW_NEW - 444)) | (1 << (PostgreSQLParser.KW_OLD - 444)) | (1 << (PostgreSQLParser.KW_VALUE - 444)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 444)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 444)) | (1 << (PostgreSQLParser.KW_OUT - 444)) | (1 << (PostgreSQLParser.KW_ROUTINES - 444)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 444)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 444)) | (1 << (PostgreSQLParser.KW_INPUT - 444)) | (1 << (PostgreSQLParser.KW_SUPPORT - 444)) | (1 << (PostgreSQLParser.KW_PARALLEL - 444)) | (1 << (PostgreSQLParser.KW_SQL - 444)) | (1 << (PostgreSQLParser.KW_DEPENDS - 444)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 444)) | (1 << (PostgreSQLParser.KW_CONFLICT - 444)) | (1 << (PostgreSQLParser.KW_SKIP - 444)) | (1 << (PostgreSQLParser.KW_LOCKED - 444)) | (1 << (PostgreSQLParser.KW_TIES - 444)) | (1 << (PostgreSQLParser.KW_ROLLUP - 444)) | (1 << (PostgreSQLParser.KW_CUBE - 444)) | (1 << (PostgreSQLParser.KW_GROUPING - 444)) | (1 << (PostgreSQLParser.KW_SETS - 444)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 444)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 444)) | (1 << (PostgreSQLParser.KW_COLUMNS - 444)))) !== 0) || ((((_la - 476)) & ~0x1F) === 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.KW_XMLNAMESPACES - 476)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 476)) | (1 << (PostgreSQLParser.KW_WITHIN - 476)) | (1 << (PostgreSQLParser.KW_FILTER - 476)) | (1 << (PostgreSQLParser.KW_GROUPS - 476)) | (1 << (PostgreSQLParser.KW_OTHERS - 476)) | (1 << (PostgreSQLParser.KW_NFC - 476)) | (1 << (PostgreSQLParser.KW_NFD - 476)) | (1 << (PostgreSQLParser.KW_NFKC - 476)) | (1 << (PostgreSQLParser.KW_NFKD - 476)) | (1 << (PostgreSQLParser.KW_UESCAPE - 476)) | (1 << (PostgreSQLParser.KW_VIEWS - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 476)) | (1 << (PostgreSQLParser.KW_DUMP - 476)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.KW_ERROR - 476)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 476)) | (1 << (PostgreSQLParser.KW_ALIAS - 476)) | (1 << (PostgreSQLParser.KW_CONSTANT - 476)) | (1 << (PostgreSQLParser.KW_PERFORM - 476)) | (1 << (PostgreSQLParser.KW_GET - 476)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.KW_STACKED - 476)) | (1 << (PostgreSQLParser.KW_ELSIF - 476)) | (1 << (PostgreSQLParser.KW_REVERSE - 476)) | (1 << (PostgreSQLParser.KW_SLICE - 476)) | (1 << (PostgreSQLParser.KW_EXIT - 476)))) !== 0) || ((((_la - 508)) & ~0x1F) === 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.KW_RETURN - 508)) | (1 << (PostgreSQLParser.KW_QUERY - 508)) | (1 << (PostgreSQLParser.KW_RAISE - 508)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 508)) | (1 << (PostgreSQLParser.KW_DEBUG - 508)) | (1 << (PostgreSQLParser.KW_LOG - 508)) | (1 << (PostgreSQLParser.KW_INFO - 508)) | (1 << (PostgreSQLParser.KW_NOTICE - 508)) | (1 << (PostgreSQLParser.KW_WARNING - 508)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 508)) | (1 << (PostgreSQLParser.KW_ASSERT - 508)) | (1 << (PostgreSQLParser.KW_OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 3217; + this.state = 3264; this.opt_class(); } } @@ -13532,24 +14180,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3220; + this.state = 3267; this.func_expr_windowless(); - this.state = 3222; + this.state = 3269; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 198, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 204, this._ctx) ) { case 1: { - this.state = 3221; + this.state = 3268; this.opt_collate(); } break; } - this.state = 3225; + this.state = 3272; 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)) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.KW_OVER - 124)) | (1 << (PostgreSQLParser.KW_ABORT - 124)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 124)) | (1 << (PostgreSQLParser.KW_ACCESS - 124)) | (1 << (PostgreSQLParser.KW_ACTION - 124)) | (1 << (PostgreSQLParser.KW_ADD - 124)) | (1 << (PostgreSQLParser.KW_ADMIN - 124)) | (1 << (PostgreSQLParser.KW_AFTER - 124)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 124)) | (1 << (PostgreSQLParser.KW_ALSO - 124)) | (1 << (PostgreSQLParser.KW_ALTER - 124)) | (1 << (PostgreSQLParser.KW_ALWAYS - 124)) | (1 << (PostgreSQLParser.KW_ASSERTION - 124)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.KW_AT - 124)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.KW_BACKWARD - 124)) | (1 << (PostgreSQLParser.KW_BEFORE - 124)) | (1 << (PostgreSQLParser.KW_BEGIN - 124)) | (1 << (PostgreSQLParser.KW_BY - 124)) | (1 << (PostgreSQLParser.KW_CACHE - 124)) | (1 << (PostgreSQLParser.KW_CALLED - 124)) | (1 << (PostgreSQLParser.KW_CASCADE - 124)) | (1 << (PostgreSQLParser.KW_CASCADED - 124)) | (1 << (PostgreSQLParser.KW_CATALOG - 124)) | (1 << (PostgreSQLParser.KW_CHAIN - 124)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.KW_CLASS - 156)) | (1 << (PostgreSQLParser.KW_CLOSE - 156)) | (1 << (PostgreSQLParser.KW_CLUSTER - 156)) | (1 << (PostgreSQLParser.KW_COMMENT - 156)) | (1 << (PostgreSQLParser.KW_COMMENTS - 156)) | (1 << (PostgreSQLParser.KW_COMMIT - 156)) | (1 << (PostgreSQLParser.KW_COMMITTED - 156)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 156)) | (1 << (PostgreSQLParser.KW_CONNECTION - 156)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.KW_CONTENT - 156)) | (1 << (PostgreSQLParser.KW_CONTINUE - 156)) | (1 << (PostgreSQLParser.KW_CONVERSION - 156)) | (1 << (PostgreSQLParser.KW_COPY - 156)) | (1 << (PostgreSQLParser.KW_COST - 156)) | (1 << (PostgreSQLParser.KW_CSV - 156)) | (1 << (PostgreSQLParser.KW_CURSOR - 156)) | (1 << (PostgreSQLParser.KW_CYCLE - 156)) | (1 << (PostgreSQLParser.KW_DATA - 156)) | (1 << (PostgreSQLParser.KW_DATABASE - 156)) | (1 << (PostgreSQLParser.KW_DAY - 156)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 156)) | (1 << (PostgreSQLParser.KW_DECLARE - 156)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 156)) | (1 << (PostgreSQLParser.KW_DEFERRED - 156)) | (1 << (PostgreSQLParser.KW_DEFINER - 156)) | (1 << (PostgreSQLParser.KW_DELETE - 156)) | (1 << (PostgreSQLParser.KW_DELIMITER - 156)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 156)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 156)) | (1 << (PostgreSQLParser.KW_DISABLE - 156)) | (1 << (PostgreSQLParser.KW_DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.KW_DOCUMENT - 188)) | (1 << (PostgreSQLParser.KW_DOMAIN - 188)) | (1 << (PostgreSQLParser.KW_DOUBLE - 188)) | (1 << (PostgreSQLParser.KW_DROP - 188)) | (1 << (PostgreSQLParser.KW_EACH - 188)) | (1 << (PostgreSQLParser.KW_ENABLE - 188)) | (1 << (PostgreSQLParser.KW_ENCODING - 188)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 188)) | (1 << (PostgreSQLParser.KW_ENUM - 188)) | (1 << (PostgreSQLParser.KW_ESCAPE - 188)) | (1 << (PostgreSQLParser.KW_EVENT - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 188)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.KW_EXECUTE - 188)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 188)) | (1 << (PostgreSQLParser.KW_EXTENSION - 188)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 188)) | (1 << (PostgreSQLParser.KW_FAMILY - 188)) | (1 << (PostgreSQLParser.KW_FIRST - 188)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 188)) | (1 << (PostgreSQLParser.KW_FORCE - 188)) | (1 << (PostgreSQLParser.KW_FORWARD - 188)) | (1 << (PostgreSQLParser.KW_FUNCTION - 188)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 188)) | (1 << (PostgreSQLParser.KW_GLOBAL - 188)) | (1 << (PostgreSQLParser.KW_GRANTED - 188)) | (1 << (PostgreSQLParser.KW_HANDLER - 188)) | (1 << (PostgreSQLParser.KW_HEADER - 188)) | (1 << (PostgreSQLParser.KW_HOLD - 188)) | (1 << (PostgreSQLParser.KW_HOUR - 188)) | (1 << (PostgreSQLParser.KW_IDENTITY - 188)))) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.KW_IF - 220)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 220)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 220)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 220)) | (1 << (PostgreSQLParser.KW_INCLUDING - 220)) | (1 << (PostgreSQLParser.KW_INCREMENT - 220)) | (1 << (PostgreSQLParser.KW_INDEX - 220)) | (1 << (PostgreSQLParser.KW_INDEXES - 220)) | (1 << (PostgreSQLParser.KW_INHERIT - 220)) | (1 << (PostgreSQLParser.KW_INHERITS - 220)) | (1 << (PostgreSQLParser.KW_INLINE - 220)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 220)) | (1 << (PostgreSQLParser.KW_INSERT - 220)) | (1 << (PostgreSQLParser.KW_INSTEAD - 220)) | (1 << (PostgreSQLParser.KW_INVOKER - 220)) | (1 << (PostgreSQLParser.KW_ISOLATION - 220)) | (1 << (PostgreSQLParser.KW_KEY - 220)) | (1 << (PostgreSQLParser.KW_LABEL - 220)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 220)) | (1 << (PostgreSQLParser.KW_LARGE - 220)) | (1 << (PostgreSQLParser.KW_LAST - 220)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 220)) | (1 << (PostgreSQLParser.KW_LEVEL - 220)))) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.KW_LISTEN - 252)) | (1 << (PostgreSQLParser.KW_LOAD - 252)) | (1 << (PostgreSQLParser.KW_LOCAL - 252)) | (1 << (PostgreSQLParser.KW_LOCATION - 252)) | (1 << (PostgreSQLParser.KW_LOCK - 252)) | (1 << (PostgreSQLParser.KW_MAPPING - 252)) | (1 << (PostgreSQLParser.KW_MATCH - 252)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 252)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 252)) | (1 << (PostgreSQLParser.KW_MINUTE - 252)) | (1 << (PostgreSQLParser.KW_MINVALUE - 252)) | (1 << (PostgreSQLParser.KW_MODE - 252)) | (1 << (PostgreSQLParser.KW_MONTH - 252)) | (1 << (PostgreSQLParser.KW_MOVE - 252)) | (1 << (PostgreSQLParser.KW_NAME - 252)) | (1 << (PostgreSQLParser.KW_NAMES - 252)) | (1 << (PostgreSQLParser.KW_NEXT - 252)) | (1 << (PostgreSQLParser.KW_NO - 252)) | (1 << (PostgreSQLParser.KW_NOTHING - 252)) | (1 << (PostgreSQLParser.KW_NOTIFY - 252)) | (1 << (PostgreSQLParser.KW_NOWAIT - 252)) | (1 << (PostgreSQLParser.KW_NULLS - 252)) | (1 << (PostgreSQLParser.KW_OBJECT - 252)) | (1 << (PostgreSQLParser.KW_OF - 252)) | (1 << (PostgreSQLParser.KW_OFF - 252)) | (1 << (PostgreSQLParser.KW_OIDS - 252)) | (1 << (PostgreSQLParser.KW_OPERATOR - 252)) | (1 << (PostgreSQLParser.KW_OPTION - 252)) | (1 << (PostgreSQLParser.KW_OPTIONS - 252)) | (1 << (PostgreSQLParser.KW_OWNED - 252)) | (1 << (PostgreSQLParser.KW_OWNER - 252)) | (1 << (PostgreSQLParser.KW_PARSER - 252)))) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.KW_PARTIAL - 284)) | (1 << (PostgreSQLParser.KW_PARTITION - 284)) | (1 << (PostgreSQLParser.KW_PASSING - 284)) | (1 << (PostgreSQLParser.KW_PASSWORD - 284)) | (1 << (PostgreSQLParser.KW_PLANS - 284)) | (1 << (PostgreSQLParser.KW_PRECEDING - 284)) | (1 << (PostgreSQLParser.KW_PREPARE - 284)) | (1 << (PostgreSQLParser.KW_PREPARED - 284)) | (1 << (PostgreSQLParser.KW_PRESERVE - 284)) | (1 << (PostgreSQLParser.KW_PRIOR - 284)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 284)) | (1 << (PostgreSQLParser.KW_PROGRAM - 284)) | (1 << (PostgreSQLParser.KW_QUOTE - 284)) | (1 << (PostgreSQLParser.KW_RANGE - 284)) | (1 << (PostgreSQLParser.KW_READ - 284)) | (1 << (PostgreSQLParser.KW_REASSIGN - 284)) | (1 << (PostgreSQLParser.KW_RECHECK - 284)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 284)) | (1 << (PostgreSQLParser.KW_REF - 284)) | (1 << (PostgreSQLParser.KW_REFRESH - 284)) | (1 << (PostgreSQLParser.KW_REINDEX - 284)) | (1 << (PostgreSQLParser.KW_RELATIVE - 284)) | (1 << (PostgreSQLParser.KW_RELEASE - 284)) | (1 << (PostgreSQLParser.KW_RENAME - 284)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 284)) | (1 << (PostgreSQLParser.KW_REPLACE - 284)) | (1 << (PostgreSQLParser.KW_REPLICA - 284)) | (1 << (PostgreSQLParser.KW_RESET - 284)) | (1 << (PostgreSQLParser.KW_RESTART - 284)) | (1 << (PostgreSQLParser.KW_RESTRICT - 284)))) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.KW_RETURNS - 316)) | (1 << (PostgreSQLParser.KW_REVOKE - 316)) | (1 << (PostgreSQLParser.KW_ROLE - 316)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 316)) | (1 << (PostgreSQLParser.KW_ROWS - 316)) | (1 << (PostgreSQLParser.KW_RULE - 316)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 316)) | (1 << (PostgreSQLParser.KW_SCHEMA - 316)) | (1 << (PostgreSQLParser.KW_SCROLL - 316)) | (1 << (PostgreSQLParser.KW_SEARCH - 316)) | (1 << (PostgreSQLParser.KW_SECOND - 316)) | (1 << (PostgreSQLParser.KW_SECURITY - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 316)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.KW_SERVER - 316)) | (1 << (PostgreSQLParser.KW_SESSION - 316)) | (1 << (PostgreSQLParser.KW_SET - 316)) | (1 << (PostgreSQLParser.KW_SHARE - 316)) | (1 << (PostgreSQLParser.KW_SHOW - 316)) | (1 << (PostgreSQLParser.KW_SIMPLE - 316)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 316)) | (1 << (PostgreSQLParser.KW_STABLE - 316)) | (1 << (PostgreSQLParser.KW_STANDALONE - 316)) | (1 << (PostgreSQLParser.KW_START - 316)) | (1 << (PostgreSQLParser.KW_STATEMENT - 316)) | (1 << (PostgreSQLParser.KW_STATISTICS - 316)) | (1 << (PostgreSQLParser.KW_STDIN - 316)) | (1 << (PostgreSQLParser.KW_STDOUT - 316)) | (1 << (PostgreSQLParser.KW_STORAGE - 316)) | (1 << (PostgreSQLParser.KW_STRICT - 316)) | (1 << (PostgreSQLParser.KW_STRIP - 316)))) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.KW_SYSID - 348)) | (1 << (PostgreSQLParser.KW_SYSTEM - 348)) | (1 << (PostgreSQLParser.KW_TABLES - 348)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 348)) | (1 << (PostgreSQLParser.KW_TEMP - 348)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 348)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 348)) | (1 << (PostgreSQLParser.KW_TEXT - 348)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 348)) | (1 << (PostgreSQLParser.KW_TRIGGER - 348)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 348)) | (1 << (PostgreSQLParser.KW_TRUSTED - 348)) | (1 << (PostgreSQLParser.KW_TYPE - 348)) | (1 << (PostgreSQLParser.KW_TYPES - 348)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 348)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 348)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 348)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 348)) | (1 << (PostgreSQLParser.KW_UNTIL - 348)) | (1 << (PostgreSQLParser.KW_UPDATE - 348)) | (1 << (PostgreSQLParser.KW_VACUUM - 348)) | (1 << (PostgreSQLParser.KW_VALID - 348)) | (1 << (PostgreSQLParser.KW_VALIDATE - 348)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 348)) | (1 << (PostgreSQLParser.KW_VARYING - 348)) | (1 << (PostgreSQLParser.KW_VERSION - 348)) | (1 << (PostgreSQLParser.KW_VIEW - 348)) | (1 << (PostgreSQLParser.KW_VOLATILE - 348)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 348)) | (1 << (PostgreSQLParser.KW_WITHOUT - 348)))) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.KW_WORK - 380)) | (1 << (PostgreSQLParser.KW_WRAPPER - 380)) | (1 << (PostgreSQLParser.KW_WRITE - 380)) | (1 << (PostgreSQLParser.KW_XML - 380)) | (1 << (PostgreSQLParser.KW_YEAR - 380)) | (1 << (PostgreSQLParser.KW_YES - 380)) | (1 << (PostgreSQLParser.KW_ZONE - 380)) | (1 << (PostgreSQLParser.KW_BETWEEN - 380)) | (1 << (PostgreSQLParser.KW_BIGINT - 380)) | (1 << (PostgreSQLParser.KW_BIT - 380)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 380)) | (1 << (PostgreSQLParser.KW_CHAR - 380)) | (1 << (PostgreSQLParser.KW_CHARACTER - 380)) | (1 << (PostgreSQLParser.KW_COALESCE - 380)) | (1 << (PostgreSQLParser.KW_DEC - 380)) | (1 << (PostgreSQLParser.KW_DECIMAL - 380)) | (1 << (PostgreSQLParser.KW_EXISTS - 380)) | (1 << (PostgreSQLParser.KW_EXTRACT - 380)) | (1 << (PostgreSQLParser.KW_FLOAT - 380)) | (1 << (PostgreSQLParser.KW_GREATEST - 380)) | (1 << (PostgreSQLParser.KW_INOUT - 380)) | (1 << (PostgreSQLParser.KW_INT - 380)) | (1 << (PostgreSQLParser.KW_INTEGER - 380)) | (1 << (PostgreSQLParser.KW_INTERVAL - 380)) | (1 << (PostgreSQLParser.KW_LEAST - 380)) | (1 << (PostgreSQLParser.KW_NATIONAL - 380)) | (1 << (PostgreSQLParser.KW_NCHAR - 380)) | (1 << (PostgreSQLParser.KW_NONE - 380)) | (1 << (PostgreSQLParser.KW_NULLIF - 380)) | (1 << (PostgreSQLParser.KW_NUMERIC - 380)) | (1 << (PostgreSQLParser.KW_OVERLAY - 380)) | (1 << (PostgreSQLParser.KW_POSITION - 380)))) !== 0) || ((((_la - 412)) & ~0x1F) === 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.KW_PRECISION - 412)) | (1 << (PostgreSQLParser.KW_REAL - 412)) | (1 << (PostgreSQLParser.KW_ROW - 412)) | (1 << (PostgreSQLParser.KW_SETOF - 412)) | (1 << (PostgreSQLParser.KW_SMALLINT - 412)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 412)) | (1 << (PostgreSQLParser.KW_TIME - 412)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 412)) | (1 << (PostgreSQLParser.KW_TREAT - 412)) | (1 << (PostgreSQLParser.KW_TRIM - 412)) | (1 << (PostgreSQLParser.KW_VALUES - 412)) | (1 << (PostgreSQLParser.KW_VARCHAR - 412)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 412)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 412)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 412)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 412)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 412)) | (1 << (PostgreSQLParser.KW_XMLPI - 412)) | (1 << (PostgreSQLParser.KW_XMLROOT - 412)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.KW_CALL - 412)) | (1 << (PostgreSQLParser.KW_CURRENT - 412)) | (1 << (PostgreSQLParser.KW_ATTACH - 412)) | (1 << (PostgreSQLParser.KW_DETACH - 412)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 412)) | (1 << (PostgreSQLParser.KW_GENERATED - 412)) | (1 << (PostgreSQLParser.KW_LOGGED - 412)) | (1 << (PostgreSQLParser.KW_STORED - 412)) | (1 << (PostgreSQLParser.KW_INCLUDE - 412)) | (1 << (PostgreSQLParser.KW_ROUTINE - 412)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 412)))) !== 0) || ((((_la - 444)) & ~0x1F) === 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.KW_IMPORT - 444)) | (1 << (PostgreSQLParser.KW_POLICY - 444)) | (1 << (PostgreSQLParser.KW_METHOD - 444)) | (1 << (PostgreSQLParser.KW_REFERENCING - 444)) | (1 << (PostgreSQLParser.KW_NEW - 444)) | (1 << (PostgreSQLParser.KW_OLD - 444)) | (1 << (PostgreSQLParser.KW_VALUE - 444)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 444)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 444)) | (1 << (PostgreSQLParser.KW_OUT - 444)) | (1 << (PostgreSQLParser.KW_ROUTINES - 444)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 444)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 444)) | (1 << (PostgreSQLParser.KW_INPUT - 444)) | (1 << (PostgreSQLParser.KW_SUPPORT - 444)) | (1 << (PostgreSQLParser.KW_PARALLEL - 444)) | (1 << (PostgreSQLParser.KW_SQL - 444)) | (1 << (PostgreSQLParser.KW_DEPENDS - 444)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 444)) | (1 << (PostgreSQLParser.KW_CONFLICT - 444)) | (1 << (PostgreSQLParser.KW_SKIP - 444)) | (1 << (PostgreSQLParser.KW_LOCKED - 444)) | (1 << (PostgreSQLParser.KW_TIES - 444)) | (1 << (PostgreSQLParser.KW_ROLLUP - 444)) | (1 << (PostgreSQLParser.KW_CUBE - 444)) | (1 << (PostgreSQLParser.KW_GROUPING - 444)) | (1 << (PostgreSQLParser.KW_SETS - 444)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 444)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 444)) | (1 << (PostgreSQLParser.KW_COLUMNS - 444)))) !== 0) || ((((_la - 476)) & ~0x1F) === 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.KW_XMLNAMESPACES - 476)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 476)) | (1 << (PostgreSQLParser.KW_WITHIN - 476)) | (1 << (PostgreSQLParser.KW_FILTER - 476)) | (1 << (PostgreSQLParser.KW_GROUPS - 476)) | (1 << (PostgreSQLParser.KW_OTHERS - 476)) | (1 << (PostgreSQLParser.KW_NFC - 476)) | (1 << (PostgreSQLParser.KW_NFD - 476)) | (1 << (PostgreSQLParser.KW_NFKC - 476)) | (1 << (PostgreSQLParser.KW_NFKD - 476)) | (1 << (PostgreSQLParser.KW_UESCAPE - 476)) | (1 << (PostgreSQLParser.KW_VIEWS - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 476)) | (1 << (PostgreSQLParser.KW_DUMP - 476)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.KW_ERROR - 476)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 476)) | (1 << (PostgreSQLParser.KW_ALIAS - 476)) | (1 << (PostgreSQLParser.KW_CONSTANT - 476)) | (1 << (PostgreSQLParser.KW_PERFORM - 476)) | (1 << (PostgreSQLParser.KW_GET - 476)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.KW_STACKED - 476)) | (1 << (PostgreSQLParser.KW_ELSIF - 476)) | (1 << (PostgreSQLParser.KW_REVERSE - 476)) | (1 << (PostgreSQLParser.KW_SLICE - 476)) | (1 << (PostgreSQLParser.KW_EXIT - 476)))) !== 0) || ((((_la - 508)) & ~0x1F) === 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.KW_RETURN - 508)) | (1 << (PostgreSQLParser.KW_QUERY - 508)) | (1 << (PostgreSQLParser.KW_RAISE - 508)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 508)) | (1 << (PostgreSQLParser.KW_DEBUG - 508)) | (1 << (PostgreSQLParser.KW_LOG - 508)) | (1 << (PostgreSQLParser.KW_INFO - 508)) | (1 << (PostgreSQLParser.KW_NOTICE - 508)) | (1 << (PostgreSQLParser.KW_WARNING - 508)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 508)) | (1 << (PostgreSQLParser.KW_ASSERT - 508)) | (1 << (PostgreSQLParser.KW_OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 3224; + this.state = 3271; this.opt_class(); } } @@ -13560,28 +14208,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 3227; + this.state = 3274; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3228; + this.state = 3275; this.a_expr(); - this.state = 3229; + this.state = 3276; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 3231; + this.state = 3278; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 200, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 206, this._ctx) ) { case 1: { - this.state = 3230; + this.state = 3277; this.opt_collate(); } break; } - this.state = 3234; + this.state = 3281; 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)) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.KW_OVER - 124)) | (1 << (PostgreSQLParser.KW_ABORT - 124)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 124)) | (1 << (PostgreSQLParser.KW_ACCESS - 124)) | (1 << (PostgreSQLParser.KW_ACTION - 124)) | (1 << (PostgreSQLParser.KW_ADD - 124)) | (1 << (PostgreSQLParser.KW_ADMIN - 124)) | (1 << (PostgreSQLParser.KW_AFTER - 124)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 124)) | (1 << (PostgreSQLParser.KW_ALSO - 124)) | (1 << (PostgreSQLParser.KW_ALTER - 124)) | (1 << (PostgreSQLParser.KW_ALWAYS - 124)) | (1 << (PostgreSQLParser.KW_ASSERTION - 124)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.KW_AT - 124)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.KW_BACKWARD - 124)) | (1 << (PostgreSQLParser.KW_BEFORE - 124)) | (1 << (PostgreSQLParser.KW_BEGIN - 124)) | (1 << (PostgreSQLParser.KW_BY - 124)) | (1 << (PostgreSQLParser.KW_CACHE - 124)) | (1 << (PostgreSQLParser.KW_CALLED - 124)) | (1 << (PostgreSQLParser.KW_CASCADE - 124)) | (1 << (PostgreSQLParser.KW_CASCADED - 124)) | (1 << (PostgreSQLParser.KW_CATALOG - 124)) | (1 << (PostgreSQLParser.KW_CHAIN - 124)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.KW_CLASS - 156)) | (1 << (PostgreSQLParser.KW_CLOSE - 156)) | (1 << (PostgreSQLParser.KW_CLUSTER - 156)) | (1 << (PostgreSQLParser.KW_COMMENT - 156)) | (1 << (PostgreSQLParser.KW_COMMENTS - 156)) | (1 << (PostgreSQLParser.KW_COMMIT - 156)) | (1 << (PostgreSQLParser.KW_COMMITTED - 156)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 156)) | (1 << (PostgreSQLParser.KW_CONNECTION - 156)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.KW_CONTENT - 156)) | (1 << (PostgreSQLParser.KW_CONTINUE - 156)) | (1 << (PostgreSQLParser.KW_CONVERSION - 156)) | (1 << (PostgreSQLParser.KW_COPY - 156)) | (1 << (PostgreSQLParser.KW_COST - 156)) | (1 << (PostgreSQLParser.KW_CSV - 156)) | (1 << (PostgreSQLParser.KW_CURSOR - 156)) | (1 << (PostgreSQLParser.KW_CYCLE - 156)) | (1 << (PostgreSQLParser.KW_DATA - 156)) | (1 << (PostgreSQLParser.KW_DATABASE - 156)) | (1 << (PostgreSQLParser.KW_DAY - 156)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 156)) | (1 << (PostgreSQLParser.KW_DECLARE - 156)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 156)) | (1 << (PostgreSQLParser.KW_DEFERRED - 156)) | (1 << (PostgreSQLParser.KW_DEFINER - 156)) | (1 << (PostgreSQLParser.KW_DELETE - 156)) | (1 << (PostgreSQLParser.KW_DELIMITER - 156)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 156)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 156)) | (1 << (PostgreSQLParser.KW_DISABLE - 156)) | (1 << (PostgreSQLParser.KW_DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.KW_DOCUMENT - 188)) | (1 << (PostgreSQLParser.KW_DOMAIN - 188)) | (1 << (PostgreSQLParser.KW_DOUBLE - 188)) | (1 << (PostgreSQLParser.KW_DROP - 188)) | (1 << (PostgreSQLParser.KW_EACH - 188)) | (1 << (PostgreSQLParser.KW_ENABLE - 188)) | (1 << (PostgreSQLParser.KW_ENCODING - 188)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 188)) | (1 << (PostgreSQLParser.KW_ENUM - 188)) | (1 << (PostgreSQLParser.KW_ESCAPE - 188)) | (1 << (PostgreSQLParser.KW_EVENT - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 188)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.KW_EXECUTE - 188)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 188)) | (1 << (PostgreSQLParser.KW_EXTENSION - 188)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 188)) | (1 << (PostgreSQLParser.KW_FAMILY - 188)) | (1 << (PostgreSQLParser.KW_FIRST - 188)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 188)) | (1 << (PostgreSQLParser.KW_FORCE - 188)) | (1 << (PostgreSQLParser.KW_FORWARD - 188)) | (1 << (PostgreSQLParser.KW_FUNCTION - 188)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 188)) | (1 << (PostgreSQLParser.KW_GLOBAL - 188)) | (1 << (PostgreSQLParser.KW_GRANTED - 188)) | (1 << (PostgreSQLParser.KW_HANDLER - 188)) | (1 << (PostgreSQLParser.KW_HEADER - 188)) | (1 << (PostgreSQLParser.KW_HOLD - 188)) | (1 << (PostgreSQLParser.KW_HOUR - 188)) | (1 << (PostgreSQLParser.KW_IDENTITY - 188)))) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.KW_IF - 220)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 220)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 220)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 220)) | (1 << (PostgreSQLParser.KW_INCLUDING - 220)) | (1 << (PostgreSQLParser.KW_INCREMENT - 220)) | (1 << (PostgreSQLParser.KW_INDEX - 220)) | (1 << (PostgreSQLParser.KW_INDEXES - 220)) | (1 << (PostgreSQLParser.KW_INHERIT - 220)) | (1 << (PostgreSQLParser.KW_INHERITS - 220)) | (1 << (PostgreSQLParser.KW_INLINE - 220)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 220)) | (1 << (PostgreSQLParser.KW_INSERT - 220)) | (1 << (PostgreSQLParser.KW_INSTEAD - 220)) | (1 << (PostgreSQLParser.KW_INVOKER - 220)) | (1 << (PostgreSQLParser.KW_ISOLATION - 220)) | (1 << (PostgreSQLParser.KW_KEY - 220)) | (1 << (PostgreSQLParser.KW_LABEL - 220)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 220)) | (1 << (PostgreSQLParser.KW_LARGE - 220)) | (1 << (PostgreSQLParser.KW_LAST - 220)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 220)) | (1 << (PostgreSQLParser.KW_LEVEL - 220)))) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.KW_LISTEN - 252)) | (1 << (PostgreSQLParser.KW_LOAD - 252)) | (1 << (PostgreSQLParser.KW_LOCAL - 252)) | (1 << (PostgreSQLParser.KW_LOCATION - 252)) | (1 << (PostgreSQLParser.KW_LOCK - 252)) | (1 << (PostgreSQLParser.KW_MAPPING - 252)) | (1 << (PostgreSQLParser.KW_MATCH - 252)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 252)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 252)) | (1 << (PostgreSQLParser.KW_MINUTE - 252)) | (1 << (PostgreSQLParser.KW_MINVALUE - 252)) | (1 << (PostgreSQLParser.KW_MODE - 252)) | (1 << (PostgreSQLParser.KW_MONTH - 252)) | (1 << (PostgreSQLParser.KW_MOVE - 252)) | (1 << (PostgreSQLParser.KW_NAME - 252)) | (1 << (PostgreSQLParser.KW_NAMES - 252)) | (1 << (PostgreSQLParser.KW_NEXT - 252)) | (1 << (PostgreSQLParser.KW_NO - 252)) | (1 << (PostgreSQLParser.KW_NOTHING - 252)) | (1 << (PostgreSQLParser.KW_NOTIFY - 252)) | (1 << (PostgreSQLParser.KW_NOWAIT - 252)) | (1 << (PostgreSQLParser.KW_NULLS - 252)) | (1 << (PostgreSQLParser.KW_OBJECT - 252)) | (1 << (PostgreSQLParser.KW_OF - 252)) | (1 << (PostgreSQLParser.KW_OFF - 252)) | (1 << (PostgreSQLParser.KW_OIDS - 252)) | (1 << (PostgreSQLParser.KW_OPERATOR - 252)) | (1 << (PostgreSQLParser.KW_OPTION - 252)) | (1 << (PostgreSQLParser.KW_OPTIONS - 252)) | (1 << (PostgreSQLParser.KW_OWNED - 252)) | (1 << (PostgreSQLParser.KW_OWNER - 252)) | (1 << (PostgreSQLParser.KW_PARSER - 252)))) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.KW_PARTIAL - 284)) | (1 << (PostgreSQLParser.KW_PARTITION - 284)) | (1 << (PostgreSQLParser.KW_PASSING - 284)) | (1 << (PostgreSQLParser.KW_PASSWORD - 284)) | (1 << (PostgreSQLParser.KW_PLANS - 284)) | (1 << (PostgreSQLParser.KW_PRECEDING - 284)) | (1 << (PostgreSQLParser.KW_PREPARE - 284)) | (1 << (PostgreSQLParser.KW_PREPARED - 284)) | (1 << (PostgreSQLParser.KW_PRESERVE - 284)) | (1 << (PostgreSQLParser.KW_PRIOR - 284)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 284)) | (1 << (PostgreSQLParser.KW_PROGRAM - 284)) | (1 << (PostgreSQLParser.KW_QUOTE - 284)) | (1 << (PostgreSQLParser.KW_RANGE - 284)) | (1 << (PostgreSQLParser.KW_READ - 284)) | (1 << (PostgreSQLParser.KW_REASSIGN - 284)) | (1 << (PostgreSQLParser.KW_RECHECK - 284)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 284)) | (1 << (PostgreSQLParser.KW_REF - 284)) | (1 << (PostgreSQLParser.KW_REFRESH - 284)) | (1 << (PostgreSQLParser.KW_REINDEX - 284)) | (1 << (PostgreSQLParser.KW_RELATIVE - 284)) | (1 << (PostgreSQLParser.KW_RELEASE - 284)) | (1 << (PostgreSQLParser.KW_RENAME - 284)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 284)) | (1 << (PostgreSQLParser.KW_REPLACE - 284)) | (1 << (PostgreSQLParser.KW_REPLICA - 284)) | (1 << (PostgreSQLParser.KW_RESET - 284)) | (1 << (PostgreSQLParser.KW_RESTART - 284)) | (1 << (PostgreSQLParser.KW_RESTRICT - 284)))) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.KW_RETURNS - 316)) | (1 << (PostgreSQLParser.KW_REVOKE - 316)) | (1 << (PostgreSQLParser.KW_ROLE - 316)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 316)) | (1 << (PostgreSQLParser.KW_ROWS - 316)) | (1 << (PostgreSQLParser.KW_RULE - 316)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 316)) | (1 << (PostgreSQLParser.KW_SCHEMA - 316)) | (1 << (PostgreSQLParser.KW_SCROLL - 316)) | (1 << (PostgreSQLParser.KW_SEARCH - 316)) | (1 << (PostgreSQLParser.KW_SECOND - 316)) | (1 << (PostgreSQLParser.KW_SECURITY - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 316)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.KW_SERVER - 316)) | (1 << (PostgreSQLParser.KW_SESSION - 316)) | (1 << (PostgreSQLParser.KW_SET - 316)) | (1 << (PostgreSQLParser.KW_SHARE - 316)) | (1 << (PostgreSQLParser.KW_SHOW - 316)) | (1 << (PostgreSQLParser.KW_SIMPLE - 316)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 316)) | (1 << (PostgreSQLParser.KW_STABLE - 316)) | (1 << (PostgreSQLParser.KW_STANDALONE - 316)) | (1 << (PostgreSQLParser.KW_START - 316)) | (1 << (PostgreSQLParser.KW_STATEMENT - 316)) | (1 << (PostgreSQLParser.KW_STATISTICS - 316)) | (1 << (PostgreSQLParser.KW_STDIN - 316)) | (1 << (PostgreSQLParser.KW_STDOUT - 316)) | (1 << (PostgreSQLParser.KW_STORAGE - 316)) | (1 << (PostgreSQLParser.KW_STRICT - 316)) | (1 << (PostgreSQLParser.KW_STRIP - 316)))) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.KW_SYSID - 348)) | (1 << (PostgreSQLParser.KW_SYSTEM - 348)) | (1 << (PostgreSQLParser.KW_TABLES - 348)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 348)) | (1 << (PostgreSQLParser.KW_TEMP - 348)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 348)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 348)) | (1 << (PostgreSQLParser.KW_TEXT - 348)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 348)) | (1 << (PostgreSQLParser.KW_TRIGGER - 348)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 348)) | (1 << (PostgreSQLParser.KW_TRUSTED - 348)) | (1 << (PostgreSQLParser.KW_TYPE - 348)) | (1 << (PostgreSQLParser.KW_TYPES - 348)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 348)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 348)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 348)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 348)) | (1 << (PostgreSQLParser.KW_UNTIL - 348)) | (1 << (PostgreSQLParser.KW_UPDATE - 348)) | (1 << (PostgreSQLParser.KW_VACUUM - 348)) | (1 << (PostgreSQLParser.KW_VALID - 348)) | (1 << (PostgreSQLParser.KW_VALIDATE - 348)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 348)) | (1 << (PostgreSQLParser.KW_VARYING - 348)) | (1 << (PostgreSQLParser.KW_VERSION - 348)) | (1 << (PostgreSQLParser.KW_VIEW - 348)) | (1 << (PostgreSQLParser.KW_VOLATILE - 348)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 348)) | (1 << (PostgreSQLParser.KW_WITHOUT - 348)))) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.KW_WORK - 380)) | (1 << (PostgreSQLParser.KW_WRAPPER - 380)) | (1 << (PostgreSQLParser.KW_WRITE - 380)) | (1 << (PostgreSQLParser.KW_XML - 380)) | (1 << (PostgreSQLParser.KW_YEAR - 380)) | (1 << (PostgreSQLParser.KW_YES - 380)) | (1 << (PostgreSQLParser.KW_ZONE - 380)) | (1 << (PostgreSQLParser.KW_BETWEEN - 380)) | (1 << (PostgreSQLParser.KW_BIGINT - 380)) | (1 << (PostgreSQLParser.KW_BIT - 380)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 380)) | (1 << (PostgreSQLParser.KW_CHAR - 380)) | (1 << (PostgreSQLParser.KW_CHARACTER - 380)) | (1 << (PostgreSQLParser.KW_COALESCE - 380)) | (1 << (PostgreSQLParser.KW_DEC - 380)) | (1 << (PostgreSQLParser.KW_DECIMAL - 380)) | (1 << (PostgreSQLParser.KW_EXISTS - 380)) | (1 << (PostgreSQLParser.KW_EXTRACT - 380)) | (1 << (PostgreSQLParser.KW_FLOAT - 380)) | (1 << (PostgreSQLParser.KW_GREATEST - 380)) | (1 << (PostgreSQLParser.KW_INOUT - 380)) | (1 << (PostgreSQLParser.KW_INT - 380)) | (1 << (PostgreSQLParser.KW_INTEGER - 380)) | (1 << (PostgreSQLParser.KW_INTERVAL - 380)) | (1 << (PostgreSQLParser.KW_LEAST - 380)) | (1 << (PostgreSQLParser.KW_NATIONAL - 380)) | (1 << (PostgreSQLParser.KW_NCHAR - 380)) | (1 << (PostgreSQLParser.KW_NONE - 380)) | (1 << (PostgreSQLParser.KW_NULLIF - 380)) | (1 << (PostgreSQLParser.KW_NUMERIC - 380)) | (1 << (PostgreSQLParser.KW_OVERLAY - 380)) | (1 << (PostgreSQLParser.KW_POSITION - 380)))) !== 0) || ((((_la - 412)) & ~0x1F) === 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.KW_PRECISION - 412)) | (1 << (PostgreSQLParser.KW_REAL - 412)) | (1 << (PostgreSQLParser.KW_ROW - 412)) | (1 << (PostgreSQLParser.KW_SETOF - 412)) | (1 << (PostgreSQLParser.KW_SMALLINT - 412)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 412)) | (1 << (PostgreSQLParser.KW_TIME - 412)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 412)) | (1 << (PostgreSQLParser.KW_TREAT - 412)) | (1 << (PostgreSQLParser.KW_TRIM - 412)) | (1 << (PostgreSQLParser.KW_VALUES - 412)) | (1 << (PostgreSQLParser.KW_VARCHAR - 412)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 412)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 412)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 412)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 412)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 412)) | (1 << (PostgreSQLParser.KW_XMLPI - 412)) | (1 << (PostgreSQLParser.KW_XMLROOT - 412)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.KW_CALL - 412)) | (1 << (PostgreSQLParser.KW_CURRENT - 412)) | (1 << (PostgreSQLParser.KW_ATTACH - 412)) | (1 << (PostgreSQLParser.KW_DETACH - 412)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 412)) | (1 << (PostgreSQLParser.KW_GENERATED - 412)) | (1 << (PostgreSQLParser.KW_LOGGED - 412)) | (1 << (PostgreSQLParser.KW_STORED - 412)) | (1 << (PostgreSQLParser.KW_INCLUDE - 412)) | (1 << (PostgreSQLParser.KW_ROUTINE - 412)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 412)))) !== 0) || ((((_la - 444)) & ~0x1F) === 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.KW_IMPORT - 444)) | (1 << (PostgreSQLParser.KW_POLICY - 444)) | (1 << (PostgreSQLParser.KW_METHOD - 444)) | (1 << (PostgreSQLParser.KW_REFERENCING - 444)) | (1 << (PostgreSQLParser.KW_NEW - 444)) | (1 << (PostgreSQLParser.KW_OLD - 444)) | (1 << (PostgreSQLParser.KW_VALUE - 444)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 444)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 444)) | (1 << (PostgreSQLParser.KW_OUT - 444)) | (1 << (PostgreSQLParser.KW_ROUTINES - 444)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 444)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 444)) | (1 << (PostgreSQLParser.KW_INPUT - 444)) | (1 << (PostgreSQLParser.KW_SUPPORT - 444)) | (1 << (PostgreSQLParser.KW_PARALLEL - 444)) | (1 << (PostgreSQLParser.KW_SQL - 444)) | (1 << (PostgreSQLParser.KW_DEPENDS - 444)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 444)) | (1 << (PostgreSQLParser.KW_CONFLICT - 444)) | (1 << (PostgreSQLParser.KW_SKIP - 444)) | (1 << (PostgreSQLParser.KW_LOCKED - 444)) | (1 << (PostgreSQLParser.KW_TIES - 444)) | (1 << (PostgreSQLParser.KW_ROLLUP - 444)) | (1 << (PostgreSQLParser.KW_CUBE - 444)) | (1 << (PostgreSQLParser.KW_GROUPING - 444)) | (1 << (PostgreSQLParser.KW_SETS - 444)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 444)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 444)) | (1 << (PostgreSQLParser.KW_COLUMNS - 444)))) !== 0) || ((((_la - 476)) & ~0x1F) === 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.KW_XMLNAMESPACES - 476)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 476)) | (1 << (PostgreSQLParser.KW_WITHIN - 476)) | (1 << (PostgreSQLParser.KW_FILTER - 476)) | (1 << (PostgreSQLParser.KW_GROUPS - 476)) | (1 << (PostgreSQLParser.KW_OTHERS - 476)) | (1 << (PostgreSQLParser.KW_NFC - 476)) | (1 << (PostgreSQLParser.KW_NFD - 476)) | (1 << (PostgreSQLParser.KW_NFKC - 476)) | (1 << (PostgreSQLParser.KW_NFKD - 476)) | (1 << (PostgreSQLParser.KW_UESCAPE - 476)) | (1 << (PostgreSQLParser.KW_VIEWS - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 476)) | (1 << (PostgreSQLParser.KW_DUMP - 476)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.KW_ERROR - 476)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 476)) | (1 << (PostgreSQLParser.KW_ALIAS - 476)) | (1 << (PostgreSQLParser.KW_CONSTANT - 476)) | (1 << (PostgreSQLParser.KW_PERFORM - 476)) | (1 << (PostgreSQLParser.KW_GET - 476)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.KW_STACKED - 476)) | (1 << (PostgreSQLParser.KW_ELSIF - 476)) | (1 << (PostgreSQLParser.KW_REVERSE - 476)) | (1 << (PostgreSQLParser.KW_SLICE - 476)) | (1 << (PostgreSQLParser.KW_EXIT - 476)))) !== 0) || ((((_la - 508)) & ~0x1F) === 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.KW_RETURN - 508)) | (1 << (PostgreSQLParser.KW_QUERY - 508)) | (1 << (PostgreSQLParser.KW_RAISE - 508)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 508)) | (1 << (PostgreSQLParser.KW_DEBUG - 508)) | (1 << (PostgreSQLParser.KW_LOG - 508)) | (1 << (PostgreSQLParser.KW_INFO - 508)) | (1 << (PostgreSQLParser.KW_NOTICE - 508)) | (1 << (PostgreSQLParser.KW_WARNING - 508)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 508)) | (1 << (PostgreSQLParser.KW_ASSERT - 508)) | (1 << (PostgreSQLParser.KW_OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 3233; + this.state = 3280; this.opt_class(); } } @@ -13607,13 +14255,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public table_access_method_clause(): Table_access_method_clauseContext { let _localctx: Table_access_method_clauseContext = new Table_access_method_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 246, PostgreSQLParser.RULE_table_access_method_clause); + this.enterRule(_localctx, 250, PostgreSQLParser.RULE_table_access_method_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3238; - this.match(PostgreSQLParser.USING); - this.state = 3239; + this.state = 3285; + this.match(PostgreSQLParser.KW_USING); + this.state = 3286; this.name(); } } @@ -13634,31 +14282,40 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public optwith(): OptwithContext { let _localctx: OptwithContext = new OptwithContext(this._ctx, this.state); - this.enterRule(_localctx, 248, PostgreSQLParser.RULE_optwith); + this.enterRule(_localctx, 252, PostgreSQLParser.RULE_optwith); try { - this.state = 3245; + this.state = 3294; this._errHandler.sync(this); - switch (this._input.LA(1)) { - case PostgreSQLParser.WITH: + switch ( this.interpreter.adaptivePredict(this._input, 209, this._ctx) ) { + case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3241; - this.match(PostgreSQLParser.WITH); - this.state = 3242; + this.state = 3288; + this.match(PostgreSQLParser.KW_WITH); + this.state = 3289; this.reloptions(); } break; - case PostgreSQLParser.WITHOUT: + + case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3243; - this.match(PostgreSQLParser.WITHOUT); - this.state = 3244; - this.match(PostgreSQLParser.OIDS); + this.state = 3290; + this.match(PostgreSQLParser.KW_WITHOUT); + this.state = 3291; + this.match(PostgreSQLParser.KW_OIDS); + } + break; + + case 3: + this.enterOuterAlt(_localctx, 3); + { + this.state = 3292; + this.match(PostgreSQLParser.KW_WITH); + this.state = 3293; + this.match(PostgreSQLParser.KW_OIDS); } break; - default: - throw new NoViableAltException(this); } } catch (re) { @@ -13678,37 +14335,37 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public oncommitoption(): OncommitoptionContext { let _localctx: OncommitoptionContext = new OncommitoptionContext(this._ctx, this.state); - this.enterRule(_localctx, 250, PostgreSQLParser.RULE_oncommitoption); + this.enterRule(_localctx, 254, PostgreSQLParser.RULE_oncommitoption); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3247; - this.match(PostgreSQLParser.ON); - this.state = 3248; - this.match(PostgreSQLParser.COMMIT); - this.state = 3254; + this.state = 3296; + this.match(PostgreSQLParser.KW_ON); + this.state = 3297; + this.match(PostgreSQLParser.KW_COMMIT); + this.state = 3303; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.DROP: + case PostgreSQLParser.KW_DROP: { - this.state = 3249; - this.match(PostgreSQLParser.DROP); + this.state = 3298; + this.match(PostgreSQLParser.KW_DROP); } break; - case PostgreSQLParser.DELETE_P: + case PostgreSQLParser.KW_DELETE: { - this.state = 3250; - this.match(PostgreSQLParser.DELETE_P); - this.state = 3251; - this.match(PostgreSQLParser.ROWS); + this.state = 3299; + this.match(PostgreSQLParser.KW_DELETE); + this.state = 3300; + this.match(PostgreSQLParser.KW_ROWS); } break; - case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.KW_PRESERVE: { - this.state = 3252; - this.match(PostgreSQLParser.PRESERVE); - this.state = 3253; - this.match(PostgreSQLParser.ROWS); + this.state = 3301; + this.match(PostgreSQLParser.KW_PRESERVE); + this.state = 3302; + this.match(PostgreSQLParser.KW_ROWS); } break; default: @@ -13733,13 +14390,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opttablespace(): OpttablespaceContext { let _localctx: OpttablespaceContext = new OpttablespaceContext(this._ctx, this.state); - this.enterRule(_localctx, 252, PostgreSQLParser.RULE_opttablespace); + this.enterRule(_localctx, 256, PostgreSQLParser.RULE_opttablespace); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3256; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 3257; + this.state = 3305; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 3306; this.name(); } } @@ -13760,17 +14417,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public optconstablespace(): OptconstablespaceContext { let _localctx: OptconstablespaceContext = new OptconstablespaceContext(this._ctx, this.state); - this.enterRule(_localctx, 254, PostgreSQLParser.RULE_optconstablespace); + this.enterRule(_localctx, 258, PostgreSQLParser.RULE_optconstablespace); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3259; - this.match(PostgreSQLParser.USING); - this.state = 3260; - this.match(PostgreSQLParser.INDEX); - this.state = 3261; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 3262; + this.state = 3308; + this.match(PostgreSQLParser.KW_USING); + this.state = 3309; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 3310; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 3311; this.name(); } } @@ -13791,15 +14448,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public existingindex(): ExistingindexContext { let _localctx: ExistingindexContext = new ExistingindexContext(this._ctx, this.state); - this.enterRule(_localctx, 256, PostgreSQLParser.RULE_existingindex); + this.enterRule(_localctx, 260, PostgreSQLParser.RULE_existingindex); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3264; - this.match(PostgreSQLParser.USING); - this.state = 3265; - this.match(PostgreSQLParser.INDEX); - this.state = 3266; + this.state = 3313; + this.match(PostgreSQLParser.KW_USING); + this.state = 3314; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 3315; this.name(); } } @@ -13820,48 +14477,48 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createstatsstmt(): CreatestatsstmtContext { let _localctx: CreatestatsstmtContext = new CreatestatsstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 258, PostgreSQLParser.RULE_createstatsstmt); + this.enterRule(_localctx, 262, PostgreSQLParser.RULE_createstatsstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3268; - this.match(PostgreSQLParser.CREATE); - this.state = 3269; - this.match(PostgreSQLParser.STATISTICS); - this.state = 3273; + this.state = 3317; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3318; + this.match(PostgreSQLParser.KW_STATISTICS); + this.state = 3322; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 205, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 211, this._ctx) ) { case 1: { - this.state = 3270; - this.match(PostgreSQLParser.IF_P); - this.state = 3271; - this.match(PostgreSQLParser.NOT); - this.state = 3272; - this.match(PostgreSQLParser.EXISTS); + this.state = 3319; + this.match(PostgreSQLParser.KW_IF); + this.state = 3320; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3321; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 3275; + this.state = 3324; this.any_name(); - this.state = 3277; + this.state = 3326; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 3276; + this.state = 3325; this.opt_name_list(); } } - this.state = 3279; - this.match(PostgreSQLParser.ON); - this.state = 3280; + this.state = 3328; + this.match(PostgreSQLParser.KW_ON); + this.state = 3329; this.expr_list(); - this.state = 3281; - this.match(PostgreSQLParser.FROM); - this.state = 3282; + this.state = 3330; + this.match(PostgreSQLParser.KW_FROM); + this.state = 3331; this.from_list(); } } @@ -13882,33 +14539,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterstatsstmt(): AlterstatsstmtContext { let _localctx: AlterstatsstmtContext = new AlterstatsstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 260, PostgreSQLParser.RULE_alterstatsstmt); + this.enterRule(_localctx, 264, PostgreSQLParser.RULE_alterstatsstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3284; - this.match(PostgreSQLParser.ALTER); - this.state = 3285; - this.match(PostgreSQLParser.STATISTICS); - this.state = 3288; + this.state = 3333; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3334; + this.match(PostgreSQLParser.KW_STATISTICS); + this.state = 3337; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 207, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 213, this._ctx) ) { case 1: { - this.state = 3286; - this.match(PostgreSQLParser.IF_P); - this.state = 3287; - this.match(PostgreSQLParser.EXISTS); + this.state = 3335; + this.match(PostgreSQLParser.KW_IF); + this.state = 3336; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 3290; + this.state = 3339; this.any_name(); - this.state = 3291; - this.match(PostgreSQLParser.SET); - this.state = 3292; - this.match(PostgreSQLParser.STATISTICS); - this.state = 3293; + this.state = 3340; + this.match(PostgreSQLParser.KW_SET); + this.state = 3341; + this.match(PostgreSQLParser.KW_STATISTICS); + this.state = 3342; this.signediconst(); } } @@ -13929,51 +14586,51 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createasstmt(): CreateasstmtContext { let _localctx: CreateasstmtContext = new CreateasstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 262, PostgreSQLParser.RULE_createasstmt); + this.enterRule(_localctx, 266, PostgreSQLParser.RULE_createasstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3295; - this.match(PostgreSQLParser.CREATE); - this.state = 3297; + this.state = 3344; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3346; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GLOBAL || _la === PostgreSQLParser.LOCAL || ((((_la - 343)) & ~0x1F) === 0 && ((1 << (_la - 343)) & ((1 << (PostgreSQLParser.TEMP - 343)) | (1 << (PostgreSQLParser.TEMPORARY - 343)) | (1 << (PostgreSQLParser.UNLOGGED - 343)))) !== 0)) { + if (_la === PostgreSQLParser.KW_GLOBAL || _la === PostgreSQLParser.KW_LOCAL || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & ((1 << (PostgreSQLParser.KW_TEMP - 352)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 352)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 352)))) !== 0)) { { - this.state = 3296; + this.state = 3345; this.opttemp(); } } - this.state = 3299; - this.match(PostgreSQLParser.TABLE); - this.state = 3303; + this.state = 3348; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 3352; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 209, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 215, this._ctx) ) { case 1: { - this.state = 3300; - this.match(PostgreSQLParser.IF_P); - this.state = 3301; - this.match(PostgreSQLParser.NOT); - this.state = 3302; - this.match(PostgreSQLParser.EXISTS); + this.state = 3349; + this.match(PostgreSQLParser.KW_IF); + this.state = 3350; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3351; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 3305; + this.state = 3354; this.create_as_target(); - this.state = 3306; - this.match(PostgreSQLParser.AS); - this.state = 3307; + this.state = 3355; + this.match(PostgreSQLParser.KW_AS); + this.state = 3356; this.selectstmt(); - this.state = 3309; + this.state = 3358; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 210, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 216, this._ctx) ) { case 1: { - this.state = 3308; + this.state = 3357; this.opt_with_data(); } break; @@ -13997,59 +14654,59 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public create_as_target(): Create_as_targetContext { let _localctx: Create_as_targetContext = new Create_as_targetContext(this._ctx, this.state); - this.enterRule(_localctx, 264, PostgreSQLParser.RULE_create_as_target); + this.enterRule(_localctx, 268, PostgreSQLParser.RULE_create_as_target); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3311; + this.state = 3360; this.qualified_name(); - this.state = 3313; + this.state = 3362; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 3312; + this.state = 3361; this.opt_column_list(); } } - this.state = 3316; + this.state = 3365; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 3315; + this.state = 3364; this.table_access_method_clause(); } } - this.state = 3319; + this.state = 3368; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH || _la === PostgreSQLParser.WITHOUT) { + if (_la === PostgreSQLParser.KW_WITH || _la === PostgreSQLParser.KW_WITHOUT) { { - this.state = 3318; + this.state = 3367; this.optwith(); } } - this.state = 3322; + this.state = 3371; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ON) { + if (_la === PostgreSQLParser.KW_ON) { { - this.state = 3321; + this.state = 3370; this.oncommitoption(); } } - this.state = 3325; + this.state = 3374; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TABLESPACE) { + if (_la === PostgreSQLParser.KW_TABLESPACE) { { - this.state = 3324; + this.state = 3373; this.opttablespace(); } } @@ -14073,27 +14730,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_with_data(): Opt_with_dataContext { let _localctx: Opt_with_dataContext = new Opt_with_dataContext(this._ctx, this.state); - this.enterRule(_localctx, 266, PostgreSQLParser.RULE_opt_with_data); + this.enterRule(_localctx, 270, PostgreSQLParser.RULE_opt_with_data); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3327; - this.match(PostgreSQLParser.WITH); - this.state = 3331; + this.state = 3376; + this.match(PostgreSQLParser.KW_WITH); + this.state = 3380; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.DATA_P: + case PostgreSQLParser.KW_DATA: { - this.state = 3328; - this.match(PostgreSQLParser.DATA_P); + this.state = 3377; + this.match(PostgreSQLParser.KW_DATA); } break; - case PostgreSQLParser.NO: + case PostgreSQLParser.KW_NO: { - this.state = 3329; - this.match(PostgreSQLParser.NO); - this.state = 3330; - this.match(PostgreSQLParser.DATA_P); + this.state = 3378; + this.match(PostgreSQLParser.KW_NO); + this.state = 3379; + this.match(PostgreSQLParser.KW_DATA); } break; default: @@ -14118,53 +14775,53 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public creatematviewstmt(): CreatematviewstmtContext { let _localctx: CreatematviewstmtContext = new CreatematviewstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 268, PostgreSQLParser.RULE_creatematviewstmt); + this.enterRule(_localctx, 272, PostgreSQLParser.RULE_creatematviewstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3333; - this.match(PostgreSQLParser.CREATE); - this.state = 3335; + this.state = 3382; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3384; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.UNLOGGED) { + if (_la === PostgreSQLParser.KW_UNLOGGED) { { - this.state = 3334; + this.state = 3383; this.optnolog(); } } - this.state = 3337; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 3338; - this.match(PostgreSQLParser.VIEW); - this.state = 3342; + this.state = 3386; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 3387; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 3391; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 218, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 224, this._ctx) ) { case 1: { - this.state = 3339; - this.match(PostgreSQLParser.IF_P); - this.state = 3340; - this.match(PostgreSQLParser.NOT); - this.state = 3341; - this.match(PostgreSQLParser.EXISTS); + this.state = 3388; + this.match(PostgreSQLParser.KW_IF); + this.state = 3389; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3390; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 3344; + this.state = 3393; this.create_mv_target(); - this.state = 3345; - this.match(PostgreSQLParser.AS); - this.state = 3346; + this.state = 3394; + this.match(PostgreSQLParser.KW_AS); + this.state = 3395; this.selectstmt(); - this.state = 3348; + this.state = 3397; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 219, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 225, this._ctx) ) { case 1: { - this.state = 3347; + this.state = 3396; this.opt_with_data(); } break; @@ -14188,49 +14845,49 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public create_mv_target(): Create_mv_targetContext { let _localctx: Create_mv_targetContext = new Create_mv_targetContext(this._ctx, this.state); - this.enterRule(_localctx, 270, PostgreSQLParser.RULE_create_mv_target); + this.enterRule(_localctx, 274, PostgreSQLParser.RULE_create_mv_target); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3350; + this.state = 3399; this.qualified_name(); - this.state = 3352; + this.state = 3401; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 3351; + this.state = 3400; this.opt_column_list(); } } - this.state = 3355; + this.state = 3404; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 3354; + this.state = 3403; this.table_access_method_clause(); } } - this.state = 3358; + this.state = 3407; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH) { + if (_la === PostgreSQLParser.KW_WITH) { { - this.state = 3357; + this.state = 3406; this.opt_reloptions(); } } - this.state = 3361; + this.state = 3410; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TABLESPACE) { + if (_la === PostgreSQLParser.KW_TABLESPACE) { { - this.state = 3360; + this.state = 3409; this.opttablespace(); } } @@ -14254,12 +14911,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public optnolog(): OptnologContext { let _localctx: OptnologContext = new OptnologContext(this._ctx, this.state); - this.enterRule(_localctx, 272, PostgreSQLParser.RULE_optnolog); + this.enterRule(_localctx, 276, PostgreSQLParser.RULE_optnolog); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3363; - this.match(PostgreSQLParser.UNLOGGED); + this.state = 3412; + this.match(PostgreSQLParser.KW_UNLOGGED); } } catch (re) { @@ -14279,35 +14936,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public refreshmatviewstmt(): RefreshmatviewstmtContext { let _localctx: RefreshmatviewstmtContext = new RefreshmatviewstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 274, PostgreSQLParser.RULE_refreshmatviewstmt); + this.enterRule(_localctx, 278, PostgreSQLParser.RULE_refreshmatviewstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3365; - this.match(PostgreSQLParser.REFRESH); - this.state = 3366; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 3367; - this.match(PostgreSQLParser.VIEW); - this.state = 3369; + this.state = 3414; + this.match(PostgreSQLParser.KW_REFRESH); + this.state = 3415; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 3416; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 3418; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CONCURRENTLY) { + if (_la === PostgreSQLParser.KW_CONCURRENTLY) { { - this.state = 3368; + this.state = 3417; this.opt_concurrently(); } } - this.state = 3371; + this.state = 3420; this.qualified_name(); - this.state = 3373; + this.state = 3422; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 225, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 231, this._ctx) ) { case 1: { - this.state = 3372; + this.state = 3421; this.opt_with_data(); } break; @@ -14331,47 +14988,47 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createseqstmt(): CreateseqstmtContext { let _localctx: CreateseqstmtContext = new CreateseqstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 276, PostgreSQLParser.RULE_createseqstmt); + this.enterRule(_localctx, 280, PostgreSQLParser.RULE_createseqstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3375; - this.match(PostgreSQLParser.CREATE); - this.state = 3377; + this.state = 3424; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3426; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GLOBAL || _la === PostgreSQLParser.LOCAL || ((((_la - 343)) & ~0x1F) === 0 && ((1 << (_la - 343)) & ((1 << (PostgreSQLParser.TEMP - 343)) | (1 << (PostgreSQLParser.TEMPORARY - 343)) | (1 << (PostgreSQLParser.UNLOGGED - 343)))) !== 0)) { + if (_la === PostgreSQLParser.KW_GLOBAL || _la === PostgreSQLParser.KW_LOCAL || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & ((1 << (PostgreSQLParser.KW_TEMP - 352)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 352)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 352)))) !== 0)) { { - this.state = 3376; + this.state = 3425; this.opttemp(); } } - this.state = 3379; - this.match(PostgreSQLParser.SEQUENCE); - this.state = 3383; + this.state = 3428; + this.match(PostgreSQLParser.KW_SEQUENCE); + this.state = 3432; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 227, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 233, this._ctx) ) { case 1: { - this.state = 3380; - this.match(PostgreSQLParser.IF_P); - this.state = 3381; - this.match(PostgreSQLParser.NOT); - this.state = 3382; - this.match(PostgreSQLParser.EXISTS); + this.state = 3429; + this.match(PostgreSQLParser.KW_IF); + this.state = 3430; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3431; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 3385; + this.state = 3434; this.qualified_name(); - this.state = 3387; + this.state = 3436; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 228, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 234, this._ctx) ) { case 1: { - this.state = 3386; + this.state = 3435; this.optseqoptlist(); } break; @@ -14395,29 +15052,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterseqstmt(): AlterseqstmtContext { let _localctx: AlterseqstmtContext = new AlterseqstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 278, PostgreSQLParser.RULE_alterseqstmt); + this.enterRule(_localctx, 282, PostgreSQLParser.RULE_alterseqstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3389; - this.match(PostgreSQLParser.ALTER); - this.state = 3390; - this.match(PostgreSQLParser.SEQUENCE); - this.state = 3393; + this.state = 3438; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3439; + this.match(PostgreSQLParser.KW_SEQUENCE); + this.state = 3442; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 229, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 235, this._ctx) ) { case 1: { - this.state = 3391; - this.match(PostgreSQLParser.IF_P); - this.state = 3392; - this.match(PostgreSQLParser.EXISTS); + this.state = 3440; + this.match(PostgreSQLParser.KW_IF); + this.state = 3441; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 3395; + this.state = 3444; this.qualified_name(); - this.state = 3396; + this.state = 3445; this.seqoptlist(); } } @@ -14438,11 +15095,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public optseqoptlist(): OptseqoptlistContext { let _localctx: OptseqoptlistContext = new OptseqoptlistContext(this._ctx, this.state); - this.enterRule(_localctx, 280, PostgreSQLParser.RULE_optseqoptlist); + this.enterRule(_localctx, 284, PostgreSQLParser.RULE_optseqoptlist); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3398; + this.state = 3447; this.seqoptlist(); } } @@ -14463,15 +15120,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public optparenthesizedseqoptlist(): OptparenthesizedseqoptlistContext { let _localctx: OptparenthesizedseqoptlistContext = new OptparenthesizedseqoptlistContext(this._ctx, this.state); - this.enterRule(_localctx, 282, PostgreSQLParser.RULE_optparenthesizedseqoptlist); + this.enterRule(_localctx, 286, PostgreSQLParser.RULE_optparenthesizedseqoptlist); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3400; + this.state = 3449; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3401; + this.state = 3450; this.seqoptlist(); - this.state = 3402; + this.state = 3451; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -14492,12 +15149,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public seqoptlist(): SeqoptlistContext { let _localctx: SeqoptlistContext = new SeqoptlistContext(this._ctx, this.state); - this.enterRule(_localctx, 284, PostgreSQLParser.RULE_seqoptlist); + this.enterRule(_localctx, 288, PostgreSQLParser.RULE_seqoptlist); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 3405; + this.state = 3454; this._errHandler.sync(this); _alt = 1; do { @@ -14505,7 +15162,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 1: { { - this.state = 3404; + this.state = 3453; this.seqoptelem(); } } @@ -14513,9 +15170,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 3407; + this.state = 3456; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 230, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 236, this._ctx); } while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER); } } @@ -14536,82 +15193,82 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public seqoptelem(): SeqoptelemContext { let _localctx: SeqoptelemContext = new SeqoptelemContext(this._ctx, this.state); - this.enterRule(_localctx, 286, PostgreSQLParser.RULE_seqoptelem); + this.enterRule(_localctx, 290, PostgreSQLParser.RULE_seqoptelem); let _la: number; try { - this.state = 3443; + this.state = 3492; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.AS: + case PostgreSQLParser.KW_AS: this.enterOuterAlt(_localctx, 1); { - this.state = 3409; - this.match(PostgreSQLParser.AS); - this.state = 3410; + this.state = 3458; + this.match(PostgreSQLParser.KW_AS); + this.state = 3459; this.simpletypename(); } break; - case PostgreSQLParser.CACHE: + case PostgreSQLParser.KW_CACHE: this.enterOuterAlt(_localctx, 2); { - this.state = 3411; - this.match(PostgreSQLParser.CACHE); - this.state = 3412; + this.state = 3460; + this.match(PostgreSQLParser.KW_CACHE); + this.state = 3461; this.numericonly(); } break; - case PostgreSQLParser.CYCLE: + case PostgreSQLParser.KW_CYCLE: this.enterOuterAlt(_localctx, 3); { - this.state = 3413; - this.match(PostgreSQLParser.CYCLE); + this.state = 3462; + this.match(PostgreSQLParser.KW_CYCLE); } break; - case PostgreSQLParser.INCREMENT: + case PostgreSQLParser.KW_INCREMENT: this.enterOuterAlt(_localctx, 4); { - this.state = 3414; - this.match(PostgreSQLParser.INCREMENT); - this.state = 3416; + this.state = 3463; + this.match(PostgreSQLParser.KW_INCREMENT); + this.state = 3465; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.BY) { + if (_la === PostgreSQLParser.KW_BY) { { - this.state = 3415; + this.state = 3464; this.opt_by(); } } - this.state = 3418; + this.state = 3467; this.numericonly(); } break; - case PostgreSQLParser.MAXVALUE: + case PostgreSQLParser.KW_MAXVALUE: this.enterOuterAlt(_localctx, 5); { - this.state = 3419; - this.match(PostgreSQLParser.MAXVALUE); - this.state = 3420; + this.state = 3468; + this.match(PostgreSQLParser.KW_MAXVALUE); + this.state = 3469; this.numericonly(); } break; - case PostgreSQLParser.MINVALUE: + case PostgreSQLParser.KW_MINVALUE: this.enterOuterAlt(_localctx, 6); { - this.state = 3421; - this.match(PostgreSQLParser.MINVALUE); - this.state = 3422; + this.state = 3470; + this.match(PostgreSQLParser.KW_MINVALUE); + this.state = 3471; this.numericonly(); } break; - case PostgreSQLParser.NO: + case PostgreSQLParser.KW_NO: this.enterOuterAlt(_localctx, 7); { - this.state = 3423; - this.match(PostgreSQLParser.NO); - this.state = 3424; + this.state = 3472; + this.match(PostgreSQLParser.KW_NO); + this.state = 3473; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.CYCLE || _la === PostgreSQLParser.MAXVALUE || _la === PostgreSQLParser.MINVALUE)) { + if (!(_la === PostgreSQLParser.KW_CYCLE || _la === PostgreSQLParser.KW_MAXVALUE || _la === PostgreSQLParser.KW_MINVALUE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -14623,68 +15280,68 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.OWNED: + case PostgreSQLParser.KW_OWNED: this.enterOuterAlt(_localctx, 8); { - this.state = 3425; - this.match(PostgreSQLParser.OWNED); - this.state = 3426; - this.match(PostgreSQLParser.BY); - this.state = 3427; + this.state = 3474; + this.match(PostgreSQLParser.KW_OWNED); + this.state = 3475; + this.match(PostgreSQLParser.KW_BY); + this.state = 3476; this.any_name(); } break; - case PostgreSQLParser.SEQUENCE: + case PostgreSQLParser.KW_SEQUENCE: this.enterOuterAlt(_localctx, 9); { - this.state = 3428; - this.match(PostgreSQLParser.SEQUENCE); - this.state = 3429; - this.match(PostgreSQLParser.NAME_P); - this.state = 3430; + this.state = 3477; + this.match(PostgreSQLParser.KW_SEQUENCE); + this.state = 3478; + this.match(PostgreSQLParser.KW_NAME); + this.state = 3479; this.any_name(); } break; - case PostgreSQLParser.START: + case PostgreSQLParser.KW_START: this.enterOuterAlt(_localctx, 10); { - this.state = 3431; - this.match(PostgreSQLParser.START); - this.state = 3433; + this.state = 3480; + this.match(PostgreSQLParser.KW_START); + this.state = 3482; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH) { + if (_la === PostgreSQLParser.KW_WITH) { { - this.state = 3432; + this.state = 3481; this.opt_with(); } } - this.state = 3435; + this.state = 3484; this.numericonly(); } break; - case PostgreSQLParser.RESTART: + case PostgreSQLParser.KW_RESTART: this.enterOuterAlt(_localctx, 11); { - this.state = 3436; - this.match(PostgreSQLParser.RESTART); - this.state = 3438; + this.state = 3485; + this.match(PostgreSQLParser.KW_RESTART); + this.state = 3487; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 233, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 239, this._ctx) ) { case 1: { - this.state = 3437; + this.state = 3486; this.opt_with(); } break; } - this.state = 3441; + this.state = 3490; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS || _la === PostgreSQLParser.Integral || _la === PostgreSQLParser.Numeric) { { - this.state = 3440; + this.state = 3489; this.numericonly(); } } @@ -14712,12 +15369,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_by(): Opt_byContext { let _localctx: Opt_byContext = new Opt_byContext(this._ctx, this.state); - this.enterRule(_localctx, 288, PostgreSQLParser.RULE_opt_by); + this.enterRule(_localctx, 292, PostgreSQLParser.RULE_opt_by); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3445; - this.match(PostgreSQLParser.BY); + this.state = 3494; + this.match(PostgreSQLParser.KW_BY); } } catch (re) { @@ -14737,15 +15394,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public numericonly(): NumericonlyContext { let _localctx: NumericonlyContext = new NumericonlyContext(this._ctx, this.state); - this.enterRule(_localctx, 290, PostgreSQLParser.RULE_numericonly); + this.enterRule(_localctx, 294, PostgreSQLParser.RULE_numericonly); try { - this.state = 3453; + this.state = 3502; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 236, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 242, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3447; + this.state = 3496; this.fconst(); } break; @@ -14753,9 +15410,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3448; + this.state = 3497; this.match(PostgreSQLParser.PLUS); - this.state = 3449; + this.state = 3498; this.fconst(); } break; @@ -14763,9 +15420,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 3450; + this.state = 3499; this.match(PostgreSQLParser.MINUS); - this.state = 3451; + this.state = 3500; this.fconst(); } break; @@ -14773,7 +15430,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 3452; + this.state = 3501; this.signediconst(); } break; @@ -14796,26 +15453,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public numericonly_list(): Numericonly_listContext { let _localctx: Numericonly_listContext = new Numericonly_listContext(this._ctx, this.state); - this.enterRule(_localctx, 292, PostgreSQLParser.RULE_numericonly_list); + this.enterRule(_localctx, 296, PostgreSQLParser.RULE_numericonly_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3455; + this.state = 3504; this.numericonly(); - this.state = 3460; + this.state = 3509; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 3456; + this.state = 3505; this.match(PostgreSQLParser.COMMA); - this.state = 3457; + this.state = 3506; this.numericonly(); } } - this.state = 3462; + this.state = 3511; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -14838,72 +15495,72 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createplangstmt(): CreateplangstmtContext { let _localctx: CreateplangstmtContext = new CreateplangstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 294, PostgreSQLParser.RULE_createplangstmt); + this.enterRule(_localctx, 298, PostgreSQLParser.RULE_createplangstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3463; - this.match(PostgreSQLParser.CREATE); - this.state = 3465; + this.state = 3512; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3514; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OR) { + if (_la === PostgreSQLParser.KW_OR) { { - this.state = 3464; + this.state = 3513; this.opt_or_replace(); } } - this.state = 3468; + this.state = 3517; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TRUSTED) { + if (_la === PostgreSQLParser.KW_TRUSTED) { { - this.state = 3467; + this.state = 3516; this.opt_trusted(); } } - this.state = 3471; + this.state = 3520; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PROCEDURAL) { + if (_la === PostgreSQLParser.KW_PROCEDURAL) { { - this.state = 3470; + this.state = 3519; this.opt_procedural(); } } - this.state = 3473; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 3474; + this.state = 3522; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 3523; this.name(); - this.state = 3483; + this.state = 3532; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.HANDLER) { + if (_la === PostgreSQLParser.KW_HANDLER) { { - this.state = 3475; - this.match(PostgreSQLParser.HANDLER); - this.state = 3476; + this.state = 3524; + this.match(PostgreSQLParser.KW_HANDLER); + this.state = 3525; this.handler_name(); - this.state = 3478; + this.state = 3527; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INLINE_P) { + if (_la === PostgreSQLParser.KW_INLINE) { { - this.state = 3477; + this.state = 3526; this.opt_inline_handler(); } } - this.state = 3481; + this.state = 3530; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO || _la === PostgreSQLParser.VALIDATOR) { + if (_la === PostgreSQLParser.KW_NO || _la === PostgreSQLParser.KW_VALIDATOR) { { - this.state = 3480; + this.state = 3529; this.opt_validator(); } } @@ -14930,12 +15587,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_trusted(): Opt_trustedContext { let _localctx: Opt_trustedContext = new Opt_trustedContext(this._ctx, this.state); - this.enterRule(_localctx, 296, PostgreSQLParser.RULE_opt_trusted); + this.enterRule(_localctx, 300, PostgreSQLParser.RULE_opt_trusted); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3485; - this.match(PostgreSQLParser.TRUSTED); + this.state = 3534; + this.match(PostgreSQLParser.KW_TRUSTED); } } catch (re) { @@ -14955,19 +15612,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public handler_name(): Handler_nameContext { let _localctx: Handler_nameContext = new Handler_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 298, PostgreSQLParser.RULE_handler_name); + this.enterRule(_localctx, 302, PostgreSQLParser.RULE_handler_name); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3487; + this.state = 3536; this.name(); - this.state = 3489; + this.state = 3538; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.DOT) { { - this.state = 3488; + this.state = 3537; this.attrs(); } } @@ -14991,13 +15648,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_inline_handler(): Opt_inline_handlerContext { let _localctx: Opt_inline_handlerContext = new Opt_inline_handlerContext(this._ctx, this.state); - this.enterRule(_localctx, 300, PostgreSQLParser.RULE_opt_inline_handler); + this.enterRule(_localctx, 304, PostgreSQLParser.RULE_opt_inline_handler); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3491; - this.match(PostgreSQLParser.INLINE_P); - this.state = 3492; + this.state = 3540; + this.match(PostgreSQLParser.KW_INLINE); + this.state = 3541; this.handler_name(); } } @@ -15018,27 +15675,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public validator_clause(): Validator_clauseContext { let _localctx: Validator_clauseContext = new Validator_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 302, PostgreSQLParser.RULE_validator_clause); + this.enterRule(_localctx, 306, PostgreSQLParser.RULE_validator_clause); try { - this.state = 3498; + this.state = 3547; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.VALIDATOR: + case PostgreSQLParser.KW_VALIDATOR: this.enterOuterAlt(_localctx, 1); { - this.state = 3494; - this.match(PostgreSQLParser.VALIDATOR); - this.state = 3495; + this.state = 3543; + this.match(PostgreSQLParser.KW_VALIDATOR); + this.state = 3544; this.handler_name(); } break; - case PostgreSQLParser.NO: + case PostgreSQLParser.KW_NO: this.enterOuterAlt(_localctx, 2); { - this.state = 3496; - this.match(PostgreSQLParser.NO); - this.state = 3497; - this.match(PostgreSQLParser.VALIDATOR); + this.state = 3545; + this.match(PostgreSQLParser.KW_NO); + this.state = 3546; + this.match(PostgreSQLParser.KW_VALIDATOR); } break; default: @@ -15062,11 +15719,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_validator(): Opt_validatorContext { let _localctx: Opt_validatorContext = new Opt_validatorContext(this._ctx, this.state); - this.enterRule(_localctx, 304, PostgreSQLParser.RULE_opt_validator); + this.enterRule(_localctx, 308, PostgreSQLParser.RULE_opt_validator); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3500; + this.state = 3549; this.validator_clause(); } } @@ -15087,12 +15744,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_procedural(): Opt_proceduralContext { let _localctx: Opt_proceduralContext = new Opt_proceduralContext(this._ctx, this.state); - this.enterRule(_localctx, 306, PostgreSQLParser.RULE_opt_procedural); + this.enterRule(_localctx, 310, PostgreSQLParser.RULE_opt_procedural); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3502; - this.match(PostgreSQLParser.PROCEDURAL); + this.state = 3551; + this.match(PostgreSQLParser.KW_PROCEDURAL); } } catch (re) { @@ -15112,37 +15769,37 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createtablespacestmt(): CreatetablespacestmtContext { let _localctx: CreatetablespacestmtContext = new CreatetablespacestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 308, PostgreSQLParser.RULE_createtablespacestmt); + this.enterRule(_localctx, 312, PostgreSQLParser.RULE_createtablespacestmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3504; - this.match(PostgreSQLParser.CREATE); - this.state = 3505; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 3506; + this.state = 3553; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3554; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 3555; this.name(); - this.state = 3508; + this.state = 3557; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OWNER) { + if (_la === PostgreSQLParser.KW_OWNER) { { - this.state = 3507; + this.state = 3556; this.opttablespaceowner(); } } - this.state = 3510; - this.match(PostgreSQLParser.LOCATION); - this.state = 3511; + this.state = 3559; + this.match(PostgreSQLParser.KW_LOCATION); + this.state = 3560; this.sconst(); - this.state = 3513; + this.state = 3562; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 247, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 253, this._ctx) ) { case 1: { - this.state = 3512; + this.state = 3561; this.opt_reloptions(); } break; @@ -15166,13 +15823,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opttablespaceowner(): OpttablespaceownerContext { let _localctx: OpttablespaceownerContext = new OpttablespaceownerContext(this._ctx, this.state); - this.enterRule(_localctx, 310, PostgreSQLParser.RULE_opttablespaceowner); + this.enterRule(_localctx, 314, PostgreSQLParser.RULE_opttablespaceowner); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3515; - this.match(PostgreSQLParser.OWNER); - this.state = 3516; + this.state = 3564; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 3565; this.rolespec(); } } @@ -15193,27 +15850,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public droptablespacestmt(): DroptablespacestmtContext { let _localctx: DroptablespacestmtContext = new DroptablespacestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 312, PostgreSQLParser.RULE_droptablespacestmt); + this.enterRule(_localctx, 316, PostgreSQLParser.RULE_droptablespacestmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3518; - this.match(PostgreSQLParser.DROP); - this.state = 3519; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 3522; + this.state = 3567; + this.match(PostgreSQLParser.KW_DROP); + this.state = 3568; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 3571; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 248, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 254, this._ctx) ) { case 1: { - this.state = 3520; - this.match(PostgreSQLParser.IF_P); - this.state = 3521; - this.match(PostgreSQLParser.EXISTS); + this.state = 3569; + this.match(PostgreSQLParser.KW_IF); + this.state = 3570; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 3524; + this.state = 3573; this.name(); } } @@ -15234,41 +15891,41 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createextensionstmt(): CreateextensionstmtContext { let _localctx: CreateextensionstmtContext = new CreateextensionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 314, PostgreSQLParser.RULE_createextensionstmt); + this.enterRule(_localctx, 318, PostgreSQLParser.RULE_createextensionstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3526; - this.match(PostgreSQLParser.CREATE); - this.state = 3527; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3531; + this.state = 3575; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3576; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3580; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 249, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 255, this._ctx) ) { case 1: { - this.state = 3528; - this.match(PostgreSQLParser.IF_P); - this.state = 3529; - this.match(PostgreSQLParser.NOT); - this.state = 3530; - this.match(PostgreSQLParser.EXISTS); + this.state = 3577; + this.match(PostgreSQLParser.KW_IF); + this.state = 3578; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3579; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 3533; + this.state = 3582; this.name(); - this.state = 3535; + this.state = 3584; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 250, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 256, this._ctx) ) { case 1: { - this.state = 3534; + this.state = 3583; this.opt_with(); } break; } - this.state = 3537; + this.state = 3586; this.create_extension_opt_list(); } } @@ -15289,22 +15946,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public create_extension_opt_list(): Create_extension_opt_listContext { let _localctx: Create_extension_opt_listContext = new Create_extension_opt_listContext(this._ctx, this.state); - this.enterRule(_localctx, 316, PostgreSQLParser.RULE_create_extension_opt_list); + this.enterRule(_localctx, 320, PostgreSQLParser.RULE_create_extension_opt_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3542; + this.state = 3591; this._errHandler.sync(this); _la = this._input.LA(1); - while (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.SCHEMA || _la === PostgreSQLParser.VERSION_P) { + while (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_SCHEMA || _la === PostgreSQLParser.KW_VERSION) { { { - this.state = 3539; + this.state = 3588; this.create_extension_opt_item(); } } - this.state = 3544; + this.state = 3593; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -15327,43 +15984,43 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public create_extension_opt_item(): Create_extension_opt_itemContext { let _localctx: Create_extension_opt_itemContext = new Create_extension_opt_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 318, PostgreSQLParser.RULE_create_extension_opt_item); + this.enterRule(_localctx, 322, PostgreSQLParser.RULE_create_extension_opt_item); try { - this.state = 3552; + this.state = 3601; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.KW_SCHEMA: this.enterOuterAlt(_localctx, 1); { - this.state = 3545; - this.match(PostgreSQLParser.SCHEMA); - this.state = 3546; + this.state = 3594; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 3595; this.name(); } break; - case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.KW_VERSION: this.enterOuterAlt(_localctx, 2); { - this.state = 3547; - this.match(PostgreSQLParser.VERSION_P); - this.state = 3548; + this.state = 3596; + this.match(PostgreSQLParser.KW_VERSION); + this.state = 3597; this.nonreservedword_or_sconst(); } break; - case PostgreSQLParser.FROM: + case PostgreSQLParser.KW_FROM: this.enterOuterAlt(_localctx, 3); { - this.state = 3549; - this.match(PostgreSQLParser.FROM); - this.state = 3550; + this.state = 3598; + this.match(PostgreSQLParser.KW_FROM); + this.state = 3599; this.nonreservedword_or_sconst(); } break; - case PostgreSQLParser.CASCADE: + case PostgreSQLParser.KW_CASCADE: this.enterOuterAlt(_localctx, 4); { - this.state = 3551; - this.match(PostgreSQLParser.CASCADE); + this.state = 3600; + this.match(PostgreSQLParser.KW_CASCADE); } break; default: @@ -15387,19 +16044,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterextensionstmt(): AlterextensionstmtContext { let _localctx: AlterextensionstmtContext = new AlterextensionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 320, PostgreSQLParser.RULE_alterextensionstmt); + this.enterRule(_localctx, 324, PostgreSQLParser.RULE_alterextensionstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3554; - this.match(PostgreSQLParser.ALTER); - this.state = 3555; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3556; + this.state = 3603; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3604; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3605; this.name(); - this.state = 3557; - this.match(PostgreSQLParser.UPDATE); - this.state = 3558; + this.state = 3606; + this.match(PostgreSQLParser.KW_UPDATE); + this.state = 3607; this.alter_extension_opt_list(); } } @@ -15420,22 +16077,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alter_extension_opt_list(): Alter_extension_opt_listContext { let _localctx: Alter_extension_opt_listContext = new Alter_extension_opt_listContext(this._ctx, this.state); - this.enterRule(_localctx, 322, PostgreSQLParser.RULE_alter_extension_opt_list); + this.enterRule(_localctx, 326, PostgreSQLParser.RULE_alter_extension_opt_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3563; + this.state = 3612; this._errHandler.sync(this); _la = this._input.LA(1); - while (_la === PostgreSQLParser.TO) { + while (_la === PostgreSQLParser.KW_TO) { { { - this.state = 3560; + this.state = 3609; this.alter_extension_opt_item(); } } - this.state = 3565; + this.state = 3614; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -15458,13 +16115,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alter_extension_opt_item(): Alter_extension_opt_itemContext { let _localctx: Alter_extension_opt_itemContext = new Alter_extension_opt_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 324, PostgreSQLParser.RULE_alter_extension_opt_item); + this.enterRule(_localctx, 328, PostgreSQLParser.RULE_alter_extension_opt_item); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3566; - this.match(PostgreSQLParser.TO); - this.state = 3567; + this.state = 3615; + this.match(PostgreSQLParser.KW_TO); + this.state = 3616; this.nonreservedword_or_sconst(); } } @@ -15485,25 +16142,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterextensioncontentsstmt(): AlterextensioncontentsstmtContext { let _localctx: AlterextensioncontentsstmtContext = new AlterextensioncontentsstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 326, PostgreSQLParser.RULE_alterextensioncontentsstmt); + this.enterRule(_localctx, 330, PostgreSQLParser.RULE_alterextensioncontentsstmt); try { - this.state = 3673; + this.state = 3722; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 254, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 260, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3569; - this.match(PostgreSQLParser.ALTER); - this.state = 3570; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3571; + this.state = 3618; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3619; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3620; this.name(); - this.state = 3572; + this.state = 3621; this.add_drop(); - this.state = 3573; + this.state = 3622; this.object_type_name(); - this.state = 3574; + this.state = 3623; this.name(); } break; @@ -15511,17 +16168,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3576; - this.match(PostgreSQLParser.ALTER); - this.state = 3577; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3578; + this.state = 3625; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3626; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3627; this.name(); - this.state = 3579; + this.state = 3628; this.add_drop(); - this.state = 3580; + this.state = 3629; this.object_type_any_name(); - this.state = 3581; + this.state = 3630; this.any_name(); } break; @@ -15529,17 +16186,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 3583; - this.match(PostgreSQLParser.ALTER); - this.state = 3584; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3585; + this.state = 3632; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3633; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3634; this.name(); - this.state = 3586; + this.state = 3635; this.add_drop(); - this.state = 3587; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 3588; + this.state = 3636; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 3637; this.aggregate_with_argtypes(); } break; @@ -15547,25 +16204,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 3590; - this.match(PostgreSQLParser.ALTER); - this.state = 3591; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3592; + this.state = 3639; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3640; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3641; this.name(); - this.state = 3593; + this.state = 3642; this.add_drop(); - this.state = 3594; - this.match(PostgreSQLParser.CAST); - this.state = 3595; + this.state = 3643; + this.match(PostgreSQLParser.KW_CAST); + this.state = 3644; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3596; + this.state = 3645; this.typename(); - this.state = 3597; - this.match(PostgreSQLParser.AS); - this.state = 3598; + this.state = 3646; + this.match(PostgreSQLParser.KW_AS); + this.state = 3647; this.typename(); - this.state = 3599; + this.state = 3648; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -15573,17 +16230,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 3601; - this.match(PostgreSQLParser.ALTER); - this.state = 3602; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3603; + this.state = 3650; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3651; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3652; this.name(); - this.state = 3604; + this.state = 3653; this.add_drop(); - this.state = 3605; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 3606; + this.state = 3654; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 3655; this.typename(); } break; @@ -15591,17 +16248,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 3608; - this.match(PostgreSQLParser.ALTER); - this.state = 3609; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3610; + this.state = 3657; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3658; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3659; this.name(); - this.state = 3611; + this.state = 3660; this.add_drop(); - this.state = 3612; - this.match(PostgreSQLParser.FUNCTION); - this.state = 3613; + this.state = 3661; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 3662; this.function_with_argtypes(); } break; @@ -15609,17 +16266,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 3615; - this.match(PostgreSQLParser.ALTER); - this.state = 3616; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3617; + this.state = 3664; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3665; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3666; this.name(); - this.state = 3618; + this.state = 3667; this.add_drop(); - this.state = 3619; - this.match(PostgreSQLParser.OPERATOR); - this.state = 3620; + this.state = 3668; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 3669; this.operator_with_argtypes(); } break; @@ -15627,23 +16284,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 3622; - this.match(PostgreSQLParser.ALTER); - this.state = 3623; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3624; + this.state = 3671; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3672; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3673; this.name(); - this.state = 3625; + this.state = 3674; this.add_drop(); - this.state = 3626; - this.match(PostgreSQLParser.OPERATOR); - this.state = 3627; - this.match(PostgreSQLParser.CLASS); - this.state = 3628; + this.state = 3675; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 3676; + this.match(PostgreSQLParser.KW_CLASS); + this.state = 3677; this.any_name(); - this.state = 3629; - this.match(PostgreSQLParser.USING); - this.state = 3630; + this.state = 3678; + this.match(PostgreSQLParser.KW_USING); + this.state = 3679; this.name(); } break; @@ -15651,23 +16308,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 3632; - this.match(PostgreSQLParser.ALTER); - this.state = 3633; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3634; + this.state = 3681; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3682; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3683; this.name(); - this.state = 3635; + this.state = 3684; this.add_drop(); - this.state = 3636; - this.match(PostgreSQLParser.OPERATOR); - this.state = 3637; - this.match(PostgreSQLParser.FAMILY); - this.state = 3638; + this.state = 3685; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 3686; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 3687; this.any_name(); - this.state = 3639; - this.match(PostgreSQLParser.USING); - this.state = 3640; + this.state = 3688; + this.match(PostgreSQLParser.KW_USING); + this.state = 3689; this.name(); } break; @@ -15675,17 +16332,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 3642; - this.match(PostgreSQLParser.ALTER); - this.state = 3643; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3644; + this.state = 3691; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3692; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3693; this.name(); - this.state = 3645; + this.state = 3694; this.add_drop(); - this.state = 3646; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 3647; + this.state = 3695; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 3696; this.function_with_argtypes(); } break; @@ -15693,17 +16350,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 3649; - this.match(PostgreSQLParser.ALTER); - this.state = 3650; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3651; + this.state = 3698; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3699; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3700; this.name(); - this.state = 3652; + this.state = 3701; this.add_drop(); - this.state = 3653; - this.match(PostgreSQLParser.ROUTINE); - this.state = 3654; + this.state = 3702; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 3703; this.function_with_argtypes(); } break; @@ -15711,23 +16368,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 3656; - this.match(PostgreSQLParser.ALTER); - this.state = 3657; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3658; + this.state = 3705; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3706; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3707; this.name(); - this.state = 3659; + this.state = 3708; this.add_drop(); - this.state = 3660; - this.match(PostgreSQLParser.TRANSFORM); - this.state = 3661; - this.match(PostgreSQLParser.FOR); - this.state = 3662; + this.state = 3709; + this.match(PostgreSQLParser.KW_TRANSFORM); + this.state = 3710; + this.match(PostgreSQLParser.KW_FOR); + this.state = 3711; this.typename(); - this.state = 3663; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 3664; + this.state = 3712; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 3713; this.name(); } break; @@ -15735,17 +16392,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 3666; - this.match(PostgreSQLParser.ALTER); - this.state = 3667; - this.match(PostgreSQLParser.EXTENSION); - this.state = 3668; + this.state = 3715; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3716; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 3717; this.name(); - this.state = 3669; + this.state = 3718; this.add_drop(); - this.state = 3670; - this.match(PostgreSQLParser.TYPE_P); - this.state = 3671; + this.state = 3719; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 3720; this.typename(); } break; @@ -15768,37 +16425,37 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createfdwstmt(): CreatefdwstmtContext { let _localctx: CreatefdwstmtContext = new CreatefdwstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 328, PostgreSQLParser.RULE_createfdwstmt); + this.enterRule(_localctx, 332, PostgreSQLParser.RULE_createfdwstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3675; - this.match(PostgreSQLParser.CREATE); - this.state = 3676; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3677; - this.match(PostgreSQLParser.DATA_P); - this.state = 3678; - this.match(PostgreSQLParser.WRAPPER); - this.state = 3679; + this.state = 3724; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3725; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3726; + this.match(PostgreSQLParser.KW_DATA); + this.state = 3727; + this.match(PostgreSQLParser.KW_WRAPPER); + this.state = 3728; this.name(); - this.state = 3681; + this.state = 3730; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.HANDLER || _la === PostgreSQLParser.NO || _la === PostgreSQLParser.VALIDATOR) { + if (_la === PostgreSQLParser.KW_HANDLER || _la === PostgreSQLParser.KW_NO || _la === PostgreSQLParser.KW_VALIDATOR) { { - this.state = 3680; + this.state = 3729; this.opt_fdw_options(); } } - this.state = 3684; + this.state = 3733; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3683; + this.state = 3732; this.create_generic_options(); } } @@ -15822,17 +16479,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public fdw_option(): Fdw_optionContext { let _localctx: Fdw_optionContext = new Fdw_optionContext(this._ctx, this.state); - this.enterRule(_localctx, 330, PostgreSQLParser.RULE_fdw_option); + this.enterRule(_localctx, 334, PostgreSQLParser.RULE_fdw_option); try { - this.state = 3694; + this.state = 3743; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 257, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 263, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3686; - this.match(PostgreSQLParser.HANDLER); - this.state = 3687; + this.state = 3735; + this.match(PostgreSQLParser.KW_HANDLER); + this.state = 3736; this.handler_name(); } break; @@ -15840,19 +16497,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3688; - this.match(PostgreSQLParser.NO); - this.state = 3689; - this.match(PostgreSQLParser.HANDLER); + this.state = 3737; + this.match(PostgreSQLParser.KW_NO); + this.state = 3738; + this.match(PostgreSQLParser.KW_HANDLER); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 3690; - this.match(PostgreSQLParser.VALIDATOR); - this.state = 3691; + this.state = 3739; + this.match(PostgreSQLParser.KW_VALIDATOR); + this.state = 3740; this.handler_name(); } break; @@ -15860,10 +16517,10 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 3692; - this.match(PostgreSQLParser.NO); - this.state = 3693; - this.match(PostgreSQLParser.VALIDATOR); + this.state = 3741; + this.match(PostgreSQLParser.KW_NO); + this.state = 3742; + this.match(PostgreSQLParser.KW_VALIDATOR); } break; } @@ -15885,25 +16542,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public fdw_options(): Fdw_optionsContext { let _localctx: Fdw_optionsContext = new Fdw_optionsContext(this._ctx, this.state); - this.enterRule(_localctx, 332, PostgreSQLParser.RULE_fdw_options); + this.enterRule(_localctx, 336, PostgreSQLParser.RULE_fdw_options); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3697; + this.state = 3746; this._errHandler.sync(this); _la = this._input.LA(1); do { { { - this.state = 3696; + this.state = 3745; this.fdw_option(); } } - this.state = 3699; + this.state = 3748; this._errHandler.sync(this); _la = this._input.LA(1); - } while (_la === PostgreSQLParser.HANDLER || _la === PostgreSQLParser.NO || _la === PostgreSQLParser.VALIDATOR); + } while (_la === PostgreSQLParser.KW_HANDLER || _la === PostgreSQLParser.KW_NO || _la === PostgreSQLParser.KW_VALIDATOR); } } catch (re) { @@ -15923,11 +16580,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_fdw_options(): Opt_fdw_optionsContext { let _localctx: Opt_fdw_optionsContext = new Opt_fdw_optionsContext(this._ctx, this.state); - this.enterRule(_localctx, 334, PostgreSQLParser.RULE_opt_fdw_options); + this.enterRule(_localctx, 338, PostgreSQLParser.RULE_opt_fdw_options); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3701; + this.state = 3750; this.fdw_options(); } } @@ -15948,36 +16605,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterfdwstmt(): AlterfdwstmtContext { let _localctx: AlterfdwstmtContext = new AlterfdwstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 336, PostgreSQLParser.RULE_alterfdwstmt); + this.enterRule(_localctx, 340, PostgreSQLParser.RULE_alterfdwstmt); let _la: number; try { - this.state = 3720; + this.state = 3769; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 260, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 266, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3703; - this.match(PostgreSQLParser.ALTER); - this.state = 3704; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3705; - this.match(PostgreSQLParser.DATA_P); - this.state = 3706; - this.match(PostgreSQLParser.WRAPPER); - this.state = 3707; + this.state = 3752; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3753; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3754; + this.match(PostgreSQLParser.KW_DATA); + this.state = 3755; + this.match(PostgreSQLParser.KW_WRAPPER); + this.state = 3756; this.name(); - this.state = 3709; + this.state = 3758; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.HANDLER || _la === PostgreSQLParser.NO || _la === PostgreSQLParser.VALIDATOR) { + if (_la === PostgreSQLParser.KW_HANDLER || _la === PostgreSQLParser.KW_NO || _la === PostgreSQLParser.KW_VALIDATOR) { { - this.state = 3708; + this.state = 3757; this.opt_fdw_options(); } } - this.state = 3711; + this.state = 3760; this.alter_generic_options(); } break; @@ -15985,17 +16642,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3713; - this.match(PostgreSQLParser.ALTER); - this.state = 3714; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3715; - this.match(PostgreSQLParser.DATA_P); - this.state = 3716; - this.match(PostgreSQLParser.WRAPPER); - this.state = 3717; + this.state = 3762; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3763; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3764; + this.match(PostgreSQLParser.KW_DATA); + this.state = 3765; + this.match(PostgreSQLParser.KW_WRAPPER); + this.state = 3766; this.name(); - this.state = 3718; + this.state = 3767; this.fdw_options(); } break; @@ -16018,17 +16675,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public create_generic_options(): Create_generic_optionsContext { let _localctx: Create_generic_optionsContext = new Create_generic_optionsContext(this._ctx, this.state); - this.enterRule(_localctx, 338, PostgreSQLParser.RULE_create_generic_options); + this.enterRule(_localctx, 342, PostgreSQLParser.RULE_create_generic_options); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3722; - this.match(PostgreSQLParser.OPTIONS); - this.state = 3723; + this.state = 3771; + this.match(PostgreSQLParser.KW_OPTIONS); + this.state = 3772; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3724; + this.state = 3773; this.generic_option_list(); - this.state = 3725; + this.state = 3774; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -16049,26 +16706,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public generic_option_list(): Generic_option_listContext { let _localctx: Generic_option_listContext = new Generic_option_listContext(this._ctx, this.state); - this.enterRule(_localctx, 340, PostgreSQLParser.RULE_generic_option_list); + this.enterRule(_localctx, 344, PostgreSQLParser.RULE_generic_option_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3727; + this.state = 3776; this.generic_option_elem(); - this.state = 3732; + this.state = 3781; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 3728; + this.state = 3777; this.match(PostgreSQLParser.COMMA); - this.state = 3729; + this.state = 3778; this.generic_option_elem(); } } - this.state = 3734; + this.state = 3783; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -16091,17 +16748,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alter_generic_options(): Alter_generic_optionsContext { let _localctx: Alter_generic_optionsContext = new Alter_generic_optionsContext(this._ctx, this.state); - this.enterRule(_localctx, 342, PostgreSQLParser.RULE_alter_generic_options); + this.enterRule(_localctx, 346, PostgreSQLParser.RULE_alter_generic_options); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3735; - this.match(PostgreSQLParser.OPTIONS); - this.state = 3736; + this.state = 3784; + this.match(PostgreSQLParser.KW_OPTIONS); + this.state = 3785; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3737; + this.state = 3786; this.alter_generic_option_list(); - this.state = 3738; + this.state = 3787; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -16122,26 +16779,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alter_generic_option_list(): Alter_generic_option_listContext { let _localctx: Alter_generic_option_listContext = new Alter_generic_option_listContext(this._ctx, this.state); - this.enterRule(_localctx, 344, PostgreSQLParser.RULE_alter_generic_option_list); + this.enterRule(_localctx, 348, PostgreSQLParser.RULE_alter_generic_option_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3740; + this.state = 3789; this.alter_generic_option_elem(); - this.state = 3745; + this.state = 3794; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 3741; + this.state = 3790; this.match(PostgreSQLParser.COMMA); - this.state = 3742; + this.state = 3791; this.alter_generic_option_elem(); } } - this.state = 3747; + this.state = 3796; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -16164,15 +16821,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alter_generic_option_elem(): Alter_generic_option_elemContext { let _localctx: Alter_generic_option_elemContext = new Alter_generic_option_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 346, PostgreSQLParser.RULE_alter_generic_option_elem); + this.enterRule(_localctx, 350, PostgreSQLParser.RULE_alter_generic_option_elem); try { - this.state = 3755; + this.state = 3804; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 263, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 269, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3748; + this.state = 3797; this.generic_option_elem(); } break; @@ -16180,9 +16837,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3749; - this.match(PostgreSQLParser.SET); - this.state = 3750; + this.state = 3798; + this.match(PostgreSQLParser.KW_SET); + this.state = 3799; this.generic_option_elem(); } break; @@ -16190,9 +16847,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 3751; - this.match(PostgreSQLParser.ADD_P); - this.state = 3752; + this.state = 3800; + this.match(PostgreSQLParser.KW_ADD); + this.state = 3801; this.generic_option_elem(); } break; @@ -16200,10 +16857,10 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 3753; - this.match(PostgreSQLParser.DROP); - this.state = 3754; - this.generic_option_name(); + this.state = 3802; + this.match(PostgreSQLParser.KW_DROP); + this.state = 3803; + this.generic_option_elem(); } break; } @@ -16225,13 +16882,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public generic_option_elem(): Generic_option_elemContext { let _localctx: Generic_option_elemContext = new Generic_option_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 348, PostgreSQLParser.RULE_generic_option_elem); + this.enterRule(_localctx, 352, PostgreSQLParser.RULE_generic_option_elem); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3757; + this.state = 3806; this.generic_option_name(); - this.state = 3758; + this.state = 3807; this.generic_option_arg(); } } @@ -16252,11 +16909,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public generic_option_name(): Generic_option_nameContext { let _localctx: Generic_option_nameContext = new Generic_option_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 350, PostgreSQLParser.RULE_generic_option_name); + this.enterRule(_localctx, 354, PostgreSQLParser.RULE_generic_option_name); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3760; + this.state = 3809; this.collabel(); } } @@ -16277,11 +16934,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public generic_option_arg(): Generic_option_argContext { let _localctx: Generic_option_argContext = new Generic_option_argContext(this._ctx, this.state); - this.enterRule(_localctx, 352, PostgreSQLParser.RULE_generic_option_arg); + this.enterRule(_localctx, 356, PostgreSQLParser.RULE_generic_option_arg); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3762; + this.state = 3811; this.sconst(); } } @@ -16302,55 +16959,55 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createforeignserverstmt(): CreateforeignserverstmtContext { let _localctx: CreateforeignserverstmtContext = new CreateforeignserverstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 354, PostgreSQLParser.RULE_createforeignserverstmt); + this.enterRule(_localctx, 358, PostgreSQLParser.RULE_createforeignserverstmt); let _la: number; try { - this.state = 3799; + this.state = 3848; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 270, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 276, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3764; - this.match(PostgreSQLParser.CREATE); - this.state = 3765; - this.match(PostgreSQLParser.SERVER); - this.state = 3766; + this.state = 3813; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3814; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3815; this.name(); - this.state = 3768; + this.state = 3817; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TYPE_P) { + if (_la === PostgreSQLParser.KW_TYPE) { { - this.state = 3767; + this.state = 3816; this.opt_type(); } } - this.state = 3771; + this.state = 3820; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.VERSION_P) { + if (_la === PostgreSQLParser.KW_VERSION) { { - this.state = 3770; + this.state = 3819; this.opt_foreign_server_version(); } } - this.state = 3773; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3774; - this.match(PostgreSQLParser.DATA_P); - this.state = 3775; - this.match(PostgreSQLParser.WRAPPER); - this.state = 3776; + this.state = 3822; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3823; + this.match(PostgreSQLParser.KW_DATA); + this.state = 3824; + this.match(PostgreSQLParser.KW_WRAPPER); + this.state = 3825; this.name(); - this.state = 3778; + this.state = 3827; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3777; + this.state = 3826; this.create_generic_options(); } } @@ -16361,52 +17018,52 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3780; - this.match(PostgreSQLParser.CREATE); - this.state = 3781; - this.match(PostgreSQLParser.SERVER); - this.state = 3782; - this.match(PostgreSQLParser.IF_P); - this.state = 3783; - this.match(PostgreSQLParser.NOT); - this.state = 3784; - this.match(PostgreSQLParser.EXISTS); - this.state = 3785; + this.state = 3829; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3830; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3831; + this.match(PostgreSQLParser.KW_IF); + this.state = 3832; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3833; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 3834; this.name(); - this.state = 3787; + this.state = 3836; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TYPE_P) { + if (_la === PostgreSQLParser.KW_TYPE) { { - this.state = 3786; + this.state = 3835; this.opt_type(); } } - this.state = 3790; + this.state = 3839; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.VERSION_P) { + if (_la === PostgreSQLParser.KW_VERSION) { { - this.state = 3789; + this.state = 3838; this.opt_foreign_server_version(); } } - this.state = 3792; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3793; - this.match(PostgreSQLParser.DATA_P); - this.state = 3794; - this.match(PostgreSQLParser.WRAPPER); - this.state = 3795; + this.state = 3841; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3842; + this.match(PostgreSQLParser.KW_DATA); + this.state = 3843; + this.match(PostgreSQLParser.KW_WRAPPER); + this.state = 3844; this.name(); - this.state = 3797; + this.state = 3846; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3796; + this.state = 3845; this.create_generic_options(); } } @@ -16432,13 +17089,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_type(): Opt_typeContext { let _localctx: Opt_typeContext = new Opt_typeContext(this._ctx, this.state); - this.enterRule(_localctx, 356, PostgreSQLParser.RULE_opt_type); + this.enterRule(_localctx, 360, PostgreSQLParser.RULE_opt_type); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3801; - this.match(PostgreSQLParser.TYPE_P); - this.state = 3802; + this.state = 3850; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 3851; this.sconst(); } } @@ -16459,13 +17116,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public foreign_server_version(): Foreign_server_versionContext { let _localctx: Foreign_server_versionContext = new Foreign_server_versionContext(this._ctx, this.state); - this.enterRule(_localctx, 358, PostgreSQLParser.RULE_foreign_server_version); + this.enterRule(_localctx, 362, PostgreSQLParser.RULE_foreign_server_version); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3804; - this.match(PostgreSQLParser.VERSION_P); - this.state = 3807; + this.state = 3853; + this.match(PostgreSQLParser.KW_VERSION); + this.state = 3856; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: @@ -16473,14 +17130,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.BeginDollarStringConstant: case PostgreSQLParser.EscapeStringConstant: { - this.state = 3805; + this.state = 3854; this.sconst(); } break; - case PostgreSQLParser.NULL_P: + case PostgreSQLParser.KW_NULL: { - this.state = 3806; - this.match(PostgreSQLParser.NULL_P); + this.state = 3855; + this.match(PostgreSQLParser.KW_NULL); } break; default: @@ -16505,11 +17162,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_foreign_server_version(): Opt_foreign_server_versionContext { let _localctx: Opt_foreign_server_versionContext = new Opt_foreign_server_versionContext(this._ctx, this.state); - this.enterRule(_localctx, 360, PostgreSQLParser.RULE_opt_foreign_server_version); + this.enterRule(_localctx, 364, PostgreSQLParser.RULE_opt_foreign_server_version); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3809; + this.state = 3858; this.foreign_server_version(); } } @@ -16530,36 +17187,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterforeignserverstmt(): AlterforeignserverstmtContext { let _localctx: AlterforeignserverstmtContext = new AlterforeignserverstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 362, PostgreSQLParser.RULE_alterforeignserverstmt); + this.enterRule(_localctx, 366, PostgreSQLParser.RULE_alterforeignserverstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3811; - this.match(PostgreSQLParser.ALTER); - this.state = 3812; - this.match(PostgreSQLParser.SERVER); - this.state = 3813; + this.state = 3860; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 3861; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3862; this.name(); - this.state = 3819; + this.state = 3868; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.OPTIONS: + case PostgreSQLParser.KW_OPTIONS: { - this.state = 3814; + this.state = 3863; this.alter_generic_options(); } break; - case PostgreSQLParser.VERSION_P: + case PostgreSQLParser.KW_VERSION: { - this.state = 3815; + this.state = 3864; this.foreign_server_version(); - this.state = 3817; + this.state = 3866; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3816; + this.state = 3865; this.alter_generic_options(); } } @@ -16588,57 +17245,57 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createforeigntablestmt(): CreateforeigntablestmtContext { let _localctx: CreateforeigntablestmtContext = new CreateforeigntablestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 364, PostgreSQLParser.RULE_createforeigntablestmt); + this.enterRule(_localctx, 368, PostgreSQLParser.RULE_createforeigntablestmt); let _la: number; try { - this.state = 3893; + this.state = 3942; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 284, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 290, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3821; - this.match(PostgreSQLParser.CREATE); - this.state = 3822; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3823; - this.match(PostgreSQLParser.TABLE); - this.state = 3824; + this.state = 3870; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3871; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3872; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 3873; this.qualified_name(); - this.state = 3825; + this.state = 3874; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3827; + this.state = 3876; 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.CHECK - 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)) | (1 << (PostgreSQLParser.FOREIGN - 33)))) !== 0) || ((((_la - 85)) & ~0x1F) === 0 && ((1 << (_la - 85)) & ((1 << (PostgreSQLParser.PRIMARY - 85)) | (1 << (PostgreSQLParser.TABLE - 85)) | (1 << (PostgreSQLParser.UNIQUE - 85)) | (1 << (PostgreSQLParser.IS - 85)))) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & ((1 << (PostgreSQLParser.LIKE - 120)) | (1 << (PostgreSQLParser.OUTER_P - 120)) | (1 << (PostgreSQLParser.OVER - 120)) | (1 << (PostgreSQLParser.ABORT_P - 120)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 120)) | (1 << (PostgreSQLParser.ACCESS - 120)) | (1 << (PostgreSQLParser.ACTION - 120)) | (1 << (PostgreSQLParser.ADD_P - 120)) | (1 << (PostgreSQLParser.ADMIN - 120)) | (1 << (PostgreSQLParser.AFTER - 120)) | (1 << (PostgreSQLParser.AGGREGATE - 120)) | (1 << (PostgreSQLParser.ALSO - 120)) | (1 << (PostgreSQLParser.ALTER - 120)) | (1 << (PostgreSQLParser.ALWAYS - 120)) | (1 << (PostgreSQLParser.ASSERTION - 120)) | (1 << (PostgreSQLParser.ASSIGNMENT - 120)) | (1 << (PostgreSQLParser.AT - 120)) | (1 << (PostgreSQLParser.ATTRIBUTE - 120)) | (1 << (PostgreSQLParser.BACKWARD - 120)) | (1 << (PostgreSQLParser.BEFORE - 120)) | (1 << (PostgreSQLParser.BEGIN_P - 120)) | (1 << (PostgreSQLParser.BY - 120)) | (1 << (PostgreSQLParser.CACHE - 120)) | (1 << (PostgreSQLParser.CALLED - 120)) | (1 << (PostgreSQLParser.CASCADE - 120)) | (1 << (PostgreSQLParser.CASCADED - 120)))) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & ((1 << (PostgreSQLParser.CATALOG - 152)) | (1 << (PostgreSQLParser.CHAIN - 152)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 152)) | (1 << (PostgreSQLParser.CHECKPOINT - 152)) | (1 << (PostgreSQLParser.CLASS - 152)) | (1 << (PostgreSQLParser.CLOSE - 152)) | (1 << (PostgreSQLParser.CLUSTER - 152)) | (1 << (PostgreSQLParser.COMMENT - 152)) | (1 << (PostgreSQLParser.COMMENTS - 152)) | (1 << (PostgreSQLParser.COMMIT - 152)) | (1 << (PostgreSQLParser.COMMITTED - 152)) | (1 << (PostgreSQLParser.CONFIGURATION - 152)) | (1 << (PostgreSQLParser.CONNECTION - 152)) | (1 << (PostgreSQLParser.CONSTRAINTS - 152)) | (1 << (PostgreSQLParser.CONTENT_P - 152)) | (1 << (PostgreSQLParser.CONTINUE_P - 152)) | (1 << (PostgreSQLParser.CONVERSION_P - 152)) | (1 << (PostgreSQLParser.COPY - 152)) | (1 << (PostgreSQLParser.COST - 152)) | (1 << (PostgreSQLParser.CSV - 152)) | (1 << (PostgreSQLParser.CURSOR - 152)) | (1 << (PostgreSQLParser.CYCLE - 152)) | (1 << (PostgreSQLParser.DATA_P - 152)) | (1 << (PostgreSQLParser.DATABASE - 152)) | (1 << (PostgreSQLParser.DAY_P - 152)) | (1 << (PostgreSQLParser.DEALLOCATE - 152)) | (1 << (PostgreSQLParser.DECLARE - 152)) | (1 << (PostgreSQLParser.DEFAULTS - 152)) | (1 << (PostgreSQLParser.DEFERRED - 152)) | (1 << (PostgreSQLParser.DEFINER - 152)) | (1 << (PostgreSQLParser.DELETE_P - 152)) | (1 << (PostgreSQLParser.DELIMITER - 152)))) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & ((1 << (PostgreSQLParser.DELIMITERS - 184)) | (1 << (PostgreSQLParser.DICTIONARY - 184)) | (1 << (PostgreSQLParser.DISABLE_P - 184)) | (1 << (PostgreSQLParser.DISCARD - 184)) | (1 << (PostgreSQLParser.DOCUMENT_P - 184)) | (1 << (PostgreSQLParser.DOMAIN_P - 184)) | (1 << (PostgreSQLParser.DOUBLE_P - 184)) | (1 << (PostgreSQLParser.DROP - 184)) | (1 << (PostgreSQLParser.EACH - 184)) | (1 << (PostgreSQLParser.ENABLE_P - 184)) | (1 << (PostgreSQLParser.ENCODING - 184)) | (1 << (PostgreSQLParser.ENCRYPTED - 184)) | (1 << (PostgreSQLParser.ENUM_P - 184)) | (1 << (PostgreSQLParser.ESCAPE - 184)) | (1 << (PostgreSQLParser.EVENT - 184)) | (1 << (PostgreSQLParser.EXCLUDE - 184)) | (1 << (PostgreSQLParser.EXCLUDING - 184)) | (1 << (PostgreSQLParser.EXCLUSIVE - 184)) | (1 << (PostgreSQLParser.EXECUTE - 184)) | (1 << (PostgreSQLParser.EXPLAIN - 184)) | (1 << (PostgreSQLParser.EXTENSION - 184)) | (1 << (PostgreSQLParser.EXTERNAL - 184)) | (1 << (PostgreSQLParser.FAMILY - 184)) | (1 << (PostgreSQLParser.FIRST_P - 184)) | (1 << (PostgreSQLParser.FOLLOWING - 184)) | (1 << (PostgreSQLParser.FORCE - 184)) | (1 << (PostgreSQLParser.FORWARD - 184)) | (1 << (PostgreSQLParser.FUNCTION - 184)) | (1 << (PostgreSQLParser.FUNCTIONS - 184)) | (1 << (PostgreSQLParser.GLOBAL - 184)) | (1 << (PostgreSQLParser.GRANTED - 184)) | (1 << (PostgreSQLParser.HANDLER - 184)))) !== 0) || ((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & ((1 << (PostgreSQLParser.HEADER_P - 216)) | (1 << (PostgreSQLParser.HOLD - 216)) | (1 << (PostgreSQLParser.HOUR_P - 216)) | (1 << (PostgreSQLParser.IDENTITY_P - 216)) | (1 << (PostgreSQLParser.IF_P - 216)) | (1 << (PostgreSQLParser.IMMEDIATE - 216)) | (1 << (PostgreSQLParser.IMMUTABLE - 216)) | (1 << (PostgreSQLParser.IMPLICIT_P - 216)) | (1 << (PostgreSQLParser.INCLUDING - 216)) | (1 << (PostgreSQLParser.INCREMENT - 216)) | (1 << (PostgreSQLParser.INDEX - 216)) | (1 << (PostgreSQLParser.INDEXES - 216)) | (1 << (PostgreSQLParser.INHERIT - 216)) | (1 << (PostgreSQLParser.INHERITS - 216)) | (1 << (PostgreSQLParser.INLINE_P - 216)) | (1 << (PostgreSQLParser.INSENSITIVE - 216)) | (1 << (PostgreSQLParser.INSERT - 216)) | (1 << (PostgreSQLParser.INSTEAD - 216)) | (1 << (PostgreSQLParser.INVOKER - 216)) | (1 << (PostgreSQLParser.ISOLATION - 216)) | (1 << (PostgreSQLParser.KEY - 216)) | (1 << (PostgreSQLParser.LABEL - 216)) | (1 << (PostgreSQLParser.LANGUAGE - 216)) | (1 << (PostgreSQLParser.LARGE_P - 216)) | (1 << (PostgreSQLParser.LAST_P - 216)) | (1 << (PostgreSQLParser.LEAKPROOF - 216)) | (1 << (PostgreSQLParser.LEVEL - 216)) | (1 << (PostgreSQLParser.LISTEN - 216)) | (1 << (PostgreSQLParser.LOAD - 216)) | (1 << (PostgreSQLParser.LOCAL - 216)) | (1 << (PostgreSQLParser.LOCATION - 216)) | (1 << (PostgreSQLParser.LOCK_P - 216)))) !== 0) || ((((_la - 248)) & ~0x1F) === 0 && ((1 << (_la - 248)) & ((1 << (PostgreSQLParser.MAPPING - 248)) | (1 << (PostgreSQLParser.MATCH - 248)) | (1 << (PostgreSQLParser.MATERIALIZED - 248)) | (1 << (PostgreSQLParser.MAXVALUE - 248)) | (1 << (PostgreSQLParser.MINUTE_P - 248)) | (1 << (PostgreSQLParser.MINVALUE - 248)) | (1 << (PostgreSQLParser.MODE - 248)) | (1 << (PostgreSQLParser.MONTH_P - 248)) | (1 << (PostgreSQLParser.MOVE - 248)) | (1 << (PostgreSQLParser.NAME_P - 248)) | (1 << (PostgreSQLParser.NAMES - 248)) | (1 << (PostgreSQLParser.NEXT - 248)) | (1 << (PostgreSQLParser.NO - 248)) | (1 << (PostgreSQLParser.NOTHING - 248)) | (1 << (PostgreSQLParser.NOTIFY - 248)) | (1 << (PostgreSQLParser.NOWAIT - 248)) | (1 << (PostgreSQLParser.NULLS_P - 248)) | (1 << (PostgreSQLParser.OBJECT_P - 248)) | (1 << (PostgreSQLParser.OF - 248)) | (1 << (PostgreSQLParser.OFF - 248)) | (1 << (PostgreSQLParser.OIDS - 248)) | (1 << (PostgreSQLParser.OPERATOR - 248)) | (1 << (PostgreSQLParser.OPTION - 248)) | (1 << (PostgreSQLParser.OPTIONS - 248)) | (1 << (PostgreSQLParser.OWNED - 248)) | (1 << (PostgreSQLParser.OWNER - 248)) | (1 << (PostgreSQLParser.PARSER - 248)) | (1 << (PostgreSQLParser.PARTIAL - 248)) | (1 << (PostgreSQLParser.PARTITION - 248)) | (1 << (PostgreSQLParser.PASSING - 248)) | (1 << (PostgreSQLParser.PASSWORD - 248)) | (1 << (PostgreSQLParser.PLANS - 248)))) !== 0) || ((((_la - 280)) & ~0x1F) === 0 && ((1 << (_la - 280)) & ((1 << (PostgreSQLParser.PRECEDING - 280)) | (1 << (PostgreSQLParser.PREPARE - 280)) | (1 << (PostgreSQLParser.PREPARED - 280)) | (1 << (PostgreSQLParser.PRESERVE - 280)) | (1 << (PostgreSQLParser.PRIOR - 280)) | (1 << (PostgreSQLParser.PRIVILEGES - 280)) | (1 << (PostgreSQLParser.PROCEDURAL - 280)) | (1 << (PostgreSQLParser.PROCEDURE - 280)) | (1 << (PostgreSQLParser.PROGRAM - 280)) | (1 << (PostgreSQLParser.QUOTE - 280)) | (1 << (PostgreSQLParser.RANGE - 280)) | (1 << (PostgreSQLParser.READ - 280)) | (1 << (PostgreSQLParser.REASSIGN - 280)) | (1 << (PostgreSQLParser.RECHECK - 280)) | (1 << (PostgreSQLParser.RECURSIVE - 280)) | (1 << (PostgreSQLParser.REF - 280)) | (1 << (PostgreSQLParser.REFRESH - 280)) | (1 << (PostgreSQLParser.REINDEX - 280)) | (1 << (PostgreSQLParser.RELATIVE_P - 280)) | (1 << (PostgreSQLParser.RELEASE - 280)) | (1 << (PostgreSQLParser.RENAME - 280)) | (1 << (PostgreSQLParser.REPEATABLE - 280)) | (1 << (PostgreSQLParser.REPLACE - 280)) | (1 << (PostgreSQLParser.REPLICA - 280)) | (1 << (PostgreSQLParser.RESET - 280)) | (1 << (PostgreSQLParser.RESTART - 280)) | (1 << (PostgreSQLParser.RESTRICT - 280)) | (1 << (PostgreSQLParser.RETURNS - 280)) | (1 << (PostgreSQLParser.REVOKE - 280)) | (1 << (PostgreSQLParser.ROLE - 280)) | (1 << (PostgreSQLParser.ROLLBACK - 280)) | (1 << (PostgreSQLParser.ROWS - 280)))) !== 0) || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & ((1 << (PostgreSQLParser.RULE - 312)) | (1 << (PostgreSQLParser.SAVEPOINT - 312)) | (1 << (PostgreSQLParser.SCHEMA - 312)) | (1 << (PostgreSQLParser.SCROLL - 312)) | (1 << (PostgreSQLParser.SEARCH - 312)) | (1 << (PostgreSQLParser.SECOND_P - 312)) | (1 << (PostgreSQLParser.SECURITY - 312)) | (1 << (PostgreSQLParser.SEQUENCE - 312)) | (1 << (PostgreSQLParser.SEQUENCES - 312)) | (1 << (PostgreSQLParser.SERIALIZABLE - 312)) | (1 << (PostgreSQLParser.SERVER - 312)) | (1 << (PostgreSQLParser.SESSION - 312)) | (1 << (PostgreSQLParser.SET - 312)) | (1 << (PostgreSQLParser.SHARE - 312)) | (1 << (PostgreSQLParser.SHOW - 312)) | (1 << (PostgreSQLParser.SIMPLE - 312)) | (1 << (PostgreSQLParser.SNAPSHOT - 312)) | (1 << (PostgreSQLParser.STABLE - 312)) | (1 << (PostgreSQLParser.STANDALONE_P - 312)) | (1 << (PostgreSQLParser.START - 312)) | (1 << (PostgreSQLParser.STATEMENT - 312)) | (1 << (PostgreSQLParser.STATISTICS - 312)) | (1 << (PostgreSQLParser.STDIN - 312)) | (1 << (PostgreSQLParser.STDOUT - 312)) | (1 << (PostgreSQLParser.STORAGE - 312)) | (1 << (PostgreSQLParser.STRICT_P - 312)) | (1 << (PostgreSQLParser.STRIP_P - 312)) | (1 << (PostgreSQLParser.SYSID - 312)) | (1 << (PostgreSQLParser.SYSTEM_P - 312)) | (1 << (PostgreSQLParser.TABLES - 312)) | (1 << (PostgreSQLParser.TABLESPACE - 312)) | (1 << (PostgreSQLParser.TEMP - 312)))) !== 0) || ((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & ((1 << (PostgreSQLParser.TEMPLATE - 344)) | (1 << (PostgreSQLParser.TEMPORARY - 344)) | (1 << (PostgreSQLParser.TEXT_P - 344)) | (1 << (PostgreSQLParser.TRANSACTION - 344)) | (1 << (PostgreSQLParser.TRIGGER - 344)) | (1 << (PostgreSQLParser.TRUNCATE - 344)) | (1 << (PostgreSQLParser.TRUSTED - 344)) | (1 << (PostgreSQLParser.TYPE_P - 344)) | (1 << (PostgreSQLParser.TYPES_P - 344)) | (1 << (PostgreSQLParser.UNBOUNDED - 344)) | (1 << (PostgreSQLParser.UNCOMMITTED - 344)) | (1 << (PostgreSQLParser.UNENCRYPTED - 344)) | (1 << (PostgreSQLParser.UNKNOWN - 344)) | (1 << (PostgreSQLParser.UNLISTEN - 344)) | (1 << (PostgreSQLParser.UNLOGGED - 344)) | (1 << (PostgreSQLParser.UNTIL - 344)) | (1 << (PostgreSQLParser.UPDATE - 344)) | (1 << (PostgreSQLParser.VACUUM - 344)) | (1 << (PostgreSQLParser.VALID - 344)) | (1 << (PostgreSQLParser.VALIDATE - 344)) | (1 << (PostgreSQLParser.VALIDATOR - 344)) | (1 << (PostgreSQLParser.VARYING - 344)) | (1 << (PostgreSQLParser.VERSION_P - 344)) | (1 << (PostgreSQLParser.VIEW - 344)) | (1 << (PostgreSQLParser.VOLATILE - 344)) | (1 << (PostgreSQLParser.WHITESPACE_P - 344)) | (1 << (PostgreSQLParser.WITHOUT - 344)) | (1 << (PostgreSQLParser.WORK - 344)) | (1 << (PostgreSQLParser.WRAPPER - 344)) | (1 << (PostgreSQLParser.WRITE - 344)) | (1 << (PostgreSQLParser.XML_P - 344)) | (1 << (PostgreSQLParser.YEAR_P - 344)))) !== 0) || ((((_la - 376)) & ~0x1F) === 0 && ((1 << (_la - 376)) & ((1 << (PostgreSQLParser.YES_P - 376)) | (1 << (PostgreSQLParser.ZONE - 376)) | (1 << (PostgreSQLParser.BETWEEN - 376)) | (1 << (PostgreSQLParser.BIGINT - 376)) | (1 << (PostgreSQLParser.BIT - 376)) | (1 << (PostgreSQLParser.BOOLEAN_P - 376)) | (1 << (PostgreSQLParser.CHAR_P - 376)) | (1 << (PostgreSQLParser.CHARACTER - 376)) | (1 << (PostgreSQLParser.COALESCE - 376)) | (1 << (PostgreSQLParser.DEC - 376)) | (1 << (PostgreSQLParser.DECIMAL_P - 376)) | (1 << (PostgreSQLParser.EXISTS - 376)) | (1 << (PostgreSQLParser.EXTRACT - 376)) | (1 << (PostgreSQLParser.FLOAT_P - 376)) | (1 << (PostgreSQLParser.GREATEST - 376)) | (1 << (PostgreSQLParser.INOUT - 376)) | (1 << (PostgreSQLParser.INT_P - 376)) | (1 << (PostgreSQLParser.INTEGER - 376)) | (1 << (PostgreSQLParser.INTERVAL - 376)) | (1 << (PostgreSQLParser.LEAST - 376)) | (1 << (PostgreSQLParser.NATIONAL - 376)) | (1 << (PostgreSQLParser.NCHAR - 376)) | (1 << (PostgreSQLParser.NONE - 376)) | (1 << (PostgreSQLParser.NULLIF - 376)) | (1 << (PostgreSQLParser.NUMERIC - 376)) | (1 << (PostgreSQLParser.OVERLAY - 376)) | (1 << (PostgreSQLParser.POSITION - 376)) | (1 << (PostgreSQLParser.PRECISION - 376)) | (1 << (PostgreSQLParser.REAL - 376)) | (1 << (PostgreSQLParser.ROW - 376)) | (1 << (PostgreSQLParser.SETOF - 376)) | (1 << (PostgreSQLParser.SMALLINT - 376)))) !== 0) || ((((_la - 408)) & ~0x1F) === 0 && ((1 << (_la - 408)) & ((1 << (PostgreSQLParser.SUBSTRING - 408)) | (1 << (PostgreSQLParser.TIME - 408)) | (1 << (PostgreSQLParser.TIMESTAMP - 408)) | (1 << (PostgreSQLParser.TREAT - 408)) | (1 << (PostgreSQLParser.TRIM - 408)) | (1 << (PostgreSQLParser.VALUES - 408)) | (1 << (PostgreSQLParser.VARCHAR - 408)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 408)) | (1 << (PostgreSQLParser.XMLCONCAT - 408)) | (1 << (PostgreSQLParser.XMLELEMENT - 408)) | (1 << (PostgreSQLParser.XMLEXISTS - 408)) | (1 << (PostgreSQLParser.XMLFOREST - 408)) | (1 << (PostgreSQLParser.XMLPARSE - 408)) | (1 << (PostgreSQLParser.XMLPI - 408)) | (1 << (PostgreSQLParser.XMLROOT - 408)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 408)) | (1 << (PostgreSQLParser.CALL - 408)) | (1 << (PostgreSQLParser.CURRENT_P - 408)) | (1 << (PostgreSQLParser.ATTACH - 408)) | (1 << (PostgreSQLParser.DETACH - 408)) | (1 << (PostgreSQLParser.EXPRESSION - 408)) | (1 << (PostgreSQLParser.GENERATED - 408)) | (1 << (PostgreSQLParser.LOGGED - 408)) | (1 << (PostgreSQLParser.STORED - 408)) | (1 << (PostgreSQLParser.INCLUDE - 408)) | (1 << (PostgreSQLParser.ROUTINE - 408)) | (1 << (PostgreSQLParser.TRANSFORM - 408)) | (1 << (PostgreSQLParser.IMPORT_P - 408)) | (1 << (PostgreSQLParser.POLICY - 408)) | (1 << (PostgreSQLParser.METHOD - 408)) | (1 << (PostgreSQLParser.REFERENCING - 408)) | (1 << (PostgreSQLParser.NEW - 408)))) !== 0) || ((((_la - 440)) & ~0x1F) === 0 && ((1 << (_la - 440)) & ((1 << (PostgreSQLParser.OLD - 440)) | (1 << (PostgreSQLParser.VALUE_P - 440)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 440)) | (1 << (PostgreSQLParser.PUBLICATION - 440)) | (1 << (PostgreSQLParser.OUT_P - 440)) | (1 << (PostgreSQLParser.ROUTINES - 440)) | (1 << (PostgreSQLParser.SCHEMAS - 440)) | (1 << (PostgreSQLParser.PROCEDURES - 440)) | (1 << (PostgreSQLParser.INPUT_P - 440)) | (1 << (PostgreSQLParser.SUPPORT - 440)) | (1 << (PostgreSQLParser.PARALLEL - 440)) | (1 << (PostgreSQLParser.SQL_P - 440)) | (1 << (PostgreSQLParser.DEPENDS - 440)) | (1 << (PostgreSQLParser.OVERRIDING - 440)) | (1 << (PostgreSQLParser.CONFLICT - 440)) | (1 << (PostgreSQLParser.SKIP_P - 440)) | (1 << (PostgreSQLParser.LOCKED - 440)) | (1 << (PostgreSQLParser.TIES - 440)) | (1 << (PostgreSQLParser.ROLLUP - 440)) | (1 << (PostgreSQLParser.CUBE - 440)) | (1 << (PostgreSQLParser.GROUPING - 440)) | (1 << (PostgreSQLParser.SETS - 440)) | (1 << (PostgreSQLParser.ORDINALITY - 440)) | (1 << (PostgreSQLParser.XMLTABLE - 440)) | (1 << (PostgreSQLParser.COLUMNS - 440)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 440)) | (1 << (PostgreSQLParser.ROWTYPE - 440)) | (1 << (PostgreSQLParser.NORMALIZED - 440)) | (1 << (PostgreSQLParser.WITHIN - 440)) | (1 << (PostgreSQLParser.FILTER - 440)))) !== 0) || ((((_la - 472)) & ~0x1F) === 0 && ((1 << (_la - 472)) & ((1 << (PostgreSQLParser.GROUPS - 472)) | (1 << (PostgreSQLParser.OTHERS - 472)) | (1 << (PostgreSQLParser.NFC - 472)) | (1 << (PostgreSQLParser.NFD - 472)) | (1 << (PostgreSQLParser.NFKC - 472)) | (1 << (PostgreSQLParser.NFKD - 472)) | (1 << (PostgreSQLParser.UESCAPE - 472)) | (1 << (PostgreSQLParser.VIEWS - 472)) | (1 << (PostgreSQLParser.NORMALIZE - 472)) | (1 << (PostgreSQLParser.DUMP - 472)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 472)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 472)) | (1 << (PostgreSQLParser.ERROR - 472)) | (1 << (PostgreSQLParser.USE_VARIABLE - 472)) | (1 << (PostgreSQLParser.USE_COLUMN - 472)) | (1 << (PostgreSQLParser.ALIAS - 472)) | (1 << (PostgreSQLParser.CONSTANT - 472)) | (1 << (PostgreSQLParser.PERFORM - 472)) | (1 << (PostgreSQLParser.GET - 472)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 472)) | (1 << (PostgreSQLParser.STACKED - 472)) | (1 << (PostgreSQLParser.ELSIF - 472)) | (1 << (PostgreSQLParser.REVERSE - 472)) | (1 << (PostgreSQLParser.SLICE - 472)) | (1 << (PostgreSQLParser.EXIT - 472)) | (1 << (PostgreSQLParser.RETURN - 472)) | (1 << (PostgreSQLParser.QUERY - 472)) | (1 << (PostgreSQLParser.RAISE - 472)) | (1 << (PostgreSQLParser.SQLSTATE - 472)) | (1 << (PostgreSQLParser.DEBUG - 472)))) !== 0) || ((((_la - 504)) & ~0x1F) === 0 && ((1 << (_la - 504)) & ((1 << (PostgreSQLParser.LOG - 504)) | (1 << (PostgreSQLParser.INFO - 504)) | (1 << (PostgreSQLParser.NOTICE - 504)) | (1 << (PostgreSQLParser.WARNING - 504)) | (1 << (PostgreSQLParser.EXCEPTION - 504)) | (1 << (PostgreSQLParser.ASSERT - 504)) | (1 << (PostgreSQLParser.OPEN - 504)) | (1 << (PostgreSQLParser.Identifier - 504)) | (1 << (PostgreSQLParser.QuotedIdentifier - 504)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 504)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CHECK - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)) | (1 << (PostgreSQLParser.KW_FOREIGN - 33)))) !== 0) || ((((_la - 85)) & ~0x1F) === 0 && ((1 << (_la - 85)) & ((1 << (PostgreSQLParser.KW_PRIMARY - 85)) | (1 << (PostgreSQLParser.KW_TABLE - 85)) | (1 << (PostgreSQLParser.KW_UNIQUE - 85)) | (1 << (PostgreSQLParser.KW_IS - 85)))) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & ((1 << (PostgreSQLParser.KW_LIKE - 120)) | (1 << (PostgreSQLParser.KW_OUTER - 120)) | (1 << (PostgreSQLParser.KW_OVER - 120)) | (1 << (PostgreSQLParser.KW_ABORT - 120)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 120)) | (1 << (PostgreSQLParser.KW_ACCESS - 120)) | (1 << (PostgreSQLParser.KW_ACTION - 120)) | (1 << (PostgreSQLParser.KW_ADD - 120)) | (1 << (PostgreSQLParser.KW_ADMIN - 120)) | (1 << (PostgreSQLParser.KW_AFTER - 120)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 120)) | (1 << (PostgreSQLParser.KW_ALSO - 120)) | (1 << (PostgreSQLParser.KW_ALTER - 120)) | (1 << (PostgreSQLParser.KW_ALWAYS - 120)) | (1 << (PostgreSQLParser.KW_ASSERTION - 120)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 120)) | (1 << (PostgreSQLParser.KW_AT - 120)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 120)) | (1 << (PostgreSQLParser.KW_BACKWARD - 120)) | (1 << (PostgreSQLParser.KW_BEFORE - 120)) | (1 << (PostgreSQLParser.KW_BEGIN - 120)) | (1 << (PostgreSQLParser.KW_BY - 120)) | (1 << (PostgreSQLParser.KW_CACHE - 120)) | (1 << (PostgreSQLParser.KW_CALLED - 120)) | (1 << (PostgreSQLParser.KW_CASCADE - 120)) | (1 << (PostgreSQLParser.KW_CASCADED - 120)))) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & ((1 << (PostgreSQLParser.KW_CATALOG - 152)) | (1 << (PostgreSQLParser.KW_CHAIN - 152)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 152)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 152)) | (1 << (PostgreSQLParser.KW_CLASS - 152)) | (1 << (PostgreSQLParser.KW_CLOSE - 152)) | (1 << (PostgreSQLParser.KW_CLUSTER - 152)) | (1 << (PostgreSQLParser.KW_COMMENT - 152)) | (1 << (PostgreSQLParser.KW_COMMENTS - 152)) | (1 << (PostgreSQLParser.KW_COMMIT - 152)) | (1 << (PostgreSQLParser.KW_COMMITTED - 152)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 152)) | (1 << (PostgreSQLParser.KW_CONNECTION - 152)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 152)) | (1 << (PostgreSQLParser.KW_CONTENT - 152)) | (1 << (PostgreSQLParser.KW_CONTINUE - 152)) | (1 << (PostgreSQLParser.KW_CONVERSION - 152)) | (1 << (PostgreSQLParser.KW_COPY - 152)) | (1 << (PostgreSQLParser.KW_COST - 152)) | (1 << (PostgreSQLParser.KW_CSV - 152)) | (1 << (PostgreSQLParser.KW_CURSOR - 152)) | (1 << (PostgreSQLParser.KW_CYCLE - 152)) | (1 << (PostgreSQLParser.KW_DATA - 152)) | (1 << (PostgreSQLParser.KW_DATABASE - 152)) | (1 << (PostgreSQLParser.KW_DAY - 152)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 152)) | (1 << (PostgreSQLParser.KW_DECLARE - 152)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 152)) | (1 << (PostgreSQLParser.KW_DEFERRED - 152)) | (1 << (PostgreSQLParser.KW_DEFINER - 152)) | (1 << (PostgreSQLParser.KW_DELETE - 152)) | (1 << (PostgreSQLParser.KW_DELIMITER - 152)))) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & ((1 << (PostgreSQLParser.KW_DELIMITERS - 184)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 184)) | (1 << (PostgreSQLParser.KW_DISABLE - 184)) | (1 << (PostgreSQLParser.KW_DISCARD - 184)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 184)) | (1 << (PostgreSQLParser.KW_DOMAIN - 184)) | (1 << (PostgreSQLParser.KW_DOUBLE - 184)) | (1 << (PostgreSQLParser.KW_DROP - 184)) | (1 << (PostgreSQLParser.KW_EACH - 184)) | (1 << (PostgreSQLParser.KW_ENABLE - 184)) | (1 << (PostgreSQLParser.KW_ENCODING - 184)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 184)) | (1 << (PostgreSQLParser.KW_ENUM - 184)) | (1 << (PostgreSQLParser.KW_ESCAPE - 184)) | (1 << (PostgreSQLParser.KW_EVENT - 184)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 184)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 184)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 184)) | (1 << (PostgreSQLParser.KW_EXECUTE - 184)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 184)) | (1 << (PostgreSQLParser.KW_EXTENSION - 184)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 184)) | (1 << (PostgreSQLParser.KW_FAMILY - 184)) | (1 << (PostgreSQLParser.KW_FIRST - 184)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 184)) | (1 << (PostgreSQLParser.KW_FORCE - 184)) | (1 << (PostgreSQLParser.KW_FORWARD - 184)) | (1 << (PostgreSQLParser.KW_FUNCTION - 184)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 184)) | (1 << (PostgreSQLParser.KW_GLOBAL - 184)) | (1 << (PostgreSQLParser.KW_GRANTED - 184)) | (1 << (PostgreSQLParser.KW_HANDLER - 184)))) !== 0) || ((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & ((1 << (PostgreSQLParser.KW_HEADER - 216)) | (1 << (PostgreSQLParser.KW_HOLD - 216)) | (1 << (PostgreSQLParser.KW_HOUR - 216)) | (1 << (PostgreSQLParser.KW_IDENTITY - 216)) | (1 << (PostgreSQLParser.KW_IF - 216)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 216)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 216)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 216)) | (1 << (PostgreSQLParser.KW_INCLUDING - 216)) | (1 << (PostgreSQLParser.KW_INCREMENT - 216)) | (1 << (PostgreSQLParser.KW_INDEX - 216)) | (1 << (PostgreSQLParser.KW_INDEXES - 216)) | (1 << (PostgreSQLParser.KW_INHERIT - 216)) | (1 << (PostgreSQLParser.KW_INHERITS - 216)) | (1 << (PostgreSQLParser.KW_INLINE - 216)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 216)) | (1 << (PostgreSQLParser.KW_INSERT - 216)) | (1 << (PostgreSQLParser.KW_INSTEAD - 216)) | (1 << (PostgreSQLParser.KW_INVOKER - 216)) | (1 << (PostgreSQLParser.KW_ISOLATION - 216)) | (1 << (PostgreSQLParser.KW_KEY - 216)) | (1 << (PostgreSQLParser.KW_LABEL - 216)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 216)))) !== 0) || ((((_la - 248)) & ~0x1F) === 0 && ((1 << (_la - 248)) & ((1 << (PostgreSQLParser.KW_LARGE - 248)) | (1 << (PostgreSQLParser.KW_LAST - 248)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 248)) | (1 << (PostgreSQLParser.KW_LEVEL - 248)) | (1 << (PostgreSQLParser.KW_LISTEN - 248)) | (1 << (PostgreSQLParser.KW_LOAD - 248)) | (1 << (PostgreSQLParser.KW_LOCAL - 248)) | (1 << (PostgreSQLParser.KW_LOCATION - 248)) | (1 << (PostgreSQLParser.KW_LOCK - 248)) | (1 << (PostgreSQLParser.KW_MAPPING - 248)) | (1 << (PostgreSQLParser.KW_MATCH - 248)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 248)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 248)) | (1 << (PostgreSQLParser.KW_MINUTE - 248)) | (1 << (PostgreSQLParser.KW_MINVALUE - 248)) | (1 << (PostgreSQLParser.KW_MODE - 248)) | (1 << (PostgreSQLParser.KW_MONTH - 248)) | (1 << (PostgreSQLParser.KW_MOVE - 248)) | (1 << (PostgreSQLParser.KW_NAME - 248)) | (1 << (PostgreSQLParser.KW_NAMES - 248)) | (1 << (PostgreSQLParser.KW_NEXT - 248)) | (1 << (PostgreSQLParser.KW_NO - 248)) | (1 << (PostgreSQLParser.KW_NOTHING - 248)) | (1 << (PostgreSQLParser.KW_NOTIFY - 248)) | (1 << (PostgreSQLParser.KW_NOWAIT - 248)) | (1 << (PostgreSQLParser.KW_NULLS - 248)) | (1 << (PostgreSQLParser.KW_OBJECT - 248)) | (1 << (PostgreSQLParser.KW_OF - 248)) | (1 << (PostgreSQLParser.KW_OFF - 248)) | (1 << (PostgreSQLParser.KW_OIDS - 248)) | (1 << (PostgreSQLParser.KW_OPERATOR - 248)) | (1 << (PostgreSQLParser.KW_OPTION - 248)))) !== 0) || ((((_la - 280)) & ~0x1F) === 0 && ((1 << (_la - 280)) & ((1 << (PostgreSQLParser.KW_OPTIONS - 280)) | (1 << (PostgreSQLParser.KW_OWNED - 280)) | (1 << (PostgreSQLParser.KW_OWNER - 280)) | (1 << (PostgreSQLParser.KW_PARSER - 280)) | (1 << (PostgreSQLParser.KW_PARTIAL - 280)) | (1 << (PostgreSQLParser.KW_PARTITION - 280)) | (1 << (PostgreSQLParser.KW_PASSING - 280)) | (1 << (PostgreSQLParser.KW_PASSWORD - 280)) | (1 << (PostgreSQLParser.KW_PLANS - 280)) | (1 << (PostgreSQLParser.KW_PRECEDING - 280)) | (1 << (PostgreSQLParser.KW_PREPARE - 280)) | (1 << (PostgreSQLParser.KW_PREPARED - 280)) | (1 << (PostgreSQLParser.KW_PRESERVE - 280)) | (1 << (PostgreSQLParser.KW_PRIOR - 280)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 280)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 280)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 280)) | (1 << (PostgreSQLParser.KW_PROGRAM - 280)) | (1 << (PostgreSQLParser.KW_QUOTE - 280)) | (1 << (PostgreSQLParser.KW_RANGE - 280)) | (1 << (PostgreSQLParser.KW_READ - 280)) | (1 << (PostgreSQLParser.KW_REASSIGN - 280)) | (1 << (PostgreSQLParser.KW_RECHECK - 280)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 280)) | (1 << (PostgreSQLParser.KW_REF - 280)) | (1 << (PostgreSQLParser.KW_REFRESH - 280)) | (1 << (PostgreSQLParser.KW_REINDEX - 280)) | (1 << (PostgreSQLParser.KW_RELATIVE - 280)) | (1 << (PostgreSQLParser.KW_RELEASE - 280)) | (1 << (PostgreSQLParser.KW_RENAME - 280)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 280)) | (1 << (PostgreSQLParser.KW_REPLACE - 280)))) !== 0) || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & ((1 << (PostgreSQLParser.KW_REPLICA - 312)) | (1 << (PostgreSQLParser.KW_RESET - 312)) | (1 << (PostgreSQLParser.KW_RESTART - 312)) | (1 << (PostgreSQLParser.KW_RESTRICT - 312)) | (1 << (PostgreSQLParser.KW_RETURNS - 312)) | (1 << (PostgreSQLParser.KW_REVOKE - 312)) | (1 << (PostgreSQLParser.KW_ROLE - 312)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 312)) | (1 << (PostgreSQLParser.KW_ROWS - 312)) | (1 << (PostgreSQLParser.KW_RULE - 312)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 312)) | (1 << (PostgreSQLParser.KW_SCHEMA - 312)) | (1 << (PostgreSQLParser.KW_SCROLL - 312)) | (1 << (PostgreSQLParser.KW_SEARCH - 312)) | (1 << (PostgreSQLParser.KW_SECOND - 312)) | (1 << (PostgreSQLParser.KW_SECURITY - 312)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 312)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 312)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 312)) | (1 << (PostgreSQLParser.KW_SERVER - 312)) | (1 << (PostgreSQLParser.KW_SESSION - 312)) | (1 << (PostgreSQLParser.KW_SET - 312)) | (1 << (PostgreSQLParser.KW_SHARE - 312)) | (1 << (PostgreSQLParser.KW_SHOW - 312)) | (1 << (PostgreSQLParser.KW_SIMPLE - 312)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 312)) | (1 << (PostgreSQLParser.KW_STABLE - 312)) | (1 << (PostgreSQLParser.KW_STANDALONE - 312)) | (1 << (PostgreSQLParser.KW_START - 312)) | (1 << (PostgreSQLParser.KW_STATEMENT - 312)) | (1 << (PostgreSQLParser.KW_STATISTICS - 312)) | (1 << (PostgreSQLParser.KW_STDIN - 312)))) !== 0) || ((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & ((1 << (PostgreSQLParser.KW_STDOUT - 344)) | (1 << (PostgreSQLParser.KW_STORAGE - 344)) | (1 << (PostgreSQLParser.KW_STRICT - 344)) | (1 << (PostgreSQLParser.KW_STRIP - 344)) | (1 << (PostgreSQLParser.KW_SYSID - 344)) | (1 << (PostgreSQLParser.KW_SYSTEM - 344)) | (1 << (PostgreSQLParser.KW_TABLES - 344)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 344)) | (1 << (PostgreSQLParser.KW_TEMP - 344)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 344)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 344)) | (1 << (PostgreSQLParser.KW_TEXT - 344)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 344)) | (1 << (PostgreSQLParser.KW_TRIGGER - 344)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 344)) | (1 << (PostgreSQLParser.KW_TRUSTED - 344)) | (1 << (PostgreSQLParser.KW_TYPE - 344)) | (1 << (PostgreSQLParser.KW_TYPES - 344)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 344)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 344)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 344)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 344)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 344)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 344)) | (1 << (PostgreSQLParser.KW_UNTIL - 344)) | (1 << (PostgreSQLParser.KW_UPDATE - 344)) | (1 << (PostgreSQLParser.KW_VACUUM - 344)) | (1 << (PostgreSQLParser.KW_VALID - 344)) | (1 << (PostgreSQLParser.KW_VALIDATE - 344)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 344)) | (1 << (PostgreSQLParser.KW_VARYING - 344)) | (1 << (PostgreSQLParser.KW_VERSION - 344)))) !== 0) || ((((_la - 376)) & ~0x1F) === 0 && ((1 << (_la - 376)) & ((1 << (PostgreSQLParser.KW_VIEW - 376)) | (1 << (PostgreSQLParser.KW_VOLATILE - 376)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 376)) | (1 << (PostgreSQLParser.KW_WITHOUT - 376)) | (1 << (PostgreSQLParser.KW_WORK - 376)) | (1 << (PostgreSQLParser.KW_WRAPPER - 376)) | (1 << (PostgreSQLParser.KW_WRITE - 376)) | (1 << (PostgreSQLParser.KW_XML - 376)) | (1 << (PostgreSQLParser.KW_YEAR - 376)) | (1 << (PostgreSQLParser.KW_YES - 376)) | (1 << (PostgreSQLParser.KW_ZONE - 376)) | (1 << (PostgreSQLParser.KW_BETWEEN - 376)) | (1 << (PostgreSQLParser.KW_BIGINT - 376)) | (1 << (PostgreSQLParser.KW_BIT - 376)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 376)) | (1 << (PostgreSQLParser.KW_CHAR - 376)) | (1 << (PostgreSQLParser.KW_CHARACTER - 376)) | (1 << (PostgreSQLParser.KW_COALESCE - 376)) | (1 << (PostgreSQLParser.KW_DEC - 376)) | (1 << (PostgreSQLParser.KW_DECIMAL - 376)) | (1 << (PostgreSQLParser.KW_EXISTS - 376)) | (1 << (PostgreSQLParser.KW_EXTRACT - 376)) | (1 << (PostgreSQLParser.KW_FLOAT - 376)) | (1 << (PostgreSQLParser.KW_GREATEST - 376)) | (1 << (PostgreSQLParser.KW_INOUT - 376)) | (1 << (PostgreSQLParser.KW_INT - 376)) | (1 << (PostgreSQLParser.KW_INTEGER - 376)) | (1 << (PostgreSQLParser.KW_INTERVAL - 376)) | (1 << (PostgreSQLParser.KW_LEAST - 376)) | (1 << (PostgreSQLParser.KW_NATIONAL - 376)) | (1 << (PostgreSQLParser.KW_NCHAR - 376)) | (1 << (PostgreSQLParser.KW_NONE - 376)))) !== 0) || ((((_la - 408)) & ~0x1F) === 0 && ((1 << (_la - 408)) & ((1 << (PostgreSQLParser.KW_NULLIF - 408)) | (1 << (PostgreSQLParser.KW_NUMERIC - 408)) | (1 << (PostgreSQLParser.KW_OVERLAY - 408)) | (1 << (PostgreSQLParser.KW_POSITION - 408)) | (1 << (PostgreSQLParser.KW_PRECISION - 408)) | (1 << (PostgreSQLParser.KW_REAL - 408)) | (1 << (PostgreSQLParser.KW_ROW - 408)) | (1 << (PostgreSQLParser.KW_SETOF - 408)) | (1 << (PostgreSQLParser.KW_SMALLINT - 408)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 408)) | (1 << (PostgreSQLParser.KW_TIME - 408)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 408)) | (1 << (PostgreSQLParser.KW_TREAT - 408)) | (1 << (PostgreSQLParser.KW_TRIM - 408)) | (1 << (PostgreSQLParser.KW_VALUES - 408)) | (1 << (PostgreSQLParser.KW_VARCHAR - 408)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 408)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 408)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 408)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 408)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 408)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 408)) | (1 << (PostgreSQLParser.KW_XMLPI - 408)) | (1 << (PostgreSQLParser.KW_XMLROOT - 408)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 408)) | (1 << (PostgreSQLParser.KW_CALL - 408)) | (1 << (PostgreSQLParser.KW_CURRENT - 408)) | (1 << (PostgreSQLParser.KW_ATTACH - 408)) | (1 << (PostgreSQLParser.KW_DETACH - 408)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 408)) | (1 << (PostgreSQLParser.KW_GENERATED - 408)) | (1 << (PostgreSQLParser.KW_LOGGED - 408)))) !== 0) || ((((_la - 440)) & ~0x1F) === 0 && ((1 << (_la - 440)) & ((1 << (PostgreSQLParser.KW_STORED - 440)) | (1 << (PostgreSQLParser.KW_INCLUDE - 440)) | (1 << (PostgreSQLParser.KW_ROUTINE - 440)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 440)) | (1 << (PostgreSQLParser.KW_IMPORT - 440)) | (1 << (PostgreSQLParser.KW_POLICY - 440)) | (1 << (PostgreSQLParser.KW_METHOD - 440)) | (1 << (PostgreSQLParser.KW_REFERENCING - 440)) | (1 << (PostgreSQLParser.KW_NEW - 440)) | (1 << (PostgreSQLParser.KW_OLD - 440)) | (1 << (PostgreSQLParser.KW_VALUE - 440)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 440)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 440)) | (1 << (PostgreSQLParser.KW_OUT - 440)) | (1 << (PostgreSQLParser.KW_ROUTINES - 440)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 440)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 440)) | (1 << (PostgreSQLParser.KW_INPUT - 440)) | (1 << (PostgreSQLParser.KW_SUPPORT - 440)) | (1 << (PostgreSQLParser.KW_PARALLEL - 440)) | (1 << (PostgreSQLParser.KW_SQL - 440)) | (1 << (PostgreSQLParser.KW_DEPENDS - 440)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 440)) | (1 << (PostgreSQLParser.KW_CONFLICT - 440)) | (1 << (PostgreSQLParser.KW_SKIP - 440)) | (1 << (PostgreSQLParser.KW_LOCKED - 440)) | (1 << (PostgreSQLParser.KW_TIES - 440)) | (1 << (PostgreSQLParser.KW_ROLLUP - 440)) | (1 << (PostgreSQLParser.KW_CUBE - 440)) | (1 << (PostgreSQLParser.KW_GROUPING - 440)) | (1 << (PostgreSQLParser.KW_SETS - 440)))) !== 0) || ((((_la - 473)) & ~0x1F) === 0 && ((1 << (_la - 473)) & ((1 << (PostgreSQLParser.KW_ORDINALITY - 473)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 473)) | (1 << (PostgreSQLParser.KW_COLUMNS - 473)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 473)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 473)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 473)) | (1 << (PostgreSQLParser.KW_WITHIN - 473)) | (1 << (PostgreSQLParser.KW_FILTER - 473)) | (1 << (PostgreSQLParser.KW_GROUPS - 473)) | (1 << (PostgreSQLParser.KW_OTHERS - 473)) | (1 << (PostgreSQLParser.KW_NFC - 473)) | (1 << (PostgreSQLParser.KW_NFD - 473)) | (1 << (PostgreSQLParser.KW_NFKC - 473)) | (1 << (PostgreSQLParser.KW_NFKD - 473)) | (1 << (PostgreSQLParser.KW_UESCAPE - 473)) | (1 << (PostgreSQLParser.KW_VIEWS - 473)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 473)) | (1 << (PostgreSQLParser.KW_DUMP - 473)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 473)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 473)) | (1 << (PostgreSQLParser.KW_ERROR - 473)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 473)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 473)) | (1 << (PostgreSQLParser.KW_ALIAS - 473)) | (1 << (PostgreSQLParser.KW_CONSTANT - 473)) | (1 << (PostgreSQLParser.KW_PERFORM - 473)) | (1 << (PostgreSQLParser.KW_GET - 473)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 473)) | (1 << (PostgreSQLParser.KW_STACKED - 473)) | (1 << (PostgreSQLParser.KW_ELSIF - 473)) | (1 << (PostgreSQLParser.KW_REVERSE - 473)))) !== 0) || ((((_la - 506)) & ~0x1F) === 0 && ((1 << (_la - 506)) & ((1 << (PostgreSQLParser.KW_SLICE - 506)) | (1 << (PostgreSQLParser.KW_EXIT - 506)) | (1 << (PostgreSQLParser.KW_RETURN - 506)) | (1 << (PostgreSQLParser.KW_QUERY - 506)) | (1 << (PostgreSQLParser.KW_RAISE - 506)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 506)) | (1 << (PostgreSQLParser.KW_DEBUG - 506)) | (1 << (PostgreSQLParser.KW_LOG - 506)) | (1 << (PostgreSQLParser.KW_INFO - 506)) | (1 << (PostgreSQLParser.KW_NOTICE - 506)) | (1 << (PostgreSQLParser.KW_WARNING - 506)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 506)) | (1 << (PostgreSQLParser.KW_ASSERT - 506)) | (1 << (PostgreSQLParser.KW_OPEN - 506)) | (1 << (PostgreSQLParser.Identifier - 506)) | (1 << (PostgreSQLParser.QuotedIdentifier - 506)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 506)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 3826; + this.state = 3875; this.opttableelementlist(); } } - this.state = 3829; + this.state = 3878; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 3831; + this.state = 3880; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INHERITS) { + if (_la === PostgreSQLParser.KW_INHERITS) { { - this.state = 3830; + this.state = 3879; this.optinherit(); } } - this.state = 3833; - this.match(PostgreSQLParser.SERVER); - this.state = 3834; + this.state = 3882; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3883; this.name(); - this.state = 3836; + this.state = 3885; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3835; + this.state = 3884; this.create_generic_options(); } } @@ -16649,54 +17306,54 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3838; - this.match(PostgreSQLParser.CREATE); - this.state = 3839; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3840; - this.match(PostgreSQLParser.TABLE); - this.state = 3841; - this.match(PostgreSQLParser.IF_P); - this.state = 3842; - this.match(PostgreSQLParser.NOT); - this.state = 3843; - this.match(PostgreSQLParser.EXISTS); - this.state = 3844; + this.state = 3887; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3888; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3889; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 3890; + this.match(PostgreSQLParser.KW_IF); + this.state = 3891; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3892; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 3893; this.qualified_name(); - this.state = 3845; + this.state = 3894; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3847; + this.state = 3896; 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.CHECK - 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)) | (1 << (PostgreSQLParser.FOREIGN - 33)))) !== 0) || ((((_la - 85)) & ~0x1F) === 0 && ((1 << (_la - 85)) & ((1 << (PostgreSQLParser.PRIMARY - 85)) | (1 << (PostgreSQLParser.TABLE - 85)) | (1 << (PostgreSQLParser.UNIQUE - 85)) | (1 << (PostgreSQLParser.IS - 85)))) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & ((1 << (PostgreSQLParser.LIKE - 120)) | (1 << (PostgreSQLParser.OUTER_P - 120)) | (1 << (PostgreSQLParser.OVER - 120)) | (1 << (PostgreSQLParser.ABORT_P - 120)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 120)) | (1 << (PostgreSQLParser.ACCESS - 120)) | (1 << (PostgreSQLParser.ACTION - 120)) | (1 << (PostgreSQLParser.ADD_P - 120)) | (1 << (PostgreSQLParser.ADMIN - 120)) | (1 << (PostgreSQLParser.AFTER - 120)) | (1 << (PostgreSQLParser.AGGREGATE - 120)) | (1 << (PostgreSQLParser.ALSO - 120)) | (1 << (PostgreSQLParser.ALTER - 120)) | (1 << (PostgreSQLParser.ALWAYS - 120)) | (1 << (PostgreSQLParser.ASSERTION - 120)) | (1 << (PostgreSQLParser.ASSIGNMENT - 120)) | (1 << (PostgreSQLParser.AT - 120)) | (1 << (PostgreSQLParser.ATTRIBUTE - 120)) | (1 << (PostgreSQLParser.BACKWARD - 120)) | (1 << (PostgreSQLParser.BEFORE - 120)) | (1 << (PostgreSQLParser.BEGIN_P - 120)) | (1 << (PostgreSQLParser.BY - 120)) | (1 << (PostgreSQLParser.CACHE - 120)) | (1 << (PostgreSQLParser.CALLED - 120)) | (1 << (PostgreSQLParser.CASCADE - 120)) | (1 << (PostgreSQLParser.CASCADED - 120)))) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & ((1 << (PostgreSQLParser.CATALOG - 152)) | (1 << (PostgreSQLParser.CHAIN - 152)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 152)) | (1 << (PostgreSQLParser.CHECKPOINT - 152)) | (1 << (PostgreSQLParser.CLASS - 152)) | (1 << (PostgreSQLParser.CLOSE - 152)) | (1 << (PostgreSQLParser.CLUSTER - 152)) | (1 << (PostgreSQLParser.COMMENT - 152)) | (1 << (PostgreSQLParser.COMMENTS - 152)) | (1 << (PostgreSQLParser.COMMIT - 152)) | (1 << (PostgreSQLParser.COMMITTED - 152)) | (1 << (PostgreSQLParser.CONFIGURATION - 152)) | (1 << (PostgreSQLParser.CONNECTION - 152)) | (1 << (PostgreSQLParser.CONSTRAINTS - 152)) | (1 << (PostgreSQLParser.CONTENT_P - 152)) | (1 << (PostgreSQLParser.CONTINUE_P - 152)) | (1 << (PostgreSQLParser.CONVERSION_P - 152)) | (1 << (PostgreSQLParser.COPY - 152)) | (1 << (PostgreSQLParser.COST - 152)) | (1 << (PostgreSQLParser.CSV - 152)) | (1 << (PostgreSQLParser.CURSOR - 152)) | (1 << (PostgreSQLParser.CYCLE - 152)) | (1 << (PostgreSQLParser.DATA_P - 152)) | (1 << (PostgreSQLParser.DATABASE - 152)) | (1 << (PostgreSQLParser.DAY_P - 152)) | (1 << (PostgreSQLParser.DEALLOCATE - 152)) | (1 << (PostgreSQLParser.DECLARE - 152)) | (1 << (PostgreSQLParser.DEFAULTS - 152)) | (1 << (PostgreSQLParser.DEFERRED - 152)) | (1 << (PostgreSQLParser.DEFINER - 152)) | (1 << (PostgreSQLParser.DELETE_P - 152)) | (1 << (PostgreSQLParser.DELIMITER - 152)))) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & ((1 << (PostgreSQLParser.DELIMITERS - 184)) | (1 << (PostgreSQLParser.DICTIONARY - 184)) | (1 << (PostgreSQLParser.DISABLE_P - 184)) | (1 << (PostgreSQLParser.DISCARD - 184)) | (1 << (PostgreSQLParser.DOCUMENT_P - 184)) | (1 << (PostgreSQLParser.DOMAIN_P - 184)) | (1 << (PostgreSQLParser.DOUBLE_P - 184)) | (1 << (PostgreSQLParser.DROP - 184)) | (1 << (PostgreSQLParser.EACH - 184)) | (1 << (PostgreSQLParser.ENABLE_P - 184)) | (1 << (PostgreSQLParser.ENCODING - 184)) | (1 << (PostgreSQLParser.ENCRYPTED - 184)) | (1 << (PostgreSQLParser.ENUM_P - 184)) | (1 << (PostgreSQLParser.ESCAPE - 184)) | (1 << (PostgreSQLParser.EVENT - 184)) | (1 << (PostgreSQLParser.EXCLUDE - 184)) | (1 << (PostgreSQLParser.EXCLUDING - 184)) | (1 << (PostgreSQLParser.EXCLUSIVE - 184)) | (1 << (PostgreSQLParser.EXECUTE - 184)) | (1 << (PostgreSQLParser.EXPLAIN - 184)) | (1 << (PostgreSQLParser.EXTENSION - 184)) | (1 << (PostgreSQLParser.EXTERNAL - 184)) | (1 << (PostgreSQLParser.FAMILY - 184)) | (1 << (PostgreSQLParser.FIRST_P - 184)) | (1 << (PostgreSQLParser.FOLLOWING - 184)) | (1 << (PostgreSQLParser.FORCE - 184)) | (1 << (PostgreSQLParser.FORWARD - 184)) | (1 << (PostgreSQLParser.FUNCTION - 184)) | (1 << (PostgreSQLParser.FUNCTIONS - 184)) | (1 << (PostgreSQLParser.GLOBAL - 184)) | (1 << (PostgreSQLParser.GRANTED - 184)) | (1 << (PostgreSQLParser.HANDLER - 184)))) !== 0) || ((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & ((1 << (PostgreSQLParser.HEADER_P - 216)) | (1 << (PostgreSQLParser.HOLD - 216)) | (1 << (PostgreSQLParser.HOUR_P - 216)) | (1 << (PostgreSQLParser.IDENTITY_P - 216)) | (1 << (PostgreSQLParser.IF_P - 216)) | (1 << (PostgreSQLParser.IMMEDIATE - 216)) | (1 << (PostgreSQLParser.IMMUTABLE - 216)) | (1 << (PostgreSQLParser.IMPLICIT_P - 216)) | (1 << (PostgreSQLParser.INCLUDING - 216)) | (1 << (PostgreSQLParser.INCREMENT - 216)) | (1 << (PostgreSQLParser.INDEX - 216)) | (1 << (PostgreSQLParser.INDEXES - 216)) | (1 << (PostgreSQLParser.INHERIT - 216)) | (1 << (PostgreSQLParser.INHERITS - 216)) | (1 << (PostgreSQLParser.INLINE_P - 216)) | (1 << (PostgreSQLParser.INSENSITIVE - 216)) | (1 << (PostgreSQLParser.INSERT - 216)) | (1 << (PostgreSQLParser.INSTEAD - 216)) | (1 << (PostgreSQLParser.INVOKER - 216)) | (1 << (PostgreSQLParser.ISOLATION - 216)) | (1 << (PostgreSQLParser.KEY - 216)) | (1 << (PostgreSQLParser.LABEL - 216)) | (1 << (PostgreSQLParser.LANGUAGE - 216)) | (1 << (PostgreSQLParser.LARGE_P - 216)) | (1 << (PostgreSQLParser.LAST_P - 216)) | (1 << (PostgreSQLParser.LEAKPROOF - 216)) | (1 << (PostgreSQLParser.LEVEL - 216)) | (1 << (PostgreSQLParser.LISTEN - 216)) | (1 << (PostgreSQLParser.LOAD - 216)) | (1 << (PostgreSQLParser.LOCAL - 216)) | (1 << (PostgreSQLParser.LOCATION - 216)) | (1 << (PostgreSQLParser.LOCK_P - 216)))) !== 0) || ((((_la - 248)) & ~0x1F) === 0 && ((1 << (_la - 248)) & ((1 << (PostgreSQLParser.MAPPING - 248)) | (1 << (PostgreSQLParser.MATCH - 248)) | (1 << (PostgreSQLParser.MATERIALIZED - 248)) | (1 << (PostgreSQLParser.MAXVALUE - 248)) | (1 << (PostgreSQLParser.MINUTE_P - 248)) | (1 << (PostgreSQLParser.MINVALUE - 248)) | (1 << (PostgreSQLParser.MODE - 248)) | (1 << (PostgreSQLParser.MONTH_P - 248)) | (1 << (PostgreSQLParser.MOVE - 248)) | (1 << (PostgreSQLParser.NAME_P - 248)) | (1 << (PostgreSQLParser.NAMES - 248)) | (1 << (PostgreSQLParser.NEXT - 248)) | (1 << (PostgreSQLParser.NO - 248)) | (1 << (PostgreSQLParser.NOTHING - 248)) | (1 << (PostgreSQLParser.NOTIFY - 248)) | (1 << (PostgreSQLParser.NOWAIT - 248)) | (1 << (PostgreSQLParser.NULLS_P - 248)) | (1 << (PostgreSQLParser.OBJECT_P - 248)) | (1 << (PostgreSQLParser.OF - 248)) | (1 << (PostgreSQLParser.OFF - 248)) | (1 << (PostgreSQLParser.OIDS - 248)) | (1 << (PostgreSQLParser.OPERATOR - 248)) | (1 << (PostgreSQLParser.OPTION - 248)) | (1 << (PostgreSQLParser.OPTIONS - 248)) | (1 << (PostgreSQLParser.OWNED - 248)) | (1 << (PostgreSQLParser.OWNER - 248)) | (1 << (PostgreSQLParser.PARSER - 248)) | (1 << (PostgreSQLParser.PARTIAL - 248)) | (1 << (PostgreSQLParser.PARTITION - 248)) | (1 << (PostgreSQLParser.PASSING - 248)) | (1 << (PostgreSQLParser.PASSWORD - 248)) | (1 << (PostgreSQLParser.PLANS - 248)))) !== 0) || ((((_la - 280)) & ~0x1F) === 0 && ((1 << (_la - 280)) & ((1 << (PostgreSQLParser.PRECEDING - 280)) | (1 << (PostgreSQLParser.PREPARE - 280)) | (1 << (PostgreSQLParser.PREPARED - 280)) | (1 << (PostgreSQLParser.PRESERVE - 280)) | (1 << (PostgreSQLParser.PRIOR - 280)) | (1 << (PostgreSQLParser.PRIVILEGES - 280)) | (1 << (PostgreSQLParser.PROCEDURAL - 280)) | (1 << (PostgreSQLParser.PROCEDURE - 280)) | (1 << (PostgreSQLParser.PROGRAM - 280)) | (1 << (PostgreSQLParser.QUOTE - 280)) | (1 << (PostgreSQLParser.RANGE - 280)) | (1 << (PostgreSQLParser.READ - 280)) | (1 << (PostgreSQLParser.REASSIGN - 280)) | (1 << (PostgreSQLParser.RECHECK - 280)) | (1 << (PostgreSQLParser.RECURSIVE - 280)) | (1 << (PostgreSQLParser.REF - 280)) | (1 << (PostgreSQLParser.REFRESH - 280)) | (1 << (PostgreSQLParser.REINDEX - 280)) | (1 << (PostgreSQLParser.RELATIVE_P - 280)) | (1 << (PostgreSQLParser.RELEASE - 280)) | (1 << (PostgreSQLParser.RENAME - 280)) | (1 << (PostgreSQLParser.REPEATABLE - 280)) | (1 << (PostgreSQLParser.REPLACE - 280)) | (1 << (PostgreSQLParser.REPLICA - 280)) | (1 << (PostgreSQLParser.RESET - 280)) | (1 << (PostgreSQLParser.RESTART - 280)) | (1 << (PostgreSQLParser.RESTRICT - 280)) | (1 << (PostgreSQLParser.RETURNS - 280)) | (1 << (PostgreSQLParser.REVOKE - 280)) | (1 << (PostgreSQLParser.ROLE - 280)) | (1 << (PostgreSQLParser.ROLLBACK - 280)) | (1 << (PostgreSQLParser.ROWS - 280)))) !== 0) || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & ((1 << (PostgreSQLParser.RULE - 312)) | (1 << (PostgreSQLParser.SAVEPOINT - 312)) | (1 << (PostgreSQLParser.SCHEMA - 312)) | (1 << (PostgreSQLParser.SCROLL - 312)) | (1 << (PostgreSQLParser.SEARCH - 312)) | (1 << (PostgreSQLParser.SECOND_P - 312)) | (1 << (PostgreSQLParser.SECURITY - 312)) | (1 << (PostgreSQLParser.SEQUENCE - 312)) | (1 << (PostgreSQLParser.SEQUENCES - 312)) | (1 << (PostgreSQLParser.SERIALIZABLE - 312)) | (1 << (PostgreSQLParser.SERVER - 312)) | (1 << (PostgreSQLParser.SESSION - 312)) | (1 << (PostgreSQLParser.SET - 312)) | (1 << (PostgreSQLParser.SHARE - 312)) | (1 << (PostgreSQLParser.SHOW - 312)) | (1 << (PostgreSQLParser.SIMPLE - 312)) | (1 << (PostgreSQLParser.SNAPSHOT - 312)) | (1 << (PostgreSQLParser.STABLE - 312)) | (1 << (PostgreSQLParser.STANDALONE_P - 312)) | (1 << (PostgreSQLParser.START - 312)) | (1 << (PostgreSQLParser.STATEMENT - 312)) | (1 << (PostgreSQLParser.STATISTICS - 312)) | (1 << (PostgreSQLParser.STDIN - 312)) | (1 << (PostgreSQLParser.STDOUT - 312)) | (1 << (PostgreSQLParser.STORAGE - 312)) | (1 << (PostgreSQLParser.STRICT_P - 312)) | (1 << (PostgreSQLParser.STRIP_P - 312)) | (1 << (PostgreSQLParser.SYSID - 312)) | (1 << (PostgreSQLParser.SYSTEM_P - 312)) | (1 << (PostgreSQLParser.TABLES - 312)) | (1 << (PostgreSQLParser.TABLESPACE - 312)) | (1 << (PostgreSQLParser.TEMP - 312)))) !== 0) || ((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & ((1 << (PostgreSQLParser.TEMPLATE - 344)) | (1 << (PostgreSQLParser.TEMPORARY - 344)) | (1 << (PostgreSQLParser.TEXT_P - 344)) | (1 << (PostgreSQLParser.TRANSACTION - 344)) | (1 << (PostgreSQLParser.TRIGGER - 344)) | (1 << (PostgreSQLParser.TRUNCATE - 344)) | (1 << (PostgreSQLParser.TRUSTED - 344)) | (1 << (PostgreSQLParser.TYPE_P - 344)) | (1 << (PostgreSQLParser.TYPES_P - 344)) | (1 << (PostgreSQLParser.UNBOUNDED - 344)) | (1 << (PostgreSQLParser.UNCOMMITTED - 344)) | (1 << (PostgreSQLParser.UNENCRYPTED - 344)) | (1 << (PostgreSQLParser.UNKNOWN - 344)) | (1 << (PostgreSQLParser.UNLISTEN - 344)) | (1 << (PostgreSQLParser.UNLOGGED - 344)) | (1 << (PostgreSQLParser.UNTIL - 344)) | (1 << (PostgreSQLParser.UPDATE - 344)) | (1 << (PostgreSQLParser.VACUUM - 344)) | (1 << (PostgreSQLParser.VALID - 344)) | (1 << (PostgreSQLParser.VALIDATE - 344)) | (1 << (PostgreSQLParser.VALIDATOR - 344)) | (1 << (PostgreSQLParser.VARYING - 344)) | (1 << (PostgreSQLParser.VERSION_P - 344)) | (1 << (PostgreSQLParser.VIEW - 344)) | (1 << (PostgreSQLParser.VOLATILE - 344)) | (1 << (PostgreSQLParser.WHITESPACE_P - 344)) | (1 << (PostgreSQLParser.WITHOUT - 344)) | (1 << (PostgreSQLParser.WORK - 344)) | (1 << (PostgreSQLParser.WRAPPER - 344)) | (1 << (PostgreSQLParser.WRITE - 344)) | (1 << (PostgreSQLParser.XML_P - 344)) | (1 << (PostgreSQLParser.YEAR_P - 344)))) !== 0) || ((((_la - 376)) & ~0x1F) === 0 && ((1 << (_la - 376)) & ((1 << (PostgreSQLParser.YES_P - 376)) | (1 << (PostgreSQLParser.ZONE - 376)) | (1 << (PostgreSQLParser.BETWEEN - 376)) | (1 << (PostgreSQLParser.BIGINT - 376)) | (1 << (PostgreSQLParser.BIT - 376)) | (1 << (PostgreSQLParser.BOOLEAN_P - 376)) | (1 << (PostgreSQLParser.CHAR_P - 376)) | (1 << (PostgreSQLParser.CHARACTER - 376)) | (1 << (PostgreSQLParser.COALESCE - 376)) | (1 << (PostgreSQLParser.DEC - 376)) | (1 << (PostgreSQLParser.DECIMAL_P - 376)) | (1 << (PostgreSQLParser.EXISTS - 376)) | (1 << (PostgreSQLParser.EXTRACT - 376)) | (1 << (PostgreSQLParser.FLOAT_P - 376)) | (1 << (PostgreSQLParser.GREATEST - 376)) | (1 << (PostgreSQLParser.INOUT - 376)) | (1 << (PostgreSQLParser.INT_P - 376)) | (1 << (PostgreSQLParser.INTEGER - 376)) | (1 << (PostgreSQLParser.INTERVAL - 376)) | (1 << (PostgreSQLParser.LEAST - 376)) | (1 << (PostgreSQLParser.NATIONAL - 376)) | (1 << (PostgreSQLParser.NCHAR - 376)) | (1 << (PostgreSQLParser.NONE - 376)) | (1 << (PostgreSQLParser.NULLIF - 376)) | (1 << (PostgreSQLParser.NUMERIC - 376)) | (1 << (PostgreSQLParser.OVERLAY - 376)) | (1 << (PostgreSQLParser.POSITION - 376)) | (1 << (PostgreSQLParser.PRECISION - 376)) | (1 << (PostgreSQLParser.REAL - 376)) | (1 << (PostgreSQLParser.ROW - 376)) | (1 << (PostgreSQLParser.SETOF - 376)) | (1 << (PostgreSQLParser.SMALLINT - 376)))) !== 0) || ((((_la - 408)) & ~0x1F) === 0 && ((1 << (_la - 408)) & ((1 << (PostgreSQLParser.SUBSTRING - 408)) | (1 << (PostgreSQLParser.TIME - 408)) | (1 << (PostgreSQLParser.TIMESTAMP - 408)) | (1 << (PostgreSQLParser.TREAT - 408)) | (1 << (PostgreSQLParser.TRIM - 408)) | (1 << (PostgreSQLParser.VALUES - 408)) | (1 << (PostgreSQLParser.VARCHAR - 408)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 408)) | (1 << (PostgreSQLParser.XMLCONCAT - 408)) | (1 << (PostgreSQLParser.XMLELEMENT - 408)) | (1 << (PostgreSQLParser.XMLEXISTS - 408)) | (1 << (PostgreSQLParser.XMLFOREST - 408)) | (1 << (PostgreSQLParser.XMLPARSE - 408)) | (1 << (PostgreSQLParser.XMLPI - 408)) | (1 << (PostgreSQLParser.XMLROOT - 408)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 408)) | (1 << (PostgreSQLParser.CALL - 408)) | (1 << (PostgreSQLParser.CURRENT_P - 408)) | (1 << (PostgreSQLParser.ATTACH - 408)) | (1 << (PostgreSQLParser.DETACH - 408)) | (1 << (PostgreSQLParser.EXPRESSION - 408)) | (1 << (PostgreSQLParser.GENERATED - 408)) | (1 << (PostgreSQLParser.LOGGED - 408)) | (1 << (PostgreSQLParser.STORED - 408)) | (1 << (PostgreSQLParser.INCLUDE - 408)) | (1 << (PostgreSQLParser.ROUTINE - 408)) | (1 << (PostgreSQLParser.TRANSFORM - 408)) | (1 << (PostgreSQLParser.IMPORT_P - 408)) | (1 << (PostgreSQLParser.POLICY - 408)) | (1 << (PostgreSQLParser.METHOD - 408)) | (1 << (PostgreSQLParser.REFERENCING - 408)) | (1 << (PostgreSQLParser.NEW - 408)))) !== 0) || ((((_la - 440)) & ~0x1F) === 0 && ((1 << (_la - 440)) & ((1 << (PostgreSQLParser.OLD - 440)) | (1 << (PostgreSQLParser.VALUE_P - 440)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 440)) | (1 << (PostgreSQLParser.PUBLICATION - 440)) | (1 << (PostgreSQLParser.OUT_P - 440)) | (1 << (PostgreSQLParser.ROUTINES - 440)) | (1 << (PostgreSQLParser.SCHEMAS - 440)) | (1 << (PostgreSQLParser.PROCEDURES - 440)) | (1 << (PostgreSQLParser.INPUT_P - 440)) | (1 << (PostgreSQLParser.SUPPORT - 440)) | (1 << (PostgreSQLParser.PARALLEL - 440)) | (1 << (PostgreSQLParser.SQL_P - 440)) | (1 << (PostgreSQLParser.DEPENDS - 440)) | (1 << (PostgreSQLParser.OVERRIDING - 440)) | (1 << (PostgreSQLParser.CONFLICT - 440)) | (1 << (PostgreSQLParser.SKIP_P - 440)) | (1 << (PostgreSQLParser.LOCKED - 440)) | (1 << (PostgreSQLParser.TIES - 440)) | (1 << (PostgreSQLParser.ROLLUP - 440)) | (1 << (PostgreSQLParser.CUBE - 440)) | (1 << (PostgreSQLParser.GROUPING - 440)) | (1 << (PostgreSQLParser.SETS - 440)) | (1 << (PostgreSQLParser.ORDINALITY - 440)) | (1 << (PostgreSQLParser.XMLTABLE - 440)) | (1 << (PostgreSQLParser.COLUMNS - 440)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 440)) | (1 << (PostgreSQLParser.ROWTYPE - 440)) | (1 << (PostgreSQLParser.NORMALIZED - 440)) | (1 << (PostgreSQLParser.WITHIN - 440)) | (1 << (PostgreSQLParser.FILTER - 440)))) !== 0) || ((((_la - 472)) & ~0x1F) === 0 && ((1 << (_la - 472)) & ((1 << (PostgreSQLParser.GROUPS - 472)) | (1 << (PostgreSQLParser.OTHERS - 472)) | (1 << (PostgreSQLParser.NFC - 472)) | (1 << (PostgreSQLParser.NFD - 472)) | (1 << (PostgreSQLParser.NFKC - 472)) | (1 << (PostgreSQLParser.NFKD - 472)) | (1 << (PostgreSQLParser.UESCAPE - 472)) | (1 << (PostgreSQLParser.VIEWS - 472)) | (1 << (PostgreSQLParser.NORMALIZE - 472)) | (1 << (PostgreSQLParser.DUMP - 472)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 472)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 472)) | (1 << (PostgreSQLParser.ERROR - 472)) | (1 << (PostgreSQLParser.USE_VARIABLE - 472)) | (1 << (PostgreSQLParser.USE_COLUMN - 472)) | (1 << (PostgreSQLParser.ALIAS - 472)) | (1 << (PostgreSQLParser.CONSTANT - 472)) | (1 << (PostgreSQLParser.PERFORM - 472)) | (1 << (PostgreSQLParser.GET - 472)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 472)) | (1 << (PostgreSQLParser.STACKED - 472)) | (1 << (PostgreSQLParser.ELSIF - 472)) | (1 << (PostgreSQLParser.REVERSE - 472)) | (1 << (PostgreSQLParser.SLICE - 472)) | (1 << (PostgreSQLParser.EXIT - 472)) | (1 << (PostgreSQLParser.RETURN - 472)) | (1 << (PostgreSQLParser.QUERY - 472)) | (1 << (PostgreSQLParser.RAISE - 472)) | (1 << (PostgreSQLParser.SQLSTATE - 472)) | (1 << (PostgreSQLParser.DEBUG - 472)))) !== 0) || ((((_la - 504)) & ~0x1F) === 0 && ((1 << (_la - 504)) & ((1 << (PostgreSQLParser.LOG - 504)) | (1 << (PostgreSQLParser.INFO - 504)) | (1 << (PostgreSQLParser.NOTICE - 504)) | (1 << (PostgreSQLParser.WARNING - 504)) | (1 << (PostgreSQLParser.EXCEPTION - 504)) | (1 << (PostgreSQLParser.ASSERT - 504)) | (1 << (PostgreSQLParser.OPEN - 504)) | (1 << (PostgreSQLParser.Identifier - 504)) | (1 << (PostgreSQLParser.QuotedIdentifier - 504)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 504)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CHECK - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)) | (1 << (PostgreSQLParser.KW_FOREIGN - 33)))) !== 0) || ((((_la - 85)) & ~0x1F) === 0 && ((1 << (_la - 85)) & ((1 << (PostgreSQLParser.KW_PRIMARY - 85)) | (1 << (PostgreSQLParser.KW_TABLE - 85)) | (1 << (PostgreSQLParser.KW_UNIQUE - 85)) | (1 << (PostgreSQLParser.KW_IS - 85)))) !== 0) || ((((_la - 120)) & ~0x1F) === 0 && ((1 << (_la - 120)) & ((1 << (PostgreSQLParser.KW_LIKE - 120)) | (1 << (PostgreSQLParser.KW_OUTER - 120)) | (1 << (PostgreSQLParser.KW_OVER - 120)) | (1 << (PostgreSQLParser.KW_ABORT - 120)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 120)) | (1 << (PostgreSQLParser.KW_ACCESS - 120)) | (1 << (PostgreSQLParser.KW_ACTION - 120)) | (1 << (PostgreSQLParser.KW_ADD - 120)) | (1 << (PostgreSQLParser.KW_ADMIN - 120)) | (1 << (PostgreSQLParser.KW_AFTER - 120)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 120)) | (1 << (PostgreSQLParser.KW_ALSO - 120)) | (1 << (PostgreSQLParser.KW_ALTER - 120)) | (1 << (PostgreSQLParser.KW_ALWAYS - 120)) | (1 << (PostgreSQLParser.KW_ASSERTION - 120)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 120)) | (1 << (PostgreSQLParser.KW_AT - 120)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 120)) | (1 << (PostgreSQLParser.KW_BACKWARD - 120)) | (1 << (PostgreSQLParser.KW_BEFORE - 120)) | (1 << (PostgreSQLParser.KW_BEGIN - 120)) | (1 << (PostgreSQLParser.KW_BY - 120)) | (1 << (PostgreSQLParser.KW_CACHE - 120)) | (1 << (PostgreSQLParser.KW_CALLED - 120)) | (1 << (PostgreSQLParser.KW_CASCADE - 120)) | (1 << (PostgreSQLParser.KW_CASCADED - 120)))) !== 0) || ((((_la - 152)) & ~0x1F) === 0 && ((1 << (_la - 152)) & ((1 << (PostgreSQLParser.KW_CATALOG - 152)) | (1 << (PostgreSQLParser.KW_CHAIN - 152)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 152)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 152)) | (1 << (PostgreSQLParser.KW_CLASS - 152)) | (1 << (PostgreSQLParser.KW_CLOSE - 152)) | (1 << (PostgreSQLParser.KW_CLUSTER - 152)) | (1 << (PostgreSQLParser.KW_COMMENT - 152)) | (1 << (PostgreSQLParser.KW_COMMENTS - 152)) | (1 << (PostgreSQLParser.KW_COMMIT - 152)) | (1 << (PostgreSQLParser.KW_COMMITTED - 152)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 152)) | (1 << (PostgreSQLParser.KW_CONNECTION - 152)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 152)) | (1 << (PostgreSQLParser.KW_CONTENT - 152)) | (1 << (PostgreSQLParser.KW_CONTINUE - 152)) | (1 << (PostgreSQLParser.KW_CONVERSION - 152)) | (1 << (PostgreSQLParser.KW_COPY - 152)) | (1 << (PostgreSQLParser.KW_COST - 152)) | (1 << (PostgreSQLParser.KW_CSV - 152)) | (1 << (PostgreSQLParser.KW_CURSOR - 152)) | (1 << (PostgreSQLParser.KW_CYCLE - 152)) | (1 << (PostgreSQLParser.KW_DATA - 152)) | (1 << (PostgreSQLParser.KW_DATABASE - 152)) | (1 << (PostgreSQLParser.KW_DAY - 152)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 152)) | (1 << (PostgreSQLParser.KW_DECLARE - 152)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 152)) | (1 << (PostgreSQLParser.KW_DEFERRED - 152)) | (1 << (PostgreSQLParser.KW_DEFINER - 152)) | (1 << (PostgreSQLParser.KW_DELETE - 152)) | (1 << (PostgreSQLParser.KW_DELIMITER - 152)))) !== 0) || ((((_la - 184)) & ~0x1F) === 0 && ((1 << (_la - 184)) & ((1 << (PostgreSQLParser.KW_DELIMITERS - 184)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 184)) | (1 << (PostgreSQLParser.KW_DISABLE - 184)) | (1 << (PostgreSQLParser.KW_DISCARD - 184)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 184)) | (1 << (PostgreSQLParser.KW_DOMAIN - 184)) | (1 << (PostgreSQLParser.KW_DOUBLE - 184)) | (1 << (PostgreSQLParser.KW_DROP - 184)) | (1 << (PostgreSQLParser.KW_EACH - 184)) | (1 << (PostgreSQLParser.KW_ENABLE - 184)) | (1 << (PostgreSQLParser.KW_ENCODING - 184)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 184)) | (1 << (PostgreSQLParser.KW_ENUM - 184)) | (1 << (PostgreSQLParser.KW_ESCAPE - 184)) | (1 << (PostgreSQLParser.KW_EVENT - 184)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 184)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 184)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 184)) | (1 << (PostgreSQLParser.KW_EXECUTE - 184)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 184)) | (1 << (PostgreSQLParser.KW_EXTENSION - 184)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 184)) | (1 << (PostgreSQLParser.KW_FAMILY - 184)) | (1 << (PostgreSQLParser.KW_FIRST - 184)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 184)) | (1 << (PostgreSQLParser.KW_FORCE - 184)) | (1 << (PostgreSQLParser.KW_FORWARD - 184)) | (1 << (PostgreSQLParser.KW_FUNCTION - 184)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 184)) | (1 << (PostgreSQLParser.KW_GLOBAL - 184)) | (1 << (PostgreSQLParser.KW_GRANTED - 184)) | (1 << (PostgreSQLParser.KW_HANDLER - 184)))) !== 0) || ((((_la - 216)) & ~0x1F) === 0 && ((1 << (_la - 216)) & ((1 << (PostgreSQLParser.KW_HEADER - 216)) | (1 << (PostgreSQLParser.KW_HOLD - 216)) | (1 << (PostgreSQLParser.KW_HOUR - 216)) | (1 << (PostgreSQLParser.KW_IDENTITY - 216)) | (1 << (PostgreSQLParser.KW_IF - 216)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 216)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 216)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 216)) | (1 << (PostgreSQLParser.KW_INCLUDING - 216)) | (1 << (PostgreSQLParser.KW_INCREMENT - 216)) | (1 << (PostgreSQLParser.KW_INDEX - 216)) | (1 << (PostgreSQLParser.KW_INDEXES - 216)) | (1 << (PostgreSQLParser.KW_INHERIT - 216)) | (1 << (PostgreSQLParser.KW_INHERITS - 216)) | (1 << (PostgreSQLParser.KW_INLINE - 216)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 216)) | (1 << (PostgreSQLParser.KW_INSERT - 216)) | (1 << (PostgreSQLParser.KW_INSTEAD - 216)) | (1 << (PostgreSQLParser.KW_INVOKER - 216)) | (1 << (PostgreSQLParser.KW_ISOLATION - 216)) | (1 << (PostgreSQLParser.KW_KEY - 216)) | (1 << (PostgreSQLParser.KW_LABEL - 216)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 216)))) !== 0) || ((((_la - 248)) & ~0x1F) === 0 && ((1 << (_la - 248)) & ((1 << (PostgreSQLParser.KW_LARGE - 248)) | (1 << (PostgreSQLParser.KW_LAST - 248)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 248)) | (1 << (PostgreSQLParser.KW_LEVEL - 248)) | (1 << (PostgreSQLParser.KW_LISTEN - 248)) | (1 << (PostgreSQLParser.KW_LOAD - 248)) | (1 << (PostgreSQLParser.KW_LOCAL - 248)) | (1 << (PostgreSQLParser.KW_LOCATION - 248)) | (1 << (PostgreSQLParser.KW_LOCK - 248)) | (1 << (PostgreSQLParser.KW_MAPPING - 248)) | (1 << (PostgreSQLParser.KW_MATCH - 248)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 248)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 248)) | (1 << (PostgreSQLParser.KW_MINUTE - 248)) | (1 << (PostgreSQLParser.KW_MINVALUE - 248)) | (1 << (PostgreSQLParser.KW_MODE - 248)) | (1 << (PostgreSQLParser.KW_MONTH - 248)) | (1 << (PostgreSQLParser.KW_MOVE - 248)) | (1 << (PostgreSQLParser.KW_NAME - 248)) | (1 << (PostgreSQLParser.KW_NAMES - 248)) | (1 << (PostgreSQLParser.KW_NEXT - 248)) | (1 << (PostgreSQLParser.KW_NO - 248)) | (1 << (PostgreSQLParser.KW_NOTHING - 248)) | (1 << (PostgreSQLParser.KW_NOTIFY - 248)) | (1 << (PostgreSQLParser.KW_NOWAIT - 248)) | (1 << (PostgreSQLParser.KW_NULLS - 248)) | (1 << (PostgreSQLParser.KW_OBJECT - 248)) | (1 << (PostgreSQLParser.KW_OF - 248)) | (1 << (PostgreSQLParser.KW_OFF - 248)) | (1 << (PostgreSQLParser.KW_OIDS - 248)) | (1 << (PostgreSQLParser.KW_OPERATOR - 248)) | (1 << (PostgreSQLParser.KW_OPTION - 248)))) !== 0) || ((((_la - 280)) & ~0x1F) === 0 && ((1 << (_la - 280)) & ((1 << (PostgreSQLParser.KW_OPTIONS - 280)) | (1 << (PostgreSQLParser.KW_OWNED - 280)) | (1 << (PostgreSQLParser.KW_OWNER - 280)) | (1 << (PostgreSQLParser.KW_PARSER - 280)) | (1 << (PostgreSQLParser.KW_PARTIAL - 280)) | (1 << (PostgreSQLParser.KW_PARTITION - 280)) | (1 << (PostgreSQLParser.KW_PASSING - 280)) | (1 << (PostgreSQLParser.KW_PASSWORD - 280)) | (1 << (PostgreSQLParser.KW_PLANS - 280)) | (1 << (PostgreSQLParser.KW_PRECEDING - 280)) | (1 << (PostgreSQLParser.KW_PREPARE - 280)) | (1 << (PostgreSQLParser.KW_PREPARED - 280)) | (1 << (PostgreSQLParser.KW_PRESERVE - 280)) | (1 << (PostgreSQLParser.KW_PRIOR - 280)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 280)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 280)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 280)) | (1 << (PostgreSQLParser.KW_PROGRAM - 280)) | (1 << (PostgreSQLParser.KW_QUOTE - 280)) | (1 << (PostgreSQLParser.KW_RANGE - 280)) | (1 << (PostgreSQLParser.KW_READ - 280)) | (1 << (PostgreSQLParser.KW_REASSIGN - 280)) | (1 << (PostgreSQLParser.KW_RECHECK - 280)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 280)) | (1 << (PostgreSQLParser.KW_REF - 280)) | (1 << (PostgreSQLParser.KW_REFRESH - 280)) | (1 << (PostgreSQLParser.KW_REINDEX - 280)) | (1 << (PostgreSQLParser.KW_RELATIVE - 280)) | (1 << (PostgreSQLParser.KW_RELEASE - 280)) | (1 << (PostgreSQLParser.KW_RENAME - 280)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 280)) | (1 << (PostgreSQLParser.KW_REPLACE - 280)))) !== 0) || ((((_la - 312)) & ~0x1F) === 0 && ((1 << (_la - 312)) & ((1 << (PostgreSQLParser.KW_REPLICA - 312)) | (1 << (PostgreSQLParser.KW_RESET - 312)) | (1 << (PostgreSQLParser.KW_RESTART - 312)) | (1 << (PostgreSQLParser.KW_RESTRICT - 312)) | (1 << (PostgreSQLParser.KW_RETURNS - 312)) | (1 << (PostgreSQLParser.KW_REVOKE - 312)) | (1 << (PostgreSQLParser.KW_ROLE - 312)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 312)) | (1 << (PostgreSQLParser.KW_ROWS - 312)) | (1 << (PostgreSQLParser.KW_RULE - 312)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 312)) | (1 << (PostgreSQLParser.KW_SCHEMA - 312)) | (1 << (PostgreSQLParser.KW_SCROLL - 312)) | (1 << (PostgreSQLParser.KW_SEARCH - 312)) | (1 << (PostgreSQLParser.KW_SECOND - 312)) | (1 << (PostgreSQLParser.KW_SECURITY - 312)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 312)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 312)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 312)) | (1 << (PostgreSQLParser.KW_SERVER - 312)) | (1 << (PostgreSQLParser.KW_SESSION - 312)) | (1 << (PostgreSQLParser.KW_SET - 312)) | (1 << (PostgreSQLParser.KW_SHARE - 312)) | (1 << (PostgreSQLParser.KW_SHOW - 312)) | (1 << (PostgreSQLParser.KW_SIMPLE - 312)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 312)) | (1 << (PostgreSQLParser.KW_STABLE - 312)) | (1 << (PostgreSQLParser.KW_STANDALONE - 312)) | (1 << (PostgreSQLParser.KW_START - 312)) | (1 << (PostgreSQLParser.KW_STATEMENT - 312)) | (1 << (PostgreSQLParser.KW_STATISTICS - 312)) | (1 << (PostgreSQLParser.KW_STDIN - 312)))) !== 0) || ((((_la - 344)) & ~0x1F) === 0 && ((1 << (_la - 344)) & ((1 << (PostgreSQLParser.KW_STDOUT - 344)) | (1 << (PostgreSQLParser.KW_STORAGE - 344)) | (1 << (PostgreSQLParser.KW_STRICT - 344)) | (1 << (PostgreSQLParser.KW_STRIP - 344)) | (1 << (PostgreSQLParser.KW_SYSID - 344)) | (1 << (PostgreSQLParser.KW_SYSTEM - 344)) | (1 << (PostgreSQLParser.KW_TABLES - 344)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 344)) | (1 << (PostgreSQLParser.KW_TEMP - 344)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 344)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 344)) | (1 << (PostgreSQLParser.KW_TEXT - 344)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 344)) | (1 << (PostgreSQLParser.KW_TRIGGER - 344)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 344)) | (1 << (PostgreSQLParser.KW_TRUSTED - 344)) | (1 << (PostgreSQLParser.KW_TYPE - 344)) | (1 << (PostgreSQLParser.KW_TYPES - 344)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 344)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 344)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 344)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 344)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 344)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 344)) | (1 << (PostgreSQLParser.KW_UNTIL - 344)) | (1 << (PostgreSQLParser.KW_UPDATE - 344)) | (1 << (PostgreSQLParser.KW_VACUUM - 344)) | (1 << (PostgreSQLParser.KW_VALID - 344)) | (1 << (PostgreSQLParser.KW_VALIDATE - 344)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 344)) | (1 << (PostgreSQLParser.KW_VARYING - 344)) | (1 << (PostgreSQLParser.KW_VERSION - 344)))) !== 0) || ((((_la - 376)) & ~0x1F) === 0 && ((1 << (_la - 376)) & ((1 << (PostgreSQLParser.KW_VIEW - 376)) | (1 << (PostgreSQLParser.KW_VOLATILE - 376)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 376)) | (1 << (PostgreSQLParser.KW_WITHOUT - 376)) | (1 << (PostgreSQLParser.KW_WORK - 376)) | (1 << (PostgreSQLParser.KW_WRAPPER - 376)) | (1 << (PostgreSQLParser.KW_WRITE - 376)) | (1 << (PostgreSQLParser.KW_XML - 376)) | (1 << (PostgreSQLParser.KW_YEAR - 376)) | (1 << (PostgreSQLParser.KW_YES - 376)) | (1 << (PostgreSQLParser.KW_ZONE - 376)) | (1 << (PostgreSQLParser.KW_BETWEEN - 376)) | (1 << (PostgreSQLParser.KW_BIGINT - 376)) | (1 << (PostgreSQLParser.KW_BIT - 376)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 376)) | (1 << (PostgreSQLParser.KW_CHAR - 376)) | (1 << (PostgreSQLParser.KW_CHARACTER - 376)) | (1 << (PostgreSQLParser.KW_COALESCE - 376)) | (1 << (PostgreSQLParser.KW_DEC - 376)) | (1 << (PostgreSQLParser.KW_DECIMAL - 376)) | (1 << (PostgreSQLParser.KW_EXISTS - 376)) | (1 << (PostgreSQLParser.KW_EXTRACT - 376)) | (1 << (PostgreSQLParser.KW_FLOAT - 376)) | (1 << (PostgreSQLParser.KW_GREATEST - 376)) | (1 << (PostgreSQLParser.KW_INOUT - 376)) | (1 << (PostgreSQLParser.KW_INT - 376)) | (1 << (PostgreSQLParser.KW_INTEGER - 376)) | (1 << (PostgreSQLParser.KW_INTERVAL - 376)) | (1 << (PostgreSQLParser.KW_LEAST - 376)) | (1 << (PostgreSQLParser.KW_NATIONAL - 376)) | (1 << (PostgreSQLParser.KW_NCHAR - 376)) | (1 << (PostgreSQLParser.KW_NONE - 376)))) !== 0) || ((((_la - 408)) & ~0x1F) === 0 && ((1 << (_la - 408)) & ((1 << (PostgreSQLParser.KW_NULLIF - 408)) | (1 << (PostgreSQLParser.KW_NUMERIC - 408)) | (1 << (PostgreSQLParser.KW_OVERLAY - 408)) | (1 << (PostgreSQLParser.KW_POSITION - 408)) | (1 << (PostgreSQLParser.KW_PRECISION - 408)) | (1 << (PostgreSQLParser.KW_REAL - 408)) | (1 << (PostgreSQLParser.KW_ROW - 408)) | (1 << (PostgreSQLParser.KW_SETOF - 408)) | (1 << (PostgreSQLParser.KW_SMALLINT - 408)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 408)) | (1 << (PostgreSQLParser.KW_TIME - 408)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 408)) | (1 << (PostgreSQLParser.KW_TREAT - 408)) | (1 << (PostgreSQLParser.KW_TRIM - 408)) | (1 << (PostgreSQLParser.KW_VALUES - 408)) | (1 << (PostgreSQLParser.KW_VARCHAR - 408)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 408)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 408)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 408)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 408)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 408)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 408)) | (1 << (PostgreSQLParser.KW_XMLPI - 408)) | (1 << (PostgreSQLParser.KW_XMLROOT - 408)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 408)) | (1 << (PostgreSQLParser.KW_CALL - 408)) | (1 << (PostgreSQLParser.KW_CURRENT - 408)) | (1 << (PostgreSQLParser.KW_ATTACH - 408)) | (1 << (PostgreSQLParser.KW_DETACH - 408)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 408)) | (1 << (PostgreSQLParser.KW_GENERATED - 408)) | (1 << (PostgreSQLParser.KW_LOGGED - 408)))) !== 0) || ((((_la - 440)) & ~0x1F) === 0 && ((1 << (_la - 440)) & ((1 << (PostgreSQLParser.KW_STORED - 440)) | (1 << (PostgreSQLParser.KW_INCLUDE - 440)) | (1 << (PostgreSQLParser.KW_ROUTINE - 440)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 440)) | (1 << (PostgreSQLParser.KW_IMPORT - 440)) | (1 << (PostgreSQLParser.KW_POLICY - 440)) | (1 << (PostgreSQLParser.KW_METHOD - 440)) | (1 << (PostgreSQLParser.KW_REFERENCING - 440)) | (1 << (PostgreSQLParser.KW_NEW - 440)) | (1 << (PostgreSQLParser.KW_OLD - 440)) | (1 << (PostgreSQLParser.KW_VALUE - 440)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 440)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 440)) | (1 << (PostgreSQLParser.KW_OUT - 440)) | (1 << (PostgreSQLParser.KW_ROUTINES - 440)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 440)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 440)) | (1 << (PostgreSQLParser.KW_INPUT - 440)) | (1 << (PostgreSQLParser.KW_SUPPORT - 440)) | (1 << (PostgreSQLParser.KW_PARALLEL - 440)) | (1 << (PostgreSQLParser.KW_SQL - 440)) | (1 << (PostgreSQLParser.KW_DEPENDS - 440)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 440)) | (1 << (PostgreSQLParser.KW_CONFLICT - 440)) | (1 << (PostgreSQLParser.KW_SKIP - 440)) | (1 << (PostgreSQLParser.KW_LOCKED - 440)) | (1 << (PostgreSQLParser.KW_TIES - 440)) | (1 << (PostgreSQLParser.KW_ROLLUP - 440)) | (1 << (PostgreSQLParser.KW_CUBE - 440)) | (1 << (PostgreSQLParser.KW_GROUPING - 440)) | (1 << (PostgreSQLParser.KW_SETS - 440)))) !== 0) || ((((_la - 473)) & ~0x1F) === 0 && ((1 << (_la - 473)) & ((1 << (PostgreSQLParser.KW_ORDINALITY - 473)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 473)) | (1 << (PostgreSQLParser.KW_COLUMNS - 473)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 473)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 473)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 473)) | (1 << (PostgreSQLParser.KW_WITHIN - 473)) | (1 << (PostgreSQLParser.KW_FILTER - 473)) | (1 << (PostgreSQLParser.KW_GROUPS - 473)) | (1 << (PostgreSQLParser.KW_OTHERS - 473)) | (1 << (PostgreSQLParser.KW_NFC - 473)) | (1 << (PostgreSQLParser.KW_NFD - 473)) | (1 << (PostgreSQLParser.KW_NFKC - 473)) | (1 << (PostgreSQLParser.KW_NFKD - 473)) | (1 << (PostgreSQLParser.KW_UESCAPE - 473)) | (1 << (PostgreSQLParser.KW_VIEWS - 473)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 473)) | (1 << (PostgreSQLParser.KW_DUMP - 473)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 473)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 473)) | (1 << (PostgreSQLParser.KW_ERROR - 473)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 473)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 473)) | (1 << (PostgreSQLParser.KW_ALIAS - 473)) | (1 << (PostgreSQLParser.KW_CONSTANT - 473)) | (1 << (PostgreSQLParser.KW_PERFORM - 473)) | (1 << (PostgreSQLParser.KW_GET - 473)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 473)) | (1 << (PostgreSQLParser.KW_STACKED - 473)) | (1 << (PostgreSQLParser.KW_ELSIF - 473)) | (1 << (PostgreSQLParser.KW_REVERSE - 473)))) !== 0) || ((((_la - 506)) & ~0x1F) === 0 && ((1 << (_la - 506)) & ((1 << (PostgreSQLParser.KW_SLICE - 506)) | (1 << (PostgreSQLParser.KW_EXIT - 506)) | (1 << (PostgreSQLParser.KW_RETURN - 506)) | (1 << (PostgreSQLParser.KW_QUERY - 506)) | (1 << (PostgreSQLParser.KW_RAISE - 506)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 506)) | (1 << (PostgreSQLParser.KW_DEBUG - 506)) | (1 << (PostgreSQLParser.KW_LOG - 506)) | (1 << (PostgreSQLParser.KW_INFO - 506)) | (1 << (PostgreSQLParser.KW_NOTICE - 506)) | (1 << (PostgreSQLParser.KW_WARNING - 506)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 506)) | (1 << (PostgreSQLParser.KW_ASSERT - 506)) | (1 << (PostgreSQLParser.KW_OPEN - 506)) | (1 << (PostgreSQLParser.Identifier - 506)) | (1 << (PostgreSQLParser.QuotedIdentifier - 506)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 506)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 3846; + this.state = 3895; this.opttableelementlist(); } } - this.state = 3849; + this.state = 3898; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 3851; + this.state = 3900; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INHERITS) { + if (_la === PostgreSQLParser.KW_INHERITS) { { - this.state = 3850; + this.state = 3899; this.optinherit(); } } - this.state = 3853; - this.match(PostgreSQLParser.SERVER); - this.state = 3854; + this.state = 3902; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3903; this.name(); - this.state = 3856; + this.state = 3905; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3855; + this.state = 3904; this.create_generic_options(); } } @@ -16707,42 +17364,42 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 3858; - this.match(PostgreSQLParser.CREATE); - this.state = 3859; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3860; - this.match(PostgreSQLParser.TABLE); - this.state = 3861; + this.state = 3907; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3908; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3909; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 3910; this.qualified_name(); - this.state = 3862; - this.match(PostgreSQLParser.PARTITION); - this.state = 3863; - this.match(PostgreSQLParser.OF); - this.state = 3864; + this.state = 3911; + this.match(PostgreSQLParser.KW_PARTITION); + this.state = 3912; + this.match(PostgreSQLParser.KW_OF); + this.state = 3913; this.qualified_name(); - this.state = 3866; + this.state = 3915; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 3865; + this.state = 3914; this.opttypedtableelementlist(); } } - this.state = 3868; + this.state = 3917; this.partitionboundspec(); - this.state = 3869; - this.match(PostgreSQLParser.SERVER); - this.state = 3870; + this.state = 3918; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3919; this.name(); - this.state = 3872; + this.state = 3921; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3871; + this.state = 3920; this.create_generic_options(); } } @@ -16753,48 +17410,48 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 3874; - this.match(PostgreSQLParser.CREATE); - this.state = 3875; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3876; - this.match(PostgreSQLParser.TABLE); - this.state = 3877; - this.match(PostgreSQLParser.IF_P); - this.state = 3878; - this.match(PostgreSQLParser.NOT); - this.state = 3879; - this.match(PostgreSQLParser.EXISTS); - this.state = 3880; + this.state = 3923; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3924; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3925; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 3926; + this.match(PostgreSQLParser.KW_IF); + this.state = 3927; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3928; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 3929; this.qualified_name(); - this.state = 3881; - this.match(PostgreSQLParser.PARTITION); - this.state = 3882; - this.match(PostgreSQLParser.OF); - this.state = 3883; + this.state = 3930; + this.match(PostgreSQLParser.KW_PARTITION); + this.state = 3931; + this.match(PostgreSQLParser.KW_OF); + this.state = 3932; this.qualified_name(); - this.state = 3885; + this.state = 3934; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 3884; + this.state = 3933; this.opttypedtableelementlist(); } } - this.state = 3887; + this.state = 3936; this.partitionboundspec(); - this.state = 3888; - this.match(PostgreSQLParser.SERVER); - this.state = 3889; + this.state = 3937; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3938; this.name(); - this.state = 3891; + this.state = 3940; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3890; + this.state = 3939; this.create_generic_options(); } } @@ -16820,45 +17477,45 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public importforeignschemastmt(): ImportforeignschemastmtContext { let _localctx: ImportforeignschemastmtContext = new ImportforeignschemastmtContext(this._ctx, this.state); - this.enterRule(_localctx, 366, PostgreSQLParser.RULE_importforeignschemastmt); + this.enterRule(_localctx, 370, PostgreSQLParser.RULE_importforeignschemastmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3895; - this.match(PostgreSQLParser.IMPORT_P); - this.state = 3896; - this.match(PostgreSQLParser.FOREIGN); - this.state = 3897; - this.match(PostgreSQLParser.SCHEMA); - this.state = 3898; + this.state = 3944; + this.match(PostgreSQLParser.KW_IMPORT); + this.state = 3945; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 3946; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 3947; this.name(); - this.state = 3900; + this.state = 3949; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.EXCEPT || _la === PostgreSQLParser.LIMIT) { + if (_la === PostgreSQLParser.KW_EXCEPT || _la === PostgreSQLParser.KW_LIMIT) { { - this.state = 3899; + this.state = 3948; this.import_qualification(); } } - this.state = 3902; - this.match(PostgreSQLParser.FROM); - this.state = 3903; - this.match(PostgreSQLParser.SERVER); - this.state = 3904; + this.state = 3951; + this.match(PostgreSQLParser.KW_FROM); + this.state = 3952; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3953; this.name(); - this.state = 3905; - this.match(PostgreSQLParser.INTO); - this.state = 3906; + this.state = 3954; + this.match(PostgreSQLParser.KW_INTO); + this.state = 3955; this.name(); - this.state = 3908; + this.state = 3957; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3907; + this.state = 3956; this.create_generic_options(); } } @@ -16882,25 +17539,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public import_qualification_type(): Import_qualification_typeContext { let _localctx: Import_qualification_typeContext = new Import_qualification_typeContext(this._ctx, this.state); - this.enterRule(_localctx, 368, PostgreSQLParser.RULE_import_qualification_type); + this.enterRule(_localctx, 372, PostgreSQLParser.RULE_import_qualification_type); try { - this.state = 3913; + this.state = 3962; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.LIMIT: + case PostgreSQLParser.KW_LIMIT: this.enterOuterAlt(_localctx, 1); { - this.state = 3910; - this.match(PostgreSQLParser.LIMIT); - this.state = 3911; - this.match(PostgreSQLParser.TO); + this.state = 3959; + this.match(PostgreSQLParser.KW_LIMIT); + this.state = 3960; + this.match(PostgreSQLParser.KW_TO); } break; - case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.KW_EXCEPT: this.enterOuterAlt(_localctx, 2); { - this.state = 3912; - this.match(PostgreSQLParser.EXCEPT); + this.state = 3961; + this.match(PostgreSQLParser.KW_EXCEPT); } break; default: @@ -16924,17 +17581,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public import_qualification(): Import_qualificationContext { let _localctx: Import_qualificationContext = new Import_qualificationContext(this._ctx, this.state); - this.enterRule(_localctx, 370, PostgreSQLParser.RULE_import_qualification); + this.enterRule(_localctx, 374, PostgreSQLParser.RULE_import_qualification); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3915; + this.state = 3964; this.import_qualification_type(); - this.state = 3916; + this.state = 3965; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 3917; + this.state = 3966; this.relation_expr_list(); - this.state = 3918; + this.state = 3967; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -16955,35 +17612,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createusermappingstmt(): CreateusermappingstmtContext { let _localctx: CreateusermappingstmtContext = new CreateusermappingstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 372, PostgreSQLParser.RULE_createusermappingstmt); + this.enterRule(_localctx, 376, PostgreSQLParser.RULE_createusermappingstmt); let _la: number; try { - this.state = 3943; + this.state = 3992; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 290, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 296, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3920; - this.match(PostgreSQLParser.CREATE); - this.state = 3921; - this.match(PostgreSQLParser.USER); - this.state = 3922; - this.match(PostgreSQLParser.MAPPING); - this.state = 3923; - this.match(PostgreSQLParser.FOR); - this.state = 3924; + this.state = 3969; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3970; + this.match(PostgreSQLParser.KW_USER); + this.state = 3971; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 3972; + this.match(PostgreSQLParser.KW_FOR); + this.state = 3973; this.auth_ident(); - this.state = 3925; - this.match(PostgreSQLParser.SERVER); - this.state = 3926; + this.state = 3974; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3975; this.name(); - this.state = 3928; + this.state = 3977; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3927; + this.state = 3976; this.create_generic_options(); } } @@ -16994,32 +17651,32 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3930; - this.match(PostgreSQLParser.CREATE); - this.state = 3931; - this.match(PostgreSQLParser.USER); - this.state = 3932; - this.match(PostgreSQLParser.MAPPING); - this.state = 3933; - this.match(PostgreSQLParser.IF_P); - this.state = 3934; - this.match(PostgreSQLParser.NOT); - this.state = 3935; - this.match(PostgreSQLParser.EXISTS); - this.state = 3936; - this.match(PostgreSQLParser.FOR); - this.state = 3937; + this.state = 3979; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 3980; + this.match(PostgreSQLParser.KW_USER); + this.state = 3981; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 3982; + this.match(PostgreSQLParser.KW_IF); + this.state = 3983; + this.match(PostgreSQLParser.KW_NOT); + this.state = 3984; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 3985; + this.match(PostgreSQLParser.KW_FOR); + this.state = 3986; this.auth_ident(); - this.state = 3938; - this.match(PostgreSQLParser.SERVER); - this.state = 3939; + this.state = 3987; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 3988; this.name(); - this.state = 3941; + this.state = 3990; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPTIONS) { + if (_la === PostgreSQLParser.KW_OPTIONS) { { - this.state = 3940; + this.state = 3989; this.create_generic_options(); } } @@ -17045,424 +17702,425 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public auth_ident(): Auth_identContext { let _localctx: Auth_identContext = new Auth_identContext(this._ctx, this.state); - this.enterRule(_localctx, 374, PostgreSQLParser.RULE_auth_ident); + this.enterRule(_localctx, 378, PostgreSQLParser.RULE_auth_ident); try { - this.state = 3947; + this.state = 3996; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: + case PostgreSQLParser.KW_PUBLIC: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -17470,15 +18128,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 3945; + this.state = 3994; this.rolespec(); } break; - case PostgreSQLParser.USER: + case PostgreSQLParser.KW_USER: this.enterOuterAlt(_localctx, 2); { - this.state = 3946; - this.match(PostgreSQLParser.USER); + this.state = 3995; + this.match(PostgreSQLParser.KW_USER); } break; default: @@ -17502,27 +18160,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dropusermappingstmt(): DropusermappingstmtContext { let _localctx: DropusermappingstmtContext = new DropusermappingstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 376, PostgreSQLParser.RULE_dropusermappingstmt); + this.enterRule(_localctx, 380, PostgreSQLParser.RULE_dropusermappingstmt); try { - this.state = 3967; + this.state = 4016; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 292, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 298, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 3949; - this.match(PostgreSQLParser.DROP); - this.state = 3950; - this.match(PostgreSQLParser.USER); - this.state = 3951; - this.match(PostgreSQLParser.MAPPING); - this.state = 3952; - this.match(PostgreSQLParser.FOR); - this.state = 3953; + this.state = 3998; + this.match(PostgreSQLParser.KW_DROP); + this.state = 3999; + this.match(PostgreSQLParser.KW_USER); + this.state = 4000; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 4001; + this.match(PostgreSQLParser.KW_FOR); + this.state = 4002; this.auth_ident(); - this.state = 3954; - this.match(PostgreSQLParser.SERVER); - this.state = 3955; + this.state = 4003; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 4004; this.name(); } break; @@ -17530,23 +18188,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 3957; - this.match(PostgreSQLParser.DROP); - this.state = 3958; - this.match(PostgreSQLParser.USER); - this.state = 3959; - this.match(PostgreSQLParser.MAPPING); - this.state = 3960; - this.match(PostgreSQLParser.IF_P); - this.state = 3961; - this.match(PostgreSQLParser.EXISTS); - this.state = 3962; - this.match(PostgreSQLParser.FOR); - this.state = 3963; + this.state = 4006; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4007; + this.match(PostgreSQLParser.KW_USER); + this.state = 4008; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 4009; + this.match(PostgreSQLParser.KW_IF); + this.state = 4010; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4011; + this.match(PostgreSQLParser.KW_FOR); + this.state = 4012; this.auth_ident(); - this.state = 3964; - this.match(PostgreSQLParser.SERVER); - this.state = 3965; + this.state = 4013; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 4014; this.name(); } break; @@ -17569,25 +18227,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterusermappingstmt(): AlterusermappingstmtContext { let _localctx: AlterusermappingstmtContext = new AlterusermappingstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 378, PostgreSQLParser.RULE_alterusermappingstmt); + this.enterRule(_localctx, 382, PostgreSQLParser.RULE_alterusermappingstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 3969; - this.match(PostgreSQLParser.ALTER); - this.state = 3970; - this.match(PostgreSQLParser.USER); - this.state = 3971; - this.match(PostgreSQLParser.MAPPING); - this.state = 3972; - this.match(PostgreSQLParser.FOR); - this.state = 3973; + this.state = 4018; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 4019; + this.match(PostgreSQLParser.KW_USER); + this.state = 4020; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 4021; + this.match(PostgreSQLParser.KW_FOR); + this.state = 4022; this.auth_ident(); - this.state = 3974; - this.match(PostgreSQLParser.SERVER); - this.state = 3975; + this.state = 4023; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 4024; this.name(); - this.state = 3976; + this.state = 4025; this.alter_generic_options(); } } @@ -17608,67 +18266,67 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createpolicystmt(): CreatepolicystmtContext { let _localctx: CreatepolicystmtContext = new CreatepolicystmtContext(this._ctx, this.state); - this.enterRule(_localctx, 380, PostgreSQLParser.RULE_createpolicystmt); + this.enterRule(_localctx, 384, PostgreSQLParser.RULE_createpolicystmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3978; - this.match(PostgreSQLParser.CREATE); - this.state = 3979; - this.match(PostgreSQLParser.POLICY); - this.state = 3980; + this.state = 4027; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4028; + this.match(PostgreSQLParser.KW_POLICY); + this.state = 4029; this.name(); - this.state = 3981; - this.match(PostgreSQLParser.ON); - this.state = 3982; + this.state = 4030; + this.match(PostgreSQLParser.KW_ON); + this.state = 4031; this.qualified_name(); - this.state = 3984; + this.state = 4033; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 3983; + this.state = 4032; this.rowsecuritydefaultpermissive(); } } - this.state = 3987; + this.state = 4036; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 3986; + this.state = 4035; this.rowsecuritydefaultforcmd(); } } - this.state = 3990; + this.state = 4039; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TO) { + if (_la === PostgreSQLParser.KW_TO) { { - this.state = 3989; + this.state = 4038; this.rowsecuritydefaulttorole(); } } - this.state = 3993; + this.state = 4042; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 3992; + this.state = 4041; this.rowsecurityoptionalexpr(); } } - this.state = 3996; + this.state = 4045; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 297, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 303, this._ctx) ) { case 1: { - this.state = 3995; + this.state = 4044; this.rowsecurityoptionalwithcheck(); } break; @@ -17692,47 +18350,47 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterpolicystmt(): AlterpolicystmtContext { let _localctx: AlterpolicystmtContext = new AlterpolicystmtContext(this._ctx, this.state); - this.enterRule(_localctx, 382, PostgreSQLParser.RULE_alterpolicystmt); + this.enterRule(_localctx, 386, PostgreSQLParser.RULE_alterpolicystmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 3998; - this.match(PostgreSQLParser.ALTER); - this.state = 3999; - this.match(PostgreSQLParser.POLICY); - this.state = 4000; + this.state = 4047; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 4048; + this.match(PostgreSQLParser.KW_POLICY); + this.state = 4049; this.name(); - this.state = 4001; - this.match(PostgreSQLParser.ON); - this.state = 4002; + this.state = 4050; + this.match(PostgreSQLParser.KW_ON); + this.state = 4051; this.qualified_name(); - this.state = 4004; + this.state = 4053; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TO) { + if (_la === PostgreSQLParser.KW_TO) { { - this.state = 4003; + this.state = 4052; this.rowsecurityoptionaltorole(); } } - this.state = 4007; + this.state = 4056; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 4006; + this.state = 4055; this.rowsecurityoptionalexpr(); } } - this.state = 4010; + this.state = 4059; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 300, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 306, this._ctx) ) { case 1: { - this.state = 4009; + this.state = 4058; this.rowsecurityoptionalwithcheck(); } break; @@ -17756,17 +18414,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rowsecurityoptionalexpr(): RowsecurityoptionalexprContext { let _localctx: RowsecurityoptionalexprContext = new RowsecurityoptionalexprContext(this._ctx, this.state); - this.enterRule(_localctx, 384, PostgreSQLParser.RULE_rowsecurityoptionalexpr); + this.enterRule(_localctx, 388, PostgreSQLParser.RULE_rowsecurityoptionalexpr); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4012; - this.match(PostgreSQLParser.USING); - this.state = 4013; + this.state = 4061; + this.match(PostgreSQLParser.KW_USING); + this.state = 4062; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4014; + this.state = 4063; this.a_expr(); - this.state = 4015; + this.state = 4064; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -17787,19 +18445,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rowsecurityoptionalwithcheck(): RowsecurityoptionalwithcheckContext { let _localctx: RowsecurityoptionalwithcheckContext = new RowsecurityoptionalwithcheckContext(this._ctx, this.state); - this.enterRule(_localctx, 386, PostgreSQLParser.RULE_rowsecurityoptionalwithcheck); + this.enterRule(_localctx, 390, PostgreSQLParser.RULE_rowsecurityoptionalwithcheck); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4017; - this.match(PostgreSQLParser.WITH); - this.state = 4018; - this.match(PostgreSQLParser.CHECK); - this.state = 4019; + this.state = 4066; + this.match(PostgreSQLParser.KW_WITH); + this.state = 4067; + this.match(PostgreSQLParser.KW_CHECK); + this.state = 4068; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4020; + this.state = 4069; this.a_expr(); - this.state = 4021; + this.state = 4070; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -17820,13 +18478,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rowsecuritydefaulttorole(): RowsecuritydefaulttoroleContext { let _localctx: RowsecuritydefaulttoroleContext = new RowsecuritydefaulttoroleContext(this._ctx, this.state); - this.enterRule(_localctx, 388, PostgreSQLParser.RULE_rowsecuritydefaulttorole); + this.enterRule(_localctx, 392, PostgreSQLParser.RULE_rowsecuritydefaulttorole); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4023; - this.match(PostgreSQLParser.TO); - this.state = 4024; + this.state = 4072; + this.match(PostgreSQLParser.KW_TO); + this.state = 4073; this.role_list(); } } @@ -17847,13 +18505,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rowsecurityoptionaltorole(): RowsecurityoptionaltoroleContext { let _localctx: RowsecurityoptionaltoroleContext = new RowsecurityoptionaltoroleContext(this._ctx, this.state); - this.enterRule(_localctx, 390, PostgreSQLParser.RULE_rowsecurityoptionaltorole); + this.enterRule(_localctx, 394, PostgreSQLParser.RULE_rowsecurityoptionaltorole); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4026; - this.match(PostgreSQLParser.TO); - this.state = 4027; + this.state = 4075; + this.match(PostgreSQLParser.KW_TO); + this.state = 4076; this.role_list(); } } @@ -17874,13 +18532,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rowsecuritydefaultpermissive(): RowsecuritydefaultpermissiveContext { let _localctx: RowsecuritydefaultpermissiveContext = new RowsecuritydefaultpermissiveContext(this._ctx, this.state); - this.enterRule(_localctx, 392, PostgreSQLParser.RULE_rowsecuritydefaultpermissive); + this.enterRule(_localctx, 396, PostgreSQLParser.RULE_rowsecuritydefaultpermissive); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4029; - this.match(PostgreSQLParser.AS); - this.state = 4030; + this.state = 4078; + this.match(PostgreSQLParser.KW_AS); + this.state = 4079; this.identifier(); } } @@ -17901,13 +18559,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rowsecuritydefaultforcmd(): RowsecuritydefaultforcmdContext { let _localctx: RowsecuritydefaultforcmdContext = new RowsecuritydefaultforcmdContext(this._ctx, this.state); - this.enterRule(_localctx, 394, PostgreSQLParser.RULE_rowsecuritydefaultforcmd); + this.enterRule(_localctx, 398, PostgreSQLParser.RULE_rowsecuritydefaultforcmd); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4032; - this.match(PostgreSQLParser.FOR); - this.state = 4033; + this.state = 4081; + this.match(PostgreSQLParser.KW_FOR); + this.state = 4082; this.row_security_cmd(); } } @@ -17928,14 +18586,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public row_security_cmd(): Row_security_cmdContext { let _localctx: Row_security_cmdContext = new Row_security_cmdContext(this._ctx, this.state); - this.enterRule(_localctx, 396, PostgreSQLParser.RULE_row_security_cmd); + this.enterRule(_localctx, 400, PostgreSQLParser.RULE_row_security_cmd); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4035; + this.state = 4084; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ALL || _la === PostgreSQLParser.SELECT || _la === PostgreSQLParser.DELETE_P || _la === PostgreSQLParser.INSERT || _la === PostgreSQLParser.UPDATE)) { + if (!(_la === PostgreSQLParser.KW_ALL || _la === PostgreSQLParser.KW_SELECT || _la === PostgreSQLParser.KW_DELETE || _la === PostgreSQLParser.KW_INSERT || _la === PostgreSQLParser.KW_UPDATE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -17964,25 +18622,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createamstmt(): CreateamstmtContext { let _localctx: CreateamstmtContext = new CreateamstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 398, PostgreSQLParser.RULE_createamstmt); + this.enterRule(_localctx, 402, PostgreSQLParser.RULE_createamstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4037; - this.match(PostgreSQLParser.CREATE); - this.state = 4038; - this.match(PostgreSQLParser.ACCESS); - this.state = 4039; - this.match(PostgreSQLParser.METHOD); - this.state = 4040; + this.state = 4086; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4087; + this.match(PostgreSQLParser.KW_ACCESS); + this.state = 4088; + this.match(PostgreSQLParser.KW_METHOD); + this.state = 4089; this.name(); - this.state = 4041; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4042; + this.state = 4090; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4091; this.am_type(); - this.state = 4043; - this.match(PostgreSQLParser.HANDLER); - this.state = 4044; + this.state = 4092; + this.match(PostgreSQLParser.KW_HANDLER); + this.state = 4093; this.handler_name(); } } @@ -18003,14 +18661,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public am_type(): Am_typeContext { let _localctx: Am_typeContext = new Am_typeContext(this._ctx, this.state); - this.enterRule(_localctx, 400, PostgreSQLParser.RULE_am_type); + this.enterRule(_localctx, 404, PostgreSQLParser.RULE_am_type); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4046; + this.state = 4095; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.TABLE || _la === PostgreSQLParser.INDEX)) { + if (!(_la === PostgreSQLParser.KW_TABLE || _la === PostgreSQLParser.KW_INDEX)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -18039,70 +18697,70 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createtrigstmt(): CreatetrigstmtContext { let _localctx: CreatetrigstmtContext = new CreatetrigstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 402, PostgreSQLParser.RULE_createtrigstmt); + this.enterRule(_localctx, 406, PostgreSQLParser.RULE_createtrigstmt); let _la: number; try { - this.state = 4096; + this.state = 4147; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 306, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 314, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4048; - this.match(PostgreSQLParser.CREATE); - this.state = 4049; - this.match(PostgreSQLParser.TRIGGER); - this.state = 4050; + this.state = 4097; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4098; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 4099; this.name(); - this.state = 4051; + this.state = 4100; this.triggeractiontime(); - this.state = 4052; + this.state = 4101; this.triggerevents(); - this.state = 4053; - this.match(PostgreSQLParser.ON); - this.state = 4054; + this.state = 4102; + this.match(PostgreSQLParser.KW_ON); + this.state = 4103; this.qualified_name(); - this.state = 4056; + this.state = 4105; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.REFERENCING) { + if (_la === PostgreSQLParser.KW_REFERENCING) { { - this.state = 4055; + this.state = 4104; this.triggerreferencing(); } } - this.state = 4059; + this.state = 4108; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 4058; + this.state = 4107; this.triggerforspec(); } } - this.state = 4062; + this.state = 4111; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHEN) { + if (_la === PostgreSQLParser.KW_WHEN) { { - this.state = 4061; + this.state = 4110; this.triggerwhen(); } } - this.state = 4064; - this.match(PostgreSQLParser.EXECUTE); - this.state = 4065; + this.state = 4113; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 4114; this.function_or_procedure(); - this.state = 4066; + this.state = 4115; this.func_name(); - this.state = 4067; + this.state = 4116; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4068; + this.state = 4117; this.triggerfuncargs(); - this.state = 4069; + this.state = 4118; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -18110,61 +18768,73 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4071; - this.match(PostgreSQLParser.CREATE); - this.state = 4072; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 4073; - this.match(PostgreSQLParser.TRIGGER); - this.state = 4074; - this.name(); - this.state = 4075; - this.match(PostgreSQLParser.AFTER); - this.state = 4076; - this.triggerevents(); - this.state = 4077; - this.match(PostgreSQLParser.ON); - this.state = 4078; - this.qualified_name(); - this.state = 4080; + this.state = 4120; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4122; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM) { + if (_la === PostgreSQLParser.KW_CONSTRAINT) { { - this.state = 4079; + this.state = 4121; + this.match(PostgreSQLParser.KW_CONSTRAINT); + } + } + + this.state = 4124; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 4125; + this.name(); + this.state = 4126; + this.triggeractiontime(); + this.state = 4127; + this.triggerevents(); + this.state = 4128; + this.match(PostgreSQLParser.KW_ON); + this.state = 4129; + this.qualified_name(); + this.state = 4131; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM) { + { + this.state = 4130; this.optconstrfromtable(); } } - this.state = 4082; + this.state = 4133; this.constraintattributespec(); - this.state = 4083; - this.match(PostgreSQLParser.FOR); - this.state = 4084; - this.match(PostgreSQLParser.EACH); - this.state = 4085; - this.match(PostgreSQLParser.ROW); - this.state = 4087; + this.state = 4135; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHEN) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 4086; + this.state = 4134; + this.foreachrow(); + } + } + + this.state = 4138; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_WHEN) { + { + this.state = 4137; this.triggerwhen(); } } - this.state = 4089; - this.match(PostgreSQLParser.EXECUTE); - this.state = 4090; + this.state = 4140; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 4141; this.function_or_procedure(); - this.state = 4091; + this.state = 4142; this.func_name(); - this.state = 4092; + this.state = 4143; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4093; + this.state = 4144; this.triggerfuncargs(); - this.state = 4094; + this.state = 4145; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -18187,32 +18857,32 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggeractiontime(): TriggeractiontimeContext { let _localctx: TriggeractiontimeContext = new TriggeractiontimeContext(this._ctx, this.state); - this.enterRule(_localctx, 404, PostgreSQLParser.RULE_triggeractiontime); + this.enterRule(_localctx, 408, PostgreSQLParser.RULE_triggeractiontime); try { - this.state = 4102; + this.state = 4153; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.BEFORE: + case PostgreSQLParser.KW_BEFORE: this.enterOuterAlt(_localctx, 1); { - this.state = 4098; - this.match(PostgreSQLParser.BEFORE); + this.state = 4149; + this.match(PostgreSQLParser.KW_BEFORE); } break; - case PostgreSQLParser.AFTER: + case PostgreSQLParser.KW_AFTER: this.enterOuterAlt(_localctx, 2); { - this.state = 4099; - this.match(PostgreSQLParser.AFTER); + this.state = 4150; + this.match(PostgreSQLParser.KW_AFTER); } break; - case PostgreSQLParser.INSTEAD: + case PostgreSQLParser.KW_INSTEAD: this.enterOuterAlt(_localctx, 3); { - this.state = 4100; - this.match(PostgreSQLParser.INSTEAD); - this.state = 4101; - this.match(PostgreSQLParser.OF); + this.state = 4151; + this.match(PostgreSQLParser.KW_INSTEAD); + this.state = 4152; + this.match(PostgreSQLParser.KW_OF); } break; default: @@ -18234,28 +18904,102 @@ export class PostgreSQLParser extends PostgreSQLParserBase { return _localctx; } // @RuleVersion(0) - public triggerevents(): TriggereventsContext { - let _localctx: TriggereventsContext = new TriggereventsContext(this._ctx, this.state); - this.enterRule(_localctx, 406, PostgreSQLParser.RULE_triggerevents); + public foreachrow(): ForeachrowContext { + let _localctx: ForeachrowContext = new ForeachrowContext(this._ctx, this.state); + this.enterRule(_localctx, 410, PostgreSQLParser.RULE_foreachrow); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4104; - this.triggeroneevent(); - this.state = 4109; + this.state = 4155; + this.match(PostgreSQLParser.KW_FOR); + this.state = 4157; this._errHandler.sync(this); _la = this._input.LA(1); - while (_la === PostgreSQLParser.OR) { + if (_la === PostgreSQLParser.KW_EACH) { + { + this.state = 4156; + this.match(PostgreSQLParser.KW_EACH); + } + } + + this.state = 4159; + this.roworstatment(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public roworstatment(): RoworstatmentContext { + let _localctx: RoworstatmentContext = new RoworstatmentContext(this._ctx, this.state); + this.enterRule(_localctx, 412, PostgreSQLParser.RULE_roworstatment); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 4161; + _la = this._input.LA(1); + if (!(_la === PostgreSQLParser.KW_STATEMENT || _la === PostgreSQLParser.KW_ROW)) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public triggerevents(): TriggereventsContext { + let _localctx: TriggereventsContext = new TriggereventsContext(this._ctx, this.state); + this.enterRule(_localctx, 414, PostgreSQLParser.RULE_triggerevents); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 4163; + this.triggeroneevent(); + this.state = 4168; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === PostgreSQLParser.KW_OR) { { { - this.state = 4105; - this.match(PostgreSQLParser.OR); - this.state = 4106; + this.state = 4164; + this.match(PostgreSQLParser.KW_OR); + this.state = 4165; this.triggeroneevent(); } } - this.state = 4111; + this.state = 4170; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -18278,43 +19022,43 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggeroneevent(): TriggeroneeventContext { let _localctx: TriggeroneeventContext = new TriggeroneeventContext(this._ctx, this.state); - this.enterRule(_localctx, 408, PostgreSQLParser.RULE_triggeroneevent); + this.enterRule(_localctx, 416, PostgreSQLParser.RULE_triggeroneevent); try { - this.state = 4119; + this.state = 4178; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 309, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 318, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4112; - this.match(PostgreSQLParser.INSERT); + this.state = 4171; + this.match(PostgreSQLParser.KW_INSERT); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4113; - this.match(PostgreSQLParser.DELETE_P); + this.state = 4172; + this.match(PostgreSQLParser.KW_DELETE); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4114; - this.match(PostgreSQLParser.UPDATE); + this.state = 4173; + this.match(PostgreSQLParser.KW_UPDATE); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4115; - this.match(PostgreSQLParser.UPDATE); - this.state = 4116; - this.match(PostgreSQLParser.OF); - this.state = 4117; + this.state = 4174; + this.match(PostgreSQLParser.KW_UPDATE); + this.state = 4175; + this.match(PostgreSQLParser.KW_OF); + this.state = 4176; this.columnlist(); } break; @@ -18322,8 +19066,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 4118; - this.match(PostgreSQLParser.TRUNCATE); + this.state = 4177; + this.match(PostgreSQLParser.KW_TRUNCATE); } break; } @@ -18345,13 +19089,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggerreferencing(): TriggerreferencingContext { let _localctx: TriggerreferencingContext = new TriggerreferencingContext(this._ctx, this.state); - this.enterRule(_localctx, 410, PostgreSQLParser.RULE_triggerreferencing); + this.enterRule(_localctx, 418, PostgreSQLParser.RULE_triggerreferencing); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4121; - this.match(PostgreSQLParser.REFERENCING); - this.state = 4122; + this.state = 4180; + this.match(PostgreSQLParser.KW_REFERENCING); + this.state = 4181; this.triggertransitions(); } } @@ -18372,25 +19116,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggertransitions(): TriggertransitionsContext { let _localctx: TriggertransitionsContext = new TriggertransitionsContext(this._ctx, this.state); - this.enterRule(_localctx, 412, PostgreSQLParser.RULE_triggertransitions); + this.enterRule(_localctx, 420, PostgreSQLParser.RULE_triggertransitions); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4125; + this.state = 4184; this._errHandler.sync(this); _la = this._input.LA(1); do { { { - this.state = 4124; + this.state = 4183; this.triggertransition(); } } - this.state = 4127; + this.state = 4186; this._errHandler.sync(this); _la = this._input.LA(1); - } while (_la === PostgreSQLParser.NEW || _la === PostgreSQLParser.OLD); + } while (_la === PostgreSQLParser.KW_NEW || _la === PostgreSQLParser.KW_OLD); } } catch (re) { @@ -18410,26 +19154,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggertransition(): TriggertransitionContext { let _localctx: TriggertransitionContext = new TriggertransitionContext(this._ctx, this.state); - this.enterRule(_localctx, 414, PostgreSQLParser.RULE_triggertransition); + this.enterRule(_localctx, 422, PostgreSQLParser.RULE_triggertransition); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4129; + this.state = 4188; this.transitionoldornew(); - this.state = 4130; + this.state = 4189; this.transitionrowortable(); - this.state = 4132; + this.state = 4191; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 4131; + this.state = 4190; this.opt_as(); } } - this.state = 4134; + this.state = 4193; this.transitionrelname(); } } @@ -18450,14 +19194,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public transitionoldornew(): TransitionoldornewContext { let _localctx: TransitionoldornewContext = new TransitionoldornewContext(this._ctx, this.state); - this.enterRule(_localctx, 416, PostgreSQLParser.RULE_transitionoldornew); + this.enterRule(_localctx, 424, PostgreSQLParser.RULE_transitionoldornew); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4136; + this.state = 4195; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.NEW || _la === PostgreSQLParser.OLD)) { + if (!(_la === PostgreSQLParser.KW_NEW || _la === PostgreSQLParser.KW_OLD)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -18486,14 +19230,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public transitionrowortable(): TransitionrowortableContext { let _localctx: TransitionrowortableContext = new TransitionrowortableContext(this._ctx, this.state); - this.enterRule(_localctx, 418, PostgreSQLParser.RULE_transitionrowortable); + this.enterRule(_localctx, 426, PostgreSQLParser.RULE_transitionrowortable); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4138; + this.state = 4197; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.TABLE || _la === PostgreSQLParser.ROW)) { + if (!(_la === PostgreSQLParser.KW_TABLE || _la === PostgreSQLParser.KW_ROW)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -18522,11 +19266,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public transitionrelname(): TransitionrelnameContext { let _localctx: TransitionrelnameContext = new TransitionrelnameContext(this._ctx, this.state); - this.enterRule(_localctx, 420, PostgreSQLParser.RULE_transitionrelname); + this.enterRule(_localctx, 428, PostgreSQLParser.RULE_transitionrelname); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4140; + this.state = 4199; this.colid(); } } @@ -18547,24 +19291,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggerforspec(): TriggerforspecContext { let _localctx: TriggerforspecContext = new TriggerforspecContext(this._ctx, this.state); - this.enterRule(_localctx, 422, PostgreSQLParser.RULE_triggerforspec); + this.enterRule(_localctx, 430, PostgreSQLParser.RULE_triggerforspec); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4142; - this.match(PostgreSQLParser.FOR); - this.state = 4144; + this.state = 4201; + this.match(PostgreSQLParser.KW_FOR); + this.state = 4203; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.EACH) { + if (_la === PostgreSQLParser.KW_EACH) { { - this.state = 4143; + this.state = 4202; this.triggerforopteach(); } } - this.state = 4146; + this.state = 4205; this.triggerfortype(); } } @@ -18585,12 +19329,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggerforopteach(): TriggerforopteachContext { let _localctx: TriggerforopteachContext = new TriggerforopteachContext(this._ctx, this.state); - this.enterRule(_localctx, 424, PostgreSQLParser.RULE_triggerforopteach); + this.enterRule(_localctx, 432, PostgreSQLParser.RULE_triggerforopteach); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4148; - this.match(PostgreSQLParser.EACH); + this.state = 4207; + this.match(PostgreSQLParser.KW_EACH); } } catch (re) { @@ -18610,14 +19354,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggerfortype(): TriggerfortypeContext { let _localctx: TriggerfortypeContext = new TriggerfortypeContext(this._ctx, this.state); - this.enterRule(_localctx, 426, PostgreSQLParser.RULE_triggerfortype); + this.enterRule(_localctx, 434, PostgreSQLParser.RULE_triggerfortype); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4150; + this.state = 4209; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.STATEMENT || _la === PostgreSQLParser.ROW)) { + if (!(_la === PostgreSQLParser.KW_STATEMENT || _la === PostgreSQLParser.KW_ROW)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -18646,17 +19390,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggerwhen(): TriggerwhenContext { let _localctx: TriggerwhenContext = new TriggerwhenContext(this._ctx, this.state); - this.enterRule(_localctx, 428, PostgreSQLParser.RULE_triggerwhen); + this.enterRule(_localctx, 436, PostgreSQLParser.RULE_triggerwhen); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4152; - this.match(PostgreSQLParser.WHEN); - this.state = 4153; + this.state = 4211; + this.match(PostgreSQLParser.KW_WHEN); + this.state = 4212; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4154; + this.state = 4213; this.a_expr(); - this.state = 4155; + this.state = 4214; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -18677,14 +19421,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public function_or_procedure(): Function_or_procedureContext { let _localctx: Function_or_procedureContext = new Function_or_procedureContext(this._ctx, this.state); - this.enterRule(_localctx, 430, PostgreSQLParser.RULE_function_or_procedure); + this.enterRule(_localctx, 438, PostgreSQLParser.RULE_function_or_procedure); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4157; + this.state = 4216; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FUNCTION || _la === PostgreSQLParser.PROCEDURE)) { + if (!(_la === PostgreSQLParser.KW_FUNCTION || _la === PostgreSQLParser.KW_PROCEDURE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -18713,492 +19457,492 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggerfuncargs(): TriggerfuncargsContext { let _localctx: TriggerfuncargsContext = new TriggerfuncargsContext(this._ctx, this.state); - this.enterRule(_localctx, 432, PostgreSQLParser.RULE_triggerfuncargs); + this.enterRule(_localctx, 440, PostgreSQLParser.RULE_triggerfuncargs); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4161; + this.state = 4220; 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.KW_ALL: + case PostgreSQLParser.KW_ANALYSE: + case PostgreSQLParser.KW_ANALYZE: + case PostgreSQLParser.KW_AND: + case PostgreSQLParser.KW_ANY: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_AS: + case PostgreSQLParser.KW_ASC: + case PostgreSQLParser.KW_ASYMMETRIC: + case PostgreSQLParser.KW_BOTH: + case PostgreSQLParser.KW_CASE: + case PostgreSQLParser.KW_CAST: + case PostgreSQLParser.KW_CHECK: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CREATE: + case PostgreSQLParser.KW_CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DEFERRABLE: + case PostgreSQLParser.KW_DESC: + case PostgreSQLParser.KW_DISTINCT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_ELSE: + case PostgreSQLParser.KW_EXCEPT: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_FOR: + case PostgreSQLParser.KW_FOREIGN: + case PostgreSQLParser.KW_FROM: + case PostgreSQLParser.KW_GRANT: + case PostgreSQLParser.KW_GROUP: + case PostgreSQLParser.KW_HAVING: + case PostgreSQLParser.KW_IN: + case PostgreSQLParser.KW_INITIALLY: + case PostgreSQLParser.KW_INTERSECT: + case PostgreSQLParser.KW_LATERAL: + case PostgreSQLParser.KW_LEADING: + case PostgreSQLParser.KW_LIMIT: + case PostgreSQLParser.KW_LOCALTIME: + case PostgreSQLParser.KW_LOCALTIMESTAMP: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_NULL: + case PostgreSQLParser.KW_OFFSET: + case PostgreSQLParser.KW_ON: + case PostgreSQLParser.KW_ONLY: + case PostgreSQLParser.KW_OR: + case PostgreSQLParser.KW_ORDER: + case PostgreSQLParser.KW_PLACING: + case PostgreSQLParser.KW_PRIMARY: + case PostgreSQLParser.KW_REFERENCES: + case PostgreSQLParser.KW_RETURNING: + case PostgreSQLParser.KW_SELECT: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_SOME: + case PostgreSQLParser.KW_SYMMETRIC: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_THEN: + case PostgreSQLParser.KW_TO: + case PostgreSQLParser.KW_TRAILING: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_UNION: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_USING: + case PostgreSQLParser.KW_VARIADIC: + case PostgreSQLParser.KW_WHEN: + case PostgreSQLParser.KW_WHERE: + case PostgreSQLParser.KW_WINDOW: + case PostgreSQLParser.KW_WITH: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_END: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -19211,7 +19955,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: case PostgreSQLParser.EscapeStringConstant: { - this.state = 4159; + this.state = 4218; this.triggerfuncarg(); } break; @@ -19224,19 +19968,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 4167; + this.state = 4226; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 4163; + this.state = 4222; this.match(PostgreSQLParser.COMMA); - this.state = 4164; + this.state = 4223; this.triggerfuncarg(); } } - this.state = 4169; + this.state = 4228; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -19259,22 +20003,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public triggerfuncarg(): TriggerfuncargContext { let _localctx: TriggerfuncargContext = new TriggerfuncargContext(this._ctx, this.state); - this.enterRule(_localctx, 434, PostgreSQLParser.RULE_triggerfuncarg); + this.enterRule(_localctx, 442, PostgreSQLParser.RULE_triggerfuncarg); try { - this.state = 4174; + this.state = 4233; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.Integral: this.enterOuterAlt(_localctx, 1); { - this.state = 4170; + this.state = 4229; this.iconst(); } break; case PostgreSQLParser.Numeric: this.enterOuterAlt(_localctx, 2); { - this.state = 4171; + this.state = 4230; this.fconst(); } break; @@ -19284,488 +20028,488 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 3); { - this.state = 4172; + this.state = 4231; 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.KW_ALL: + case PostgreSQLParser.KW_ANALYSE: + case PostgreSQLParser.KW_ANALYZE: + case PostgreSQLParser.KW_AND: + case PostgreSQLParser.KW_ANY: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_AS: + case PostgreSQLParser.KW_ASC: + case PostgreSQLParser.KW_ASYMMETRIC: + case PostgreSQLParser.KW_BOTH: + case PostgreSQLParser.KW_CASE: + case PostgreSQLParser.KW_CAST: + case PostgreSQLParser.KW_CHECK: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CREATE: + case PostgreSQLParser.KW_CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DEFERRABLE: + case PostgreSQLParser.KW_DESC: + case PostgreSQLParser.KW_DISTINCT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_ELSE: + case PostgreSQLParser.KW_EXCEPT: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_FOR: + case PostgreSQLParser.KW_FOREIGN: + case PostgreSQLParser.KW_FROM: + case PostgreSQLParser.KW_GRANT: + case PostgreSQLParser.KW_GROUP: + case PostgreSQLParser.KW_HAVING: + case PostgreSQLParser.KW_IN: + case PostgreSQLParser.KW_INITIALLY: + case PostgreSQLParser.KW_INTERSECT: + case PostgreSQLParser.KW_LATERAL: + case PostgreSQLParser.KW_LEADING: + case PostgreSQLParser.KW_LIMIT: + case PostgreSQLParser.KW_LOCALTIME: + case PostgreSQLParser.KW_LOCALTIMESTAMP: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_NULL: + case PostgreSQLParser.KW_OFFSET: + case PostgreSQLParser.KW_ON: + case PostgreSQLParser.KW_ONLY: + case PostgreSQLParser.KW_OR: + case PostgreSQLParser.KW_ORDER: + case PostgreSQLParser.KW_PLACING: + case PostgreSQLParser.KW_PRIMARY: + case PostgreSQLParser.KW_REFERENCES: + case PostgreSQLParser.KW_RETURNING: + case PostgreSQLParser.KW_SELECT: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_SOME: + case PostgreSQLParser.KW_SYMMETRIC: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_THEN: + case PostgreSQLParser.KW_TO: + case PostgreSQLParser.KW_TRAILING: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_UNION: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_USING: + case PostgreSQLParser.KW_VARIADIC: + case PostgreSQLParser.KW_WHEN: + case PostgreSQLParser.KW_WHERE: + case PostgreSQLParser.KW_WINDOW: + case PostgreSQLParser.KW_WITH: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_END: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -19773,7 +20517,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 4); { - this.state = 4173; + this.state = 4232; this.collabel(); } break; @@ -19798,13 +20542,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public optconstrfromtable(): OptconstrfromtableContext { let _localctx: OptconstrfromtableContext = new OptconstrfromtableContext(this._ctx, this.state); - this.enterRule(_localctx, 436, PostgreSQLParser.RULE_optconstrfromtable); + this.enterRule(_localctx, 444, PostgreSQLParser.RULE_optconstrfromtable); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4176; - this.match(PostgreSQLParser.FROM); - this.state = 4177; + this.state = 4235; + this.match(PostgreSQLParser.KW_FROM); + this.state = 4236; this.qualified_name(); } } @@ -19825,22 +20569,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public constraintattributespec(): ConstraintattributespecContext { let _localctx: ConstraintattributespecContext = new ConstraintattributespecContext(this._ctx, this.state); - this.enterRule(_localctx, 438, PostgreSQLParser.RULE_constraintattributespec); + this.enterRule(_localctx, 446, PostgreSQLParser.RULE_constraintattributespec); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4182; + this.state = 4241; 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) { + while (((((_la - 54)) & ~0x1F) === 0 && ((1 << (_la - 54)) & ((1 << (PostgreSQLParser.KW_DEFERRABLE - 54)) | (1 << (PostgreSQLParser.KW_INITIALLY - 54)) | (1 << (PostgreSQLParser.KW_NOT - 54)))) !== 0) || _la === PostgreSQLParser.KW_NO) { { { - this.state = 4179; + this.state = 4238; this.constraintattributeElem(); } } - this.state = 4184; + this.state = 4243; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -19863,66 +20607,66 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public constraintattributeElem(): ConstraintattributeElemContext { let _localctx: ConstraintattributeElemContext = new ConstraintattributeElemContext(this._ctx, this.state); - this.enterRule(_localctx, 440, PostgreSQLParser.RULE_constraintattributeElem); + this.enterRule(_localctx, 448, PostgreSQLParser.RULE_constraintattributeElem); try { - this.state = 4196; + this.state = 4255; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 317, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 326, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4185; - this.match(PostgreSQLParser.NOT); - this.state = 4186; - this.match(PostgreSQLParser.DEFERRABLE); + this.state = 4244; + this.match(PostgreSQLParser.KW_NOT); + this.state = 4245; + this.match(PostgreSQLParser.KW_DEFERRABLE); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4187; - this.match(PostgreSQLParser.DEFERRABLE); + this.state = 4246; + this.match(PostgreSQLParser.KW_DEFERRABLE); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4188; - this.match(PostgreSQLParser.INITIALLY); - this.state = 4189; - this.match(PostgreSQLParser.IMMEDIATE); + this.state = 4247; + this.match(PostgreSQLParser.KW_INITIALLY); + this.state = 4248; + this.match(PostgreSQLParser.KW_IMMEDIATE); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4190; - this.match(PostgreSQLParser.INITIALLY); - this.state = 4191; - this.match(PostgreSQLParser.DEFERRED); + this.state = 4249; + this.match(PostgreSQLParser.KW_INITIALLY); + this.state = 4250; + this.match(PostgreSQLParser.KW_DEFERRED); } break; case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 4192; - this.match(PostgreSQLParser.NOT); - this.state = 4193; - this.match(PostgreSQLParser.VALID); + this.state = 4251; + this.match(PostgreSQLParser.KW_NOT); + this.state = 4252; + this.match(PostgreSQLParser.KW_VALID); } break; case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 4194; - this.match(PostgreSQLParser.NO); - this.state = 4195; - this.match(PostgreSQLParser.INHERIT); + this.state = 4253; + this.match(PostgreSQLParser.KW_NO); + this.state = 4254; + this.match(PostgreSQLParser.KW_INHERIT); } break; } @@ -19944,35 +20688,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createeventtrigstmt(): CreateeventtrigstmtContext { let _localctx: CreateeventtrigstmtContext = new CreateeventtrigstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 442, PostgreSQLParser.RULE_createeventtrigstmt); + this.enterRule(_localctx, 450, PostgreSQLParser.RULE_createeventtrigstmt); try { - this.state = 4224; + this.state = 4283; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 318, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 327, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4198; - this.match(PostgreSQLParser.CREATE); - this.state = 4199; - this.match(PostgreSQLParser.EVENT); - this.state = 4200; - this.match(PostgreSQLParser.TRIGGER); - this.state = 4201; + this.state = 4257; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4258; + this.match(PostgreSQLParser.KW_EVENT); + this.state = 4259; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 4260; this.name(); - this.state = 4202; - this.match(PostgreSQLParser.ON); - this.state = 4203; + this.state = 4261; + this.match(PostgreSQLParser.KW_ON); + this.state = 4262; this.collabel(); - this.state = 4204; - this.match(PostgreSQLParser.EXECUTE); - this.state = 4205; + this.state = 4263; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 4264; this.function_or_procedure(); - this.state = 4206; + this.state = 4265; this.func_name(); - this.state = 4207; + this.state = 4266; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4208; + this.state = 4267; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -19980,31 +20724,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4210; - this.match(PostgreSQLParser.CREATE); - this.state = 4211; - this.match(PostgreSQLParser.EVENT); - this.state = 4212; - this.match(PostgreSQLParser.TRIGGER); - this.state = 4213; + this.state = 4269; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4270; + this.match(PostgreSQLParser.KW_EVENT); + this.state = 4271; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 4272; this.name(); - this.state = 4214; - this.match(PostgreSQLParser.ON); - this.state = 4215; + this.state = 4273; + this.match(PostgreSQLParser.KW_ON); + this.state = 4274; this.collabel(); - this.state = 4216; - this.match(PostgreSQLParser.WHEN); - this.state = 4217; + this.state = 4275; + this.match(PostgreSQLParser.KW_WHEN); + this.state = 4276; this.event_trigger_when_list(); - this.state = 4218; - this.match(PostgreSQLParser.EXECUTE); - this.state = 4219; + this.state = 4277; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 4278; this.function_or_procedure(); - this.state = 4220; + this.state = 4279; this.func_name(); - this.state = 4221; + this.state = 4280; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4222; + this.state = 4281; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -20027,26 +20771,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public event_trigger_when_list(): Event_trigger_when_listContext { let _localctx: Event_trigger_when_listContext = new Event_trigger_when_listContext(this._ctx, this.state); - this.enterRule(_localctx, 444, PostgreSQLParser.RULE_event_trigger_when_list); + this.enterRule(_localctx, 452, PostgreSQLParser.RULE_event_trigger_when_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4226; + this.state = 4285; this.event_trigger_when_item(); - this.state = 4231; + this.state = 4290; this._errHandler.sync(this); _la = this._input.LA(1); - while (_la === PostgreSQLParser.AND) { + while (_la === PostgreSQLParser.KW_AND) { { { - this.state = 4227; - this.match(PostgreSQLParser.AND); - this.state = 4228; + this.state = 4286; + this.match(PostgreSQLParser.KW_AND); + this.state = 4287; this.event_trigger_when_item(); } } - this.state = 4233; + this.state = 4292; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -20069,19 +20813,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public event_trigger_when_item(): Event_trigger_when_itemContext { let _localctx: Event_trigger_when_itemContext = new Event_trigger_when_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 446, PostgreSQLParser.RULE_event_trigger_when_item); + this.enterRule(_localctx, 454, PostgreSQLParser.RULE_event_trigger_when_item); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4234; + this.state = 4293; this.colid(); - this.state = 4235; - this.match(PostgreSQLParser.IN_P); - this.state = 4236; + this.state = 4294; + this.match(PostgreSQLParser.KW_IN); + this.state = 4295; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4237; + this.state = 4296; this.event_trigger_value_list(); - this.state = 4238; + this.state = 4297; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -20102,26 +20846,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public event_trigger_value_list(): Event_trigger_value_listContext { let _localctx: Event_trigger_value_listContext = new Event_trigger_value_listContext(this._ctx, this.state); - this.enterRule(_localctx, 448, PostgreSQLParser.RULE_event_trigger_value_list); + this.enterRule(_localctx, 456, PostgreSQLParser.RULE_event_trigger_value_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4240; + this.state = 4299; this.sconst(); - this.state = 4245; + this.state = 4304; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 4241; + this.state = 4300; this.match(PostgreSQLParser.COMMA); - this.state = 4242; + this.state = 4301; this.sconst(); } } - this.state = 4247; + this.state = 4306; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -20144,19 +20888,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public altereventtrigstmt(): AltereventtrigstmtContext { let _localctx: AltereventtrigstmtContext = new AltereventtrigstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 450, PostgreSQLParser.RULE_altereventtrigstmt); + this.enterRule(_localctx, 458, PostgreSQLParser.RULE_altereventtrigstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4248; - this.match(PostgreSQLParser.ALTER); - this.state = 4249; - this.match(PostgreSQLParser.EVENT); - this.state = 4250; - this.match(PostgreSQLParser.TRIGGER); - this.state = 4251; + this.state = 4307; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 4308; + this.match(PostgreSQLParser.KW_EVENT); + this.state = 4309; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 4310; this.name(); - this.state = 4252; + this.state = 4311; this.enable_trigger(); } } @@ -20177,44 +20921,44 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public enable_trigger(): Enable_triggerContext { let _localctx: Enable_triggerContext = new Enable_triggerContext(this._ctx, this.state); - this.enterRule(_localctx, 452, PostgreSQLParser.RULE_enable_trigger); + this.enterRule(_localctx, 460, PostgreSQLParser.RULE_enable_trigger); try { - this.state = 4260; + this.state = 4319; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 321, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 330, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4254; - this.match(PostgreSQLParser.ENABLE_P); + this.state = 4313; + this.match(PostgreSQLParser.KW_ENABLE); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4255; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 4256; - this.match(PostgreSQLParser.REPLICA); + this.state = 4314; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 4315; + this.match(PostgreSQLParser.KW_REPLICA); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4257; - this.match(PostgreSQLParser.ENABLE_P); - this.state = 4258; - this.match(PostgreSQLParser.ALWAYS); + this.state = 4316; + this.match(PostgreSQLParser.KW_ENABLE); + this.state = 4317; + this.match(PostgreSQLParser.KW_ALWAYS); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4259; - this.match(PostgreSQLParser.DISABLE_P); + this.state = 4318; + this.match(PostgreSQLParser.KW_DISABLE); } break; } @@ -20236,25 +20980,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createassertionstmt(): CreateassertionstmtContext { let _localctx: CreateassertionstmtContext = new CreateassertionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 454, PostgreSQLParser.RULE_createassertionstmt); + this.enterRule(_localctx, 462, PostgreSQLParser.RULE_createassertionstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4262; - this.match(PostgreSQLParser.CREATE); - this.state = 4263; - this.match(PostgreSQLParser.ASSERTION); - this.state = 4264; + this.state = 4321; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4322; + this.match(PostgreSQLParser.KW_ASSERTION); + this.state = 4323; this.any_name(); - this.state = 4265; - this.match(PostgreSQLParser.CHECK); - this.state = 4266; + this.state = 4324; + this.match(PostgreSQLParser.KW_CHECK); + this.state = 4325; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4267; + this.state = 4326; this.a_expr(); - this.state = 4268; + this.state = 4327; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 4269; + this.state = 4328; this.constraintattributespec(); } } @@ -20275,34 +21019,34 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public definestmt(): DefinestmtContext { let _localctx: DefinestmtContext = new DefinestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 456, PostgreSQLParser.RULE_definestmt); + this.enterRule(_localctx, 464, PostgreSQLParser.RULE_definestmt); let _la: number; try { - this.state = 4385; + this.state = 4444; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 326, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 335, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4271; - this.match(PostgreSQLParser.CREATE); - this.state = 4273; + this.state = 4330; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4332; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OR) { + if (_la === PostgreSQLParser.KW_OR) { { - this.state = 4272; + this.state = 4331; this.opt_or_replace(); } } - this.state = 4275; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 4276; + this.state = 4334; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 4335; this.func_name(); - this.state = 4277; + this.state = 4336; this.aggr_args(); - this.state = 4278; + this.state = 4337; this.definition(); } break; @@ -20310,23 +21054,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4280; - this.match(PostgreSQLParser.CREATE); - this.state = 4282; + this.state = 4339; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4341; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OR) { + if (_la === PostgreSQLParser.KW_OR) { { - this.state = 4281; + this.state = 4340; this.opt_or_replace(); } } - this.state = 4284; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 4285; + this.state = 4343; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 4344; this.func_name(); - this.state = 4286; + this.state = 4345; this.old_aggr_definition(); } break; @@ -20334,13 +21078,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4288; - this.match(PostgreSQLParser.CREATE); - this.state = 4289; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4290; + this.state = 4347; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4348; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4349; this.any_operator(); - this.state = 4291; + this.state = 4350; this.definition(); } break; @@ -20348,170 +21092,10 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4293; - this.match(PostgreSQLParser.CREATE); - this.state = 4294; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4295; - this.any_name(); - this.state = 4296; - this.definition(); - } - break; - - case 5: - this.enterOuterAlt(_localctx, 5); - { - this.state = 4298; - this.match(PostgreSQLParser.CREATE); - this.state = 4299; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4300; - this.any_name(); - } - break; - - case 6: - this.enterOuterAlt(_localctx, 6); - { - this.state = 4301; - this.match(PostgreSQLParser.CREATE); - this.state = 4302; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4303; - this.any_name(); - this.state = 4304; - this.match(PostgreSQLParser.AS); - this.state = 4305; - this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4307; - 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 = 4306; - this.opttablefuncelementlist(); - } - } - - this.state = 4309; - this.match(PostgreSQLParser.CLOSE_PAREN); - } - break; - - case 7: - this.enterOuterAlt(_localctx, 7); - { - this.state = 4311; - this.match(PostgreSQLParser.CREATE); - this.state = 4312; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4313; - this.any_name(); - this.state = 4314; - this.match(PostgreSQLParser.AS); - this.state = 4315; - this.match(PostgreSQLParser.ENUM_P); - this.state = 4316; - this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4318; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (((((_la - 521)) & ~0x1F) === 0 && ((1 << (_la - 521)) & ((1 << (PostgreSQLParser.StringConstant - 521)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 521)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 521)) | (1 << (PostgreSQLParser.EscapeStringConstant - 521)))) !== 0)) { - { - this.state = 4317; - this.opt_enum_val_list(); - } - } - - this.state = 4320; - this.match(PostgreSQLParser.CLOSE_PAREN); - } - break; - - case 8: - this.enterOuterAlt(_localctx, 8); - { - this.state = 4322; - this.match(PostgreSQLParser.CREATE); - this.state = 4323; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4324; - this.any_name(); - this.state = 4325; - this.match(PostgreSQLParser.AS); - this.state = 4326; - this.match(PostgreSQLParser.RANGE); - this.state = 4327; - this.definition(); - } - break; - - case 9: - this.enterOuterAlt(_localctx, 9); - { - this.state = 4329; - this.match(PostgreSQLParser.CREATE); - this.state = 4330; - this.match(PostgreSQLParser.TEXT_P); - this.state = 4331; - this.match(PostgreSQLParser.SEARCH); - this.state = 4332; - this.match(PostgreSQLParser.PARSER); - this.state = 4333; - this.any_name(); - this.state = 4334; - this.definition(); - } - break; - - case 10: - this.enterOuterAlt(_localctx, 10); - { - this.state = 4336; - this.match(PostgreSQLParser.CREATE); - this.state = 4337; - this.match(PostgreSQLParser.TEXT_P); - this.state = 4338; - this.match(PostgreSQLParser.SEARCH); - this.state = 4339; - this.match(PostgreSQLParser.DICTIONARY); - this.state = 4340; - this.any_name(); - this.state = 4341; - this.definition(); - } - break; - - case 11: - this.enterOuterAlt(_localctx, 11); - { - this.state = 4343; - this.match(PostgreSQLParser.CREATE); - this.state = 4344; - this.match(PostgreSQLParser.TEXT_P); - this.state = 4345; - this.match(PostgreSQLParser.SEARCH); - this.state = 4346; - this.match(PostgreSQLParser.TEMPLATE); - this.state = 4347; - this.any_name(); - this.state = 4348; - this.definition(); - } - break; - - case 12: - this.enterOuterAlt(_localctx, 12); - { - this.state = 4350; - this.match(PostgreSQLParser.CREATE); - this.state = 4351; - this.match(PostgreSQLParser.TEXT_P); this.state = 4352; - this.match(PostgreSQLParser.SEARCH); + this.match(PostgreSQLParser.KW_CREATE); this.state = 4353; - this.match(PostgreSQLParser.CONFIGURATION); + this.match(PostgreSQLParser.KW_TYPE); this.state = 4354; this.any_name(); this.state = 4355; @@ -20519,16 +21103,176 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } break; + case 5: + this.enterOuterAlt(_localctx, 5); + { + this.state = 4357; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4358; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4359; + this.any_name(); + } + break; + + case 6: + this.enterOuterAlt(_localctx, 6); + { + this.state = 4360; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4361; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4362; + this.any_name(); + this.state = 4363; + this.match(PostgreSQLParser.KW_AS); + this.state = 4364; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4366; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.KW_OVER - 124)) | (1 << (PostgreSQLParser.KW_ABORT - 124)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 124)) | (1 << (PostgreSQLParser.KW_ACCESS - 124)) | (1 << (PostgreSQLParser.KW_ACTION - 124)) | (1 << (PostgreSQLParser.KW_ADD - 124)) | (1 << (PostgreSQLParser.KW_ADMIN - 124)) | (1 << (PostgreSQLParser.KW_AFTER - 124)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 124)) | (1 << (PostgreSQLParser.KW_ALSO - 124)) | (1 << (PostgreSQLParser.KW_ALTER - 124)) | (1 << (PostgreSQLParser.KW_ALWAYS - 124)) | (1 << (PostgreSQLParser.KW_ASSERTION - 124)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.KW_AT - 124)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.KW_BACKWARD - 124)) | (1 << (PostgreSQLParser.KW_BEFORE - 124)) | (1 << (PostgreSQLParser.KW_BEGIN - 124)) | (1 << (PostgreSQLParser.KW_BY - 124)) | (1 << (PostgreSQLParser.KW_CACHE - 124)) | (1 << (PostgreSQLParser.KW_CALLED - 124)) | (1 << (PostgreSQLParser.KW_CASCADE - 124)) | (1 << (PostgreSQLParser.KW_CASCADED - 124)) | (1 << (PostgreSQLParser.KW_CATALOG - 124)) | (1 << (PostgreSQLParser.KW_CHAIN - 124)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.KW_CLASS - 156)) | (1 << (PostgreSQLParser.KW_CLOSE - 156)) | (1 << (PostgreSQLParser.KW_CLUSTER - 156)) | (1 << (PostgreSQLParser.KW_COMMENT - 156)) | (1 << (PostgreSQLParser.KW_COMMENTS - 156)) | (1 << (PostgreSQLParser.KW_COMMIT - 156)) | (1 << (PostgreSQLParser.KW_COMMITTED - 156)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 156)) | (1 << (PostgreSQLParser.KW_CONNECTION - 156)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.KW_CONTENT - 156)) | (1 << (PostgreSQLParser.KW_CONTINUE - 156)) | (1 << (PostgreSQLParser.KW_CONVERSION - 156)) | (1 << (PostgreSQLParser.KW_COPY - 156)) | (1 << (PostgreSQLParser.KW_COST - 156)) | (1 << (PostgreSQLParser.KW_CSV - 156)) | (1 << (PostgreSQLParser.KW_CURSOR - 156)) | (1 << (PostgreSQLParser.KW_CYCLE - 156)) | (1 << (PostgreSQLParser.KW_DATA - 156)) | (1 << (PostgreSQLParser.KW_DATABASE - 156)) | (1 << (PostgreSQLParser.KW_DAY - 156)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 156)) | (1 << (PostgreSQLParser.KW_DECLARE - 156)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 156)) | (1 << (PostgreSQLParser.KW_DEFERRED - 156)) | (1 << (PostgreSQLParser.KW_DEFINER - 156)) | (1 << (PostgreSQLParser.KW_DELETE - 156)) | (1 << (PostgreSQLParser.KW_DELIMITER - 156)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 156)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 156)) | (1 << (PostgreSQLParser.KW_DISABLE - 156)) | (1 << (PostgreSQLParser.KW_DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.KW_DOCUMENT - 188)) | (1 << (PostgreSQLParser.KW_DOMAIN - 188)) | (1 << (PostgreSQLParser.KW_DOUBLE - 188)) | (1 << (PostgreSQLParser.KW_DROP - 188)) | (1 << (PostgreSQLParser.KW_EACH - 188)) | (1 << (PostgreSQLParser.KW_ENABLE - 188)) | (1 << (PostgreSQLParser.KW_ENCODING - 188)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 188)) | (1 << (PostgreSQLParser.KW_ENUM - 188)) | (1 << (PostgreSQLParser.KW_ESCAPE - 188)) | (1 << (PostgreSQLParser.KW_EVENT - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 188)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.KW_EXECUTE - 188)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 188)) | (1 << (PostgreSQLParser.KW_EXTENSION - 188)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 188)) | (1 << (PostgreSQLParser.KW_FAMILY - 188)) | (1 << (PostgreSQLParser.KW_FIRST - 188)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 188)) | (1 << (PostgreSQLParser.KW_FORCE - 188)) | (1 << (PostgreSQLParser.KW_FORWARD - 188)) | (1 << (PostgreSQLParser.KW_FUNCTION - 188)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 188)) | (1 << (PostgreSQLParser.KW_GLOBAL - 188)) | (1 << (PostgreSQLParser.KW_GRANTED - 188)) | (1 << (PostgreSQLParser.KW_HANDLER - 188)) | (1 << (PostgreSQLParser.KW_HEADER - 188)) | (1 << (PostgreSQLParser.KW_HOLD - 188)) | (1 << (PostgreSQLParser.KW_HOUR - 188)) | (1 << (PostgreSQLParser.KW_IDENTITY - 188)))) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.KW_IF - 220)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 220)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 220)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 220)) | (1 << (PostgreSQLParser.KW_INCLUDING - 220)) | (1 << (PostgreSQLParser.KW_INCREMENT - 220)) | (1 << (PostgreSQLParser.KW_INDEX - 220)) | (1 << (PostgreSQLParser.KW_INDEXES - 220)) | (1 << (PostgreSQLParser.KW_INHERIT - 220)) | (1 << (PostgreSQLParser.KW_INHERITS - 220)) | (1 << (PostgreSQLParser.KW_INLINE - 220)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 220)) | (1 << (PostgreSQLParser.KW_INSERT - 220)) | (1 << (PostgreSQLParser.KW_INSTEAD - 220)) | (1 << (PostgreSQLParser.KW_INVOKER - 220)) | (1 << (PostgreSQLParser.KW_ISOLATION - 220)) | (1 << (PostgreSQLParser.KW_KEY - 220)) | (1 << (PostgreSQLParser.KW_LABEL - 220)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 220)) | (1 << (PostgreSQLParser.KW_LARGE - 220)) | (1 << (PostgreSQLParser.KW_LAST - 220)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 220)) | (1 << (PostgreSQLParser.KW_LEVEL - 220)))) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.KW_LISTEN - 252)) | (1 << (PostgreSQLParser.KW_LOAD - 252)) | (1 << (PostgreSQLParser.KW_LOCAL - 252)) | (1 << (PostgreSQLParser.KW_LOCATION - 252)) | (1 << (PostgreSQLParser.KW_LOCK - 252)) | (1 << (PostgreSQLParser.KW_MAPPING - 252)) | (1 << (PostgreSQLParser.KW_MATCH - 252)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 252)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 252)) | (1 << (PostgreSQLParser.KW_MINUTE - 252)) | (1 << (PostgreSQLParser.KW_MINVALUE - 252)) | (1 << (PostgreSQLParser.KW_MODE - 252)) | (1 << (PostgreSQLParser.KW_MONTH - 252)) | (1 << (PostgreSQLParser.KW_MOVE - 252)) | (1 << (PostgreSQLParser.KW_NAME - 252)) | (1 << (PostgreSQLParser.KW_NAMES - 252)) | (1 << (PostgreSQLParser.KW_NEXT - 252)) | (1 << (PostgreSQLParser.KW_NO - 252)) | (1 << (PostgreSQLParser.KW_NOTHING - 252)) | (1 << (PostgreSQLParser.KW_NOTIFY - 252)) | (1 << (PostgreSQLParser.KW_NOWAIT - 252)) | (1 << (PostgreSQLParser.KW_NULLS - 252)) | (1 << (PostgreSQLParser.KW_OBJECT - 252)) | (1 << (PostgreSQLParser.KW_OF - 252)) | (1 << (PostgreSQLParser.KW_OFF - 252)) | (1 << (PostgreSQLParser.KW_OIDS - 252)) | (1 << (PostgreSQLParser.KW_OPERATOR - 252)) | (1 << (PostgreSQLParser.KW_OPTION - 252)) | (1 << (PostgreSQLParser.KW_OPTIONS - 252)) | (1 << (PostgreSQLParser.KW_OWNED - 252)) | (1 << (PostgreSQLParser.KW_OWNER - 252)) | (1 << (PostgreSQLParser.KW_PARSER - 252)))) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.KW_PARTIAL - 284)) | (1 << (PostgreSQLParser.KW_PARTITION - 284)) | (1 << (PostgreSQLParser.KW_PASSING - 284)) | (1 << (PostgreSQLParser.KW_PASSWORD - 284)) | (1 << (PostgreSQLParser.KW_PLANS - 284)) | (1 << (PostgreSQLParser.KW_PRECEDING - 284)) | (1 << (PostgreSQLParser.KW_PREPARE - 284)) | (1 << (PostgreSQLParser.KW_PREPARED - 284)) | (1 << (PostgreSQLParser.KW_PRESERVE - 284)) | (1 << (PostgreSQLParser.KW_PRIOR - 284)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 284)) | (1 << (PostgreSQLParser.KW_PROGRAM - 284)) | (1 << (PostgreSQLParser.KW_QUOTE - 284)) | (1 << (PostgreSQLParser.KW_RANGE - 284)) | (1 << (PostgreSQLParser.KW_READ - 284)) | (1 << (PostgreSQLParser.KW_REASSIGN - 284)) | (1 << (PostgreSQLParser.KW_RECHECK - 284)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 284)) | (1 << (PostgreSQLParser.KW_REF - 284)) | (1 << (PostgreSQLParser.KW_REFRESH - 284)) | (1 << (PostgreSQLParser.KW_REINDEX - 284)) | (1 << (PostgreSQLParser.KW_RELATIVE - 284)) | (1 << (PostgreSQLParser.KW_RELEASE - 284)) | (1 << (PostgreSQLParser.KW_RENAME - 284)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 284)) | (1 << (PostgreSQLParser.KW_REPLACE - 284)) | (1 << (PostgreSQLParser.KW_REPLICA - 284)) | (1 << (PostgreSQLParser.KW_RESET - 284)) | (1 << (PostgreSQLParser.KW_RESTART - 284)) | (1 << (PostgreSQLParser.KW_RESTRICT - 284)))) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.KW_RETURNS - 316)) | (1 << (PostgreSQLParser.KW_REVOKE - 316)) | (1 << (PostgreSQLParser.KW_ROLE - 316)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 316)) | (1 << (PostgreSQLParser.KW_ROWS - 316)) | (1 << (PostgreSQLParser.KW_RULE - 316)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 316)) | (1 << (PostgreSQLParser.KW_SCHEMA - 316)) | (1 << (PostgreSQLParser.KW_SCROLL - 316)) | (1 << (PostgreSQLParser.KW_SEARCH - 316)) | (1 << (PostgreSQLParser.KW_SECOND - 316)) | (1 << (PostgreSQLParser.KW_SECURITY - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 316)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.KW_SERVER - 316)) | (1 << (PostgreSQLParser.KW_SESSION - 316)) | (1 << (PostgreSQLParser.KW_SET - 316)) | (1 << (PostgreSQLParser.KW_SHARE - 316)) | (1 << (PostgreSQLParser.KW_SHOW - 316)) | (1 << (PostgreSQLParser.KW_SIMPLE - 316)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 316)) | (1 << (PostgreSQLParser.KW_STABLE - 316)) | (1 << (PostgreSQLParser.KW_STANDALONE - 316)) | (1 << (PostgreSQLParser.KW_START - 316)) | (1 << (PostgreSQLParser.KW_STATEMENT - 316)) | (1 << (PostgreSQLParser.KW_STATISTICS - 316)) | (1 << (PostgreSQLParser.KW_STDIN - 316)) | (1 << (PostgreSQLParser.KW_STDOUT - 316)) | (1 << (PostgreSQLParser.KW_STORAGE - 316)) | (1 << (PostgreSQLParser.KW_STRICT - 316)) | (1 << (PostgreSQLParser.KW_STRIP - 316)))) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.KW_SYSID - 348)) | (1 << (PostgreSQLParser.KW_SYSTEM - 348)) | (1 << (PostgreSQLParser.KW_TABLES - 348)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 348)) | (1 << (PostgreSQLParser.KW_TEMP - 348)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 348)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 348)) | (1 << (PostgreSQLParser.KW_TEXT - 348)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 348)) | (1 << (PostgreSQLParser.KW_TRIGGER - 348)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 348)) | (1 << (PostgreSQLParser.KW_TRUSTED - 348)) | (1 << (PostgreSQLParser.KW_TYPE - 348)) | (1 << (PostgreSQLParser.KW_TYPES - 348)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 348)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 348)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 348)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 348)) | (1 << (PostgreSQLParser.KW_UNTIL - 348)) | (1 << (PostgreSQLParser.KW_UPDATE - 348)) | (1 << (PostgreSQLParser.KW_VACUUM - 348)) | (1 << (PostgreSQLParser.KW_VALID - 348)) | (1 << (PostgreSQLParser.KW_VALIDATE - 348)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 348)) | (1 << (PostgreSQLParser.KW_VARYING - 348)) | (1 << (PostgreSQLParser.KW_VERSION - 348)) | (1 << (PostgreSQLParser.KW_VIEW - 348)) | (1 << (PostgreSQLParser.KW_VOLATILE - 348)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 348)) | (1 << (PostgreSQLParser.KW_WITHOUT - 348)))) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.KW_WORK - 380)) | (1 << (PostgreSQLParser.KW_WRAPPER - 380)) | (1 << (PostgreSQLParser.KW_WRITE - 380)) | (1 << (PostgreSQLParser.KW_XML - 380)) | (1 << (PostgreSQLParser.KW_YEAR - 380)) | (1 << (PostgreSQLParser.KW_YES - 380)) | (1 << (PostgreSQLParser.KW_ZONE - 380)) | (1 << (PostgreSQLParser.KW_BETWEEN - 380)) | (1 << (PostgreSQLParser.KW_BIGINT - 380)) | (1 << (PostgreSQLParser.KW_BIT - 380)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 380)) | (1 << (PostgreSQLParser.KW_CHAR - 380)) | (1 << (PostgreSQLParser.KW_CHARACTER - 380)) | (1 << (PostgreSQLParser.KW_COALESCE - 380)) | (1 << (PostgreSQLParser.KW_DEC - 380)) | (1 << (PostgreSQLParser.KW_DECIMAL - 380)) | (1 << (PostgreSQLParser.KW_EXISTS - 380)) | (1 << (PostgreSQLParser.KW_EXTRACT - 380)) | (1 << (PostgreSQLParser.KW_FLOAT - 380)) | (1 << (PostgreSQLParser.KW_GREATEST - 380)) | (1 << (PostgreSQLParser.KW_INOUT - 380)) | (1 << (PostgreSQLParser.KW_INT - 380)) | (1 << (PostgreSQLParser.KW_INTEGER - 380)) | (1 << (PostgreSQLParser.KW_INTERVAL - 380)) | (1 << (PostgreSQLParser.KW_LEAST - 380)) | (1 << (PostgreSQLParser.KW_NATIONAL - 380)) | (1 << (PostgreSQLParser.KW_NCHAR - 380)) | (1 << (PostgreSQLParser.KW_NONE - 380)) | (1 << (PostgreSQLParser.KW_NULLIF - 380)) | (1 << (PostgreSQLParser.KW_NUMERIC - 380)) | (1 << (PostgreSQLParser.KW_OVERLAY - 380)) | (1 << (PostgreSQLParser.KW_POSITION - 380)))) !== 0) || ((((_la - 412)) & ~0x1F) === 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.KW_PRECISION - 412)) | (1 << (PostgreSQLParser.KW_REAL - 412)) | (1 << (PostgreSQLParser.KW_ROW - 412)) | (1 << (PostgreSQLParser.KW_SETOF - 412)) | (1 << (PostgreSQLParser.KW_SMALLINT - 412)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 412)) | (1 << (PostgreSQLParser.KW_TIME - 412)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 412)) | (1 << (PostgreSQLParser.KW_TREAT - 412)) | (1 << (PostgreSQLParser.KW_TRIM - 412)) | (1 << (PostgreSQLParser.KW_VALUES - 412)) | (1 << (PostgreSQLParser.KW_VARCHAR - 412)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 412)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 412)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 412)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 412)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 412)) | (1 << (PostgreSQLParser.KW_XMLPI - 412)) | (1 << (PostgreSQLParser.KW_XMLROOT - 412)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.KW_CALL - 412)) | (1 << (PostgreSQLParser.KW_CURRENT - 412)) | (1 << (PostgreSQLParser.KW_ATTACH - 412)) | (1 << (PostgreSQLParser.KW_DETACH - 412)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 412)) | (1 << (PostgreSQLParser.KW_GENERATED - 412)) | (1 << (PostgreSQLParser.KW_LOGGED - 412)) | (1 << (PostgreSQLParser.KW_STORED - 412)) | (1 << (PostgreSQLParser.KW_INCLUDE - 412)) | (1 << (PostgreSQLParser.KW_ROUTINE - 412)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 412)))) !== 0) || ((((_la - 444)) & ~0x1F) === 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.KW_IMPORT - 444)) | (1 << (PostgreSQLParser.KW_POLICY - 444)) | (1 << (PostgreSQLParser.KW_METHOD - 444)) | (1 << (PostgreSQLParser.KW_REFERENCING - 444)) | (1 << (PostgreSQLParser.KW_NEW - 444)) | (1 << (PostgreSQLParser.KW_OLD - 444)) | (1 << (PostgreSQLParser.KW_VALUE - 444)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 444)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 444)) | (1 << (PostgreSQLParser.KW_OUT - 444)) | (1 << (PostgreSQLParser.KW_ROUTINES - 444)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 444)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 444)) | (1 << (PostgreSQLParser.KW_INPUT - 444)) | (1 << (PostgreSQLParser.KW_SUPPORT - 444)) | (1 << (PostgreSQLParser.KW_PARALLEL - 444)) | (1 << (PostgreSQLParser.KW_SQL - 444)) | (1 << (PostgreSQLParser.KW_DEPENDS - 444)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 444)) | (1 << (PostgreSQLParser.KW_CONFLICT - 444)) | (1 << (PostgreSQLParser.KW_SKIP - 444)) | (1 << (PostgreSQLParser.KW_LOCKED - 444)) | (1 << (PostgreSQLParser.KW_TIES - 444)) | (1 << (PostgreSQLParser.KW_ROLLUP - 444)) | (1 << (PostgreSQLParser.KW_CUBE - 444)) | (1 << (PostgreSQLParser.KW_GROUPING - 444)) | (1 << (PostgreSQLParser.KW_SETS - 444)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 444)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 444)) | (1 << (PostgreSQLParser.KW_COLUMNS - 444)))) !== 0) || ((((_la - 476)) & ~0x1F) === 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.KW_XMLNAMESPACES - 476)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 476)) | (1 << (PostgreSQLParser.KW_WITHIN - 476)) | (1 << (PostgreSQLParser.KW_FILTER - 476)) | (1 << (PostgreSQLParser.KW_GROUPS - 476)) | (1 << (PostgreSQLParser.KW_OTHERS - 476)) | (1 << (PostgreSQLParser.KW_NFC - 476)) | (1 << (PostgreSQLParser.KW_NFD - 476)) | (1 << (PostgreSQLParser.KW_NFKC - 476)) | (1 << (PostgreSQLParser.KW_NFKD - 476)) | (1 << (PostgreSQLParser.KW_UESCAPE - 476)) | (1 << (PostgreSQLParser.KW_VIEWS - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 476)) | (1 << (PostgreSQLParser.KW_DUMP - 476)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.KW_ERROR - 476)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 476)) | (1 << (PostgreSQLParser.KW_ALIAS - 476)) | (1 << (PostgreSQLParser.KW_CONSTANT - 476)) | (1 << (PostgreSQLParser.KW_PERFORM - 476)) | (1 << (PostgreSQLParser.KW_GET - 476)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.KW_STACKED - 476)) | (1 << (PostgreSQLParser.KW_ELSIF - 476)) | (1 << (PostgreSQLParser.KW_REVERSE - 476)) | (1 << (PostgreSQLParser.KW_SLICE - 476)) | (1 << (PostgreSQLParser.KW_EXIT - 476)))) !== 0) || ((((_la - 508)) & ~0x1F) === 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.KW_RETURN - 508)) | (1 << (PostgreSQLParser.KW_QUERY - 508)) | (1 << (PostgreSQLParser.KW_RAISE - 508)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 508)) | (1 << (PostgreSQLParser.KW_DEBUG - 508)) | (1 << (PostgreSQLParser.KW_LOG - 508)) | (1 << (PostgreSQLParser.KW_INFO - 508)) | (1 << (PostgreSQLParser.KW_NOTICE - 508)) | (1 << (PostgreSQLParser.KW_WARNING - 508)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 508)) | (1 << (PostgreSQLParser.KW_ASSERT - 508)) | (1 << (PostgreSQLParser.KW_OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { + { + this.state = 4365; + this.opttablefuncelementlist(); + } + } + + this.state = 4368; + this.match(PostgreSQLParser.CLOSE_PAREN); + } + break; + + case 7: + this.enterOuterAlt(_localctx, 7); + { + this.state = 4370; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4371; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4372; + this.any_name(); + this.state = 4373; + this.match(PostgreSQLParser.KW_AS); + this.state = 4374; + this.match(PostgreSQLParser.KW_ENUM); + this.state = 4375; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 4377; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (((((_la - 534)) & ~0x1F) === 0 && ((1 << (_la - 534)) & ((1 << (PostgreSQLParser.StringConstant - 534)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 534)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 534)) | (1 << (PostgreSQLParser.EscapeStringConstant - 534)))) !== 0)) { + { + this.state = 4376; + this.opt_enum_val_list(); + } + } + + this.state = 4379; + this.match(PostgreSQLParser.CLOSE_PAREN); + } + break; + + case 8: + this.enterOuterAlt(_localctx, 8); + { + this.state = 4381; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4382; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4383; + this.any_name(); + this.state = 4384; + this.match(PostgreSQLParser.KW_AS); + this.state = 4385; + this.match(PostgreSQLParser.KW_RANGE); + this.state = 4386; + this.definition(); + } + break; + + case 9: + this.enterOuterAlt(_localctx, 9); + { + this.state = 4388; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4389; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 4390; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 4391; + this.match(PostgreSQLParser.KW_PARSER); + this.state = 4392; + this.any_name(); + this.state = 4393; + this.definition(); + } + break; + + case 10: + this.enterOuterAlt(_localctx, 10); + { + this.state = 4395; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4396; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 4397; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 4398; + this.match(PostgreSQLParser.KW_DICTIONARY); + this.state = 4399; + this.any_name(); + this.state = 4400; + this.definition(); + } + break; + + case 11: + this.enterOuterAlt(_localctx, 11); + { + this.state = 4402; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4403; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 4404; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 4405; + this.match(PostgreSQLParser.KW_TEMPLATE); + this.state = 4406; + this.any_name(); + this.state = 4407; + this.definition(); + } + break; + + case 12: + this.enterOuterAlt(_localctx, 12); + { + this.state = 4409; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4410; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 4411; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 4412; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 4413; + this.any_name(); + this.state = 4414; + this.definition(); + } + break; + case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 4357; - this.match(PostgreSQLParser.CREATE); - this.state = 4358; - this.match(PostgreSQLParser.COLLATION); - this.state = 4359; + this.state = 4416; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4417; + this.match(PostgreSQLParser.KW_COLLATION); + this.state = 4418; this.any_name(); - this.state = 4360; + this.state = 4419; this.definition(); } break; @@ -20536,19 +21280,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 4362; - this.match(PostgreSQLParser.CREATE); - this.state = 4363; - this.match(PostgreSQLParser.COLLATION); - this.state = 4364; - this.match(PostgreSQLParser.IF_P); - this.state = 4365; - this.match(PostgreSQLParser.NOT); - this.state = 4366; - this.match(PostgreSQLParser.EXISTS); - this.state = 4367; + this.state = 4421; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4422; + this.match(PostgreSQLParser.KW_COLLATION); + this.state = 4423; + this.match(PostgreSQLParser.KW_IF); + this.state = 4424; + this.match(PostgreSQLParser.KW_NOT); + this.state = 4425; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4426; this.any_name(); - this.state = 4368; + this.state = 4427; this.definition(); } break; @@ -20556,15 +21300,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 4370; - this.match(PostgreSQLParser.CREATE); - this.state = 4371; - this.match(PostgreSQLParser.COLLATION); - this.state = 4372; + this.state = 4429; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4430; + this.match(PostgreSQLParser.KW_COLLATION); + this.state = 4431; this.any_name(); - this.state = 4373; - this.match(PostgreSQLParser.FROM); - this.state = 4374; + this.state = 4432; + this.match(PostgreSQLParser.KW_FROM); + this.state = 4433; this.any_name(); } break; @@ -20572,21 +21316,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 4376; - this.match(PostgreSQLParser.CREATE); - this.state = 4377; - this.match(PostgreSQLParser.COLLATION); - this.state = 4378; - this.match(PostgreSQLParser.IF_P); - this.state = 4379; - this.match(PostgreSQLParser.NOT); - this.state = 4380; - this.match(PostgreSQLParser.EXISTS); - this.state = 4381; + this.state = 4435; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4436; + this.match(PostgreSQLParser.KW_COLLATION); + this.state = 4437; + this.match(PostgreSQLParser.KW_IF); + this.state = 4438; + this.match(PostgreSQLParser.KW_NOT); + this.state = 4439; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4440; this.any_name(); - this.state = 4382; - this.match(PostgreSQLParser.FROM); - this.state = 4383; + this.state = 4441; + this.match(PostgreSQLParser.KW_FROM); + this.state = 4442; this.any_name(); } break; @@ -20609,15 +21353,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public definition(): DefinitionContext { let _localctx: DefinitionContext = new DefinitionContext(this._ctx, this.state); - this.enterRule(_localctx, 458, PostgreSQLParser.RULE_definition); + this.enterRule(_localctx, 466, PostgreSQLParser.RULE_definition); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4387; + this.state = 4446; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4388; + this.state = 4447; this.def_list(); - this.state = 4389; + this.state = 4448; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -20638,26 +21382,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public def_list(): Def_listContext { let _localctx: Def_listContext = new Def_listContext(this._ctx, this.state); - this.enterRule(_localctx, 460, PostgreSQLParser.RULE_def_list); + this.enterRule(_localctx, 468, PostgreSQLParser.RULE_def_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4391; + this.state = 4450; this.def_elem(); - this.state = 4396; + this.state = 4455; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 4392; + this.state = 4451; this.match(PostgreSQLParser.COMMA); - this.state = 4393; + this.state = 4452; this.def_elem(); } } - this.state = 4398; + this.state = 4457; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -20680,21 +21424,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public def_elem(): Def_elemContext { let _localctx: Def_elemContext = new Def_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 462, PostgreSQLParser.RULE_def_elem); + this.enterRule(_localctx, 470, PostgreSQLParser.RULE_def_elem); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4399; + this.state = 4458; this.collabel(); - this.state = 4402; + this.state = 4461; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.EQUAL) { { - this.state = 4400; + this.state = 4459; this.match(PostgreSQLParser.EQUAL); - this.state = 4401; + this.state = 4460; this.def_arg(); } } @@ -20718,15 +21462,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public def_arg(): Def_argContext { let _localctx: Def_argContext = new Def_argContext(this._ctx, this.state); - this.enterRule(_localctx, 464, PostgreSQLParser.RULE_def_arg); + this.enterRule(_localctx, 472, PostgreSQLParser.RULE_def_arg); try { - this.state = 4410; + this.state = 4469; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 329, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 338, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4404; + this.state = 4463; this.func_type(); } break; @@ -20734,7 +21478,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4405; + this.state = 4464; this.reserved_keyword(); } break; @@ -20742,7 +21486,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4406; + this.state = 4465; this.qual_all_op(); } break; @@ -20750,7 +21494,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4407; + this.state = 4466; this.numericonly(); } break; @@ -20758,7 +21502,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 4408; + this.state = 4467; this.sconst(); } break; @@ -20766,8 +21510,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 4409; - this.match(PostgreSQLParser.NONE); + this.state = 4468; + this.match(PostgreSQLParser.KW_NONE); } break; } @@ -20789,15 +21533,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public old_aggr_definition(): Old_aggr_definitionContext { let _localctx: Old_aggr_definitionContext = new Old_aggr_definitionContext(this._ctx, this.state); - this.enterRule(_localctx, 466, PostgreSQLParser.RULE_old_aggr_definition); + this.enterRule(_localctx, 474, PostgreSQLParser.RULE_old_aggr_definition); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4412; + this.state = 4471; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4413; + this.state = 4472; this.old_aggr_list(); - this.state = 4414; + this.state = 4473; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -20818,26 +21562,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public old_aggr_list(): Old_aggr_listContext { let _localctx: Old_aggr_listContext = new Old_aggr_listContext(this._ctx, this.state); - this.enterRule(_localctx, 468, PostgreSQLParser.RULE_old_aggr_list); + this.enterRule(_localctx, 476, PostgreSQLParser.RULE_old_aggr_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4416; + this.state = 4475; this.old_aggr_elem(); - this.state = 4421; + this.state = 4480; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 4417; + this.state = 4476; this.match(PostgreSQLParser.COMMA); - this.state = 4418; + this.state = 4477; this.old_aggr_elem(); } } - this.state = 4423; + this.state = 4482; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -20860,15 +21604,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public old_aggr_elem(): Old_aggr_elemContext { let _localctx: Old_aggr_elemContext = new Old_aggr_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 470, PostgreSQLParser.RULE_old_aggr_elem); + this.enterRule(_localctx, 478, PostgreSQLParser.RULE_old_aggr_elem); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4424; + this.state = 4483; this.identifier(); - this.state = 4425; + this.state = 4484; this.match(PostgreSQLParser.EQUAL); - this.state = 4426; + this.state = 4485; this.def_arg(); } } @@ -20889,11 +21633,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_enum_val_list(): Opt_enum_val_listContext { let _localctx: Opt_enum_val_listContext = new Opt_enum_val_listContext(this._ctx, this.state); - this.enterRule(_localctx, 472, PostgreSQLParser.RULE_opt_enum_val_list); + this.enterRule(_localctx, 480, PostgreSQLParser.RULE_opt_enum_val_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4428; + this.state = 4487; this.enum_val_list(); } } @@ -20914,26 +21658,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public enum_val_list(): Enum_val_listContext { let _localctx: Enum_val_listContext = new Enum_val_listContext(this._ctx, this.state); - this.enterRule(_localctx, 474, PostgreSQLParser.RULE_enum_val_list); + this.enterRule(_localctx, 482, PostgreSQLParser.RULE_enum_val_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4430; + this.state = 4489; this.sconst(); - this.state = 4435; + this.state = 4494; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 4431; + this.state = 4490; this.match(PostgreSQLParser.COMMA); - this.state = 4432; + this.state = 4491; this.sconst(); } } - this.state = 4437; + this.state = 4496; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -20956,36 +21700,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterenumstmt(): AlterenumstmtContext { let _localctx: AlterenumstmtContext = new AlterenumstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 476, PostgreSQLParser.RULE_alterenumstmt); + this.enterRule(_localctx, 484, PostgreSQLParser.RULE_alterenumstmt); let _la: number; try { - this.state = 4481; + this.state = 4540; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 335, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 344, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4438; - this.match(PostgreSQLParser.ALTER); - this.state = 4439; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4440; + this.state = 4497; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 4498; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4499; this.any_name(); - this.state = 4441; - this.match(PostgreSQLParser.ADD_P); - this.state = 4442; - this.match(PostgreSQLParser.VALUE_P); - this.state = 4444; + this.state = 4500; + this.match(PostgreSQLParser.KW_ADD); + this.state = 4501; + this.match(PostgreSQLParser.KW_VALUE); + this.state = 4503; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.IF_P) { + if (_la === PostgreSQLParser.KW_IF) { { - this.state = 4443; + this.state = 4502; this.opt_if_not_exists(); } } - this.state = 4446; + this.state = 4505; this.sconst(); } break; @@ -20993,31 +21737,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4448; - this.match(PostgreSQLParser.ALTER); - this.state = 4449; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4450; + this.state = 4507; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 4508; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4509; this.any_name(); - this.state = 4451; - this.match(PostgreSQLParser.ADD_P); - this.state = 4452; - this.match(PostgreSQLParser.VALUE_P); - this.state = 4454; + this.state = 4510; + this.match(PostgreSQLParser.KW_ADD); + this.state = 4511; + this.match(PostgreSQLParser.KW_VALUE); + this.state = 4513; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.IF_P) { + if (_la === PostgreSQLParser.KW_IF) { { - this.state = 4453; + this.state = 4512; this.opt_if_not_exists(); } } - this.state = 4456; + this.state = 4515; this.sconst(); - this.state = 4457; - this.match(PostgreSQLParser.BEFORE); - this.state = 4458; + this.state = 4516; + this.match(PostgreSQLParser.KW_BEFORE); + this.state = 4517; this.sconst(); } break; @@ -21025,31 +21769,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4460; - this.match(PostgreSQLParser.ALTER); - this.state = 4461; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4462; + this.state = 4519; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 4520; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4521; this.any_name(); - this.state = 4463; - this.match(PostgreSQLParser.ADD_P); - this.state = 4464; - this.match(PostgreSQLParser.VALUE_P); - this.state = 4466; + this.state = 4522; + this.match(PostgreSQLParser.KW_ADD); + this.state = 4523; + this.match(PostgreSQLParser.KW_VALUE); + this.state = 4525; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.IF_P) { + if (_la === PostgreSQLParser.KW_IF) { { - this.state = 4465; + this.state = 4524; this.opt_if_not_exists(); } } - this.state = 4468; + this.state = 4527; this.sconst(); - this.state = 4469; - this.match(PostgreSQLParser.AFTER); - this.state = 4470; + this.state = 4528; + this.match(PostgreSQLParser.KW_AFTER); + this.state = 4529; this.sconst(); } break; @@ -21057,21 +21801,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4472; - this.match(PostgreSQLParser.ALTER); - this.state = 4473; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4474; + this.state = 4531; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 4532; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4533; this.any_name(); - this.state = 4475; - this.match(PostgreSQLParser.RENAME); - this.state = 4476; - this.match(PostgreSQLParser.VALUE_P); - this.state = 4477; + this.state = 4534; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 4535; + this.match(PostgreSQLParser.KW_VALUE); + this.state = 4536; this.sconst(); - this.state = 4478; - this.match(PostgreSQLParser.TO); - this.state = 4479; + this.state = 4537; + this.match(PostgreSQLParser.KW_TO); + this.state = 4538; this.sconst(); } break; @@ -21094,16 +21838,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_if_not_exists(): Opt_if_not_existsContext { let _localctx: Opt_if_not_existsContext = new Opt_if_not_existsContext(this._ctx, this.state); - this.enterRule(_localctx, 478, PostgreSQLParser.RULE_opt_if_not_exists); + this.enterRule(_localctx, 486, PostgreSQLParser.RULE_opt_if_not_exists); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4483; - this.match(PostgreSQLParser.IF_P); - this.state = 4484; - this.match(PostgreSQLParser.NOT); - this.state = 4485; - this.match(PostgreSQLParser.EXISTS); + this.state = 4542; + this.match(PostgreSQLParser.KW_IF); + this.state = 4543; + this.match(PostgreSQLParser.KW_NOT); + this.state = 4544; + this.match(PostgreSQLParser.KW_EXISTS); } } catch (re) { @@ -21123,52 +21867,52 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createopclassstmt(): CreateopclassstmtContext { let _localctx: CreateopclassstmtContext = new CreateopclassstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 480, PostgreSQLParser.RULE_createopclassstmt); + this.enterRule(_localctx, 488, PostgreSQLParser.RULE_createopclassstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4487; - this.match(PostgreSQLParser.CREATE); - this.state = 4488; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4489; - this.match(PostgreSQLParser.CLASS); - this.state = 4490; + this.state = 4546; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4547; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4548; + this.match(PostgreSQLParser.KW_CLASS); + this.state = 4549; this.any_name(); - this.state = 4492; + this.state = 4551; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.DEFAULT) { + if (_la === PostgreSQLParser.KW_DEFAULT) { { - this.state = 4491; + this.state = 4550; this.opt_default(); } } - this.state = 4494; - this.match(PostgreSQLParser.FOR); - this.state = 4495; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4496; + this.state = 4553; + this.match(PostgreSQLParser.KW_FOR); + this.state = 4554; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4555; this.typename(); - this.state = 4497; - this.match(PostgreSQLParser.USING); - this.state = 4498; + this.state = 4556; + this.match(PostgreSQLParser.KW_USING); + this.state = 4557; this.name(); - this.state = 4500; + this.state = 4559; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FAMILY) { + if (_la === PostgreSQLParser.KW_FAMILY) { { - this.state = 4499; + this.state = 4558; this.opt_opfamily(); } } - this.state = 4502; - this.match(PostgreSQLParser.AS); - this.state = 4503; + this.state = 4561; + this.match(PostgreSQLParser.KW_AS); + this.state = 4562; this.opclass_item_list(); } } @@ -21189,26 +21933,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opclass_item_list(): Opclass_item_listContext { let _localctx: Opclass_item_listContext = new Opclass_item_listContext(this._ctx, this.state); - this.enterRule(_localctx, 482, PostgreSQLParser.RULE_opclass_item_list); + this.enterRule(_localctx, 490, PostgreSQLParser.RULE_opclass_item_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4505; + this.state = 4564; this.opclass_item(); - this.state = 4510; + this.state = 4569; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 4506; + this.state = 4565; this.match(PostgreSQLParser.COMMA); - this.state = 4507; + this.state = 4566; this.opclass_item(); } } - this.state = 4512; + this.state = 4571; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -21231,37 +21975,37 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opclass_item(): Opclass_itemContext { let _localctx: Opclass_itemContext = new Opclass_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 484, PostgreSQLParser.RULE_opclass_item); + this.enterRule(_localctx, 492, PostgreSQLParser.RULE_opclass_item); let _la: number; try { - this.state = 4544; + this.state = 4603; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 343, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 352, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4513; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4514; + this.state = 4572; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4573; this.iconst(); - this.state = 4515; + this.state = 4574; this.any_operator(); - this.state = 4517; + this.state = 4576; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 4516; + this.state = 4575; this.opclass_purpose(); } } - this.state = 4520; + this.state = 4579; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.RECHECK) { + if (_la === PostgreSQLParser.KW_RECHECK) { { - this.state = 4519; + this.state = 4578; this.opt_recheck(); } } @@ -21272,28 +22016,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4522; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4523; + this.state = 4581; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4582; this.iconst(); - this.state = 4524; + this.state = 4583; this.operator_with_argtypes(); - this.state = 4526; + this.state = 4585; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 4525; + this.state = 4584; this.opclass_purpose(); } } - this.state = 4529; + this.state = 4588; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.RECHECK) { + if (_la === PostgreSQLParser.KW_RECHECK) { { - this.state = 4528; + this.state = 4587; this.opt_recheck(); } } @@ -21304,11 +22048,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4531; - this.match(PostgreSQLParser.FUNCTION); - this.state = 4532; + this.state = 4590; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 4591; this.iconst(); - this.state = 4533; + this.state = 4592; this.function_with_argtypes(); } break; @@ -21316,17 +22060,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4535; - this.match(PostgreSQLParser.FUNCTION); - this.state = 4536; + this.state = 4594; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 4595; this.iconst(); - this.state = 4537; + this.state = 4596; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4538; + this.state = 4597; this.type_list(); - this.state = 4539; + this.state = 4598; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 4540; + this.state = 4599; this.function_with_argtypes(); } break; @@ -21334,9 +22078,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 4542; - this.match(PostgreSQLParser.STORAGE); - this.state = 4543; + this.state = 4601; + this.match(PostgreSQLParser.KW_STORAGE); + this.state = 4602; this.typename(); } break; @@ -21359,12 +22103,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_default(): Opt_defaultContext { let _localctx: Opt_defaultContext = new Opt_defaultContext(this._ctx, this.state); - this.enterRule(_localctx, 486, PostgreSQLParser.RULE_opt_default); + this.enterRule(_localctx, 494, PostgreSQLParser.RULE_opt_default); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4546; - this.match(PostgreSQLParser.DEFAULT); + this.state = 4605; + this.match(PostgreSQLParser.KW_DEFAULT); } } catch (re) { @@ -21384,13 +22128,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_opfamily(): Opt_opfamilyContext { let _localctx: Opt_opfamilyContext = new Opt_opfamilyContext(this._ctx, this.state); - this.enterRule(_localctx, 488, PostgreSQLParser.RULE_opt_opfamily); + this.enterRule(_localctx, 496, PostgreSQLParser.RULE_opt_opfamily); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4548; - this.match(PostgreSQLParser.FAMILY); - this.state = 4549; + this.state = 4607; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 4608; this.any_name(); } } @@ -21411,31 +22155,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opclass_purpose(): Opclass_purposeContext { let _localctx: Opclass_purposeContext = new Opclass_purposeContext(this._ctx, this.state); - this.enterRule(_localctx, 490, PostgreSQLParser.RULE_opclass_purpose); + this.enterRule(_localctx, 498, PostgreSQLParser.RULE_opclass_purpose); try { - this.state = 4557; + this.state = 4616; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 344, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 353, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4551; - this.match(PostgreSQLParser.FOR); - this.state = 4552; - this.match(PostgreSQLParser.SEARCH); + this.state = 4610; + this.match(PostgreSQLParser.KW_FOR); + this.state = 4611; + this.match(PostgreSQLParser.KW_SEARCH); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4553; - this.match(PostgreSQLParser.FOR); - this.state = 4554; - this.match(PostgreSQLParser.ORDER); - this.state = 4555; - this.match(PostgreSQLParser.BY); - this.state = 4556; + this.state = 4612; + this.match(PostgreSQLParser.KW_FOR); + this.state = 4613; + this.match(PostgreSQLParser.KW_ORDER); + this.state = 4614; + this.match(PostgreSQLParser.KW_BY); + this.state = 4615; this.any_name(); } break; @@ -21458,12 +22202,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_recheck(): Opt_recheckContext { let _localctx: Opt_recheckContext = new Opt_recheckContext(this._ctx, this.state); - this.enterRule(_localctx, 492, PostgreSQLParser.RULE_opt_recheck); + this.enterRule(_localctx, 500, PostgreSQLParser.RULE_opt_recheck); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4559; - this.match(PostgreSQLParser.RECHECK); + this.state = 4618; + this.match(PostgreSQLParser.KW_RECHECK); } } catch (re) { @@ -21483,21 +22227,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createopfamilystmt(): CreateopfamilystmtContext { let _localctx: CreateopfamilystmtContext = new CreateopfamilystmtContext(this._ctx, this.state); - this.enterRule(_localctx, 494, PostgreSQLParser.RULE_createopfamilystmt); + this.enterRule(_localctx, 502, PostgreSQLParser.RULE_createopfamilystmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4561; - this.match(PostgreSQLParser.CREATE); - this.state = 4562; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4563; - this.match(PostgreSQLParser.FAMILY); - this.state = 4564; + this.state = 4620; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 4621; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4622; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 4623; this.any_name(); - this.state = 4565; - this.match(PostgreSQLParser.USING); - this.state = 4566; + this.state = 4624; + this.match(PostgreSQLParser.KW_USING); + this.state = 4625; this.name(); } } @@ -21518,29 +22262,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alteropfamilystmt(): AlteropfamilystmtContext { let _localctx: AlteropfamilystmtContext = new AlteropfamilystmtContext(this._ctx, this.state); - this.enterRule(_localctx, 496, PostgreSQLParser.RULE_alteropfamilystmt); + this.enterRule(_localctx, 504, PostgreSQLParser.RULE_alteropfamilystmt); try { - this.state = 4586; + this.state = 4645; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 345, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 354, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4568; - this.match(PostgreSQLParser.ALTER); - this.state = 4569; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4570; - this.match(PostgreSQLParser.FAMILY); - this.state = 4571; + this.state = 4627; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 4628; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4629; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 4630; this.any_name(); - this.state = 4572; - this.match(PostgreSQLParser.USING); - this.state = 4573; + this.state = 4631; + this.match(PostgreSQLParser.KW_USING); + this.state = 4632; this.name(); - this.state = 4574; - this.match(PostgreSQLParser.ADD_P); - this.state = 4575; + this.state = 4633; + this.match(PostgreSQLParser.KW_ADD); + this.state = 4634; this.opclass_item_list(); } break; @@ -21548,21 +22292,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4577; - this.match(PostgreSQLParser.ALTER); - this.state = 4578; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4579; - this.match(PostgreSQLParser.FAMILY); - this.state = 4580; + this.state = 4636; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 4637; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4638; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 4639; this.any_name(); - this.state = 4581; - this.match(PostgreSQLParser.USING); - this.state = 4582; + this.state = 4640; + this.match(PostgreSQLParser.KW_USING); + this.state = 4641; this.name(); - this.state = 4583; - this.match(PostgreSQLParser.DROP); - this.state = 4584; + this.state = 4642; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4643; this.opclass_drop_list(); } break; @@ -21585,26 +22329,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opclass_drop_list(): Opclass_drop_listContext { let _localctx: Opclass_drop_listContext = new Opclass_drop_listContext(this._ctx, this.state); - this.enterRule(_localctx, 498, PostgreSQLParser.RULE_opclass_drop_list); + this.enterRule(_localctx, 506, PostgreSQLParser.RULE_opclass_drop_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4588; + this.state = 4647; this.opclass_drop(); - this.state = 4593; + this.state = 4652; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 4589; + this.state = 4648; this.match(PostgreSQLParser.COMMA); - this.state = 4590; + this.state = 4649; this.opclass_drop(); } } - this.state = 4595; + this.state = 4654; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -21627,38 +22371,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opclass_drop(): Opclass_dropContext { let _localctx: Opclass_dropContext = new Opclass_dropContext(this._ctx, this.state); - this.enterRule(_localctx, 500, PostgreSQLParser.RULE_opclass_drop); + this.enterRule(_localctx, 508, PostgreSQLParser.RULE_opclass_drop); try { - this.state = 4608; + this.state = 4667; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.KW_OPERATOR: this.enterOuterAlt(_localctx, 1); { - this.state = 4596; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4597; + this.state = 4655; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4656; this.iconst(); - this.state = 4598; + this.state = 4657; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4599; + this.state = 4658; this.type_list(); - this.state = 4600; + this.state = 4659; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.FUNCTION: + case PostgreSQLParser.KW_FUNCTION: this.enterOuterAlt(_localctx, 2); { - this.state = 4602; - this.match(PostgreSQLParser.FUNCTION); - this.state = 4603; + this.state = 4661; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 4662; this.iconst(); - this.state = 4604; + this.state = 4663; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4605; + this.state = 4664; this.type_list(); - this.state = 4606; + this.state = 4665; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -21683,33 +22427,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dropopclassstmt(): DropopclassstmtContext { let _localctx: DropopclassstmtContext = new DropopclassstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 502, PostgreSQLParser.RULE_dropopclassstmt); + this.enterRule(_localctx, 510, PostgreSQLParser.RULE_dropopclassstmt); let _la: number; try { - this.state = 4630; + this.state = 4689; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 350, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 359, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4610; - this.match(PostgreSQLParser.DROP); - this.state = 4611; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4612; - this.match(PostgreSQLParser.CLASS); - this.state = 4613; + this.state = 4669; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4670; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4671; + this.match(PostgreSQLParser.KW_CLASS); + this.state = 4672; this.any_name(); - this.state = 4614; - this.match(PostgreSQLParser.USING); - this.state = 4615; + this.state = 4673; + this.match(PostgreSQLParser.KW_USING); + this.state = 4674; this.name(); - this.state = 4617; + this.state = 4676; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4616; + this.state = 4675; this.opt_drop_behavior(); } } @@ -21720,28 +22464,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4619; - this.match(PostgreSQLParser.DROP); - this.state = 4620; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4621; - this.match(PostgreSQLParser.CLASS); - this.state = 4622; - this.match(PostgreSQLParser.IF_P); - this.state = 4623; - this.match(PostgreSQLParser.EXISTS); - this.state = 4624; + this.state = 4678; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4679; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4680; + this.match(PostgreSQLParser.KW_CLASS); + this.state = 4681; + this.match(PostgreSQLParser.KW_IF); + this.state = 4682; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4683; this.any_name(); - this.state = 4625; - this.match(PostgreSQLParser.USING); - this.state = 4626; + this.state = 4684; + this.match(PostgreSQLParser.KW_USING); + this.state = 4685; this.name(); - this.state = 4628; + this.state = 4687; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4627; + this.state = 4686; this.opt_drop_behavior(); } } @@ -21767,33 +22511,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dropopfamilystmt(): DropopfamilystmtContext { let _localctx: DropopfamilystmtContext = new DropopfamilystmtContext(this._ctx, this.state); - this.enterRule(_localctx, 504, PostgreSQLParser.RULE_dropopfamilystmt); + this.enterRule(_localctx, 512, PostgreSQLParser.RULE_dropopfamilystmt); let _la: number; try { - this.state = 4652; + this.state = 4711; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 353, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 362, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4632; - this.match(PostgreSQLParser.DROP); - this.state = 4633; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4634; - this.match(PostgreSQLParser.FAMILY); - this.state = 4635; + this.state = 4691; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4692; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4693; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 4694; this.any_name(); - this.state = 4636; - this.match(PostgreSQLParser.USING); - this.state = 4637; + this.state = 4695; + this.match(PostgreSQLParser.KW_USING); + this.state = 4696; this.name(); - this.state = 4639; + this.state = 4698; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4638; + this.state = 4697; this.opt_drop_behavior(); } } @@ -21804,28 +22548,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4641; - this.match(PostgreSQLParser.DROP); - this.state = 4642; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4643; - this.match(PostgreSQLParser.FAMILY); - this.state = 4644; - this.match(PostgreSQLParser.IF_P); - this.state = 4645; - this.match(PostgreSQLParser.EXISTS); - this.state = 4646; + this.state = 4700; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4701; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4702; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 4703; + this.match(PostgreSQLParser.KW_IF); + this.state = 4704; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4705; this.any_name(); - this.state = 4647; - this.match(PostgreSQLParser.USING); - this.state = 4648; + this.state = 4706; + this.match(PostgreSQLParser.KW_USING); + this.state = 4707; this.name(); - this.state = 4650; + this.state = 4709; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4649; + this.state = 4708; this.opt_drop_behavior(); } } @@ -21851,25 +22595,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dropownedstmt(): DropownedstmtContext { let _localctx: DropownedstmtContext = new DropownedstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 506, PostgreSQLParser.RULE_dropownedstmt); + this.enterRule(_localctx, 514, PostgreSQLParser.RULE_dropownedstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4654; - this.match(PostgreSQLParser.DROP); - this.state = 4655; - this.match(PostgreSQLParser.OWNED); - this.state = 4656; - this.match(PostgreSQLParser.BY); - this.state = 4657; + this.state = 4713; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4714; + this.match(PostgreSQLParser.KW_OWNED); + this.state = 4715; + this.match(PostgreSQLParser.KW_BY); + this.state = 4716; this.role_list(); - this.state = 4659; + this.state = 4718; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4658; + this.state = 4717; this.opt_drop_behavior(); } } @@ -21893,21 +22637,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public reassignownedstmt(): ReassignownedstmtContext { let _localctx: ReassignownedstmtContext = new ReassignownedstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 508, PostgreSQLParser.RULE_reassignownedstmt); + this.enterRule(_localctx, 516, PostgreSQLParser.RULE_reassignownedstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 4661; - this.match(PostgreSQLParser.REASSIGN); - this.state = 4662; - this.match(PostgreSQLParser.OWNED); - this.state = 4663; - this.match(PostgreSQLParser.BY); - this.state = 4664; + this.state = 4720; + this.match(PostgreSQLParser.KW_REASSIGN); + this.state = 4721; + this.match(PostgreSQLParser.KW_OWNED); + this.state = 4722; + this.match(PostgreSQLParser.KW_BY); + this.state = 4723; this.role_list(); - this.state = 4665; - this.match(PostgreSQLParser.TO); - this.state = 4666; + this.state = 4724; + this.match(PostgreSQLParser.KW_TO); + this.state = 4725; this.rolespec(); } } @@ -21928,31 +22672,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dropstmt(): DropstmtContext { let _localctx: DropstmtContext = new DropstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 510, PostgreSQLParser.RULE_dropstmt); + this.enterRule(_localctx, 518, PostgreSQLParser.RULE_dropstmt); let _la: number; try { - this.state = 4758; + this.state = 4817; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 367, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 376, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4668; - this.match(PostgreSQLParser.DROP); - this.state = 4669; + this.state = 4727; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4728; this.object_type_any_name(); - this.state = 4670; - this.match(PostgreSQLParser.IF_P); - this.state = 4671; - this.match(PostgreSQLParser.EXISTS); - this.state = 4672; + this.state = 4729; + this.match(PostgreSQLParser.KW_IF); + this.state = 4730; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4731; this.any_name_list(); - this.state = 4674; + this.state = 4733; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4673; + this.state = 4732; this.opt_drop_behavior(); } } @@ -21963,18 +22707,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4676; - this.match(PostgreSQLParser.DROP); - this.state = 4677; + this.state = 4735; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4736; this.object_type_any_name(); - this.state = 4678; + this.state = 4737; this.any_name_list(); - this.state = 4680; + this.state = 4739; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4679; + this.state = 4738; this.opt_drop_behavior(); } } @@ -21985,22 +22729,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4682; - this.match(PostgreSQLParser.DROP); - this.state = 4683; + this.state = 4741; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4742; this.drop_type_name(); - this.state = 4684; - this.match(PostgreSQLParser.IF_P); - this.state = 4685; - this.match(PostgreSQLParser.EXISTS); - this.state = 4686; + this.state = 4743; + this.match(PostgreSQLParser.KW_IF); + this.state = 4744; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4745; this.name_list(); - this.state = 4688; + this.state = 4747; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4687; + this.state = 4746; this.opt_drop_behavior(); } } @@ -22011,18 +22755,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4690; - this.match(PostgreSQLParser.DROP); - this.state = 4691; + this.state = 4749; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4750; this.drop_type_name(); - this.state = 4692; + this.state = 4751; this.name_list(); - this.state = 4694; + this.state = 4753; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4693; + this.state = 4752; this.opt_drop_behavior(); } } @@ -22033,22 +22777,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 4696; - this.match(PostgreSQLParser.DROP); - this.state = 4697; + this.state = 4755; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4756; this.object_type_name_on_any_name(); - this.state = 4698; + this.state = 4757; this.name(); - this.state = 4699; - this.match(PostgreSQLParser.ON); - this.state = 4700; + this.state = 4758; + this.match(PostgreSQLParser.KW_ON); + this.state = 4759; this.any_name(); - this.state = 4702; + this.state = 4761; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4701; + this.state = 4760; this.opt_drop_behavior(); } } @@ -22059,26 +22803,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 4704; - this.match(PostgreSQLParser.DROP); - this.state = 4705; + this.state = 4763; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4764; this.object_type_name_on_any_name(); - this.state = 4706; - this.match(PostgreSQLParser.IF_P); - this.state = 4707; - this.match(PostgreSQLParser.EXISTS); - this.state = 4708; + this.state = 4765; + this.match(PostgreSQLParser.KW_IF); + this.state = 4766; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4767; this.name(); - this.state = 4709; - this.match(PostgreSQLParser.ON); - this.state = 4710; + this.state = 4768; + this.match(PostgreSQLParser.KW_ON); + this.state = 4769; this.any_name(); - this.state = 4712; + this.state = 4771; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4711; + this.state = 4770; this.opt_drop_behavior(); } } @@ -22089,18 +22833,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 4714; - this.match(PostgreSQLParser.DROP); - this.state = 4715; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4716; + this.state = 4773; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4774; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4775; this.type_name_list(); - this.state = 4718; + this.state = 4777; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4717; + this.state = 4776; this.opt_drop_behavior(); } } @@ -22111,22 +22855,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 4720; - this.match(PostgreSQLParser.DROP); - this.state = 4721; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4722; - this.match(PostgreSQLParser.IF_P); - this.state = 4723; - this.match(PostgreSQLParser.EXISTS); - this.state = 4724; + this.state = 4779; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4780; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4781; + this.match(PostgreSQLParser.KW_IF); + this.state = 4782; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4783; this.type_name_list(); - this.state = 4726; + this.state = 4785; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4725; + this.state = 4784; this.opt_drop_behavior(); } } @@ -22137,18 +22881,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 4728; - this.match(PostgreSQLParser.DROP); - this.state = 4729; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 4730; + this.state = 4787; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4788; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 4789; this.type_name_list(); - this.state = 4732; + this.state = 4791; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4731; + this.state = 4790; this.opt_drop_behavior(); } } @@ -22159,22 +22903,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 4734; - this.match(PostgreSQLParser.DROP); - this.state = 4735; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 4736; - this.match(PostgreSQLParser.IF_P); - this.state = 4737; - this.match(PostgreSQLParser.EXISTS); - this.state = 4738; + this.state = 4793; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4794; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 4795; + this.match(PostgreSQLParser.KW_IF); + this.state = 4796; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4797; this.type_name_list(); - this.state = 4740; + this.state = 4799; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4739; + this.state = 4798; this.opt_drop_behavior(); } } @@ -22185,20 +22929,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 4742; - this.match(PostgreSQLParser.DROP); - this.state = 4743; - this.match(PostgreSQLParser.INDEX); - this.state = 4744; - this.match(PostgreSQLParser.CONCURRENTLY); - this.state = 4745; + this.state = 4801; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4802; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 4803; + this.match(PostgreSQLParser.KW_CONCURRENTLY); + this.state = 4804; this.any_name_list(); - this.state = 4747; + this.state = 4806; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4746; + this.state = 4805; this.opt_drop_behavior(); } } @@ -22209,24 +22953,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 4749; - this.match(PostgreSQLParser.DROP); - this.state = 4750; - this.match(PostgreSQLParser.INDEX); - this.state = 4751; - this.match(PostgreSQLParser.CONCURRENTLY); - this.state = 4752; - this.match(PostgreSQLParser.IF_P); - this.state = 4753; - this.match(PostgreSQLParser.EXISTS); - this.state = 4754; + this.state = 4808; + this.match(PostgreSQLParser.KW_DROP); + this.state = 4809; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 4810; + this.match(PostgreSQLParser.KW_CONCURRENTLY); + this.state = 4811; + this.match(PostgreSQLParser.KW_IF); + this.state = 4812; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 4813; this.any_name_list(); - this.state = 4756; + this.state = 4815; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4755; + this.state = 4814; this.opt_drop_behavior(); } } @@ -22252,132 +22996,132 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public object_type_any_name(): Object_type_any_nameContext { let _localctx: Object_type_any_nameContext = new Object_type_any_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 512, PostgreSQLParser.RULE_object_type_any_name); + this.enterRule(_localctx, 520, PostgreSQLParser.RULE_object_type_any_name); try { - this.state = 4783; + this.state = 4842; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 368, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 377, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4760; - this.match(PostgreSQLParser.TABLE); + this.state = 4819; + this.match(PostgreSQLParser.KW_TABLE); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4761; - this.match(PostgreSQLParser.SEQUENCE); + this.state = 4820; + this.match(PostgreSQLParser.KW_SEQUENCE); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4762; - this.match(PostgreSQLParser.VIEW); + this.state = 4821; + this.match(PostgreSQLParser.KW_VIEW); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4763; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 4764; - this.match(PostgreSQLParser.VIEW); + this.state = 4822; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 4823; + this.match(PostgreSQLParser.KW_VIEW); } break; case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 4765; - this.match(PostgreSQLParser.INDEX); + this.state = 4824; + this.match(PostgreSQLParser.KW_INDEX); } break; case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 4766; - this.match(PostgreSQLParser.FOREIGN); - this.state = 4767; - this.match(PostgreSQLParser.TABLE); + this.state = 4825; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 4826; + this.match(PostgreSQLParser.KW_TABLE); } break; case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 4768; - this.match(PostgreSQLParser.COLLATION); + this.state = 4827; + this.match(PostgreSQLParser.KW_COLLATION); } break; case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 4769; - this.match(PostgreSQLParser.CONVERSION_P); + this.state = 4828; + this.match(PostgreSQLParser.KW_CONVERSION); } break; case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 4770; - this.match(PostgreSQLParser.STATISTICS); + this.state = 4829; + this.match(PostgreSQLParser.KW_STATISTICS); } break; case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 4771; - this.match(PostgreSQLParser.TEXT_P); - this.state = 4772; - this.match(PostgreSQLParser.SEARCH); - this.state = 4773; - this.match(PostgreSQLParser.PARSER); + this.state = 4830; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 4831; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 4832; + this.match(PostgreSQLParser.KW_PARSER); } break; case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 4774; - this.match(PostgreSQLParser.TEXT_P); - this.state = 4775; - this.match(PostgreSQLParser.SEARCH); - this.state = 4776; - this.match(PostgreSQLParser.DICTIONARY); + this.state = 4833; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 4834; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 4835; + this.match(PostgreSQLParser.KW_DICTIONARY); } break; case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 4777; - this.match(PostgreSQLParser.TEXT_P); - this.state = 4778; - this.match(PostgreSQLParser.SEARCH); - this.state = 4779; - this.match(PostgreSQLParser.TEMPLATE); + this.state = 4836; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 4837; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 4838; + this.match(PostgreSQLParser.KW_TEMPLATE); } break; case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 4780; - this.match(PostgreSQLParser.TEXT_P); - this.state = 4781; - this.match(PostgreSQLParser.SEARCH); - this.state = 4782; - this.match(PostgreSQLParser.CONFIGURATION); + this.state = 4839; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 4840; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 4841; + this.match(PostgreSQLParser.KW_CONFIGURATION); } break; } @@ -22399,52 +23143,52 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public object_type_name(): Object_type_nameContext { let _localctx: Object_type_nameContext = new Object_type_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 514, PostgreSQLParser.RULE_object_type_name); + this.enterRule(_localctx, 522, PostgreSQLParser.RULE_object_type_name); try { - this.state = 4790; + this.state = 4849; 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: + case PostgreSQLParser.KW_FOREIGN: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_PUBLICATION: this.enterOuterAlt(_localctx, 1); { - this.state = 4785; + this.state = 4844; this.drop_type_name(); } break; - case PostgreSQLParser.DATABASE: + case PostgreSQLParser.KW_DATABASE: this.enterOuterAlt(_localctx, 2); { - this.state = 4786; - this.match(PostgreSQLParser.DATABASE); + this.state = 4845; + this.match(PostgreSQLParser.KW_DATABASE); } break; - case PostgreSQLParser.ROLE: + case PostgreSQLParser.KW_ROLE: this.enterOuterAlt(_localctx, 3); { - this.state = 4787; - this.match(PostgreSQLParser.ROLE); + this.state = 4846; + this.match(PostgreSQLParser.KW_ROLE); } break; - case PostgreSQLParser.SUBSCRIPTION: + case PostgreSQLParser.KW_SUBSCRIPTION: this.enterOuterAlt(_localctx, 4); { - this.state = 4788; - this.match(PostgreSQLParser.SUBSCRIPTION); + this.state = 4847; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); } break; - case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.KW_TABLESPACE: this.enterOuterAlt(_localctx, 5); { - this.state = 4789; - this.match(PostgreSQLParser.TABLESPACE); + this.state = 4848; + this.match(PostgreSQLParser.KW_TABLESPACE); } break; default: @@ -22468,85 +23212,85 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public drop_type_name(): Drop_type_nameContext { let _localctx: Drop_type_nameContext = new Drop_type_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 516, PostgreSQLParser.RULE_drop_type_name); + this.enterRule(_localctx, 524, PostgreSQLParser.RULE_drop_type_name); let _la: number; try { - this.state = 4807; + this.state = 4866; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.ACCESS: + case PostgreSQLParser.KW_ACCESS: this.enterOuterAlt(_localctx, 1); { - this.state = 4792; - this.match(PostgreSQLParser.ACCESS); - this.state = 4793; - this.match(PostgreSQLParser.METHOD); + this.state = 4851; + this.match(PostgreSQLParser.KW_ACCESS); + this.state = 4852; + this.match(PostgreSQLParser.KW_METHOD); } break; - case PostgreSQLParser.EVENT: + case PostgreSQLParser.KW_EVENT: this.enterOuterAlt(_localctx, 2); { - this.state = 4794; - this.match(PostgreSQLParser.EVENT); - this.state = 4795; - this.match(PostgreSQLParser.TRIGGER); + this.state = 4853; + this.match(PostgreSQLParser.KW_EVENT); + this.state = 4854; + this.match(PostgreSQLParser.KW_TRIGGER); } break; - case PostgreSQLParser.EXTENSION: + case PostgreSQLParser.KW_EXTENSION: this.enterOuterAlt(_localctx, 3); { - this.state = 4796; - this.match(PostgreSQLParser.EXTENSION); + this.state = 4855; + this.match(PostgreSQLParser.KW_EXTENSION); } break; - case PostgreSQLParser.FOREIGN: + case PostgreSQLParser.KW_FOREIGN: this.enterOuterAlt(_localctx, 4); { - this.state = 4797; - this.match(PostgreSQLParser.FOREIGN); - this.state = 4798; - this.match(PostgreSQLParser.DATA_P); - this.state = 4799; - this.match(PostgreSQLParser.WRAPPER); + this.state = 4856; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 4857; + this.match(PostgreSQLParser.KW_DATA); + this.state = 4858; + this.match(PostgreSQLParser.KW_WRAPPER); } break; - case PostgreSQLParser.LANGUAGE: - case PostgreSQLParser.PROCEDURAL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_PROCEDURAL: this.enterOuterAlt(_localctx, 5); { - this.state = 4801; + this.state = 4860; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PROCEDURAL) { + if (_la === PostgreSQLParser.KW_PROCEDURAL) { { - this.state = 4800; + this.state = 4859; this.opt_procedural(); } } - this.state = 4803; - this.match(PostgreSQLParser.LANGUAGE); + this.state = 4862; + this.match(PostgreSQLParser.KW_LANGUAGE); } break; - case PostgreSQLParser.PUBLICATION: + case PostgreSQLParser.KW_PUBLICATION: this.enterOuterAlt(_localctx, 6); { - this.state = 4804; - this.match(PostgreSQLParser.PUBLICATION); + this.state = 4863; + this.match(PostgreSQLParser.KW_PUBLICATION); } break; - case PostgreSQLParser.SCHEMA: + case PostgreSQLParser.KW_SCHEMA: this.enterOuterAlt(_localctx, 7); { - this.state = 4805; - this.match(PostgreSQLParser.SCHEMA); + this.state = 4864; + this.match(PostgreSQLParser.KW_SCHEMA); } break; - case PostgreSQLParser.SERVER: + case PostgreSQLParser.KW_SERVER: this.enterOuterAlt(_localctx, 8); { - this.state = 4806; - this.match(PostgreSQLParser.SERVER); + this.state = 4865; + this.match(PostgreSQLParser.KW_SERVER); } break; default: @@ -22570,14 +23314,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public object_type_name_on_any_name(): Object_type_name_on_any_nameContext { let _localctx: Object_type_name_on_any_nameContext = new Object_type_name_on_any_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 518, PostgreSQLParser.RULE_object_type_name_on_any_name); + this.enterRule(_localctx, 526, PostgreSQLParser.RULE_object_type_name_on_any_name); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4809; + this.state = 4868; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.RULE || _la === PostgreSQLParser.TRIGGER || _la === PostgreSQLParser.POLICY)) { + if (!(_la === PostgreSQLParser.KW_RULE || _la === PostgreSQLParser.KW_TRIGGER || _la === PostgreSQLParser.KW_POLICY)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -22606,26 +23350,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public any_name_list(): Any_name_listContext { let _localctx: Any_name_listContext = new Any_name_listContext(this._ctx, this.state); - this.enterRule(_localctx, 520, PostgreSQLParser.RULE_any_name_list); + this.enterRule(_localctx, 528, PostgreSQLParser.RULE_any_name_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4811; + this.state = 4870; this.any_name(); - this.state = 4816; + this.state = 4875; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 4812; + this.state = 4871; this.match(PostgreSQLParser.COMMA); - this.state = 4813; + this.state = 4872; this.any_name(); } } - this.state = 4818; + this.state = 4877; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -22648,19 +23392,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public any_name(): Any_nameContext { let _localctx: Any_nameContext = new Any_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 522, PostgreSQLParser.RULE_any_name); + this.enterRule(_localctx, 530, PostgreSQLParser.RULE_any_name); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4819; + this.state = 4878; this.colid(); - this.state = 4821; + this.state = 4880; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.DOT) { { - this.state = 4820; + this.state = 4879; this.attrs(); } } @@ -22684,12 +23428,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public attrs(): AttrsContext { let _localctx: AttrsContext = new AttrsContext(this._ctx, this.state); - this.enterRule(_localctx, 524, PostgreSQLParser.RULE_attrs); + this.enterRule(_localctx, 532, PostgreSQLParser.RULE_attrs); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 4825; + this.state = 4884; this._errHandler.sync(this); _alt = 1; do { @@ -22697,9 +23441,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 1: { { - this.state = 4823; + this.state = 4882; this.match(PostgreSQLParser.DOT); - this.state = 4824; + this.state = 4883; this.attr_name(); } } @@ -22707,9 +23451,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 4827; + this.state = 4886; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 374, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 383, this._ctx); } while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER); } } @@ -22730,26 +23474,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public type_name_list(): Type_name_listContext { let _localctx: Type_name_listContext = new Type_name_listContext(this._ctx, this.state); - this.enterRule(_localctx, 526, PostgreSQLParser.RULE_type_name_list); + this.enterRule(_localctx, 534, PostgreSQLParser.RULE_type_name_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4829; + this.state = 4888; this.typename(); - this.state = 4834; + this.state = 4893; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 4830; + this.state = 4889; this.match(PostgreSQLParser.COMMA); - this.state = 4831; + this.state = 4890; this.typename(); } } - this.state = 4836; + this.state = 4895; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -22772,41 +23516,41 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public truncatestmt(): TruncatestmtContext { let _localctx: TruncatestmtContext = new TruncatestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 528, PostgreSQLParser.RULE_truncatestmt); + this.enterRule(_localctx, 536, PostgreSQLParser.RULE_truncatestmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 4837; - this.match(PostgreSQLParser.TRUNCATE); - this.state = 4839; + this.state = 4896; + this.match(PostgreSQLParser.KW_TRUNCATE); + this.state = 4898; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 376, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 385, this._ctx) ) { case 1: { - this.state = 4838; + this.state = 4897; this.opt_table(); } break; } - this.state = 4841; + this.state = 4900; this.relation_expr_list(); - this.state = 4843; + this.state = 4902; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CONTINUE_P || _la === PostgreSQLParser.RESTART) { + if (_la === PostgreSQLParser.KW_CONTINUE || _la === PostgreSQLParser.KW_RESTART) { { - this.state = 4842; + this.state = 4901; this.opt_restart_seqs(); } } - this.state = 4846; + this.state = 4905; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 4845; + this.state = 4904; this.opt_drop_behavior(); } } @@ -22830,27 +23574,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_restart_seqs(): Opt_restart_seqsContext { let _localctx: Opt_restart_seqsContext = new Opt_restart_seqsContext(this._ctx, this.state); - this.enterRule(_localctx, 530, PostgreSQLParser.RULE_opt_restart_seqs); + this.enterRule(_localctx, 538, PostgreSQLParser.RULE_opt_restart_seqs); try { - this.state = 4852; + this.state = 4911; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.CONTINUE_P: + case PostgreSQLParser.KW_CONTINUE: this.enterOuterAlt(_localctx, 1); { - this.state = 4848; - this.match(PostgreSQLParser.CONTINUE_P); - this.state = 4849; - this.match(PostgreSQLParser.IDENTITY_P); + this.state = 4907; + this.match(PostgreSQLParser.KW_CONTINUE); + this.state = 4908; + this.match(PostgreSQLParser.KW_IDENTITY); } break; - case PostgreSQLParser.RESTART: + case PostgreSQLParser.KW_RESTART: this.enterOuterAlt(_localctx, 2); { - this.state = 4850; - this.match(PostgreSQLParser.RESTART); - this.state = 4851; - this.match(PostgreSQLParser.IDENTITY_P); + this.state = 4909; + this.match(PostgreSQLParser.KW_RESTART); + this.state = 4910; + this.match(PostgreSQLParser.KW_IDENTITY); } break; default: @@ -22874,25 +23618,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public commentstmt(): CommentstmtContext { let _localctx: CommentstmtContext = new CommentstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 532, PostgreSQLParser.RULE_commentstmt); + this.enterRule(_localctx, 540, PostgreSQLParser.RULE_commentstmt); try { - this.state = 5001; + this.state = 5060; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 380, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 389, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 4854; - this.match(PostgreSQLParser.COMMENT); - this.state = 4855; - this.match(PostgreSQLParser.ON); - this.state = 4856; + this.state = 4913; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4914; + this.match(PostgreSQLParser.KW_ON); + this.state = 4915; this.object_type_any_name(); - this.state = 4857; + this.state = 4916; this.any_name(); - this.state = 4858; - this.match(PostgreSQLParser.IS); - this.state = 4859; + this.state = 4917; + this.match(PostgreSQLParser.KW_IS); + this.state = 4918; this.comment_text(); } break; @@ -22900,17 +23644,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 4861; - this.match(PostgreSQLParser.COMMENT); - this.state = 4862; - this.match(PostgreSQLParser.ON); - this.state = 4863; - this.match(PostgreSQLParser.COLUMN); - this.state = 4864; + this.state = 4920; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4921; + this.match(PostgreSQLParser.KW_ON); + this.state = 4922; + this.match(PostgreSQLParser.KW_COLUMN); + this.state = 4923; this.any_name(); - this.state = 4865; - this.match(PostgreSQLParser.IS); - this.state = 4866; + this.state = 4924; + this.match(PostgreSQLParser.KW_IS); + this.state = 4925; this.comment_text(); } break; @@ -22918,17 +23662,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 4868; - this.match(PostgreSQLParser.COMMENT); - this.state = 4869; - this.match(PostgreSQLParser.ON); - this.state = 4870; + this.state = 4927; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4928; + this.match(PostgreSQLParser.KW_ON); + this.state = 4929; this.object_type_name(); - this.state = 4871; + this.state = 4930; this.name(); - this.state = 4872; - this.match(PostgreSQLParser.IS); - this.state = 4873; + this.state = 4931; + this.match(PostgreSQLParser.KW_IS); + this.state = 4932; this.comment_text(); } break; @@ -22936,17 +23680,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 4875; - this.match(PostgreSQLParser.COMMENT); - this.state = 4876; - this.match(PostgreSQLParser.ON); - this.state = 4877; - this.match(PostgreSQLParser.TYPE_P); - this.state = 4878; + this.state = 4934; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4935; + this.match(PostgreSQLParser.KW_ON); + this.state = 4936; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 4937; this.typename(); - this.state = 4879; - this.match(PostgreSQLParser.IS); - this.state = 4880; + this.state = 4938; + this.match(PostgreSQLParser.KW_IS); + this.state = 4939; this.comment_text(); } break; @@ -22954,17 +23698,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 4882; - this.match(PostgreSQLParser.COMMENT); - this.state = 4883; - this.match(PostgreSQLParser.ON); - this.state = 4884; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 4885; + this.state = 4941; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4942; + this.match(PostgreSQLParser.KW_ON); + this.state = 4943; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 4944; this.typename(); - this.state = 4886; - this.match(PostgreSQLParser.IS); - this.state = 4887; + this.state = 4945; + this.match(PostgreSQLParser.KW_IS); + this.state = 4946; this.comment_text(); } break; @@ -22972,17 +23716,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 4889; - this.match(PostgreSQLParser.COMMENT); - this.state = 4890; - this.match(PostgreSQLParser.ON); - this.state = 4891; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 4892; + this.state = 4948; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4949; + this.match(PostgreSQLParser.KW_ON); + this.state = 4950; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 4951; this.aggregate_with_argtypes(); - this.state = 4893; - this.match(PostgreSQLParser.IS); - this.state = 4894; + this.state = 4952; + this.match(PostgreSQLParser.KW_IS); + this.state = 4953; this.comment_text(); } break; @@ -22990,17 +23734,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 4896; - this.match(PostgreSQLParser.COMMENT); - this.state = 4897; - this.match(PostgreSQLParser.ON); - this.state = 4898; - this.match(PostgreSQLParser.FUNCTION); - this.state = 4899; + this.state = 4955; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4956; + this.match(PostgreSQLParser.KW_ON); + this.state = 4957; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 4958; this.function_with_argtypes(); - this.state = 4900; - this.match(PostgreSQLParser.IS); - this.state = 4901; + this.state = 4959; + this.match(PostgreSQLParser.KW_IS); + this.state = 4960; this.comment_text(); } break; @@ -23008,17 +23752,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 4903; - this.match(PostgreSQLParser.COMMENT); - this.state = 4904; - this.match(PostgreSQLParser.ON); - this.state = 4905; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4906; + this.state = 4962; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4963; + this.match(PostgreSQLParser.KW_ON); + this.state = 4964; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 4965; this.operator_with_argtypes(); - this.state = 4907; - this.match(PostgreSQLParser.IS); - this.state = 4908; + this.state = 4966; + this.match(PostgreSQLParser.KW_IS); + this.state = 4967; this.comment_text(); } break; @@ -23026,21 +23770,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 4910; - this.match(PostgreSQLParser.COMMENT); - this.state = 4911; - this.match(PostgreSQLParser.ON); - this.state = 4912; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 4913; + this.state = 4969; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4970; + this.match(PostgreSQLParser.KW_ON); + this.state = 4971; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 4972; this.name(); - this.state = 4914; - this.match(PostgreSQLParser.ON); - this.state = 4915; + this.state = 4973; + this.match(PostgreSQLParser.KW_ON); + this.state = 4974; this.any_name(); - this.state = 4916; - this.match(PostgreSQLParser.IS); - this.state = 4917; + this.state = 4975; + this.match(PostgreSQLParser.KW_IS); + this.state = 4976; this.comment_text(); } break; @@ -23048,23 +23792,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 4919; - this.match(PostgreSQLParser.COMMENT); - this.state = 4920; - this.match(PostgreSQLParser.ON); - this.state = 4921; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 4922; + this.state = 4978; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4979; + this.match(PostgreSQLParser.KW_ON); + this.state = 4980; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 4981; this.name(); - this.state = 4923; - this.match(PostgreSQLParser.ON); - this.state = 4924; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 4925; + this.state = 4982; + this.match(PostgreSQLParser.KW_ON); + this.state = 4983; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 4984; this.any_name(); - this.state = 4926; - this.match(PostgreSQLParser.IS); - this.state = 4927; + this.state = 4985; + this.match(PostgreSQLParser.KW_IS); + this.state = 4986; this.comment_text(); } break; @@ -23072,21 +23816,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 4929; - this.match(PostgreSQLParser.COMMENT); - this.state = 4930; - this.match(PostgreSQLParser.ON); - this.state = 4931; + this.state = 4988; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4989; + this.match(PostgreSQLParser.KW_ON); + this.state = 4990; this.object_type_name_on_any_name(); - this.state = 4932; + this.state = 4991; this.name(); - this.state = 4933; - this.match(PostgreSQLParser.ON); - this.state = 4934; + this.state = 4992; + this.match(PostgreSQLParser.KW_ON); + this.state = 4993; this.any_name(); - this.state = 4935; - this.match(PostgreSQLParser.IS); - this.state = 4936; + this.state = 4994; + this.match(PostgreSQLParser.KW_IS); + this.state = 4995; this.comment_text(); } break; @@ -23094,17 +23838,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 4938; - this.match(PostgreSQLParser.COMMENT); - this.state = 4939; - this.match(PostgreSQLParser.ON); - this.state = 4940; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 4941; + this.state = 4997; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 4998; + this.match(PostgreSQLParser.KW_ON); + this.state = 4999; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 5000; this.function_with_argtypes(); - this.state = 4942; - this.match(PostgreSQLParser.IS); - this.state = 4943; + this.state = 5001; + this.match(PostgreSQLParser.KW_IS); + this.state = 5002; this.comment_text(); } break; @@ -23112,17 +23856,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 4945; - this.match(PostgreSQLParser.COMMENT); - this.state = 4946; - this.match(PostgreSQLParser.ON); - this.state = 4947; - this.match(PostgreSQLParser.ROUTINE); - this.state = 4948; + this.state = 5004; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 5005; + this.match(PostgreSQLParser.KW_ON); + this.state = 5006; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 5007; this.function_with_argtypes(); - this.state = 4949; - this.match(PostgreSQLParser.IS); - this.state = 4950; + this.state = 5008; + this.match(PostgreSQLParser.KW_IS); + this.state = 5009; this.comment_text(); } break; @@ -23130,23 +23874,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 4952; - this.match(PostgreSQLParser.COMMENT); - this.state = 4953; - this.match(PostgreSQLParser.ON); - this.state = 4954; - this.match(PostgreSQLParser.TRANSFORM); - this.state = 4955; - this.match(PostgreSQLParser.FOR); - this.state = 4956; + this.state = 5011; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 5012; + this.match(PostgreSQLParser.KW_ON); + this.state = 5013; + this.match(PostgreSQLParser.KW_TRANSFORM); + this.state = 5014; + this.match(PostgreSQLParser.KW_FOR); + this.state = 5015; this.typename(); - this.state = 4957; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 4958; + this.state = 5016; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 5017; this.name(); - this.state = 4959; - this.match(PostgreSQLParser.IS); - this.state = 4960; + this.state = 5018; + this.match(PostgreSQLParser.KW_IS); + this.state = 5019; this.comment_text(); } break; @@ -23154,23 +23898,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 4962; - this.match(PostgreSQLParser.COMMENT); - this.state = 4963; - this.match(PostgreSQLParser.ON); - this.state = 4964; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4965; - this.match(PostgreSQLParser.CLASS); - this.state = 4966; + this.state = 5021; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 5022; + this.match(PostgreSQLParser.KW_ON); + this.state = 5023; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 5024; + this.match(PostgreSQLParser.KW_CLASS); + this.state = 5025; this.any_name(); - this.state = 4967; - this.match(PostgreSQLParser.USING); - this.state = 4968; + this.state = 5026; + this.match(PostgreSQLParser.KW_USING); + this.state = 5027; this.name(); - this.state = 4969; - this.match(PostgreSQLParser.IS); - this.state = 4970; + this.state = 5028; + this.match(PostgreSQLParser.KW_IS); + this.state = 5029; this.comment_text(); } break; @@ -23178,23 +23922,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 4972; - this.match(PostgreSQLParser.COMMENT); - this.state = 4973; - this.match(PostgreSQLParser.ON); - this.state = 4974; - this.match(PostgreSQLParser.OPERATOR); - this.state = 4975; - this.match(PostgreSQLParser.FAMILY); - this.state = 4976; + this.state = 5031; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 5032; + this.match(PostgreSQLParser.KW_ON); + this.state = 5033; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 5034; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 5035; this.any_name(); - this.state = 4977; - this.match(PostgreSQLParser.USING); - this.state = 4978; + this.state = 5036; + this.match(PostgreSQLParser.KW_USING); + this.state = 5037; this.name(); - this.state = 4979; - this.match(PostgreSQLParser.IS); - this.state = 4980; + this.state = 5038; + this.match(PostgreSQLParser.KW_IS); + this.state = 5039; this.comment_text(); } break; @@ -23202,19 +23946,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 4982; - this.match(PostgreSQLParser.COMMENT); - this.state = 4983; - this.match(PostgreSQLParser.ON); - this.state = 4984; - this.match(PostgreSQLParser.LARGE_P); - this.state = 4985; - this.match(PostgreSQLParser.OBJECT_P); - this.state = 4986; + this.state = 5041; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 5042; + this.match(PostgreSQLParser.KW_ON); + this.state = 5043; + this.match(PostgreSQLParser.KW_LARGE); + this.state = 5044; + this.match(PostgreSQLParser.KW_OBJECT); + this.state = 5045; this.numericonly(); - this.state = 4987; - this.match(PostgreSQLParser.IS); - this.state = 4988; + this.state = 5046; + this.match(PostgreSQLParser.KW_IS); + this.state = 5047; this.comment_text(); } break; @@ -23222,25 +23966,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 18: this.enterOuterAlt(_localctx, 18); { - this.state = 4990; - this.match(PostgreSQLParser.COMMENT); - this.state = 4991; - this.match(PostgreSQLParser.ON); - this.state = 4992; - this.match(PostgreSQLParser.CAST); - this.state = 4993; + this.state = 5049; + this.match(PostgreSQLParser.KW_COMMENT); + this.state = 5050; + this.match(PostgreSQLParser.KW_ON); + this.state = 5051; + this.match(PostgreSQLParser.KW_CAST); + this.state = 5052; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 4994; + this.state = 5053; this.typename(); - this.state = 4995; - this.match(PostgreSQLParser.AS); - this.state = 4996; + this.state = 5054; + this.match(PostgreSQLParser.KW_AS); + this.state = 5055; this.typename(); - this.state = 4997; + this.state = 5056; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 4998; - this.match(PostgreSQLParser.IS); - this.state = 4999; + this.state = 5057; + this.match(PostgreSQLParser.KW_IS); + this.state = 5058; this.comment_text(); } break; @@ -23263,9 +24007,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public comment_text(): Comment_textContext { let _localctx: Comment_textContext = new Comment_textContext(this._ctx, this.state); - this.enterRule(_localctx, 534, PostgreSQLParser.RULE_comment_text); + this.enterRule(_localctx, 542, PostgreSQLParser.RULE_comment_text); try { - this.state = 5005; + this.state = 5064; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: @@ -23274,15 +24018,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 5003; + this.state = 5062; this.sconst(); } break; - case PostgreSQLParser.NULL_P: + case PostgreSQLParser.KW_NULL: this.enterOuterAlt(_localctx, 2); { - this.state = 5004; - this.match(PostgreSQLParser.NULL_P); + this.state = 5063; + this.match(PostgreSQLParser.KW_NULL); } break; default: @@ -23306,38 +24050,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public seclabelstmt(): SeclabelstmtContext { let _localctx: SeclabelstmtContext = new SeclabelstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 536, PostgreSQLParser.RULE_seclabelstmt); + this.enterRule(_localctx, 544, PostgreSQLParser.RULE_seclabelstmt); let _la: number; try { - this.state = 5118; + this.state = 5177; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 392, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 401, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5007; - this.match(PostgreSQLParser.SECURITY); - this.state = 5008; - this.match(PostgreSQLParser.LABEL); - this.state = 5010; + this.state = 5066; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5067; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5069; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5009; + this.state = 5068; this.opt_provider(); } } - this.state = 5012; - this.match(PostgreSQLParser.ON); - this.state = 5013; + this.state = 5071; + this.match(PostgreSQLParser.KW_ON); + this.state = 5072; this.object_type_any_name(); - this.state = 5014; + this.state = 5073; this.any_name(); - this.state = 5015; - this.match(PostgreSQLParser.IS); - this.state = 5016; + this.state = 5074; + this.match(PostgreSQLParser.KW_IS); + this.state = 5075; this.security_label(); } break; @@ -23345,29 +24089,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5018; - this.match(PostgreSQLParser.SECURITY); - this.state = 5019; - this.match(PostgreSQLParser.LABEL); - this.state = 5021; + this.state = 5077; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5078; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5080; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5020; + this.state = 5079; this.opt_provider(); } } - this.state = 5023; - this.match(PostgreSQLParser.ON); - this.state = 5024; - this.match(PostgreSQLParser.COLUMN); - this.state = 5025; + this.state = 5082; + this.match(PostgreSQLParser.KW_ON); + this.state = 5083; + this.match(PostgreSQLParser.KW_COLUMN); + this.state = 5084; this.any_name(); - this.state = 5026; - this.match(PostgreSQLParser.IS); - this.state = 5027; + this.state = 5085; + this.match(PostgreSQLParser.KW_IS); + this.state = 5086; this.security_label(); } break; @@ -23375,29 +24119,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5029; - this.match(PostgreSQLParser.SECURITY); - this.state = 5030; - this.match(PostgreSQLParser.LABEL); - this.state = 5032; + this.state = 5088; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5089; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5091; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5031; + this.state = 5090; this.opt_provider(); } } - this.state = 5034; - this.match(PostgreSQLParser.ON); - this.state = 5035; + this.state = 5093; + this.match(PostgreSQLParser.KW_ON); + this.state = 5094; this.object_type_name(); - this.state = 5036; + this.state = 5095; this.name(); - this.state = 5037; - this.match(PostgreSQLParser.IS); - this.state = 5038; + this.state = 5096; + this.match(PostgreSQLParser.KW_IS); + this.state = 5097; this.security_label(); } break; @@ -23405,29 +24149,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 5040; - this.match(PostgreSQLParser.SECURITY); - this.state = 5041; - this.match(PostgreSQLParser.LABEL); - this.state = 5043; + this.state = 5099; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5100; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5102; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5042; + this.state = 5101; this.opt_provider(); } } - this.state = 5045; - this.match(PostgreSQLParser.ON); - this.state = 5046; - this.match(PostgreSQLParser.TYPE_P); - this.state = 5047; + this.state = 5104; + this.match(PostgreSQLParser.KW_ON); + this.state = 5105; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 5106; this.typename(); - this.state = 5048; - this.match(PostgreSQLParser.IS); - this.state = 5049; + this.state = 5107; + this.match(PostgreSQLParser.KW_IS); + this.state = 5108; this.security_label(); } break; @@ -23435,29 +24179,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 5051; - this.match(PostgreSQLParser.SECURITY); - this.state = 5052; - this.match(PostgreSQLParser.LABEL); - this.state = 5054; + this.state = 5110; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5111; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5113; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5053; + this.state = 5112; this.opt_provider(); } } - this.state = 5056; - this.match(PostgreSQLParser.ON); - this.state = 5057; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 5058; + this.state = 5115; + this.match(PostgreSQLParser.KW_ON); + this.state = 5116; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 5117; this.typename(); - this.state = 5059; - this.match(PostgreSQLParser.IS); - this.state = 5060; + this.state = 5118; + this.match(PostgreSQLParser.KW_IS); + this.state = 5119; this.security_label(); } break; @@ -23465,29 +24209,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 5062; - this.match(PostgreSQLParser.SECURITY); - this.state = 5063; - this.match(PostgreSQLParser.LABEL); - this.state = 5065; + this.state = 5121; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5122; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5124; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5064; + this.state = 5123; this.opt_provider(); } } - this.state = 5067; - this.match(PostgreSQLParser.ON); - this.state = 5068; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 5069; + this.state = 5126; + this.match(PostgreSQLParser.KW_ON); + this.state = 5127; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 5128; this.aggregate_with_argtypes(); - this.state = 5070; - this.match(PostgreSQLParser.IS); - this.state = 5071; + this.state = 5129; + this.match(PostgreSQLParser.KW_IS); + this.state = 5130; this.security_label(); } break; @@ -23495,29 +24239,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 5073; - this.match(PostgreSQLParser.SECURITY); - this.state = 5074; - this.match(PostgreSQLParser.LABEL); - this.state = 5076; + this.state = 5132; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5133; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5135; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5075; + this.state = 5134; this.opt_provider(); } } - this.state = 5078; - this.match(PostgreSQLParser.ON); - this.state = 5079; - this.match(PostgreSQLParser.FUNCTION); - this.state = 5080; + this.state = 5137; + this.match(PostgreSQLParser.KW_ON); + this.state = 5138; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 5139; this.function_with_argtypes(); - this.state = 5081; - this.match(PostgreSQLParser.IS); - this.state = 5082; + this.state = 5140; + this.match(PostgreSQLParser.KW_IS); + this.state = 5141; this.security_label(); } break; @@ -23525,31 +24269,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 5084; - this.match(PostgreSQLParser.SECURITY); - this.state = 5085; - this.match(PostgreSQLParser.LABEL); - this.state = 5087; + this.state = 5143; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5144; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5146; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5086; + this.state = 5145; this.opt_provider(); } } - this.state = 5089; - this.match(PostgreSQLParser.ON); - this.state = 5090; - this.match(PostgreSQLParser.LARGE_P); - this.state = 5091; - this.match(PostgreSQLParser.OBJECT_P); - this.state = 5092; + this.state = 5148; + this.match(PostgreSQLParser.KW_ON); + this.state = 5149; + this.match(PostgreSQLParser.KW_LARGE); + this.state = 5150; + this.match(PostgreSQLParser.KW_OBJECT); + this.state = 5151; this.numericonly(); - this.state = 5093; - this.match(PostgreSQLParser.IS); - this.state = 5094; + this.state = 5152; + this.match(PostgreSQLParser.KW_IS); + this.state = 5153; this.security_label(); } break; @@ -23557,29 +24301,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 5096; - this.match(PostgreSQLParser.SECURITY); - this.state = 5097; - this.match(PostgreSQLParser.LABEL); - this.state = 5099; + this.state = 5155; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5156; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5158; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5098; + this.state = 5157; this.opt_provider(); } } - this.state = 5101; - this.match(PostgreSQLParser.ON); - this.state = 5102; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 5103; + this.state = 5160; + this.match(PostgreSQLParser.KW_ON); + this.state = 5161; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 5162; this.function_with_argtypes(); - this.state = 5104; - this.match(PostgreSQLParser.IS); - this.state = 5105; + this.state = 5163; + this.match(PostgreSQLParser.KW_IS); + this.state = 5164; this.security_label(); } break; @@ -23587,29 +24331,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 5107; - this.match(PostgreSQLParser.SECURITY); - this.state = 5108; - this.match(PostgreSQLParser.LABEL); - this.state = 5110; + this.state = 5166; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5167; + this.match(PostgreSQLParser.KW_LABEL); + this.state = 5169; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 5109; + this.state = 5168; this.opt_provider(); } } - this.state = 5112; - this.match(PostgreSQLParser.ON); - this.state = 5113; - this.match(PostgreSQLParser.ROUTINE); - this.state = 5114; + this.state = 5171; + this.match(PostgreSQLParser.KW_ON); + this.state = 5172; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 5173; this.function_with_argtypes(); - this.state = 5115; - this.match(PostgreSQLParser.IS); - this.state = 5116; + this.state = 5174; + this.match(PostgreSQLParser.KW_IS); + this.state = 5175; this.security_label(); } break; @@ -23632,13 +24376,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_provider(): Opt_providerContext { let _localctx: Opt_providerContext = new Opt_providerContext(this._ctx, this.state); - this.enterRule(_localctx, 538, PostgreSQLParser.RULE_opt_provider); + this.enterRule(_localctx, 546, PostgreSQLParser.RULE_opt_provider); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5120; - this.match(PostgreSQLParser.FOR); - this.state = 5121; + this.state = 5179; + this.match(PostgreSQLParser.KW_FOR); + this.state = 5180; this.nonreservedword_or_sconst(); } } @@ -23659,9 +24403,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public security_label(): Security_labelContext { let _localctx: Security_labelContext = new Security_labelContext(this._ctx, this.state); - this.enterRule(_localctx, 540, PostgreSQLParser.RULE_security_label); + this.enterRule(_localctx, 548, PostgreSQLParser.RULE_security_label); try { - this.state = 5125; + this.state = 5184; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: @@ -23670,15 +24414,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 5123; + this.state = 5182; this.sconst(); } break; - case PostgreSQLParser.NULL_P: + case PostgreSQLParser.KW_NULL: this.enterOuterAlt(_localctx, 2); { - this.state = 5124; - this.match(PostgreSQLParser.NULL_P); + this.state = 5183; + this.match(PostgreSQLParser.KW_NULL); } break; default: @@ -23702,26 +24446,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public fetchstmt(): FetchstmtContext { let _localctx: FetchstmtContext = new FetchstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 542, PostgreSQLParser.RULE_fetchstmt); + this.enterRule(_localctx, 550, PostgreSQLParser.RULE_fetchstmt); try { - this.state = 5131; + this.state = 5190; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.FETCH: + case PostgreSQLParser.KW_FETCH: this.enterOuterAlt(_localctx, 1); { - this.state = 5127; - this.match(PostgreSQLParser.FETCH); - this.state = 5128; + this.state = 5186; + this.match(PostgreSQLParser.KW_FETCH); + this.state = 5187; this.fetch_args(); } break; - case PostgreSQLParser.MOVE: + case PostgreSQLParser.KW_MOVE: this.enterOuterAlt(_localctx, 2); { - this.state = 5129; - this.match(PostgreSQLParser.MOVE); - this.state = 5130; + this.state = 5188; + this.match(PostgreSQLParser.KW_MOVE); + this.state = 5189; this.fetch_args(); } break; @@ -23746,16 +24490,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public fetch_args(): Fetch_argsContext { let _localctx: Fetch_argsContext = new Fetch_argsContext(this._ctx, this.state); - this.enterRule(_localctx, 544, PostgreSQLParser.RULE_fetch_args); + this.enterRule(_localctx, 552, PostgreSQLParser.RULE_fetch_args); let _la: number; try { - this.state = 5218; + this.state = 5277; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 409, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 418, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5133; + this.state = 5192; this.cursor_name(); } break; @@ -23763,9 +24507,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5134; + this.state = 5193; this.from_in(); - this.state = 5135; + this.state = 5194; this.cursor_name(); } break; @@ -23773,19 +24517,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5137; - this.match(PostgreSQLParser.NEXT); - this.state = 5139; + this.state = 5196; + this.match(PostgreSQLParser.KW_NEXT); + this.state = 5198; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { { - this.state = 5138; + this.state = 5197; this.opt_from_in(); } } - this.state = 5141; + this.state = 5200; this.cursor_name(); } break; @@ -23793,19 +24537,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 5142; - this.match(PostgreSQLParser.PRIOR); - this.state = 5144; + this.state = 5201; + this.match(PostgreSQLParser.KW_PRIOR); + this.state = 5203; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { { - this.state = 5143; + this.state = 5202; this.opt_from_in(); } } - this.state = 5146; + this.state = 5205; this.cursor_name(); } break; @@ -23813,222 +24557,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 5147; - this.match(PostgreSQLParser.FIRST_P); - this.state = 5149; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5148; - this.opt_from_in(); - } - } - - this.state = 5151; - this.cursor_name(); - } - break; - - case 6: - this.enterOuterAlt(_localctx, 6); - { - this.state = 5152; - this.match(PostgreSQLParser.LAST_P); - this.state = 5154; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5153; - this.opt_from_in(); - } - } - - this.state = 5156; - this.cursor_name(); - } - break; - - case 7: - this.enterOuterAlt(_localctx, 7); - { - this.state = 5157; - this.match(PostgreSQLParser.ABSOLUTE_P); - this.state = 5158; - this.signediconst(); - this.state = 5160; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5159; - this.opt_from_in(); - } - } - - this.state = 5162; - this.cursor_name(); - } - break; - - case 8: - this.enterOuterAlt(_localctx, 8); - { - this.state = 5164; - this.match(PostgreSQLParser.RELATIVE_P); - this.state = 5165; - this.signediconst(); - this.state = 5167; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5166; - this.opt_from_in(); - } - } - - this.state = 5169; - this.cursor_name(); - } - break; - - case 9: - this.enterOuterAlt(_localctx, 9); - { - this.state = 5171; - this.signediconst(); - this.state = 5173; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5172; - this.opt_from_in(); - } - } - - this.state = 5175; - this.cursor_name(); - } - break; - - case 10: - this.enterOuterAlt(_localctx, 10); - { - this.state = 5177; - this.match(PostgreSQLParser.ALL); - this.state = 5179; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5178; - this.opt_from_in(); - } - } - - this.state = 5181; - this.cursor_name(); - } - break; - - case 11: - this.enterOuterAlt(_localctx, 11); - { - this.state = 5182; - this.match(PostgreSQLParser.FORWARD); - this.state = 5184; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5183; - this.opt_from_in(); - } - } - - this.state = 5186; - this.cursor_name(); - } - break; - - case 12: - this.enterOuterAlt(_localctx, 12); - { - this.state = 5187; - this.match(PostgreSQLParser.FORWARD); - this.state = 5188; - this.signediconst(); - this.state = 5190; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5189; - this.opt_from_in(); - } - } - - this.state = 5192; - this.cursor_name(); - } - break; - - case 13: - this.enterOuterAlt(_localctx, 13); - { - this.state = 5194; - this.match(PostgreSQLParser.FORWARD); - this.state = 5195; - this.match(PostgreSQLParser.ALL); - this.state = 5197; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5196; - this.opt_from_in(); - } - } - - this.state = 5199; - this.cursor_name(); - } - break; - - case 14: - this.enterOuterAlt(_localctx, 14); - { - this.state = 5200; - this.match(PostgreSQLParser.BACKWARD); - this.state = 5202; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { - { - this.state = 5201; - this.opt_from_in(); - } - } - - this.state = 5204; - this.cursor_name(); - } - break; - - case 15: - this.enterOuterAlt(_localctx, 15); - { - this.state = 5205; - this.match(PostgreSQLParser.BACKWARD); this.state = 5206; - this.signediconst(); + this.match(PostgreSQLParser.KW_FIRST); this.state = 5208; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { { this.state = 5207; this.opt_from_in(); @@ -24040,24 +24574,234 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } break; - case 16: - this.enterOuterAlt(_localctx, 16); + case 6: + this.enterOuterAlt(_localctx, 6); { - this.state = 5212; - this.match(PostgreSQLParser.BACKWARD); + this.state = 5211; + this.match(PostgreSQLParser.KW_LAST); this.state = 5213; - this.match(PostgreSQLParser.ALL); - this.state = 5215; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P) { + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { { - this.state = 5214; + this.state = 5212; this.opt_from_in(); } } + this.state = 5215; + this.cursor_name(); + } + break; + + case 7: + this.enterOuterAlt(_localctx, 7); + { + this.state = 5216; + this.match(PostgreSQLParser.KW_ABSOLUTE); this.state = 5217; + this.signediconst(); + this.state = 5219; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5218; + this.opt_from_in(); + } + } + + this.state = 5221; + this.cursor_name(); + } + break; + + case 8: + this.enterOuterAlt(_localctx, 8); + { + this.state = 5223; + this.match(PostgreSQLParser.KW_RELATIVE); + this.state = 5224; + this.signediconst(); + this.state = 5226; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5225; + this.opt_from_in(); + } + } + + this.state = 5228; + this.cursor_name(); + } + break; + + case 9: + this.enterOuterAlt(_localctx, 9); + { + this.state = 5230; + this.signediconst(); + this.state = 5232; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5231; + this.opt_from_in(); + } + } + + this.state = 5234; + this.cursor_name(); + } + break; + + case 10: + this.enterOuterAlt(_localctx, 10); + { + this.state = 5236; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5238; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5237; + this.opt_from_in(); + } + } + + this.state = 5240; + this.cursor_name(); + } + break; + + case 11: + this.enterOuterAlt(_localctx, 11); + { + this.state = 5241; + this.match(PostgreSQLParser.KW_FORWARD); + this.state = 5243; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5242; + this.opt_from_in(); + } + } + + this.state = 5245; + this.cursor_name(); + } + break; + + case 12: + this.enterOuterAlt(_localctx, 12); + { + this.state = 5246; + this.match(PostgreSQLParser.KW_FORWARD); + this.state = 5247; + this.signediconst(); + this.state = 5249; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5248; + this.opt_from_in(); + } + } + + this.state = 5251; + this.cursor_name(); + } + break; + + case 13: + this.enterOuterAlt(_localctx, 13); + { + this.state = 5253; + this.match(PostgreSQLParser.KW_FORWARD); + this.state = 5254; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5256; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5255; + this.opt_from_in(); + } + } + + this.state = 5258; + this.cursor_name(); + } + break; + + case 14: + this.enterOuterAlt(_localctx, 14); + { + this.state = 5259; + this.match(PostgreSQLParser.KW_BACKWARD); + this.state = 5261; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5260; + this.opt_from_in(); + } + } + + this.state = 5263; + this.cursor_name(); + } + break; + + case 15: + this.enterOuterAlt(_localctx, 15); + { + this.state = 5264; + this.match(PostgreSQLParser.KW_BACKWARD); + this.state = 5265; + this.signediconst(); + this.state = 5267; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5266; + this.opt_from_in(); + } + } + + this.state = 5269; + this.cursor_name(); + } + break; + + case 16: + this.enterOuterAlt(_localctx, 16); + { + this.state = 5271; + this.match(PostgreSQLParser.KW_BACKWARD); + this.state = 5272; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5274; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN) { + { + this.state = 5273; + this.opt_from_in(); + } + } + + this.state = 5276; this.cursor_name(); } break; @@ -24080,14 +24824,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public from_in(): From_inContext { let _localctx: From_inContext = new From_inContext(this._ctx, this.state); - this.enterRule(_localctx, 546, PostgreSQLParser.RULE_from_in); + this.enterRule(_localctx, 554, PostgreSQLParser.RULE_from_in); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5220; + this.state = 5279; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FROM || _la === PostgreSQLParser.IN_P)) { + if (!(_la === PostgreSQLParser.KW_FROM || _la === PostgreSQLParser.KW_IN)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -24116,11 +24860,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_from_in(): Opt_from_inContext { let _localctx: Opt_from_inContext = new Opt_from_inContext(this._ctx, this.state); - this.enterRule(_localctx, 548, PostgreSQLParser.RULE_opt_from_in); + this.enterRule(_localctx, 556, PostgreSQLParser.RULE_opt_from_in); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5222; + this.state = 5281; this.from_in(); } } @@ -24141,28 +24885,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public grantstmt(): GrantstmtContext { let _localctx: GrantstmtContext = new GrantstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 550, PostgreSQLParser.RULE_grantstmt); + this.enterRule(_localctx, 558, PostgreSQLParser.RULE_grantstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5224; - this.match(PostgreSQLParser.GRANT); - this.state = 5225; + this.state = 5283; + this.match(PostgreSQLParser.KW_GRANT); + this.state = 5284; this.privileges(); - this.state = 5226; - this.match(PostgreSQLParser.ON); - this.state = 5227; + this.state = 5285; + this.match(PostgreSQLParser.KW_ON); + this.state = 5286; this.privilege_target(); - this.state = 5228; - this.match(PostgreSQLParser.TO); - this.state = 5229; + this.state = 5287; + this.match(PostgreSQLParser.KW_TO); + this.state = 5288; this.grantee_list(); - this.state = 5231; + this.state = 5290; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 410, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 419, this._ctx) ) { case 1: { - this.state = 5230; + this.state = 5289; this.opt_grant_grant_option(); } break; @@ -24186,33 +24930,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public revokestmt(): RevokestmtContext { let _localctx: RevokestmtContext = new RevokestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 552, PostgreSQLParser.RULE_revokestmt); + this.enterRule(_localctx, 560, PostgreSQLParser.RULE_revokestmt); let _la: number; try { - this.state = 5254; + this.state = 5313; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 413, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 422, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5233; - this.match(PostgreSQLParser.REVOKE); - this.state = 5234; + this.state = 5292; + this.match(PostgreSQLParser.KW_REVOKE); + this.state = 5293; this.privileges(); - this.state = 5235; - this.match(PostgreSQLParser.ON); - this.state = 5236; + this.state = 5294; + this.match(PostgreSQLParser.KW_ON); + this.state = 5295; this.privilege_target(); - this.state = 5237; - this.match(PostgreSQLParser.FROM); - this.state = 5238; + this.state = 5296; + this.match(PostgreSQLParser.KW_FROM); + this.state = 5297; this.grantee_list(); - this.state = 5240; + this.state = 5299; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5239; + this.state = 5298; this.opt_drop_behavior(); } } @@ -24223,30 +24967,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5242; - this.match(PostgreSQLParser.REVOKE); - this.state = 5243; - this.match(PostgreSQLParser.GRANT); - this.state = 5244; - this.match(PostgreSQLParser.OPTION); - this.state = 5245; - this.match(PostgreSQLParser.FOR); - this.state = 5246; + this.state = 5301; + this.match(PostgreSQLParser.KW_REVOKE); + this.state = 5302; + this.match(PostgreSQLParser.KW_GRANT); + this.state = 5303; + this.match(PostgreSQLParser.KW_OPTION); + this.state = 5304; + this.match(PostgreSQLParser.KW_FOR); + this.state = 5305; this.privileges(); - this.state = 5247; - this.match(PostgreSQLParser.ON); - this.state = 5248; + this.state = 5306; + this.match(PostgreSQLParser.KW_ON); + this.state = 5307; this.privilege_target(); - this.state = 5249; - this.match(PostgreSQLParser.FROM); - this.state = 5250; + this.state = 5308; + this.match(PostgreSQLParser.KW_FROM); + this.state = 5309; this.grantee_list(); - this.state = 5252; + this.state = 5311; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5251; + this.state = 5310; this.opt_drop_behavior(); } } @@ -24272,15 +25016,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public privileges(): PrivilegesContext { let _localctx: PrivilegesContext = new PrivilegesContext(this._ctx, this.state); - this.enterRule(_localctx, 554, PostgreSQLParser.RULE_privileges); + this.enterRule(_localctx, 562, PostgreSQLParser.RULE_privileges); try { - this.state = 5271; + this.state = 5331; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 414, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 423, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5256; + this.state = 5315; this.privilege_list(); } break; @@ -24288,31 +25032,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5257; - this.match(PostgreSQLParser.ALL); + this.state = 5316; + this.match(PostgreSQLParser.KW_ALL); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5258; - this.match(PostgreSQLParser.ALL); - this.state = 5259; - this.match(PostgreSQLParser.PRIVILEGES); + this.state = 5317; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5318; + this.match(PostgreSQLParser.KW_PRIVILEGES); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 5260; - this.match(PostgreSQLParser.ALL); - this.state = 5261; + this.state = 5319; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5320; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5262; + this.state = 5321; this.columnlist(); - this.state = 5263; + this.state = 5322; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -24320,18 +25064,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 5265; - this.match(PostgreSQLParser.ALL); - this.state = 5266; - this.match(PostgreSQLParser.PRIVILEGES); - this.state = 5267; + this.state = 5324; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5325; + this.match(PostgreSQLParser.KW_PRIVILEGES); + this.state = 5326; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5268; + this.state = 5327; this.columnlist(); - this.state = 5269; + this.state = 5328; this.match(PostgreSQLParser.CLOSE_PAREN); } break; + + case 6: + this.enterOuterAlt(_localctx, 6); + { + this.state = 5330; + this.beforeprivilegeselectlist(); + } + break; } } catch (re) { @@ -24349,28 +25101,106 @@ export class PostgreSQLParser extends PostgreSQLParserBase { return _localctx; } // @RuleVersion(0) - public privilege_list(): Privilege_listContext { - let _localctx: Privilege_listContext = new Privilege_listContext(this._ctx, this.state); - this.enterRule(_localctx, 556, PostgreSQLParser.RULE_privilege_list); + public beforeprivilegeselectlist(): BeforeprivilegeselectlistContext { + let _localctx: BeforeprivilegeselectlistContext = new BeforeprivilegeselectlistContext(this._ctx, this.state); + this.enterRule(_localctx, 564, PostgreSQLParser.RULE_beforeprivilegeselectlist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5273; - this.privilege(); - this.state = 5278; + this.state = 5333; + this.beforeprivilegeselect(); + this.state = 5338; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5274; + this.state = 5334; this.match(PostgreSQLParser.COMMA); - this.state = 5275; + this.state = 5335; + this.beforeprivilegeselect(); + } + } + this.state = 5340; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public beforeprivilegeselect(): BeforeprivilegeselectContext { + let _localctx: BeforeprivilegeselectContext = new BeforeprivilegeselectContext(this._ctx, this.state); + this.enterRule(_localctx, 566, PostgreSQLParser.RULE_beforeprivilegeselect); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 5341; + _la = this._input.LA(1); + if (!(_la === PostgreSQLParser.KW_CREATE || _la === PostgreSQLParser.KW_SELECT || _la === PostgreSQLParser.KW_DELETE || _la === PostgreSQLParser.KW_EXECUTE || _la === PostgreSQLParser.KW_INSERT || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & ((1 << (PostgreSQLParser.KW_TEMP - 352)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 352)) | (1 << (PostgreSQLParser.KW_TRIGGER - 352)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 352)) | (1 << (PostgreSQLParser.KW_UPDATE - 352)))) !== 0) || ((((_la - 521)) & ~0x1F) === 0 && ((1 << (_la - 521)) & ((1 << (PostgreSQLParser.KW_PEFERENCES - 521)) | (1 << (PostgreSQLParser.KW_USAGE - 521)) | (1 << (PostgreSQLParser.KW_CONNECT - 521)))) !== 0))) { + this._errHandler.recoverInline(this); + } else { + if (this._input.LA(1) === Token.EOF) { + this.matchedEOF = true; + } + + this._errHandler.reportMatch(this); + this.consume(); + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public privilege_list(): Privilege_listContext { + let _localctx: Privilege_listContext = new Privilege_listContext(this._ctx, this.state); + this.enterRule(_localctx, 568, PostgreSQLParser.RULE_privilege_list); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 5343; + this.privilege(); + this.state = 5348; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === PostgreSQLParser.COMMA) { + { + { + this.state = 5344; + this.match(PostgreSQLParser.COMMA); + this.state = 5345; this.privilege(); } } - this.state = 5280; + this.state = 5350; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -24393,453 +25223,453 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public privilege(): PrivilegeContext { let _localctx: PrivilegeContext = new PrivilegeContext(this._ctx, this.state); - this.enterRule(_localctx, 558, PostgreSQLParser.RULE_privilege); + this.enterRule(_localctx, 570, PostgreSQLParser.RULE_privilege); let _la: number; try { - this.state = 5297; + this.state = 5367; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.SELECT: + case PostgreSQLParser.KW_SELECT: this.enterOuterAlt(_localctx, 1); { - this.state = 5281; - this.match(PostgreSQLParser.SELECT); - this.state = 5283; + this.state = 5351; + this.match(PostgreSQLParser.KW_SELECT); + this.state = 5353; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 5282; + this.state = 5352; this.opt_column_list(); } } } break; - case PostgreSQLParser.REFERENCES: + case PostgreSQLParser.KW_REFERENCES: this.enterOuterAlt(_localctx, 2); { - this.state = 5285; - this.match(PostgreSQLParser.REFERENCES); - this.state = 5287; + this.state = 5355; + this.match(PostgreSQLParser.KW_REFERENCES); + this.state = 5357; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 5286; + this.state = 5356; this.opt_column_list(); } } } break; - case PostgreSQLParser.CREATE: + case PostgreSQLParser.KW_CREATE: this.enterOuterAlt(_localctx, 3); { - this.state = 5289; - this.match(PostgreSQLParser.CREATE); - this.state = 5291; + this.state = 5359; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 5361; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 5290; + this.state = 5360; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -24847,14 +25677,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 4); { - this.state = 5293; + this.state = 5363; this.colid(); - this.state = 5295; + this.state = 5365; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 5294; + this.state = 5364; this.opt_column_list(); } } @@ -24882,15 +25712,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public privilege_target(): Privilege_targetContext { let _localctx: Privilege_targetContext = new Privilege_targetContext(this._ctx, this.state); - this.enterRule(_localctx, 560, PostgreSQLParser.RULE_privilege_target); + this.enterRule(_localctx, 572, PostgreSQLParser.RULE_privilege_target); try { - this.state = 5357; + this.state = 5427; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 421, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 431, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5299; + this.state = 5369; this.qualified_name_list(); } break; @@ -24898,9 +25728,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5300; - this.match(PostgreSQLParser.TABLE); - this.state = 5301; + this.state = 5370; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 5371; this.qualified_name_list(); } break; @@ -24908,9 +25738,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5302; - this.match(PostgreSQLParser.SEQUENCE); - this.state = 5303; + this.state = 5372; + this.match(PostgreSQLParser.KW_SEQUENCE); + this.state = 5373; this.qualified_name_list(); } break; @@ -24918,13 +25748,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 5304; - this.match(PostgreSQLParser.FOREIGN); - this.state = 5305; - this.match(PostgreSQLParser.DATA_P); - this.state = 5306; - this.match(PostgreSQLParser.WRAPPER); - this.state = 5307; + this.state = 5374; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 5375; + this.match(PostgreSQLParser.KW_DATA); + this.state = 5376; + this.match(PostgreSQLParser.KW_WRAPPER); + this.state = 5377; this.name_list(); } break; @@ -24932,11 +25762,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 5308; - this.match(PostgreSQLParser.FOREIGN); - this.state = 5309; - this.match(PostgreSQLParser.SERVER); - this.state = 5310; + this.state = 5378; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 5379; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 5380; this.name_list(); } break; @@ -24944,9 +25774,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 5311; - this.match(PostgreSQLParser.FUNCTION); - this.state = 5312; + this.state = 5381; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 5382; this.function_with_argtypes_list(); } break; @@ -24954,9 +25784,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 5313; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 5314; + this.state = 5383; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 5384; this.function_with_argtypes_list(); } break; @@ -24964,9 +25794,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 5315; - this.match(PostgreSQLParser.ROUTINE); - this.state = 5316; + this.state = 5385; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 5386; this.function_with_argtypes_list(); } break; @@ -24974,9 +25804,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 5317; - this.match(PostgreSQLParser.DATABASE); - this.state = 5318; + this.state = 5387; + this.match(PostgreSQLParser.KW_DATABASE); + this.state = 5388; this.name_list(); } break; @@ -24984,9 +25814,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 5319; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 5320; + this.state = 5389; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 5390; this.any_name_list(); } break; @@ -24994,9 +25824,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 5321; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 5322; + this.state = 5391; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 5392; this.name_list(); } break; @@ -25004,11 +25834,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 5323; - this.match(PostgreSQLParser.LARGE_P); - this.state = 5324; - this.match(PostgreSQLParser.OBJECT_P); - this.state = 5325; + this.state = 5393; + this.match(PostgreSQLParser.KW_LARGE); + this.state = 5394; + this.match(PostgreSQLParser.KW_OBJECT); + this.state = 5395; this.numericonly_list(); } break; @@ -25016,9 +25846,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 5326; - this.match(PostgreSQLParser.SCHEMA); - this.state = 5327; + this.state = 5396; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 5397; this.name_list(); } break; @@ -25026,9 +25856,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 5328; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 5329; + this.state = 5398; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 5399; this.name_list(); } break; @@ -25036,9 +25866,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 5330; - this.match(PostgreSQLParser.TYPE_P); - this.state = 5331; + this.state = 5400; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 5401; this.any_name_list(); } break; @@ -25046,15 +25876,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 5332; - this.match(PostgreSQLParser.ALL); - this.state = 5333; - this.match(PostgreSQLParser.TABLES); - this.state = 5334; - this.match(PostgreSQLParser.IN_P); - this.state = 5335; - this.match(PostgreSQLParser.SCHEMA); - this.state = 5336; + this.state = 5402; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5403; + this.match(PostgreSQLParser.KW_TABLES); + this.state = 5404; + this.match(PostgreSQLParser.KW_IN); + this.state = 5405; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 5406; this.name_list(); } break; @@ -25062,15 +25892,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 5337; - this.match(PostgreSQLParser.ALL); - this.state = 5338; - this.match(PostgreSQLParser.SEQUENCES); - this.state = 5339; - this.match(PostgreSQLParser.IN_P); - this.state = 5340; - this.match(PostgreSQLParser.SCHEMA); - this.state = 5341; + this.state = 5407; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5408; + this.match(PostgreSQLParser.KW_SEQUENCES); + this.state = 5409; + this.match(PostgreSQLParser.KW_IN); + this.state = 5410; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 5411; this.name_list(); } break; @@ -25078,15 +25908,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 18: this.enterOuterAlt(_localctx, 18); { - this.state = 5342; - this.match(PostgreSQLParser.ALL); - this.state = 5343; - this.match(PostgreSQLParser.FUNCTIONS); - this.state = 5344; - this.match(PostgreSQLParser.IN_P); - this.state = 5345; - this.match(PostgreSQLParser.SCHEMA); - this.state = 5346; + this.state = 5412; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5413; + this.match(PostgreSQLParser.KW_FUNCTIONS); + this.state = 5414; + this.match(PostgreSQLParser.KW_IN); + this.state = 5415; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 5416; this.name_list(); } break; @@ -25094,15 +25924,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 19: this.enterOuterAlt(_localctx, 19); { - this.state = 5347; - this.match(PostgreSQLParser.ALL); - this.state = 5348; - this.match(PostgreSQLParser.PROCEDURES); - this.state = 5349; - this.match(PostgreSQLParser.IN_P); - this.state = 5350; - this.match(PostgreSQLParser.SCHEMA); - this.state = 5351; + this.state = 5417; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5418; + this.match(PostgreSQLParser.KW_PROCEDURES); + this.state = 5419; + this.match(PostgreSQLParser.KW_IN); + this.state = 5420; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 5421; this.name_list(); } break; @@ -25110,15 +25940,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 20: this.enterOuterAlt(_localctx, 20); { - this.state = 5352; - this.match(PostgreSQLParser.ALL); - this.state = 5353; - this.match(PostgreSQLParser.ROUTINES); - this.state = 5354; - this.match(PostgreSQLParser.IN_P); - this.state = 5355; - this.match(PostgreSQLParser.SCHEMA); - this.state = 5356; + this.state = 5422; + this.match(PostgreSQLParser.KW_ALL); + this.state = 5423; + this.match(PostgreSQLParser.KW_ROUTINES); + this.state = 5424; + this.match(PostgreSQLParser.KW_IN); + this.state = 5425; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 5426; this.name_list(); } break; @@ -25141,26 +25971,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public grantee_list(): Grantee_listContext { let _localctx: Grantee_listContext = new Grantee_listContext(this._ctx, this.state); - this.enterRule(_localctx, 562, PostgreSQLParser.RULE_grantee_list); + this.enterRule(_localctx, 574, PostgreSQLParser.RULE_grantee_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5359; + this.state = 5429; this.grantee(); - this.state = 5364; + this.state = 5434; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5360; + this.state = 5430; this.match(PostgreSQLParser.COMMA); - this.state = 5361; + this.state = 5431; this.grantee(); } } - this.state = 5366; + this.state = 5436; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -25183,424 +26013,425 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public grantee(): GranteeContext { let _localctx: GranteeContext = new GranteeContext(this._ctx, this.state); - this.enterRule(_localctx, 564, PostgreSQLParser.RULE_grantee); + this.enterRule(_localctx, 576, PostgreSQLParser.RULE_grantee); try { - this.state = 5370; + this.state = 5440; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: + case PostgreSQLParser.KW_PUBLIC: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -25608,16 +26439,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 5367; + this.state = 5437; this.rolespec(); } break; - case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.KW_GROUP: this.enterOuterAlt(_localctx, 2); { - this.state = 5368; - this.match(PostgreSQLParser.GROUP_P); - this.state = 5369; + this.state = 5438; + this.match(PostgreSQLParser.KW_GROUP); + this.state = 5439; this.rolespec(); } break; @@ -25642,16 +26473,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_grant_grant_option(): Opt_grant_grant_optionContext { let _localctx: Opt_grant_grant_optionContext = new Opt_grant_grant_optionContext(this._ctx, this.state); - this.enterRule(_localctx, 566, PostgreSQLParser.RULE_opt_grant_grant_option); + this.enterRule(_localctx, 578, PostgreSQLParser.RULE_opt_grant_grant_option); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5372; - this.match(PostgreSQLParser.WITH); - this.state = 5373; - this.match(PostgreSQLParser.GRANT); - this.state = 5374; - this.match(PostgreSQLParser.OPTION); + this.state = 5442; + this.match(PostgreSQLParser.KW_WITH); + this.state = 5443; + this.match(PostgreSQLParser.KW_GRANT); + this.state = 5444; + this.match(PostgreSQLParser.KW_OPTION); } } catch (re) { @@ -25671,35 +26502,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public grantrolestmt(): GrantrolestmtContext { let _localctx: GrantrolestmtContext = new GrantrolestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 568, PostgreSQLParser.RULE_grantrolestmt); + this.enterRule(_localctx, 580, PostgreSQLParser.RULE_grantrolestmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5376; - this.match(PostgreSQLParser.GRANT); - this.state = 5377; + this.state = 5446; + this.match(PostgreSQLParser.KW_GRANT); + this.state = 5447; this.privilege_list(); - this.state = 5378; - this.match(PostgreSQLParser.TO); - this.state = 5379; + this.state = 5448; + this.match(PostgreSQLParser.KW_TO); + this.state = 5449; this.role_list(); - this.state = 5381; + this.state = 5451; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 424, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 434, this._ctx) ) { case 1: { - this.state = 5380; + this.state = 5450; this.opt_grant_admin_option(); } break; } - this.state = 5384; + this.state = 5454; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GRANTED) { + if (_la === PostgreSQLParser.KW_GRANTED) { { - this.state = 5383; + this.state = 5453; this.opt_granted_by(); } } @@ -25723,39 +26554,39 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public revokerolestmt(): RevokerolestmtContext { let _localctx: RevokerolestmtContext = new RevokerolestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 570, PostgreSQLParser.RULE_revokerolestmt); + this.enterRule(_localctx, 582, PostgreSQLParser.RULE_revokerolestmt); let _la: number; try { - this.state = 5409; + this.state = 5479; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 430, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 440, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5386; - this.match(PostgreSQLParser.REVOKE); - this.state = 5387; + this.state = 5456; + this.match(PostgreSQLParser.KW_REVOKE); + this.state = 5457; this.privilege_list(); - this.state = 5388; - this.match(PostgreSQLParser.FROM); - this.state = 5389; + this.state = 5458; + this.match(PostgreSQLParser.KW_FROM); + this.state = 5459; this.role_list(); - this.state = 5391; + this.state = 5461; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GRANTED) { + if (_la === PostgreSQLParser.KW_GRANTED) { { - this.state = 5390; + this.state = 5460; this.opt_granted_by(); } } - this.state = 5394; + this.state = 5464; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5393; + this.state = 5463; this.opt_drop_behavior(); } } @@ -25766,36 +26597,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5396; - this.match(PostgreSQLParser.REVOKE); - this.state = 5397; - this.match(PostgreSQLParser.ADMIN); - this.state = 5398; - this.match(PostgreSQLParser.OPTION); - this.state = 5399; - this.match(PostgreSQLParser.FOR); - this.state = 5400; + this.state = 5466; + this.match(PostgreSQLParser.KW_REVOKE); + this.state = 5467; + this.match(PostgreSQLParser.KW_ADMIN); + this.state = 5468; + this.match(PostgreSQLParser.KW_OPTION); + this.state = 5469; + this.match(PostgreSQLParser.KW_FOR); + this.state = 5470; this.privilege_list(); - this.state = 5401; - this.match(PostgreSQLParser.FROM); - this.state = 5402; + this.state = 5471; + this.match(PostgreSQLParser.KW_FROM); + this.state = 5472; this.role_list(); - this.state = 5404; + this.state = 5474; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GRANTED) { + if (_la === PostgreSQLParser.KW_GRANTED) { { - this.state = 5403; + this.state = 5473; this.opt_granted_by(); } } - this.state = 5407; + this.state = 5477; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5406; + this.state = 5476; this.opt_drop_behavior(); } } @@ -25821,16 +26652,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_grant_admin_option(): Opt_grant_admin_optionContext { let _localctx: Opt_grant_admin_optionContext = new Opt_grant_admin_optionContext(this._ctx, this.state); - this.enterRule(_localctx, 572, PostgreSQLParser.RULE_opt_grant_admin_option); + this.enterRule(_localctx, 584, PostgreSQLParser.RULE_opt_grant_admin_option); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5411; - this.match(PostgreSQLParser.WITH); - this.state = 5412; - this.match(PostgreSQLParser.ADMIN); - this.state = 5413; - this.match(PostgreSQLParser.OPTION); + this.state = 5481; + this.match(PostgreSQLParser.KW_WITH); + this.state = 5482; + this.match(PostgreSQLParser.KW_ADMIN); + this.state = 5483; + this.match(PostgreSQLParser.KW_OPTION); } } catch (re) { @@ -25850,15 +26681,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_granted_by(): Opt_granted_byContext { let _localctx: Opt_granted_byContext = new Opt_granted_byContext(this._ctx, this.state); - this.enterRule(_localctx, 574, PostgreSQLParser.RULE_opt_granted_by); + this.enterRule(_localctx, 586, PostgreSQLParser.RULE_opt_granted_by); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5415; - this.match(PostgreSQLParser.GRANTED); - this.state = 5416; - this.match(PostgreSQLParser.BY); - this.state = 5417; + this.state = 5485; + this.match(PostgreSQLParser.KW_GRANTED); + this.state = 5486; + this.match(PostgreSQLParser.KW_BY); + this.state = 5487; this.rolespec(); } } @@ -25879,19 +26710,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterdefaultprivilegesstmt(): AlterdefaultprivilegesstmtContext { let _localctx: AlterdefaultprivilegesstmtContext = new AlterdefaultprivilegesstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 576, PostgreSQLParser.RULE_alterdefaultprivilegesstmt); + this.enterRule(_localctx, 588, PostgreSQLParser.RULE_alterdefaultprivilegesstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5419; - this.match(PostgreSQLParser.ALTER); - this.state = 5420; - this.match(PostgreSQLParser.DEFAULT); - this.state = 5421; - this.match(PostgreSQLParser.PRIVILEGES); - this.state = 5422; + this.state = 5489; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 5490; + this.match(PostgreSQLParser.KW_DEFAULT); + this.state = 5491; + this.match(PostgreSQLParser.KW_PRIVILEGES); + this.state = 5492; this.defacloptionlist(); - this.state = 5423; + this.state = 5493; this.defaclaction(); } } @@ -25912,22 +26743,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public defacloptionlist(): DefacloptionlistContext { let _localctx: DefacloptionlistContext = new DefacloptionlistContext(this._ctx, this.state); - this.enterRule(_localctx, 578, PostgreSQLParser.RULE_defacloptionlist); + this.enterRule(_localctx, 590, PostgreSQLParser.RULE_defacloptionlist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5428; + this.state = 5498; this._errHandler.sync(this); _la = this._input.LA(1); - while (_la === PostgreSQLParser.FOR || _la === PostgreSQLParser.IN_P) { + while (_la === PostgreSQLParser.KW_FOR || _la === PostgreSQLParser.KW_IN) { { { - this.state = 5425; + this.state = 5495; this.defacloption(); } } - this.state = 5430; + this.state = 5500; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -25950,19 +26781,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public defacloption(): DefacloptionContext { let _localctx: DefacloptionContext = new DefacloptionContext(this._ctx, this.state); - this.enterRule(_localctx, 580, PostgreSQLParser.RULE_defacloption); + this.enterRule(_localctx, 592, PostgreSQLParser.RULE_defacloption); try { - this.state = 5440; + this.state = 5510; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 432, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 442, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5431; - this.match(PostgreSQLParser.IN_P); - this.state = 5432; - this.match(PostgreSQLParser.SCHEMA); - this.state = 5433; + this.state = 5501; + this.match(PostgreSQLParser.KW_IN); + this.state = 5502; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 5503; this.name_list(); } break; @@ -25970,11 +26801,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5434; - this.match(PostgreSQLParser.FOR); - this.state = 5435; - this.match(PostgreSQLParser.ROLE); - this.state = 5436; + this.state = 5504; + this.match(PostgreSQLParser.KW_FOR); + this.state = 5505; + this.match(PostgreSQLParser.KW_ROLE); + this.state = 5506; this.role_list(); } break; @@ -25982,11 +26813,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5437; - this.match(PostgreSQLParser.FOR); - this.state = 5438; - this.match(PostgreSQLParser.USER); - this.state = 5439; + this.state = 5507; + this.match(PostgreSQLParser.KW_FOR); + this.state = 5508; + this.match(PostgreSQLParser.KW_USER); + this.state = 5509; this.role_list(); } break; @@ -26009,33 +26840,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public defaclaction(): DefaclactionContext { let _localctx: DefaclactionContext = new DefaclactionContext(this._ctx, this.state); - this.enterRule(_localctx, 582, PostgreSQLParser.RULE_defaclaction); + this.enterRule(_localctx, 594, PostgreSQLParser.RULE_defaclaction); let _la: number; try { - this.state = 5472; + this.state = 5542; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 436, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 446, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5442; - this.match(PostgreSQLParser.GRANT); - this.state = 5443; + this.state = 5512; + this.match(PostgreSQLParser.KW_GRANT); + this.state = 5513; this.privileges(); - this.state = 5444; - this.match(PostgreSQLParser.ON); - this.state = 5445; + this.state = 5514; + this.match(PostgreSQLParser.KW_ON); + this.state = 5515; this.defacl_privilege_target(); - this.state = 5446; - this.match(PostgreSQLParser.TO); - this.state = 5447; + this.state = 5516; + this.match(PostgreSQLParser.KW_TO); + this.state = 5517; this.grantee_list(); - this.state = 5449; + this.state = 5519; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 433, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 443, this._ctx) ) { case 1: { - this.state = 5448; + this.state = 5518; this.opt_grant_grant_option(); } break; @@ -26046,24 +26877,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5451; - this.match(PostgreSQLParser.REVOKE); - this.state = 5452; + this.state = 5521; + this.match(PostgreSQLParser.KW_REVOKE); + this.state = 5522; this.privileges(); - this.state = 5453; - this.match(PostgreSQLParser.ON); - this.state = 5454; + this.state = 5523; + this.match(PostgreSQLParser.KW_ON); + this.state = 5524; this.defacl_privilege_target(); - this.state = 5455; - this.match(PostgreSQLParser.FROM); - this.state = 5456; + this.state = 5525; + this.match(PostgreSQLParser.KW_FROM); + this.state = 5526; this.grantee_list(); - this.state = 5458; + this.state = 5528; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5457; + this.state = 5527; this.opt_drop_behavior(); } } @@ -26074,30 +26905,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5460; - this.match(PostgreSQLParser.REVOKE); - this.state = 5461; - this.match(PostgreSQLParser.GRANT); - this.state = 5462; - this.match(PostgreSQLParser.OPTION); - this.state = 5463; - this.match(PostgreSQLParser.FOR); - this.state = 5464; + this.state = 5530; + this.match(PostgreSQLParser.KW_REVOKE); + this.state = 5531; + this.match(PostgreSQLParser.KW_GRANT); + this.state = 5532; + this.match(PostgreSQLParser.KW_OPTION); + this.state = 5533; + this.match(PostgreSQLParser.KW_FOR); + this.state = 5534; this.privileges(); - this.state = 5465; - this.match(PostgreSQLParser.ON); - this.state = 5466; + this.state = 5535; + this.match(PostgreSQLParser.KW_ON); + this.state = 5536; this.defacl_privilege_target(); - this.state = 5467; - this.match(PostgreSQLParser.FROM); - this.state = 5468; + this.state = 5537; + this.match(PostgreSQLParser.KW_FROM); + this.state = 5538; this.grantee_list(); - this.state = 5470; + this.state = 5540; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5469; + this.state = 5539; this.opt_drop_behavior(); } } @@ -26123,14 +26954,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public defacl_privilege_target(): Defacl_privilege_targetContext { let _localctx: Defacl_privilege_targetContext = new Defacl_privilege_targetContext(this._ctx, this.state); - this.enterRule(_localctx, 584, PostgreSQLParser.RULE_defacl_privilege_target); + this.enterRule(_localctx, 596, PostgreSQLParser.RULE_defacl_privilege_target); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5474; + this.state = 5544; _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)) { + if (!(_la === PostgreSQLParser.KW_FUNCTIONS || _la === PostgreSQLParser.KW_SEQUENCES || _la === PostgreSQLParser.KW_TABLES || _la === PostgreSQLParser.KW_TYPES || _la === PostgreSQLParser.KW_ROUTINES || _la === PostgreSQLParser.KW_SCHEMAS)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -26159,105 +26990,105 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public indexstmt(): IndexstmtContext { let _localctx: IndexstmtContext = new IndexstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 586, PostgreSQLParser.RULE_indexstmt); + this.enterRule(_localctx, 598, PostgreSQLParser.RULE_indexstmt); let _la: number; try { - this.state = 5539; + this.state = 5609; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 452, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 462, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5476; - this.match(PostgreSQLParser.CREATE); - this.state = 5478; + this.state = 5546; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 5548; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.UNIQUE) { + if (_la === PostgreSQLParser.KW_UNIQUE) { { - this.state = 5477; + this.state = 5547; this.opt_unique(); } } - this.state = 5480; - this.match(PostgreSQLParser.INDEX); - this.state = 5482; + this.state = 5550; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 5552; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CONCURRENTLY) { + if (_la === PostgreSQLParser.KW_CONCURRENTLY) { { - this.state = 5481; + this.state = 5551; this.opt_concurrently(); } } - this.state = 5485; + this.state = 5555; 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)) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.KW_OVER - 124)) | (1 << (PostgreSQLParser.KW_ABORT - 124)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 124)) | (1 << (PostgreSQLParser.KW_ACCESS - 124)) | (1 << (PostgreSQLParser.KW_ACTION - 124)) | (1 << (PostgreSQLParser.KW_ADD - 124)) | (1 << (PostgreSQLParser.KW_ADMIN - 124)) | (1 << (PostgreSQLParser.KW_AFTER - 124)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 124)) | (1 << (PostgreSQLParser.KW_ALSO - 124)) | (1 << (PostgreSQLParser.KW_ALTER - 124)) | (1 << (PostgreSQLParser.KW_ALWAYS - 124)) | (1 << (PostgreSQLParser.KW_ASSERTION - 124)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.KW_AT - 124)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.KW_BACKWARD - 124)) | (1 << (PostgreSQLParser.KW_BEFORE - 124)) | (1 << (PostgreSQLParser.KW_BEGIN - 124)) | (1 << (PostgreSQLParser.KW_BY - 124)) | (1 << (PostgreSQLParser.KW_CACHE - 124)) | (1 << (PostgreSQLParser.KW_CALLED - 124)) | (1 << (PostgreSQLParser.KW_CASCADE - 124)) | (1 << (PostgreSQLParser.KW_CASCADED - 124)) | (1 << (PostgreSQLParser.KW_CATALOG - 124)) | (1 << (PostgreSQLParser.KW_CHAIN - 124)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.KW_CLASS - 156)) | (1 << (PostgreSQLParser.KW_CLOSE - 156)) | (1 << (PostgreSQLParser.KW_CLUSTER - 156)) | (1 << (PostgreSQLParser.KW_COMMENT - 156)) | (1 << (PostgreSQLParser.KW_COMMENTS - 156)) | (1 << (PostgreSQLParser.KW_COMMIT - 156)) | (1 << (PostgreSQLParser.KW_COMMITTED - 156)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 156)) | (1 << (PostgreSQLParser.KW_CONNECTION - 156)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.KW_CONTENT - 156)) | (1 << (PostgreSQLParser.KW_CONTINUE - 156)) | (1 << (PostgreSQLParser.KW_CONVERSION - 156)) | (1 << (PostgreSQLParser.KW_COPY - 156)) | (1 << (PostgreSQLParser.KW_COST - 156)) | (1 << (PostgreSQLParser.KW_CSV - 156)) | (1 << (PostgreSQLParser.KW_CURSOR - 156)) | (1 << (PostgreSQLParser.KW_CYCLE - 156)) | (1 << (PostgreSQLParser.KW_DATA - 156)) | (1 << (PostgreSQLParser.KW_DATABASE - 156)) | (1 << (PostgreSQLParser.KW_DAY - 156)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 156)) | (1 << (PostgreSQLParser.KW_DECLARE - 156)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 156)) | (1 << (PostgreSQLParser.KW_DEFERRED - 156)) | (1 << (PostgreSQLParser.KW_DEFINER - 156)) | (1 << (PostgreSQLParser.KW_DELETE - 156)) | (1 << (PostgreSQLParser.KW_DELIMITER - 156)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 156)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 156)) | (1 << (PostgreSQLParser.KW_DISABLE - 156)) | (1 << (PostgreSQLParser.KW_DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.KW_DOCUMENT - 188)) | (1 << (PostgreSQLParser.KW_DOMAIN - 188)) | (1 << (PostgreSQLParser.KW_DOUBLE - 188)) | (1 << (PostgreSQLParser.KW_DROP - 188)) | (1 << (PostgreSQLParser.KW_EACH - 188)) | (1 << (PostgreSQLParser.KW_ENABLE - 188)) | (1 << (PostgreSQLParser.KW_ENCODING - 188)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 188)) | (1 << (PostgreSQLParser.KW_ENUM - 188)) | (1 << (PostgreSQLParser.KW_ESCAPE - 188)) | (1 << (PostgreSQLParser.KW_EVENT - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 188)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.KW_EXECUTE - 188)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 188)) | (1 << (PostgreSQLParser.KW_EXTENSION - 188)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 188)) | (1 << (PostgreSQLParser.KW_FAMILY - 188)) | (1 << (PostgreSQLParser.KW_FIRST - 188)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 188)) | (1 << (PostgreSQLParser.KW_FORCE - 188)) | (1 << (PostgreSQLParser.KW_FORWARD - 188)) | (1 << (PostgreSQLParser.KW_FUNCTION - 188)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 188)) | (1 << (PostgreSQLParser.KW_GLOBAL - 188)) | (1 << (PostgreSQLParser.KW_GRANTED - 188)) | (1 << (PostgreSQLParser.KW_HANDLER - 188)) | (1 << (PostgreSQLParser.KW_HEADER - 188)) | (1 << (PostgreSQLParser.KW_HOLD - 188)) | (1 << (PostgreSQLParser.KW_HOUR - 188)) | (1 << (PostgreSQLParser.KW_IDENTITY - 188)))) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.KW_IF - 220)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 220)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 220)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 220)) | (1 << (PostgreSQLParser.KW_INCLUDING - 220)) | (1 << (PostgreSQLParser.KW_INCREMENT - 220)) | (1 << (PostgreSQLParser.KW_INDEX - 220)) | (1 << (PostgreSQLParser.KW_INDEXES - 220)) | (1 << (PostgreSQLParser.KW_INHERIT - 220)) | (1 << (PostgreSQLParser.KW_INHERITS - 220)) | (1 << (PostgreSQLParser.KW_INLINE - 220)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 220)) | (1 << (PostgreSQLParser.KW_INSERT - 220)) | (1 << (PostgreSQLParser.KW_INSTEAD - 220)) | (1 << (PostgreSQLParser.KW_INVOKER - 220)) | (1 << (PostgreSQLParser.KW_ISOLATION - 220)) | (1 << (PostgreSQLParser.KW_KEY - 220)) | (1 << (PostgreSQLParser.KW_LABEL - 220)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 220)) | (1 << (PostgreSQLParser.KW_LARGE - 220)) | (1 << (PostgreSQLParser.KW_LAST - 220)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 220)) | (1 << (PostgreSQLParser.KW_LEVEL - 220)))) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.KW_LISTEN - 252)) | (1 << (PostgreSQLParser.KW_LOAD - 252)) | (1 << (PostgreSQLParser.KW_LOCAL - 252)) | (1 << (PostgreSQLParser.KW_LOCATION - 252)) | (1 << (PostgreSQLParser.KW_LOCK - 252)) | (1 << (PostgreSQLParser.KW_MAPPING - 252)) | (1 << (PostgreSQLParser.KW_MATCH - 252)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 252)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 252)) | (1 << (PostgreSQLParser.KW_MINUTE - 252)) | (1 << (PostgreSQLParser.KW_MINVALUE - 252)) | (1 << (PostgreSQLParser.KW_MODE - 252)) | (1 << (PostgreSQLParser.KW_MONTH - 252)) | (1 << (PostgreSQLParser.KW_MOVE - 252)) | (1 << (PostgreSQLParser.KW_NAME - 252)) | (1 << (PostgreSQLParser.KW_NAMES - 252)) | (1 << (PostgreSQLParser.KW_NEXT - 252)) | (1 << (PostgreSQLParser.KW_NO - 252)) | (1 << (PostgreSQLParser.KW_NOTHING - 252)) | (1 << (PostgreSQLParser.KW_NOTIFY - 252)) | (1 << (PostgreSQLParser.KW_NOWAIT - 252)) | (1 << (PostgreSQLParser.KW_NULLS - 252)) | (1 << (PostgreSQLParser.KW_OBJECT - 252)) | (1 << (PostgreSQLParser.KW_OF - 252)) | (1 << (PostgreSQLParser.KW_OFF - 252)) | (1 << (PostgreSQLParser.KW_OIDS - 252)) | (1 << (PostgreSQLParser.KW_OPERATOR - 252)) | (1 << (PostgreSQLParser.KW_OPTION - 252)) | (1 << (PostgreSQLParser.KW_OPTIONS - 252)) | (1 << (PostgreSQLParser.KW_OWNED - 252)) | (1 << (PostgreSQLParser.KW_OWNER - 252)) | (1 << (PostgreSQLParser.KW_PARSER - 252)))) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.KW_PARTIAL - 284)) | (1 << (PostgreSQLParser.KW_PARTITION - 284)) | (1 << (PostgreSQLParser.KW_PASSING - 284)) | (1 << (PostgreSQLParser.KW_PASSWORD - 284)) | (1 << (PostgreSQLParser.KW_PLANS - 284)) | (1 << (PostgreSQLParser.KW_PRECEDING - 284)) | (1 << (PostgreSQLParser.KW_PREPARE - 284)) | (1 << (PostgreSQLParser.KW_PREPARED - 284)) | (1 << (PostgreSQLParser.KW_PRESERVE - 284)) | (1 << (PostgreSQLParser.KW_PRIOR - 284)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 284)) | (1 << (PostgreSQLParser.KW_PROGRAM - 284)) | (1 << (PostgreSQLParser.KW_QUOTE - 284)) | (1 << (PostgreSQLParser.KW_RANGE - 284)) | (1 << (PostgreSQLParser.KW_READ - 284)) | (1 << (PostgreSQLParser.KW_REASSIGN - 284)) | (1 << (PostgreSQLParser.KW_RECHECK - 284)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 284)) | (1 << (PostgreSQLParser.KW_REF - 284)) | (1 << (PostgreSQLParser.KW_REFRESH - 284)) | (1 << (PostgreSQLParser.KW_REINDEX - 284)) | (1 << (PostgreSQLParser.KW_RELATIVE - 284)) | (1 << (PostgreSQLParser.KW_RELEASE - 284)) | (1 << (PostgreSQLParser.KW_RENAME - 284)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 284)) | (1 << (PostgreSQLParser.KW_REPLACE - 284)) | (1 << (PostgreSQLParser.KW_REPLICA - 284)) | (1 << (PostgreSQLParser.KW_RESET - 284)) | (1 << (PostgreSQLParser.KW_RESTART - 284)) | (1 << (PostgreSQLParser.KW_RESTRICT - 284)))) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.KW_RETURNS - 316)) | (1 << (PostgreSQLParser.KW_REVOKE - 316)) | (1 << (PostgreSQLParser.KW_ROLE - 316)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 316)) | (1 << (PostgreSQLParser.KW_ROWS - 316)) | (1 << (PostgreSQLParser.KW_RULE - 316)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 316)) | (1 << (PostgreSQLParser.KW_SCHEMA - 316)) | (1 << (PostgreSQLParser.KW_SCROLL - 316)) | (1 << (PostgreSQLParser.KW_SEARCH - 316)) | (1 << (PostgreSQLParser.KW_SECOND - 316)) | (1 << (PostgreSQLParser.KW_SECURITY - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 316)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.KW_SERVER - 316)) | (1 << (PostgreSQLParser.KW_SESSION - 316)) | (1 << (PostgreSQLParser.KW_SET - 316)) | (1 << (PostgreSQLParser.KW_SHARE - 316)) | (1 << (PostgreSQLParser.KW_SHOW - 316)) | (1 << (PostgreSQLParser.KW_SIMPLE - 316)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 316)) | (1 << (PostgreSQLParser.KW_STABLE - 316)) | (1 << (PostgreSQLParser.KW_STANDALONE - 316)) | (1 << (PostgreSQLParser.KW_START - 316)) | (1 << (PostgreSQLParser.KW_STATEMENT - 316)) | (1 << (PostgreSQLParser.KW_STATISTICS - 316)) | (1 << (PostgreSQLParser.KW_STDIN - 316)) | (1 << (PostgreSQLParser.KW_STDOUT - 316)) | (1 << (PostgreSQLParser.KW_STORAGE - 316)) | (1 << (PostgreSQLParser.KW_STRICT - 316)) | (1 << (PostgreSQLParser.KW_STRIP - 316)))) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.KW_SYSID - 348)) | (1 << (PostgreSQLParser.KW_SYSTEM - 348)) | (1 << (PostgreSQLParser.KW_TABLES - 348)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 348)) | (1 << (PostgreSQLParser.KW_TEMP - 348)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 348)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 348)) | (1 << (PostgreSQLParser.KW_TEXT - 348)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 348)) | (1 << (PostgreSQLParser.KW_TRIGGER - 348)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 348)) | (1 << (PostgreSQLParser.KW_TRUSTED - 348)) | (1 << (PostgreSQLParser.KW_TYPE - 348)) | (1 << (PostgreSQLParser.KW_TYPES - 348)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 348)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 348)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 348)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 348)) | (1 << (PostgreSQLParser.KW_UNTIL - 348)) | (1 << (PostgreSQLParser.KW_UPDATE - 348)) | (1 << (PostgreSQLParser.KW_VACUUM - 348)) | (1 << (PostgreSQLParser.KW_VALID - 348)) | (1 << (PostgreSQLParser.KW_VALIDATE - 348)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 348)) | (1 << (PostgreSQLParser.KW_VARYING - 348)) | (1 << (PostgreSQLParser.KW_VERSION - 348)) | (1 << (PostgreSQLParser.KW_VIEW - 348)) | (1 << (PostgreSQLParser.KW_VOLATILE - 348)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 348)) | (1 << (PostgreSQLParser.KW_WITHOUT - 348)))) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.KW_WORK - 380)) | (1 << (PostgreSQLParser.KW_WRAPPER - 380)) | (1 << (PostgreSQLParser.KW_WRITE - 380)) | (1 << (PostgreSQLParser.KW_XML - 380)) | (1 << (PostgreSQLParser.KW_YEAR - 380)) | (1 << (PostgreSQLParser.KW_YES - 380)) | (1 << (PostgreSQLParser.KW_ZONE - 380)) | (1 << (PostgreSQLParser.KW_BETWEEN - 380)) | (1 << (PostgreSQLParser.KW_BIGINT - 380)) | (1 << (PostgreSQLParser.KW_BIT - 380)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 380)) | (1 << (PostgreSQLParser.KW_CHAR - 380)) | (1 << (PostgreSQLParser.KW_CHARACTER - 380)) | (1 << (PostgreSQLParser.KW_COALESCE - 380)) | (1 << (PostgreSQLParser.KW_DEC - 380)) | (1 << (PostgreSQLParser.KW_DECIMAL - 380)) | (1 << (PostgreSQLParser.KW_EXISTS - 380)) | (1 << (PostgreSQLParser.KW_EXTRACT - 380)) | (1 << (PostgreSQLParser.KW_FLOAT - 380)) | (1 << (PostgreSQLParser.KW_GREATEST - 380)) | (1 << (PostgreSQLParser.KW_INOUT - 380)) | (1 << (PostgreSQLParser.KW_INT - 380)) | (1 << (PostgreSQLParser.KW_INTEGER - 380)) | (1 << (PostgreSQLParser.KW_INTERVAL - 380)) | (1 << (PostgreSQLParser.KW_LEAST - 380)) | (1 << (PostgreSQLParser.KW_NATIONAL - 380)) | (1 << (PostgreSQLParser.KW_NCHAR - 380)) | (1 << (PostgreSQLParser.KW_NONE - 380)) | (1 << (PostgreSQLParser.KW_NULLIF - 380)) | (1 << (PostgreSQLParser.KW_NUMERIC - 380)) | (1 << (PostgreSQLParser.KW_OVERLAY - 380)) | (1 << (PostgreSQLParser.KW_POSITION - 380)))) !== 0) || ((((_la - 412)) & ~0x1F) === 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.KW_PRECISION - 412)) | (1 << (PostgreSQLParser.KW_REAL - 412)) | (1 << (PostgreSQLParser.KW_ROW - 412)) | (1 << (PostgreSQLParser.KW_SETOF - 412)) | (1 << (PostgreSQLParser.KW_SMALLINT - 412)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 412)) | (1 << (PostgreSQLParser.KW_TIME - 412)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 412)) | (1 << (PostgreSQLParser.KW_TREAT - 412)) | (1 << (PostgreSQLParser.KW_TRIM - 412)) | (1 << (PostgreSQLParser.KW_VALUES - 412)) | (1 << (PostgreSQLParser.KW_VARCHAR - 412)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 412)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 412)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 412)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 412)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 412)) | (1 << (PostgreSQLParser.KW_XMLPI - 412)) | (1 << (PostgreSQLParser.KW_XMLROOT - 412)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.KW_CALL - 412)) | (1 << (PostgreSQLParser.KW_CURRENT - 412)) | (1 << (PostgreSQLParser.KW_ATTACH - 412)) | (1 << (PostgreSQLParser.KW_DETACH - 412)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 412)) | (1 << (PostgreSQLParser.KW_GENERATED - 412)) | (1 << (PostgreSQLParser.KW_LOGGED - 412)) | (1 << (PostgreSQLParser.KW_STORED - 412)) | (1 << (PostgreSQLParser.KW_INCLUDE - 412)) | (1 << (PostgreSQLParser.KW_ROUTINE - 412)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 412)))) !== 0) || ((((_la - 444)) & ~0x1F) === 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.KW_IMPORT - 444)) | (1 << (PostgreSQLParser.KW_POLICY - 444)) | (1 << (PostgreSQLParser.KW_METHOD - 444)) | (1 << (PostgreSQLParser.KW_REFERENCING - 444)) | (1 << (PostgreSQLParser.KW_NEW - 444)) | (1 << (PostgreSQLParser.KW_OLD - 444)) | (1 << (PostgreSQLParser.KW_VALUE - 444)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 444)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 444)) | (1 << (PostgreSQLParser.KW_OUT - 444)) | (1 << (PostgreSQLParser.KW_ROUTINES - 444)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 444)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 444)) | (1 << (PostgreSQLParser.KW_INPUT - 444)) | (1 << (PostgreSQLParser.KW_SUPPORT - 444)) | (1 << (PostgreSQLParser.KW_PARALLEL - 444)) | (1 << (PostgreSQLParser.KW_SQL - 444)) | (1 << (PostgreSQLParser.KW_DEPENDS - 444)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 444)) | (1 << (PostgreSQLParser.KW_CONFLICT - 444)) | (1 << (PostgreSQLParser.KW_SKIP - 444)) | (1 << (PostgreSQLParser.KW_LOCKED - 444)) | (1 << (PostgreSQLParser.KW_TIES - 444)) | (1 << (PostgreSQLParser.KW_ROLLUP - 444)) | (1 << (PostgreSQLParser.KW_CUBE - 444)) | (1 << (PostgreSQLParser.KW_GROUPING - 444)) | (1 << (PostgreSQLParser.KW_SETS - 444)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 444)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 444)) | (1 << (PostgreSQLParser.KW_COLUMNS - 444)))) !== 0) || ((((_la - 476)) & ~0x1F) === 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.KW_XMLNAMESPACES - 476)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 476)) | (1 << (PostgreSQLParser.KW_WITHIN - 476)) | (1 << (PostgreSQLParser.KW_FILTER - 476)) | (1 << (PostgreSQLParser.KW_GROUPS - 476)) | (1 << (PostgreSQLParser.KW_OTHERS - 476)) | (1 << (PostgreSQLParser.KW_NFC - 476)) | (1 << (PostgreSQLParser.KW_NFD - 476)) | (1 << (PostgreSQLParser.KW_NFKC - 476)) | (1 << (PostgreSQLParser.KW_NFKD - 476)) | (1 << (PostgreSQLParser.KW_UESCAPE - 476)) | (1 << (PostgreSQLParser.KW_VIEWS - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 476)) | (1 << (PostgreSQLParser.KW_DUMP - 476)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.KW_ERROR - 476)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 476)) | (1 << (PostgreSQLParser.KW_ALIAS - 476)) | (1 << (PostgreSQLParser.KW_CONSTANT - 476)) | (1 << (PostgreSQLParser.KW_PERFORM - 476)) | (1 << (PostgreSQLParser.KW_GET - 476)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.KW_STACKED - 476)) | (1 << (PostgreSQLParser.KW_ELSIF - 476)) | (1 << (PostgreSQLParser.KW_REVERSE - 476)) | (1 << (PostgreSQLParser.KW_SLICE - 476)) | (1 << (PostgreSQLParser.KW_EXIT - 476)))) !== 0) || ((((_la - 508)) & ~0x1F) === 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.KW_RETURN - 508)) | (1 << (PostgreSQLParser.KW_QUERY - 508)) | (1 << (PostgreSQLParser.KW_RAISE - 508)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 508)) | (1 << (PostgreSQLParser.KW_DEBUG - 508)) | (1 << (PostgreSQLParser.KW_LOG - 508)) | (1 << (PostgreSQLParser.KW_INFO - 508)) | (1 << (PostgreSQLParser.KW_NOTICE - 508)) | (1 << (PostgreSQLParser.KW_WARNING - 508)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 508)) | (1 << (PostgreSQLParser.KW_ASSERT - 508)) | (1 << (PostgreSQLParser.KW_OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 5484; + this.state = 5554; this.opt_index_name(); } } - this.state = 5487; - this.match(PostgreSQLParser.ON); - this.state = 5488; + this.state = 5557; + this.match(PostgreSQLParser.KW_ON); + this.state = 5558; this.relation_expr(); - this.state = 5490; + this.state = 5560; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 5489; + this.state = 5559; this.access_method_clause(); } } - this.state = 5492; + this.state = 5562; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5493; + this.state = 5563; this.index_params(); - this.state = 5494; + this.state = 5564; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 5496; + this.state = 5566; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INCLUDE) { + if (_la === PostgreSQLParser.KW_INCLUDE) { { - this.state = 5495; + this.state = 5565; this.opt_include(); } } - this.state = 5499; + this.state = 5569; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 442, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 452, this._ctx) ) { case 1: { - this.state = 5498; + this.state = 5568; this.opt_reloptions(); } break; } - this.state = 5502; + this.state = 5572; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TABLESPACE) { + if (_la === PostgreSQLParser.KW_TABLESPACE) { { - this.state = 5501; + this.state = 5571; this.opttablespace(); } } - this.state = 5505; + this.state = 5575; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 5504; + this.state = 5574; this.where_clause(); } } @@ -26268,94 +27099,94 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5507; - this.match(PostgreSQLParser.CREATE); - this.state = 5509; + this.state = 5577; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 5579; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.UNIQUE) { + if (_la === PostgreSQLParser.KW_UNIQUE) { { - this.state = 5508; + this.state = 5578; this.opt_unique(); } } - this.state = 5511; - this.match(PostgreSQLParser.INDEX); - this.state = 5513; + this.state = 5581; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 5583; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CONCURRENTLY) { + if (_la === PostgreSQLParser.KW_CONCURRENTLY) { { - this.state = 5512; + this.state = 5582; this.opt_concurrently(); } } - this.state = 5515; - this.match(PostgreSQLParser.IF_P); - this.state = 5516; - this.match(PostgreSQLParser.NOT); - this.state = 5517; - this.match(PostgreSQLParser.EXISTS); - this.state = 5518; + this.state = 5585; + this.match(PostgreSQLParser.KW_IF); + this.state = 5586; + this.match(PostgreSQLParser.KW_NOT); + this.state = 5587; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 5588; this.name(); - this.state = 5519; - this.match(PostgreSQLParser.ON); - this.state = 5520; + this.state = 5589; + this.match(PostgreSQLParser.KW_ON); + this.state = 5590; this.relation_expr(); - this.state = 5522; + this.state = 5592; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 5521; + this.state = 5591; this.access_method_clause(); } } - this.state = 5524; + this.state = 5594; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5525; + this.state = 5595; this.index_params(); - this.state = 5526; + this.state = 5596; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 5528; + this.state = 5598; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INCLUDE) { + if (_la === PostgreSQLParser.KW_INCLUDE) { { - this.state = 5527; + this.state = 5597; this.opt_include(); } } - this.state = 5531; + this.state = 5601; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 449, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 459, this._ctx) ) { case 1: { - this.state = 5530; + this.state = 5600; this.opt_reloptions(); } break; } - this.state = 5534; + this.state = 5604; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TABLESPACE) { + if (_la === PostgreSQLParser.KW_TABLESPACE) { { - this.state = 5533; + this.state = 5603; this.opttablespace(); } } - this.state = 5537; + this.state = 5607; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 5536; + this.state = 5606; this.where_clause(); } } @@ -26381,12 +27212,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_unique(): Opt_uniqueContext { let _localctx: Opt_uniqueContext = new Opt_uniqueContext(this._ctx, this.state); - this.enterRule(_localctx, 588, PostgreSQLParser.RULE_opt_unique); + this.enterRule(_localctx, 600, PostgreSQLParser.RULE_opt_unique); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5541; - this.match(PostgreSQLParser.UNIQUE); + this.state = 5611; + this.match(PostgreSQLParser.KW_UNIQUE); } } catch (re) { @@ -26406,12 +27237,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_concurrently(): Opt_concurrentlyContext { let _localctx: Opt_concurrentlyContext = new Opt_concurrentlyContext(this._ctx, this.state); - this.enterRule(_localctx, 590, PostgreSQLParser.RULE_opt_concurrently); + this.enterRule(_localctx, 602, PostgreSQLParser.RULE_opt_concurrently); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5543; - this.match(PostgreSQLParser.CONCURRENTLY); + this.state = 5613; + this.match(PostgreSQLParser.KW_CONCURRENTLY); } } catch (re) { @@ -26431,11 +27262,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_index_name(): Opt_index_nameContext { let _localctx: Opt_index_nameContext = new Opt_index_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 592, PostgreSQLParser.RULE_opt_index_name); + this.enterRule(_localctx, 604, PostgreSQLParser.RULE_opt_index_name); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5545; + this.state = 5615; this.name(); } } @@ -26456,13 +27287,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public access_method_clause(): Access_method_clauseContext { let _localctx: Access_method_clauseContext = new Access_method_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 594, PostgreSQLParser.RULE_access_method_clause); + this.enterRule(_localctx, 606, PostgreSQLParser.RULE_access_method_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5547; - this.match(PostgreSQLParser.USING); - this.state = 5548; + this.state = 5617; + this.match(PostgreSQLParser.KW_USING); + this.state = 5618; this.name(); } } @@ -26483,26 +27314,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public index_params(): Index_paramsContext { let _localctx: Index_paramsContext = new Index_paramsContext(this._ctx, this.state); - this.enterRule(_localctx, 596, PostgreSQLParser.RULE_index_params); + this.enterRule(_localctx, 608, PostgreSQLParser.RULE_index_params); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5550; + this.state = 5620; this.index_elem(); - this.state = 5555; + this.state = 5625; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5551; + this.state = 5621; this.match(PostgreSQLParser.COMMA); - this.state = 5552; + this.state = 5622; this.index_elem(); } } - this.state = 5557; + this.state = 5627; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -26525,51 +27356,51 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public index_elem_options(): Index_elem_optionsContext { let _localctx: Index_elem_optionsContext = new Index_elem_optionsContext(this._ctx, this.state); - this.enterRule(_localctx, 598, PostgreSQLParser.RULE_index_elem_options); + this.enterRule(_localctx, 610, PostgreSQLParser.RULE_index_elem_options); let _la: number; try { - this.state = 5581; + this.state = 5651; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 461, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 471, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5559; + this.state = 5629; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 454, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 464, this._ctx) ) { case 1: { - this.state = 5558; + this.state = 5628; this.opt_collate(); } break; } - this.state = 5562; + this.state = 5632; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 455, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 465, this._ctx) ) { case 1: { - this.state = 5561; + this.state = 5631; this.opt_class(); } break; } - this.state = 5565; + this.state = 5635; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ASC || _la === PostgreSQLParser.DESC) { + if (_la === PostgreSQLParser.KW_ASC || _la === PostgreSQLParser.KW_DESC) { { - this.state = 5564; + this.state = 5634; this.opt_asc_desc(); } } - this.state = 5568; + this.state = 5638; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NULLS_P) { + if (_la === PostgreSQLParser.KW_NULLS) { { - this.state = 5567; + this.state = 5637; this.opt_nulls_order(); } } @@ -26580,36 +27411,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5571; + this.state = 5641; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 458, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 468, this._ctx) ) { case 1: { - this.state = 5570; + this.state = 5640; this.opt_collate(); } break; } - this.state = 5573; + this.state = 5643; this.any_name(); - this.state = 5574; + this.state = 5644; this.reloptions(); - this.state = 5576; + this.state = 5646; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ASC || _la === PostgreSQLParser.DESC) { + if (_la === PostgreSQLParser.KW_ASC || _la === PostgreSQLParser.KW_DESC) { { - this.state = 5575; + this.state = 5645; this.opt_asc_desc(); } } - this.state = 5579; + this.state = 5649; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NULLS_P) { + if (_la === PostgreSQLParser.KW_NULLS) { { - this.state = 5578; + this.state = 5648; this.opt_nulls_order(); } } @@ -26635,17 +27466,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public index_elem(): Index_elemContext { let _localctx: Index_elemContext = new Index_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 600, PostgreSQLParser.RULE_index_elem); + this.enterRule(_localctx, 612, PostgreSQLParser.RULE_index_elem); try { - this.state = 5594; + this.state = 5664; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 462, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 472, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5583; + this.state = 5653; this.colid(); - this.state = 5584; + this.state = 5654; this.index_elem_options(); } break; @@ -26653,9 +27484,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5586; + this.state = 5656; this.func_expr_windowless(); - this.state = 5587; + this.state = 5657; this.index_elem_options(); } break; @@ -26663,13 +27494,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5589; + this.state = 5659; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5590; + this.state = 5660; this.a_expr(); - this.state = 5591; + this.state = 5661; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 5592; + this.state = 5662; this.index_elem_options(); } break; @@ -26692,17 +27523,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_include(): Opt_includeContext { let _localctx: Opt_includeContext = new Opt_includeContext(this._ctx, this.state); - this.enterRule(_localctx, 602, PostgreSQLParser.RULE_opt_include); + this.enterRule(_localctx, 614, PostgreSQLParser.RULE_opt_include); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5596; - this.match(PostgreSQLParser.INCLUDE); - this.state = 5597; + this.state = 5666; + this.match(PostgreSQLParser.KW_INCLUDE); + this.state = 5667; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5598; + this.state = 5668; this.index_including_params(); - this.state = 5599; + this.state = 5669; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -26723,26 +27554,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public index_including_params(): Index_including_paramsContext { let _localctx: Index_including_paramsContext = new Index_including_paramsContext(this._ctx, this.state); - this.enterRule(_localctx, 604, PostgreSQLParser.RULE_index_including_params); + this.enterRule(_localctx, 616, PostgreSQLParser.RULE_index_including_params); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5601; + this.state = 5671; this.index_elem(); - this.state = 5606; + this.state = 5676; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5602; + this.state = 5672; this.match(PostgreSQLParser.COMMA); - this.state = 5603; + this.state = 5673; this.index_elem(); } } - this.state = 5608; + this.state = 5678; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -26765,13 +27596,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_collate(): Opt_collateContext { let _localctx: Opt_collateContext = new Opt_collateContext(this._ctx, this.state); - this.enterRule(_localctx, 606, PostgreSQLParser.RULE_opt_collate); + this.enterRule(_localctx, 618, PostgreSQLParser.RULE_opt_collate); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5609; - this.match(PostgreSQLParser.COLLATE); - this.state = 5610; + this.state = 5679; + this.match(PostgreSQLParser.KW_COLLATE); + this.state = 5680; this.any_name(); } } @@ -26792,11 +27623,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_class(): Opt_classContext { let _localctx: Opt_classContext = new Opt_classContext(this._ctx, this.state); - this.enterRule(_localctx, 608, PostgreSQLParser.RULE_opt_class); + this.enterRule(_localctx, 620, PostgreSQLParser.RULE_opt_class); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5612; + this.state = 5682; this.any_name(); } } @@ -26817,14 +27648,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_asc_desc(): Opt_asc_descContext { let _localctx: Opt_asc_descContext = new Opt_asc_descContext(this._ctx, this.state); - this.enterRule(_localctx, 610, PostgreSQLParser.RULE_opt_asc_desc); + this.enterRule(_localctx, 622, PostgreSQLParser.RULE_opt_asc_desc); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5614; + this.state = 5684; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ASC || _la === PostgreSQLParser.DESC)) { + if (!(_la === PostgreSQLParser.KW_ASC || _la === PostgreSQLParser.KW_DESC)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -26853,28 +27684,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_nulls_order(): Opt_nulls_orderContext { let _localctx: Opt_nulls_orderContext = new Opt_nulls_orderContext(this._ctx, this.state); - this.enterRule(_localctx, 612, PostgreSQLParser.RULE_opt_nulls_order); + this.enterRule(_localctx, 624, PostgreSQLParser.RULE_opt_nulls_order); try { - this.state = 5620; + this.state = 5690; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 464, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 474, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5616; - this.match(PostgreSQLParser.NULLS_P); - this.state = 5617; - this.match(PostgreSQLParser.FIRST_P); + this.state = 5686; + this.match(PostgreSQLParser.KW_NULLS); + this.state = 5687; + this.match(PostgreSQLParser.KW_FIRST); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5618; - this.match(PostgreSQLParser.NULLS_P); - this.state = 5619; - this.match(PostgreSQLParser.LAST_P); + this.state = 5688; + this.match(PostgreSQLParser.KW_NULLS); + this.state = 5689; + this.match(PostgreSQLParser.KW_LAST); } break; } @@ -26896,26 +27727,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createfunctionstmt(): CreatefunctionstmtContext { let _localctx: CreatefunctionstmtContext = new CreatefunctionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 614, PostgreSQLParser.RULE_createfunctionstmt); + this.enterRule(_localctx, 626, PostgreSQLParser.RULE_createfunctionstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5622; - this.match(PostgreSQLParser.CREATE); - this.state = 5624; + this.state = 5692; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 5694; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OR) { + if (_la === PostgreSQLParser.KW_OR) { { - this.state = 5623; + this.state = 5693; this.opt_or_replace(); } } - this.state = 5626; + this.state = 5696; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FUNCTION || _la === PostgreSQLParser.PROCEDURE)) { + if (!(_la === PostgreSQLParser.KW_FUNCTION || _la === PostgreSQLParser.KW_PROCEDURE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -26925,36 +27756,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 5627; + this.state = 5697; this.func_name(); - this.state = 5628; + this.state = 5698; this.func_args_with_defaults(); - this.state = 5638; + this.state = 5708; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 467, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 477, this._ctx) ) { case 1: { - this.state = 5629; - this.match(PostgreSQLParser.RETURNS); - this.state = 5636; + this.state = 5699; + this.match(PostgreSQLParser.KW_RETURNS); + this.state = 5706; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 466, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 476, this._ctx) ) { case 1: { - this.state = 5630; + this.state = 5700; this.func_return(); } break; case 2: { - this.state = 5631; - this.match(PostgreSQLParser.TABLE); - this.state = 5632; + this.state = 5701; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 5702; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5633; + this.state = 5703; this.table_func_column_list(); - this.state = 5634; + this.state = 5704; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -26962,8 +27793,66 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } break; } - this.state = 5640; + this.state = 5710; this.createfunc_opt_list(); + this.state = 5713; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 478, this._ctx) ) { + case 1: + { + this.state = 5711; + this.match(PostgreSQLParser.KW_WITH); + this.state = 5712; + this.attrilist(); + } + break; + } + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public attrilist(): AttrilistContext { + let _localctx: AttrilistContext = new AttrilistContext(this._ctx, this.state); + this.enterRule(_localctx, 628, PostgreSQLParser.RULE_attrilist); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 5715; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 5716; + this.colid(); + this.state = 5721; + this._errHandler.sync(this); + _la = this._input.LA(1); + while (_la === PostgreSQLParser.COMMA) { + { + { + this.state = 5717; + this.match(PostgreSQLParser.COMMA); + this.state = 5718; + this.colid(); + } + } + this.state = 5723; + this._errHandler.sync(this); + _la = this._input.LA(1); + } + this.state = 5724; + this.match(PostgreSQLParser.CLOSE_PAREN); } } catch (re) { @@ -26983,14 +27872,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_or_replace(): Opt_or_replaceContext { let _localctx: Opt_or_replaceContext = new Opt_or_replaceContext(this._ctx, this.state); - this.enterRule(_localctx, 616, PostgreSQLParser.RULE_opt_or_replace); + this.enterRule(_localctx, 630, PostgreSQLParser.RULE_opt_or_replace); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5642; - this.match(PostgreSQLParser.OR); - this.state = 5643; - this.match(PostgreSQLParser.REPLACE); + this.state = 5726; + this.match(PostgreSQLParser.KW_OR); + this.state = 5727; + this.match(PostgreSQLParser.KW_REPLACE); } } catch (re) { @@ -27010,24 +27899,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_args(): Func_argsContext { let _localctx: Func_argsContext = new Func_argsContext(this._ctx, this.state); - this.enterRule(_localctx, 618, PostgreSQLParser.RULE_func_args); + this.enterRule(_localctx, 632, PostgreSQLParser.RULE_func_args); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5645; + this.state = 5729; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5647; + this.state = 5731; 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)) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || _la === PostgreSQLParser.KW_IN || _la === PostgreSQLParser.KW_TABLE || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (PostgreSQLParser.KW_VARIADIC - 101)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 101)) | (1 << (PostgreSQLParser.KW_BINARY - 101)) | (1 << (PostgreSQLParser.KW_COLLATION - 101)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 101)) | (1 << (PostgreSQLParser.KW_CROSS - 101)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 101)) | (1 << (PostgreSQLParser.KW_FREEZE - 101)) | (1 << (PostgreSQLParser.KW_FULL - 101)) | (1 << (PostgreSQLParser.KW_ILIKE - 101)) | (1 << (PostgreSQLParser.KW_INNER - 101)) | (1 << (PostgreSQLParser.KW_IS - 101)) | (1 << (PostgreSQLParser.KW_ISNULL - 101)) | (1 << (PostgreSQLParser.KW_JOIN - 101)) | (1 << (PostgreSQLParser.KW_LEFT - 101)) | (1 << (PostgreSQLParser.KW_LIKE - 101)) | (1 << (PostgreSQLParser.KW_NATURAL - 101)) | (1 << (PostgreSQLParser.KW_NOTNULL - 101)) | (1 << (PostgreSQLParser.KW_OUTER - 101)) | (1 << (PostgreSQLParser.KW_OVER - 101)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 101)) | (1 << (PostgreSQLParser.KW_RIGHT - 101)) | (1 << (PostgreSQLParser.KW_SIMILAR - 101)) | (1 << (PostgreSQLParser.KW_VERBOSE - 101)) | (1 << (PostgreSQLParser.KW_ABORT - 101)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 101)) | (1 << (PostgreSQLParser.KW_ACCESS - 101)) | (1 << (PostgreSQLParser.KW_ACTION - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (PostgreSQLParser.KW_ADD - 133)) | (1 << (PostgreSQLParser.KW_ADMIN - 133)) | (1 << (PostgreSQLParser.KW_AFTER - 133)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 133)) | (1 << (PostgreSQLParser.KW_ALSO - 133)) | (1 << (PostgreSQLParser.KW_ALTER - 133)) | (1 << (PostgreSQLParser.KW_ALWAYS - 133)) | (1 << (PostgreSQLParser.KW_ASSERTION - 133)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 133)) | (1 << (PostgreSQLParser.KW_AT - 133)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 133)) | (1 << (PostgreSQLParser.KW_BACKWARD - 133)) | (1 << (PostgreSQLParser.KW_BEFORE - 133)) | (1 << (PostgreSQLParser.KW_BEGIN - 133)) | (1 << (PostgreSQLParser.KW_BY - 133)) | (1 << (PostgreSQLParser.KW_CACHE - 133)) | (1 << (PostgreSQLParser.KW_CALLED - 133)) | (1 << (PostgreSQLParser.KW_CASCADE - 133)) | (1 << (PostgreSQLParser.KW_CASCADED - 133)) | (1 << (PostgreSQLParser.KW_CATALOG - 133)) | (1 << (PostgreSQLParser.KW_CHAIN - 133)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 133)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 133)) | (1 << (PostgreSQLParser.KW_CLASS - 133)) | (1 << (PostgreSQLParser.KW_CLOSE - 133)) | (1 << (PostgreSQLParser.KW_CLUSTER - 133)) | (1 << (PostgreSQLParser.KW_COMMENT - 133)) | (1 << (PostgreSQLParser.KW_COMMENTS - 133)) | (1 << (PostgreSQLParser.KW_COMMIT - 133)) | (1 << (PostgreSQLParser.KW_COMMITTED - 133)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 133)) | (1 << (PostgreSQLParser.KW_CONNECTION - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (PostgreSQLParser.KW_CONSTRAINTS - 165)) | (1 << (PostgreSQLParser.KW_CONTENT - 165)) | (1 << (PostgreSQLParser.KW_CONTINUE - 165)) | (1 << (PostgreSQLParser.KW_CONVERSION - 165)) | (1 << (PostgreSQLParser.KW_COPY - 165)) | (1 << (PostgreSQLParser.KW_COST - 165)) | (1 << (PostgreSQLParser.KW_CSV - 165)) | (1 << (PostgreSQLParser.KW_CURSOR - 165)) | (1 << (PostgreSQLParser.KW_CYCLE - 165)) | (1 << (PostgreSQLParser.KW_DATA - 165)) | (1 << (PostgreSQLParser.KW_DATABASE - 165)) | (1 << (PostgreSQLParser.KW_DAY - 165)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 165)) | (1 << (PostgreSQLParser.KW_DECLARE - 165)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 165)) | (1 << (PostgreSQLParser.KW_DEFERRED - 165)) | (1 << (PostgreSQLParser.KW_DEFINER - 165)) | (1 << (PostgreSQLParser.KW_DELETE - 165)) | (1 << (PostgreSQLParser.KW_DELIMITER - 165)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 165)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 165)) | (1 << (PostgreSQLParser.KW_DISABLE - 165)) | (1 << (PostgreSQLParser.KW_DISCARD - 165)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 165)) | (1 << (PostgreSQLParser.KW_DOMAIN - 165)) | (1 << (PostgreSQLParser.KW_DOUBLE - 165)) | (1 << (PostgreSQLParser.KW_DROP - 165)) | (1 << (PostgreSQLParser.KW_EACH - 165)) | (1 << (PostgreSQLParser.KW_ENABLE - 165)) | (1 << (PostgreSQLParser.KW_ENCODING - 165)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 165)) | (1 << (PostgreSQLParser.KW_ENUM - 165)))) !== 0) || ((((_la - 197)) & ~0x1F) === 0 && ((1 << (_la - 197)) & ((1 << (PostgreSQLParser.KW_ESCAPE - 197)) | (1 << (PostgreSQLParser.KW_EVENT - 197)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 197)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 197)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 197)) | (1 << (PostgreSQLParser.KW_EXECUTE - 197)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 197)) | (1 << (PostgreSQLParser.KW_EXTENSION - 197)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 197)) | (1 << (PostgreSQLParser.KW_FAMILY - 197)) | (1 << (PostgreSQLParser.KW_FIRST - 197)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 197)) | (1 << (PostgreSQLParser.KW_FORCE - 197)) | (1 << (PostgreSQLParser.KW_FORWARD - 197)) | (1 << (PostgreSQLParser.KW_FUNCTION - 197)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 197)) | (1 << (PostgreSQLParser.KW_GLOBAL - 197)) | (1 << (PostgreSQLParser.KW_GRANTED - 197)) | (1 << (PostgreSQLParser.KW_HANDLER - 197)) | (1 << (PostgreSQLParser.KW_HEADER - 197)) | (1 << (PostgreSQLParser.KW_HOLD - 197)) | (1 << (PostgreSQLParser.KW_HOUR - 197)) | (1 << (PostgreSQLParser.KW_IDENTITY - 197)) | (1 << (PostgreSQLParser.KW_IF - 197)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 197)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 197)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 197)) | (1 << (PostgreSQLParser.KW_INCLUDING - 197)) | (1 << (PostgreSQLParser.KW_INCREMENT - 197)) | (1 << (PostgreSQLParser.KW_INDEX - 197)) | (1 << (PostgreSQLParser.KW_INDEXES - 197)) | (1 << (PostgreSQLParser.KW_INHERIT - 197)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0)) { { - this.state = 5646; + this.state = 5730; this.func_args_list(); } } - this.state = 5649; + this.state = 5733; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -27048,26 +27937,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_args_list(): Func_args_listContext { let _localctx: Func_args_listContext = new Func_args_listContext(this._ctx, this.state); - this.enterRule(_localctx, 620, PostgreSQLParser.RULE_func_args_list); + this.enterRule(_localctx, 634, PostgreSQLParser.RULE_func_args_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5651; + this.state = 5735; this.func_arg(); - this.state = 5656; + this.state = 5740; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5652; + this.state = 5736; this.match(PostgreSQLParser.COMMA); - this.state = 5653; + this.state = 5737; this.func_arg(); } } - this.state = 5658; + this.state = 5742; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -27090,26 +27979,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public function_with_argtypes_list(): Function_with_argtypes_listContext { let _localctx: Function_with_argtypes_listContext = new Function_with_argtypes_listContext(this._ctx, this.state); - this.enterRule(_localctx, 622, PostgreSQLParser.RULE_function_with_argtypes_list); + this.enterRule(_localctx, 636, PostgreSQLParser.RULE_function_with_argtypes_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5659; + this.state = 5743; this.function_with_argtypes(); - this.state = 5664; + this.state = 5748; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5660; + this.state = 5744; this.match(PostgreSQLParser.COMMA); - this.state = 5661; + this.state = 5745; this.function_with_argtypes(); } } - this.state = 5666; + this.state = 5750; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -27132,18 +28021,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public function_with_argtypes(): Function_with_argtypesContext { let _localctx: Function_with_argtypesContext = new Function_with_argtypesContext(this._ctx, this.state); - this.enterRule(_localctx, 624, PostgreSQLParser.RULE_function_with_argtypes); + this.enterRule(_localctx, 638, PostgreSQLParser.RULE_function_with_argtypes); let _la: number; try { - this.state = 5675; + this.state = 5759; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 472, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 484, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5667; + this.state = 5751; this.func_name(); - this.state = 5668; + this.state = 5752; this.func_args(); } break; @@ -27151,7 +28040,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5670; + this.state = 5754; this.type_func_name_keyword(); } break; @@ -27159,14 +28048,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5671; + this.state = 5755; this.colid(); - this.state = 5673; + this.state = 5757; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_BRACKET || _la === PostgreSQLParser.DOT) { { - this.state = 5672; + this.state = 5756; this.indirection(); } } @@ -27192,24 +28081,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_args_with_defaults(): Func_args_with_defaultsContext { let _localctx: Func_args_with_defaultsContext = new Func_args_with_defaultsContext(this._ctx, this.state); - this.enterRule(_localctx, 626, PostgreSQLParser.RULE_func_args_with_defaults); + this.enterRule(_localctx, 640, PostgreSQLParser.RULE_func_args_with_defaults); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5677; + this.state = 5761; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5679; + this.state = 5763; 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)) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || _la === PostgreSQLParser.KW_IN || _la === PostgreSQLParser.KW_TABLE || ((((_la - 101)) & ~0x1F) === 0 && ((1 << (_la - 101)) & ((1 << (PostgreSQLParser.KW_VARIADIC - 101)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 101)) | (1 << (PostgreSQLParser.KW_BINARY - 101)) | (1 << (PostgreSQLParser.KW_COLLATION - 101)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 101)) | (1 << (PostgreSQLParser.KW_CROSS - 101)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 101)) | (1 << (PostgreSQLParser.KW_FREEZE - 101)) | (1 << (PostgreSQLParser.KW_FULL - 101)) | (1 << (PostgreSQLParser.KW_ILIKE - 101)) | (1 << (PostgreSQLParser.KW_INNER - 101)) | (1 << (PostgreSQLParser.KW_IS - 101)) | (1 << (PostgreSQLParser.KW_ISNULL - 101)) | (1 << (PostgreSQLParser.KW_JOIN - 101)) | (1 << (PostgreSQLParser.KW_LEFT - 101)) | (1 << (PostgreSQLParser.KW_LIKE - 101)) | (1 << (PostgreSQLParser.KW_NATURAL - 101)) | (1 << (PostgreSQLParser.KW_NOTNULL - 101)) | (1 << (PostgreSQLParser.KW_OUTER - 101)) | (1 << (PostgreSQLParser.KW_OVER - 101)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 101)) | (1 << (PostgreSQLParser.KW_RIGHT - 101)) | (1 << (PostgreSQLParser.KW_SIMILAR - 101)) | (1 << (PostgreSQLParser.KW_VERBOSE - 101)) | (1 << (PostgreSQLParser.KW_ABORT - 101)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 101)) | (1 << (PostgreSQLParser.KW_ACCESS - 101)) | (1 << (PostgreSQLParser.KW_ACTION - 101)))) !== 0) || ((((_la - 133)) & ~0x1F) === 0 && ((1 << (_la - 133)) & ((1 << (PostgreSQLParser.KW_ADD - 133)) | (1 << (PostgreSQLParser.KW_ADMIN - 133)) | (1 << (PostgreSQLParser.KW_AFTER - 133)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 133)) | (1 << (PostgreSQLParser.KW_ALSO - 133)) | (1 << (PostgreSQLParser.KW_ALTER - 133)) | (1 << (PostgreSQLParser.KW_ALWAYS - 133)) | (1 << (PostgreSQLParser.KW_ASSERTION - 133)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 133)) | (1 << (PostgreSQLParser.KW_AT - 133)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 133)) | (1 << (PostgreSQLParser.KW_BACKWARD - 133)) | (1 << (PostgreSQLParser.KW_BEFORE - 133)) | (1 << (PostgreSQLParser.KW_BEGIN - 133)) | (1 << (PostgreSQLParser.KW_BY - 133)) | (1 << (PostgreSQLParser.KW_CACHE - 133)) | (1 << (PostgreSQLParser.KW_CALLED - 133)) | (1 << (PostgreSQLParser.KW_CASCADE - 133)) | (1 << (PostgreSQLParser.KW_CASCADED - 133)) | (1 << (PostgreSQLParser.KW_CATALOG - 133)) | (1 << (PostgreSQLParser.KW_CHAIN - 133)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 133)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 133)) | (1 << (PostgreSQLParser.KW_CLASS - 133)) | (1 << (PostgreSQLParser.KW_CLOSE - 133)) | (1 << (PostgreSQLParser.KW_CLUSTER - 133)) | (1 << (PostgreSQLParser.KW_COMMENT - 133)) | (1 << (PostgreSQLParser.KW_COMMENTS - 133)) | (1 << (PostgreSQLParser.KW_COMMIT - 133)) | (1 << (PostgreSQLParser.KW_COMMITTED - 133)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 133)) | (1 << (PostgreSQLParser.KW_CONNECTION - 133)))) !== 0) || ((((_la - 165)) & ~0x1F) === 0 && ((1 << (_la - 165)) & ((1 << (PostgreSQLParser.KW_CONSTRAINTS - 165)) | (1 << (PostgreSQLParser.KW_CONTENT - 165)) | (1 << (PostgreSQLParser.KW_CONTINUE - 165)) | (1 << (PostgreSQLParser.KW_CONVERSION - 165)) | (1 << (PostgreSQLParser.KW_COPY - 165)) | (1 << (PostgreSQLParser.KW_COST - 165)) | (1 << (PostgreSQLParser.KW_CSV - 165)) | (1 << (PostgreSQLParser.KW_CURSOR - 165)) | (1 << (PostgreSQLParser.KW_CYCLE - 165)) | (1 << (PostgreSQLParser.KW_DATA - 165)) | (1 << (PostgreSQLParser.KW_DATABASE - 165)) | (1 << (PostgreSQLParser.KW_DAY - 165)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 165)) | (1 << (PostgreSQLParser.KW_DECLARE - 165)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 165)) | (1 << (PostgreSQLParser.KW_DEFERRED - 165)) | (1 << (PostgreSQLParser.KW_DEFINER - 165)) | (1 << (PostgreSQLParser.KW_DELETE - 165)) | (1 << (PostgreSQLParser.KW_DELIMITER - 165)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 165)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 165)) | (1 << (PostgreSQLParser.KW_DISABLE - 165)) | (1 << (PostgreSQLParser.KW_DISCARD - 165)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 165)) | (1 << (PostgreSQLParser.KW_DOMAIN - 165)) | (1 << (PostgreSQLParser.KW_DOUBLE - 165)) | (1 << (PostgreSQLParser.KW_DROP - 165)) | (1 << (PostgreSQLParser.KW_EACH - 165)) | (1 << (PostgreSQLParser.KW_ENABLE - 165)) | (1 << (PostgreSQLParser.KW_ENCODING - 165)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 165)) | (1 << (PostgreSQLParser.KW_ENUM - 165)))) !== 0) || ((((_la - 197)) & ~0x1F) === 0 && ((1 << (_la - 197)) & ((1 << (PostgreSQLParser.KW_ESCAPE - 197)) | (1 << (PostgreSQLParser.KW_EVENT - 197)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 197)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 197)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 197)) | (1 << (PostgreSQLParser.KW_EXECUTE - 197)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 197)) | (1 << (PostgreSQLParser.KW_EXTENSION - 197)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 197)) | (1 << (PostgreSQLParser.KW_FAMILY - 197)) | (1 << (PostgreSQLParser.KW_FIRST - 197)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 197)) | (1 << (PostgreSQLParser.KW_FORCE - 197)) | (1 << (PostgreSQLParser.KW_FORWARD - 197)) | (1 << (PostgreSQLParser.KW_FUNCTION - 197)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 197)) | (1 << (PostgreSQLParser.KW_GLOBAL - 197)) | (1 << (PostgreSQLParser.KW_GRANTED - 197)) | (1 << (PostgreSQLParser.KW_HANDLER - 197)) | (1 << (PostgreSQLParser.KW_HEADER - 197)) | (1 << (PostgreSQLParser.KW_HOLD - 197)) | (1 << (PostgreSQLParser.KW_HOUR - 197)) | (1 << (PostgreSQLParser.KW_IDENTITY - 197)) | (1 << (PostgreSQLParser.KW_IF - 197)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 197)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 197)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 197)) | (1 << (PostgreSQLParser.KW_INCLUDING - 197)) | (1 << (PostgreSQLParser.KW_INCREMENT - 197)) | (1 << (PostgreSQLParser.KW_INDEX - 197)) | (1 << (PostgreSQLParser.KW_INDEXES - 197)) | (1 << (PostgreSQLParser.KW_INHERIT - 197)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0)) { { - this.state = 5678; + this.state = 5762; this.func_args_with_defaults_list(); } } - this.state = 5681; + this.state = 5765; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -27230,26 +28119,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_args_with_defaults_list(): Func_args_with_defaults_listContext { let _localctx: Func_args_with_defaults_listContext = new Func_args_with_defaults_listContext(this._ctx, this.state); - this.enterRule(_localctx, 628, PostgreSQLParser.RULE_func_args_with_defaults_list); + this.enterRule(_localctx, 642, PostgreSQLParser.RULE_func_args_with_defaults_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5683; + this.state = 5767; this.func_arg_with_default(); - this.state = 5688; + this.state = 5772; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5684; + this.state = 5768; this.match(PostgreSQLParser.COMMA); - this.state = 5685; + this.state = 5769; this.func_arg_with_default(); } } - this.state = 5690; + this.state = 5774; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -27272,27 +28161,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_arg(): Func_argContext { let _localctx: Func_argContext = new Func_argContext(this._ctx, this.state); - this.enterRule(_localctx, 630, PostgreSQLParser.RULE_func_arg); + this.enterRule(_localctx, 644, PostgreSQLParser.RULE_func_arg); try { - this.state = 5704; + this.state = 5788; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 477, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 489, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5691; + this.state = 5775; this.arg_class(); - this.state = 5693; + this.state = 5777; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 475, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 487, this._ctx) ) { case 1: { - this.state = 5692; + this.state = 5776; this.param_name(); } break; } - this.state = 5695; + this.state = 5779; this.func_type(); } break; @@ -27300,19 +28189,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5697; + this.state = 5781; this.param_name(); - this.state = 5699; + this.state = 5783; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 476, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 488, this._ctx) ) { case 1: { - this.state = 5698; + this.state = 5782; this.arg_class(); } break; } - this.state = 5701; + this.state = 5785; this.func_type(); } break; @@ -27320,7 +28209,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5703; + this.state = 5787; this.func_type(); } break; @@ -27343,47 +28232,47 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public arg_class(): Arg_classContext { let _localctx: Arg_classContext = new Arg_classContext(this._ctx, this.state); - this.enterRule(_localctx, 632, PostgreSQLParser.RULE_arg_class); + this.enterRule(_localctx, 646, PostgreSQLParser.RULE_arg_class); try { - this.state = 5713; + this.state = 5797; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.IN_P: + case PostgreSQLParser.KW_IN: this.enterOuterAlt(_localctx, 1); { - this.state = 5706; - this.match(PostgreSQLParser.IN_P); - this.state = 5708; + this.state = 5790; + this.match(PostgreSQLParser.KW_IN); + this.state = 5792; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 478, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 490, this._ctx) ) { case 1: { - this.state = 5707; - this.match(PostgreSQLParser.OUT_P); + this.state = 5791; + this.match(PostgreSQLParser.KW_OUT); } break; } } break; - case PostgreSQLParser.OUT_P: + case PostgreSQLParser.KW_OUT: this.enterOuterAlt(_localctx, 2); { - this.state = 5710; - this.match(PostgreSQLParser.OUT_P); + this.state = 5794; + this.match(PostgreSQLParser.KW_OUT); } break; - case PostgreSQLParser.INOUT: + case PostgreSQLParser.KW_INOUT: this.enterOuterAlt(_localctx, 3); { - this.state = 5711; - this.match(PostgreSQLParser.INOUT); + this.state = 5795; + this.match(PostgreSQLParser.KW_INOUT); } break; - case PostgreSQLParser.VARIADIC: + case PostgreSQLParser.KW_VARIADIC: this.enterOuterAlt(_localctx, 4); { - this.state = 5712; - this.match(PostgreSQLParser.VARIADIC); + this.state = 5796; + this.match(PostgreSQLParser.KW_VARIADIC); } break; default: @@ -27407,11 +28296,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public param_name(): Param_nameContext { let _localctx: Param_nameContext = new Param_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 634, PostgreSQLParser.RULE_param_name); + this.enterRule(_localctx, 648, PostgreSQLParser.RULE_param_name); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5715; + this.state = 5799; this.type_function_name(); } } @@ -27432,11 +28321,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_return(): Func_returnContext { let _localctx: Func_returnContext = new Func_returnContext(this._ctx, this.state); - this.enterRule(_localctx, 636, PostgreSQLParser.RULE_func_return); + this.enterRule(_localctx, 650, PostgreSQLParser.RULE_func_return); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5717; + this.state = 5801; this.func_type(); } } @@ -27457,15 +28346,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_type(): Func_typeContext { let _localctx: Func_typeContext = new Func_typeContext(this._ctx, this.state); - this.enterRule(_localctx, 638, PostgreSQLParser.RULE_func_type); + this.enterRule(_localctx, 652, PostgreSQLParser.RULE_func_type); try { - this.state = 5731; + this.state = 5815; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 480, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 492, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5719; + this.state = 5803; this.typename(); } break; @@ -27473,30 +28362,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5720; + this.state = 5804; this.type_function_name(); - this.state = 5721; + this.state = 5805; this.attrs(); - this.state = 5722; + this.state = 5806; this.match(PostgreSQLParser.PERCENT); - this.state = 5723; - this.match(PostgreSQLParser.TYPE_P); + this.state = 5807; + this.match(PostgreSQLParser.KW_TYPE); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5725; - this.match(PostgreSQLParser.SETOF); - this.state = 5726; + this.state = 5809; + this.match(PostgreSQLParser.KW_SETOF); + this.state = 5810; this.type_function_name(); - this.state = 5727; + this.state = 5811; this.attrs(); - this.state = 5728; + this.state = 5812; this.match(PostgreSQLParser.PERCENT); - this.state = 5729; - this.match(PostgreSQLParser.TYPE_P); + this.state = 5813; + this.match(PostgreSQLParser.KW_TYPE); } break; } @@ -27518,21 +28407,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_arg_with_default(): Func_arg_with_defaultContext { let _localctx: Func_arg_with_defaultContext = new Func_arg_with_defaultContext(this._ctx, this.state); - this.enterRule(_localctx, 640, PostgreSQLParser.RULE_func_arg_with_default); + this.enterRule(_localctx, 654, PostgreSQLParser.RULE_func_arg_with_default); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5733; + this.state = 5817; this.func_arg(); - this.state = 5736; + this.state = 5820; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.EQUAL || _la === PostgreSQLParser.DEFAULT) { + if (_la === PostgreSQLParser.EQUAL || _la === PostgreSQLParser.KW_DEFAULT) { { - this.state = 5734; + this.state = 5818; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.EQUAL || _la === PostgreSQLParser.DEFAULT)) { + if (!(_la === PostgreSQLParser.EQUAL || _la === PostgreSQLParser.KW_DEFAULT)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -27542,7 +28431,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 5735; + this.state = 5819; this.a_expr(); } } @@ -27566,11 +28455,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public aggr_arg(): Aggr_argContext { let _localctx: Aggr_argContext = new Aggr_argContext(this._ctx, this.state); - this.enterRule(_localctx, 642, PostgreSQLParser.RULE_aggr_arg); + this.enterRule(_localctx, 656, PostgreSQLParser.RULE_aggr_arg); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5738; + this.state = 5822; this.func_arg(); } } @@ -27591,54 +28480,54 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public aggr_args(): Aggr_argsContext { let _localctx: Aggr_argsContext = new Aggr_argsContext(this._ctx, this.state); - this.enterRule(_localctx, 644, PostgreSQLParser.RULE_aggr_args); + this.enterRule(_localctx, 658, PostgreSQLParser.RULE_aggr_args); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5740; + this.state = 5824; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5751; + this.state = 5835; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 482, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 494, this._ctx) ) { case 1: { - this.state = 5741; + this.state = 5825; this.match(PostgreSQLParser.STAR); } break; case 2: { - this.state = 5742; + this.state = 5826; this.aggr_args_list(); } break; case 3: { - this.state = 5743; - this.match(PostgreSQLParser.ORDER); - this.state = 5744; - this.match(PostgreSQLParser.BY); - this.state = 5745; + this.state = 5827; + this.match(PostgreSQLParser.KW_ORDER); + this.state = 5828; + this.match(PostgreSQLParser.KW_BY); + this.state = 5829; this.aggr_args_list(); } break; case 4: { - this.state = 5746; + this.state = 5830; this.aggr_args_list(); - this.state = 5747; - this.match(PostgreSQLParser.ORDER); - this.state = 5748; - this.match(PostgreSQLParser.BY); - this.state = 5749; + this.state = 5831; + this.match(PostgreSQLParser.KW_ORDER); + this.state = 5832; + this.match(PostgreSQLParser.KW_BY); + this.state = 5833; this.aggr_args_list(); } break; } - this.state = 5753; + this.state = 5837; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -27659,26 +28548,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public aggr_args_list(): Aggr_args_listContext { let _localctx: Aggr_args_listContext = new Aggr_args_listContext(this._ctx, this.state); - this.enterRule(_localctx, 646, PostgreSQLParser.RULE_aggr_args_list); + this.enterRule(_localctx, 660, PostgreSQLParser.RULE_aggr_args_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5755; + this.state = 5839; this.aggr_arg(); - this.state = 5760; + this.state = 5844; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5756; + this.state = 5840; this.match(PostgreSQLParser.COMMA); - this.state = 5757; + this.state = 5841; this.aggr_arg(); } } - this.state = 5762; + this.state = 5846; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -27701,13 +28590,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public aggregate_with_argtypes(): Aggregate_with_argtypesContext { let _localctx: Aggregate_with_argtypesContext = new Aggregate_with_argtypesContext(this._ctx, this.state); - this.enterRule(_localctx, 648, PostgreSQLParser.RULE_aggregate_with_argtypes); + this.enterRule(_localctx, 662, PostgreSQLParser.RULE_aggregate_with_argtypes); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5763; + this.state = 5847; this.func_name(); - this.state = 5764; + this.state = 5848; this.aggr_args(); } } @@ -27728,26 +28617,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public aggregate_with_argtypes_list(): Aggregate_with_argtypes_listContext { let _localctx: Aggregate_with_argtypes_listContext = new Aggregate_with_argtypes_listContext(this._ctx, this.state); - this.enterRule(_localctx, 650, PostgreSQLParser.RULE_aggregate_with_argtypes_list); + this.enterRule(_localctx, 664, PostgreSQLParser.RULE_aggregate_with_argtypes_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5766; + this.state = 5850; this.aggregate_with_argtypes(); - this.state = 5771; + this.state = 5855; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5767; + this.state = 5851; this.match(PostgreSQLParser.COMMA); - this.state = 5768; + this.state = 5852; this.aggregate_with_argtypes(); } } - this.state = 5773; + this.state = 5857; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -27770,12 +28659,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createfunc_opt_list(): Createfunc_opt_listContext { let _localctx: Createfunc_opt_listContext = new Createfunc_opt_listContext(this._ctx, this.state); - this.enterRule(_localctx, 652, PostgreSQLParser.RULE_createfunc_opt_list); + this.enterRule(_localctx, 666, PostgreSQLParser.RULE_createfunc_opt_list); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 5775; + this.state = 5859; this._errHandler.sync(this); _alt = 1; do { @@ -27783,7 +28672,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 1: { { - this.state = 5774; + this.state = 5858; this.createfunc_opt_item(); } } @@ -27791,13 +28680,10 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 5777; + this.state = 5861; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 485, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 497, this._ctx); } while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER); - - this.ParseRoutineBody(_localctx); - } } catch (re) { @@ -27817,141 +28703,141 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public common_func_opt_item(): Common_func_opt_itemContext { let _localctx: Common_func_opt_itemContext = new Common_func_opt_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 654, PostgreSQLParser.RULE_common_func_opt_item); + this.enterRule(_localctx, 668, PostgreSQLParser.RULE_common_func_opt_item); try { - this.state = 5816; + this.state = 5898; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 486, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 498, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5781; - this.match(PostgreSQLParser.CALLED); - this.state = 5782; - this.match(PostgreSQLParser.ON); - this.state = 5783; - this.match(PostgreSQLParser.NULL_P); - this.state = 5784; - this.match(PostgreSQLParser.INPUT_P); + this.state = 5863; + this.match(PostgreSQLParser.KW_CALLED); + this.state = 5864; + this.match(PostgreSQLParser.KW_ON); + this.state = 5865; + this.match(PostgreSQLParser.KW_NULL); + this.state = 5866; + this.match(PostgreSQLParser.KW_INPUT); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5785; - this.match(PostgreSQLParser.RETURNS); - this.state = 5786; - this.match(PostgreSQLParser.NULL_P); - this.state = 5787; - this.match(PostgreSQLParser.ON); - this.state = 5788; - this.match(PostgreSQLParser.NULL_P); - this.state = 5789; - this.match(PostgreSQLParser.INPUT_P); + this.state = 5867; + this.match(PostgreSQLParser.KW_RETURNS); + this.state = 5868; + this.match(PostgreSQLParser.KW_NULL); + this.state = 5869; + this.match(PostgreSQLParser.KW_ON); + this.state = 5870; + this.match(PostgreSQLParser.KW_NULL); + this.state = 5871; + this.match(PostgreSQLParser.KW_INPUT); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5790; - this.match(PostgreSQLParser.STRICT_P); + this.state = 5872; + this.match(PostgreSQLParser.KW_STRICT); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 5791; - this.match(PostgreSQLParser.IMMUTABLE); + this.state = 5873; + this.match(PostgreSQLParser.KW_IMMUTABLE); } break; case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 5792; - this.match(PostgreSQLParser.STABLE); + this.state = 5874; + this.match(PostgreSQLParser.KW_STABLE); } break; case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 5793; - this.match(PostgreSQLParser.VOLATILE); + this.state = 5875; + this.match(PostgreSQLParser.KW_VOLATILE); } break; case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 5794; - this.match(PostgreSQLParser.EXTERNAL); - this.state = 5795; - this.match(PostgreSQLParser.SECURITY); - this.state = 5796; - this.match(PostgreSQLParser.DEFINER); + this.state = 5876; + this.match(PostgreSQLParser.KW_EXTERNAL); + this.state = 5877; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5878; + this.match(PostgreSQLParser.KW_DEFINER); } break; case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 5797; - this.match(PostgreSQLParser.EXTERNAL); - this.state = 5798; - this.match(PostgreSQLParser.SECURITY); - this.state = 5799; - this.match(PostgreSQLParser.INVOKER); + this.state = 5879; + this.match(PostgreSQLParser.KW_EXTERNAL); + this.state = 5880; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5881; + this.match(PostgreSQLParser.KW_INVOKER); } break; case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 5800; - this.match(PostgreSQLParser.SECURITY); - this.state = 5801; - this.match(PostgreSQLParser.DEFINER); + this.state = 5882; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5883; + this.match(PostgreSQLParser.KW_DEFINER); } break; case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 5802; - this.match(PostgreSQLParser.SECURITY); - this.state = 5803; - this.match(PostgreSQLParser.INVOKER); + this.state = 5884; + this.match(PostgreSQLParser.KW_SECURITY); + this.state = 5885; + this.match(PostgreSQLParser.KW_INVOKER); } break; case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 5804; - this.match(PostgreSQLParser.LEAKPROOF); + this.state = 5886; + this.match(PostgreSQLParser.KW_LEAKPROOF); } break; case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 5805; - this.match(PostgreSQLParser.NOT); - this.state = 5806; - this.match(PostgreSQLParser.LEAKPROOF); + this.state = 5887; + this.match(PostgreSQLParser.KW_NOT); + this.state = 5888; + this.match(PostgreSQLParser.KW_LEAKPROOF); } break; case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 5807; - this.match(PostgreSQLParser.COST); - this.state = 5808; + this.state = 5889; + this.match(PostgreSQLParser.KW_COST); + this.state = 5890; this.numericonly(); } break; @@ -27959,9 +28845,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 5809; - this.match(PostgreSQLParser.ROWS); - this.state = 5810; + this.state = 5891; + this.match(PostgreSQLParser.KW_ROWS); + this.state = 5892; this.numericonly(); } break; @@ -27969,9 +28855,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 5811; - this.match(PostgreSQLParser.SUPPORT); - this.state = 5812; + this.state = 5893; + this.match(PostgreSQLParser.KW_SUPPORT); + this.state = 5894; this.any_name(); } break; @@ -27979,7 +28865,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 5813; + this.state = 5895; this.functionsetresetclause(); } break; @@ -27987,9 +28873,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 5814; - this.match(PostgreSQLParser.PARALLEL); - this.state = 5815; + this.state = 5896; + this.match(PostgreSQLParser.KW_PARALLEL); + this.state = 5897; this.colid(); } break; @@ -28012,64 +28898,64 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createfunc_opt_item(): Createfunc_opt_itemContext { let _localctx: Createfunc_opt_itemContext = new Createfunc_opt_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 656, PostgreSQLParser.RULE_createfunc_opt_item); + this.enterRule(_localctx, 670, PostgreSQLParser.RULE_createfunc_opt_item); try { - this.state = 5826; + this.state = 5908; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.AS: + case PostgreSQLParser.KW_AS: this.enterOuterAlt(_localctx, 1); { - this.state = 5818; - this.match(PostgreSQLParser.AS); - this.state = 5819; + this.state = 5900; + this.match(PostgreSQLParser.KW_AS); + this.state = 5901; this.func_as(); } break; - case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.KW_LANGUAGE: this.enterOuterAlt(_localctx, 2); { - this.state = 5820; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 5821; + this.state = 5902; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 5903; this.nonreservedword_or_sconst(); } break; - case PostgreSQLParser.TRANSFORM: + case PostgreSQLParser.KW_TRANSFORM: this.enterOuterAlt(_localctx, 3); { - this.state = 5822; - this.match(PostgreSQLParser.TRANSFORM); - this.state = 5823; + this.state = 5904; + this.match(PostgreSQLParser.KW_TRANSFORM); + this.state = 5905; this.transform_type_list(); } break; - case PostgreSQLParser.WINDOW: + case PostgreSQLParser.KW_WINDOW: this.enterOuterAlt(_localctx, 4); { - this.state = 5824; - this.match(PostgreSQLParser.WINDOW); + this.state = 5906; + this.match(PostgreSQLParser.KW_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: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: this.enterOuterAlt(_localctx, 5); { - this.state = 5825; + this.state = 5907; this.common_func_opt_item(); } break; @@ -28094,15 +28980,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_as(): Func_asContext { let _localctx: Func_asContext = new Func_asContext(this._ctx, this.state); - this.enterRule(_localctx, 658, PostgreSQLParser.RULE_func_as); + this.enterRule(_localctx, 672, PostgreSQLParser.RULE_func_as); try { - this.state = 5833; + this.state = 5915; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 488, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 500, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5828; + this.state = 5910; _localctx._def = this.sconst(); } break; @@ -28110,11 +28996,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5829; + this.state = 5911; this.sconst(); - this.state = 5830; + this.state = 5912; this.match(PostgreSQLParser.COMMA); - this.state = 5831; + this.state = 5913; this.sconst(); } break; @@ -28137,34 +29023,34 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public transform_type_list(): Transform_type_listContext { let _localctx: Transform_type_listContext = new Transform_type_listContext(this._ctx, this.state); - this.enterRule(_localctx, 660, PostgreSQLParser.RULE_transform_type_list); + this.enterRule(_localctx, 674, PostgreSQLParser.RULE_transform_type_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5835; - this.match(PostgreSQLParser.FOR); - this.state = 5836; - this.match(PostgreSQLParser.TYPE_P); - this.state = 5837; + this.state = 5917; + this.match(PostgreSQLParser.KW_FOR); + this.state = 5918; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 5919; this.typename(); - this.state = 5844; + this.state = 5926; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5838; + this.state = 5920; this.match(PostgreSQLParser.COMMA); - this.state = 5839; - this.match(PostgreSQLParser.FOR); - this.state = 5840; - this.match(PostgreSQLParser.TYPE_P); - this.state = 5841; + this.state = 5921; + this.match(PostgreSQLParser.KW_FOR); + this.state = 5922; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 5923; this.typename(); } } - this.state = 5846; + this.state = 5928; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -28187,13 +29073,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_definition(): Opt_definitionContext { let _localctx: Opt_definitionContext = new Opt_definitionContext(this._ctx, this.state); - this.enterRule(_localctx, 662, PostgreSQLParser.RULE_opt_definition); + this.enterRule(_localctx, 676, PostgreSQLParser.RULE_opt_definition); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5847; - this.match(PostgreSQLParser.WITH); - this.state = 5848; + this.state = 5929; + this.match(PostgreSQLParser.KW_WITH); + this.state = 5930; this.definition(); } } @@ -28214,13 +29100,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public table_func_column(): Table_func_columnContext { let _localctx: Table_func_columnContext = new Table_func_columnContext(this._ctx, this.state); - this.enterRule(_localctx, 664, PostgreSQLParser.RULE_table_func_column); + this.enterRule(_localctx, 678, PostgreSQLParser.RULE_table_func_column); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5850; + this.state = 5932; this.param_name(); - this.state = 5851; + this.state = 5933; this.func_type(); } } @@ -28241,26 +29127,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public table_func_column_list(): Table_func_column_listContext { let _localctx: Table_func_column_listContext = new Table_func_column_listContext(this._ctx, this.state); - this.enterRule(_localctx, 666, PostgreSQLParser.RULE_table_func_column_list); + this.enterRule(_localctx, 680, PostgreSQLParser.RULE_table_func_column_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5853; + this.state = 5935; this.table_func_column(); - this.state = 5858; + this.state = 5940; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5854; + this.state = 5936; this.match(PostgreSQLParser.COMMA); - this.state = 5855; + this.state = 5937; this.table_func_column(); } } - this.state = 5860; + this.state = 5942; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -28283,16 +29169,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterfunctionstmt(): AlterfunctionstmtContext { let _localctx: AlterfunctionstmtContext = new AlterfunctionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 668, PostgreSQLParser.RULE_alterfunctionstmt); + this.enterRule(_localctx, 682, PostgreSQLParser.RULE_alterfunctionstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5861; - this.match(PostgreSQLParser.ALTER); - this.state = 5862; + this.state = 5943; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 5944; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FUNCTION || _la === PostgreSQLParser.PROCEDURE || _la === PostgreSQLParser.ROUTINE)) { + if (!(_la === PostgreSQLParser.KW_FUNCTION || _la === PostgreSQLParser.KW_PROCEDURE || _la === PostgreSQLParser.KW_ROUTINE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -28302,16 +29188,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 5863; + this.state = 5945; this.function_with_argtypes(); - this.state = 5864; + this.state = 5946; this.alterfunc_opt_list(); - this.state = 5866; + this.state = 5948; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5865; + this.state = 5947; this.opt_restrict(); } } @@ -28335,12 +29221,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterfunc_opt_list(): Alterfunc_opt_listContext { let _localctx: Alterfunc_opt_listContext = new Alterfunc_opt_listContext(this._ctx, this.state); - this.enterRule(_localctx, 670, PostgreSQLParser.RULE_alterfunc_opt_list); + this.enterRule(_localctx, 684, PostgreSQLParser.RULE_alterfunc_opt_list); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 5869; + this.state = 5951; this._errHandler.sync(this); _alt = 1; do { @@ -28348,7 +29234,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 1: { { - this.state = 5868; + this.state = 5950; this.common_func_opt_item(); } } @@ -28356,9 +29242,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 5871; + this.state = 5953; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 492, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 504, this._ctx); } while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER); } } @@ -28379,12 +29265,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_restrict(): Opt_restrictContext { let _localctx: Opt_restrictContext = new Opt_restrictContext(this._ctx, this.state); - this.enterRule(_localctx, 672, PostgreSQLParser.RULE_opt_restrict); + this.enterRule(_localctx, 686, PostgreSQLParser.RULE_opt_restrict); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5873; - this.match(PostgreSQLParser.RESTRICT); + this.state = 5955; + this.match(PostgreSQLParser.KW_RESTRICT); } } catch (re) { @@ -28404,27 +29290,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public removefuncstmt(): RemovefuncstmtContext { let _localctx: RemovefuncstmtContext = new RemovefuncstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 674, PostgreSQLParser.RULE_removefuncstmt); + this.enterRule(_localctx, 688, PostgreSQLParser.RULE_removefuncstmt); let _la: number; try { - this.state = 5917; + this.state = 5999; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 499, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 511, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5875; - this.match(PostgreSQLParser.DROP); - this.state = 5876; - this.match(PostgreSQLParser.FUNCTION); - this.state = 5877; + this.state = 5957; + this.match(PostgreSQLParser.KW_DROP); + this.state = 5958; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 5959; this.function_with_argtypes_list(); - this.state = 5879; + this.state = 5961; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5878; + this.state = 5960; this.opt_drop_behavior(); } } @@ -28435,22 +29321,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5881; - this.match(PostgreSQLParser.DROP); - this.state = 5882; - this.match(PostgreSQLParser.FUNCTION); - this.state = 5883; - this.match(PostgreSQLParser.IF_P); - this.state = 5884; - this.match(PostgreSQLParser.EXISTS); - this.state = 5885; + this.state = 5963; + this.match(PostgreSQLParser.KW_DROP); + this.state = 5964; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 5965; + this.match(PostgreSQLParser.KW_IF); + this.state = 5966; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 5967; this.function_with_argtypes_list(); - this.state = 5887; + this.state = 5969; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5886; + this.state = 5968; this.opt_drop_behavior(); } } @@ -28461,18 +29347,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5889; - this.match(PostgreSQLParser.DROP); - this.state = 5890; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 5891; + this.state = 5971; + this.match(PostgreSQLParser.KW_DROP); + this.state = 5972; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 5973; this.function_with_argtypes_list(); - this.state = 5893; + this.state = 5975; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5892; + this.state = 5974; this.opt_drop_behavior(); } } @@ -28483,22 +29369,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 5895; - this.match(PostgreSQLParser.DROP); - this.state = 5896; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 5897; - this.match(PostgreSQLParser.IF_P); - this.state = 5898; - this.match(PostgreSQLParser.EXISTS); - this.state = 5899; + this.state = 5977; + this.match(PostgreSQLParser.KW_DROP); + this.state = 5978; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 5979; + this.match(PostgreSQLParser.KW_IF); + this.state = 5980; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 5981; this.function_with_argtypes_list(); - this.state = 5901; + this.state = 5983; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5900; + this.state = 5982; this.opt_drop_behavior(); } } @@ -28509,18 +29395,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 5903; - this.match(PostgreSQLParser.DROP); - this.state = 5904; - this.match(PostgreSQLParser.ROUTINE); - this.state = 5905; + this.state = 5985; + this.match(PostgreSQLParser.KW_DROP); + this.state = 5986; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 5987; this.function_with_argtypes_list(); - this.state = 5907; + this.state = 5989; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5906; + this.state = 5988; this.opt_drop_behavior(); } } @@ -28531,22 +29417,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 5909; - this.match(PostgreSQLParser.DROP); - this.state = 5910; - this.match(PostgreSQLParser.ROUTINE); - this.state = 5911; - this.match(PostgreSQLParser.IF_P); - this.state = 5912; - this.match(PostgreSQLParser.EXISTS); - this.state = 5913; + this.state = 5991; + this.match(PostgreSQLParser.KW_DROP); + this.state = 5992; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 5993; + this.match(PostgreSQLParser.KW_IF); + this.state = 5994; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 5995; this.function_with_argtypes_list(); - this.state = 5915; + this.state = 5997; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5914; + this.state = 5996; this.opt_drop_behavior(); } } @@ -28572,27 +29458,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public removeaggrstmt(): RemoveaggrstmtContext { let _localctx: RemoveaggrstmtContext = new RemoveaggrstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 676, PostgreSQLParser.RULE_removeaggrstmt); + this.enterRule(_localctx, 690, PostgreSQLParser.RULE_removeaggrstmt); let _la: number; try { - this.state = 5933; + this.state = 6015; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 502, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 514, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5919; - this.match(PostgreSQLParser.DROP); - this.state = 5920; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 5921; + this.state = 6001; + this.match(PostgreSQLParser.KW_DROP); + this.state = 6002; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 6003; this.aggregate_with_argtypes_list(); - this.state = 5923; + this.state = 6005; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5922; + this.state = 6004; this.opt_drop_behavior(); } } @@ -28603,22 +29489,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5925; - this.match(PostgreSQLParser.DROP); - this.state = 5926; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 5927; - this.match(PostgreSQLParser.IF_P); - this.state = 5928; - this.match(PostgreSQLParser.EXISTS); - this.state = 5929; + this.state = 6007; + this.match(PostgreSQLParser.KW_DROP); + this.state = 6008; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 6009; + this.match(PostgreSQLParser.KW_IF); + this.state = 6010; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6011; this.aggregate_with_argtypes_list(); - this.state = 5931; + this.state = 6013; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5930; + this.state = 6012; this.opt_drop_behavior(); } } @@ -28644,27 +29530,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public removeoperstmt(): RemoveoperstmtContext { let _localctx: RemoveoperstmtContext = new RemoveoperstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 678, PostgreSQLParser.RULE_removeoperstmt); + this.enterRule(_localctx, 692, PostgreSQLParser.RULE_removeoperstmt); let _la: number; try { - this.state = 5949; + this.state = 6031; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 505, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 517, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5935; - this.match(PostgreSQLParser.DROP); - this.state = 5936; - this.match(PostgreSQLParser.OPERATOR); - this.state = 5937; + this.state = 6017; + this.match(PostgreSQLParser.KW_DROP); + this.state = 6018; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 6019; this.operator_with_argtypes_list(); - this.state = 5939; + this.state = 6021; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5938; + this.state = 6020; this.opt_drop_behavior(); } } @@ -28675,22 +29561,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5941; - this.match(PostgreSQLParser.DROP); - this.state = 5942; - this.match(PostgreSQLParser.OPERATOR); - this.state = 5943; - this.match(PostgreSQLParser.IF_P); - this.state = 5944; - this.match(PostgreSQLParser.EXISTS); - this.state = 5945; + this.state = 6023; + this.match(PostgreSQLParser.KW_DROP); + this.state = 6024; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 6025; + this.match(PostgreSQLParser.KW_IF); + this.state = 6026; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6027; this.operator_with_argtypes_list(); - this.state = 5947; + this.state = 6029; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 5946; + this.state = 6028; this.opt_drop_behavior(); } } @@ -28716,19 +29602,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public oper_argtypes(): Oper_argtypesContext { let _localctx: Oper_argtypesContext = new Oper_argtypesContext(this._ctx, this.state); - this.enterRule(_localctx, 680, PostgreSQLParser.RULE_oper_argtypes); + this.enterRule(_localctx, 694, PostgreSQLParser.RULE_oper_argtypes); try { - this.state = 5973; + this.state = 6055; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 506, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 518, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 5951; + this.state = 6033; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5952; + this.state = 6034; this.typename(); - this.state = 5953; + this.state = 6035; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -28736,15 +29622,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 5955; + this.state = 6037; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5956; + this.state = 6038; this.typename(); - this.state = 5957; + this.state = 6039; this.match(PostgreSQLParser.COMMA); - this.state = 5958; + this.state = 6040; this.typename(); - this.state = 5959; + this.state = 6041; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -28752,15 +29638,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 5961; + this.state = 6043; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5962; - this.match(PostgreSQLParser.NONE); - this.state = 5963; + this.state = 6044; + this.match(PostgreSQLParser.KW_NONE); + this.state = 6045; this.match(PostgreSQLParser.COMMA); - this.state = 5964; + this.state = 6046; this.typename(); - this.state = 5965; + this.state = 6047; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -28768,15 +29654,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 5967; + this.state = 6049; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 5968; + this.state = 6050; this.typename(); - this.state = 5969; + this.state = 6051; this.match(PostgreSQLParser.COMMA); - this.state = 5970; - this.match(PostgreSQLParser.NONE); - this.state = 5971; + this.state = 6052; + this.match(PostgreSQLParser.KW_NONE); + this.state = 6053; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -28799,28 +29685,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public any_operator(): Any_operatorContext { let _localctx: Any_operatorContext = new Any_operatorContext(this._ctx, this.state); - this.enterRule(_localctx, 682, PostgreSQLParser.RULE_any_operator); + this.enterRule(_localctx, 696, PostgreSQLParser.RULE_any_operator); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5980; + this.state = 6062; 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)) { + while (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.KW_OVER - 124)) | (1 << (PostgreSQLParser.KW_ABORT - 124)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 124)) | (1 << (PostgreSQLParser.KW_ACCESS - 124)) | (1 << (PostgreSQLParser.KW_ACTION - 124)) | (1 << (PostgreSQLParser.KW_ADD - 124)) | (1 << (PostgreSQLParser.KW_ADMIN - 124)) | (1 << (PostgreSQLParser.KW_AFTER - 124)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 124)) | (1 << (PostgreSQLParser.KW_ALSO - 124)) | (1 << (PostgreSQLParser.KW_ALTER - 124)) | (1 << (PostgreSQLParser.KW_ALWAYS - 124)) | (1 << (PostgreSQLParser.KW_ASSERTION - 124)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.KW_AT - 124)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.KW_BACKWARD - 124)) | (1 << (PostgreSQLParser.KW_BEFORE - 124)) | (1 << (PostgreSQLParser.KW_BEGIN - 124)) | (1 << (PostgreSQLParser.KW_BY - 124)) | (1 << (PostgreSQLParser.KW_CACHE - 124)) | (1 << (PostgreSQLParser.KW_CALLED - 124)) | (1 << (PostgreSQLParser.KW_CASCADE - 124)) | (1 << (PostgreSQLParser.KW_CASCADED - 124)) | (1 << (PostgreSQLParser.KW_CATALOG - 124)) | (1 << (PostgreSQLParser.KW_CHAIN - 124)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.KW_CLASS - 156)) | (1 << (PostgreSQLParser.KW_CLOSE - 156)) | (1 << (PostgreSQLParser.KW_CLUSTER - 156)) | (1 << (PostgreSQLParser.KW_COMMENT - 156)) | (1 << (PostgreSQLParser.KW_COMMENTS - 156)) | (1 << (PostgreSQLParser.KW_COMMIT - 156)) | (1 << (PostgreSQLParser.KW_COMMITTED - 156)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 156)) | (1 << (PostgreSQLParser.KW_CONNECTION - 156)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.KW_CONTENT - 156)) | (1 << (PostgreSQLParser.KW_CONTINUE - 156)) | (1 << (PostgreSQLParser.KW_CONVERSION - 156)) | (1 << (PostgreSQLParser.KW_COPY - 156)) | (1 << (PostgreSQLParser.KW_COST - 156)) | (1 << (PostgreSQLParser.KW_CSV - 156)) | (1 << (PostgreSQLParser.KW_CURSOR - 156)) | (1 << (PostgreSQLParser.KW_CYCLE - 156)) | (1 << (PostgreSQLParser.KW_DATA - 156)) | (1 << (PostgreSQLParser.KW_DATABASE - 156)) | (1 << (PostgreSQLParser.KW_DAY - 156)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 156)) | (1 << (PostgreSQLParser.KW_DECLARE - 156)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 156)) | (1 << (PostgreSQLParser.KW_DEFERRED - 156)) | (1 << (PostgreSQLParser.KW_DEFINER - 156)) | (1 << (PostgreSQLParser.KW_DELETE - 156)) | (1 << (PostgreSQLParser.KW_DELIMITER - 156)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 156)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 156)) | (1 << (PostgreSQLParser.KW_DISABLE - 156)) | (1 << (PostgreSQLParser.KW_DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.KW_DOCUMENT - 188)) | (1 << (PostgreSQLParser.KW_DOMAIN - 188)) | (1 << (PostgreSQLParser.KW_DOUBLE - 188)) | (1 << (PostgreSQLParser.KW_DROP - 188)) | (1 << (PostgreSQLParser.KW_EACH - 188)) | (1 << (PostgreSQLParser.KW_ENABLE - 188)) | (1 << (PostgreSQLParser.KW_ENCODING - 188)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 188)) | (1 << (PostgreSQLParser.KW_ENUM - 188)) | (1 << (PostgreSQLParser.KW_ESCAPE - 188)) | (1 << (PostgreSQLParser.KW_EVENT - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 188)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.KW_EXECUTE - 188)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 188)) | (1 << (PostgreSQLParser.KW_EXTENSION - 188)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 188)) | (1 << (PostgreSQLParser.KW_FAMILY - 188)) | (1 << (PostgreSQLParser.KW_FIRST - 188)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 188)) | (1 << (PostgreSQLParser.KW_FORCE - 188)) | (1 << (PostgreSQLParser.KW_FORWARD - 188)) | (1 << (PostgreSQLParser.KW_FUNCTION - 188)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 188)) | (1 << (PostgreSQLParser.KW_GLOBAL - 188)) | (1 << (PostgreSQLParser.KW_GRANTED - 188)) | (1 << (PostgreSQLParser.KW_HANDLER - 188)) | (1 << (PostgreSQLParser.KW_HEADER - 188)) | (1 << (PostgreSQLParser.KW_HOLD - 188)) | (1 << (PostgreSQLParser.KW_HOUR - 188)) | (1 << (PostgreSQLParser.KW_IDENTITY - 188)))) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.KW_IF - 220)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 220)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 220)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 220)) | (1 << (PostgreSQLParser.KW_INCLUDING - 220)) | (1 << (PostgreSQLParser.KW_INCREMENT - 220)) | (1 << (PostgreSQLParser.KW_INDEX - 220)) | (1 << (PostgreSQLParser.KW_INDEXES - 220)) | (1 << (PostgreSQLParser.KW_INHERIT - 220)) | (1 << (PostgreSQLParser.KW_INHERITS - 220)) | (1 << (PostgreSQLParser.KW_INLINE - 220)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 220)) | (1 << (PostgreSQLParser.KW_INSERT - 220)) | (1 << (PostgreSQLParser.KW_INSTEAD - 220)) | (1 << (PostgreSQLParser.KW_INVOKER - 220)) | (1 << (PostgreSQLParser.KW_ISOLATION - 220)) | (1 << (PostgreSQLParser.KW_KEY - 220)) | (1 << (PostgreSQLParser.KW_LABEL - 220)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 220)) | (1 << (PostgreSQLParser.KW_LARGE - 220)) | (1 << (PostgreSQLParser.KW_LAST - 220)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 220)) | (1 << (PostgreSQLParser.KW_LEVEL - 220)))) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.KW_LISTEN - 252)) | (1 << (PostgreSQLParser.KW_LOAD - 252)) | (1 << (PostgreSQLParser.KW_LOCAL - 252)) | (1 << (PostgreSQLParser.KW_LOCATION - 252)) | (1 << (PostgreSQLParser.KW_LOCK - 252)) | (1 << (PostgreSQLParser.KW_MAPPING - 252)) | (1 << (PostgreSQLParser.KW_MATCH - 252)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 252)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 252)) | (1 << (PostgreSQLParser.KW_MINUTE - 252)) | (1 << (PostgreSQLParser.KW_MINVALUE - 252)) | (1 << (PostgreSQLParser.KW_MODE - 252)) | (1 << (PostgreSQLParser.KW_MONTH - 252)) | (1 << (PostgreSQLParser.KW_MOVE - 252)) | (1 << (PostgreSQLParser.KW_NAME - 252)) | (1 << (PostgreSQLParser.KW_NAMES - 252)) | (1 << (PostgreSQLParser.KW_NEXT - 252)) | (1 << (PostgreSQLParser.KW_NO - 252)) | (1 << (PostgreSQLParser.KW_NOTHING - 252)) | (1 << (PostgreSQLParser.KW_NOTIFY - 252)) | (1 << (PostgreSQLParser.KW_NOWAIT - 252)) | (1 << (PostgreSQLParser.KW_NULLS - 252)) | (1 << (PostgreSQLParser.KW_OBJECT - 252)) | (1 << (PostgreSQLParser.KW_OF - 252)) | (1 << (PostgreSQLParser.KW_OFF - 252)) | (1 << (PostgreSQLParser.KW_OIDS - 252)) | (1 << (PostgreSQLParser.KW_OPERATOR - 252)) | (1 << (PostgreSQLParser.KW_OPTION - 252)) | (1 << (PostgreSQLParser.KW_OPTIONS - 252)) | (1 << (PostgreSQLParser.KW_OWNED - 252)) | (1 << (PostgreSQLParser.KW_OWNER - 252)) | (1 << (PostgreSQLParser.KW_PARSER - 252)))) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.KW_PARTIAL - 284)) | (1 << (PostgreSQLParser.KW_PARTITION - 284)) | (1 << (PostgreSQLParser.KW_PASSING - 284)) | (1 << (PostgreSQLParser.KW_PASSWORD - 284)) | (1 << (PostgreSQLParser.KW_PLANS - 284)) | (1 << (PostgreSQLParser.KW_PRECEDING - 284)) | (1 << (PostgreSQLParser.KW_PREPARE - 284)) | (1 << (PostgreSQLParser.KW_PREPARED - 284)) | (1 << (PostgreSQLParser.KW_PRESERVE - 284)) | (1 << (PostgreSQLParser.KW_PRIOR - 284)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 284)) | (1 << (PostgreSQLParser.KW_PROGRAM - 284)) | (1 << (PostgreSQLParser.KW_QUOTE - 284)) | (1 << (PostgreSQLParser.KW_RANGE - 284)) | (1 << (PostgreSQLParser.KW_READ - 284)) | (1 << (PostgreSQLParser.KW_REASSIGN - 284)) | (1 << (PostgreSQLParser.KW_RECHECK - 284)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 284)) | (1 << (PostgreSQLParser.KW_REF - 284)) | (1 << (PostgreSQLParser.KW_REFRESH - 284)) | (1 << (PostgreSQLParser.KW_REINDEX - 284)) | (1 << (PostgreSQLParser.KW_RELATIVE - 284)) | (1 << (PostgreSQLParser.KW_RELEASE - 284)) | (1 << (PostgreSQLParser.KW_RENAME - 284)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 284)) | (1 << (PostgreSQLParser.KW_REPLACE - 284)) | (1 << (PostgreSQLParser.KW_REPLICA - 284)) | (1 << (PostgreSQLParser.KW_RESET - 284)) | (1 << (PostgreSQLParser.KW_RESTART - 284)) | (1 << (PostgreSQLParser.KW_RESTRICT - 284)))) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.KW_RETURNS - 316)) | (1 << (PostgreSQLParser.KW_REVOKE - 316)) | (1 << (PostgreSQLParser.KW_ROLE - 316)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 316)) | (1 << (PostgreSQLParser.KW_ROWS - 316)) | (1 << (PostgreSQLParser.KW_RULE - 316)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 316)) | (1 << (PostgreSQLParser.KW_SCHEMA - 316)) | (1 << (PostgreSQLParser.KW_SCROLL - 316)) | (1 << (PostgreSQLParser.KW_SEARCH - 316)) | (1 << (PostgreSQLParser.KW_SECOND - 316)) | (1 << (PostgreSQLParser.KW_SECURITY - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 316)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.KW_SERVER - 316)) | (1 << (PostgreSQLParser.KW_SESSION - 316)) | (1 << (PostgreSQLParser.KW_SET - 316)) | (1 << (PostgreSQLParser.KW_SHARE - 316)) | (1 << (PostgreSQLParser.KW_SHOW - 316)) | (1 << (PostgreSQLParser.KW_SIMPLE - 316)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 316)) | (1 << (PostgreSQLParser.KW_STABLE - 316)) | (1 << (PostgreSQLParser.KW_STANDALONE - 316)) | (1 << (PostgreSQLParser.KW_START - 316)) | (1 << (PostgreSQLParser.KW_STATEMENT - 316)) | (1 << (PostgreSQLParser.KW_STATISTICS - 316)) | (1 << (PostgreSQLParser.KW_STDIN - 316)) | (1 << (PostgreSQLParser.KW_STDOUT - 316)) | (1 << (PostgreSQLParser.KW_STORAGE - 316)) | (1 << (PostgreSQLParser.KW_STRICT - 316)) | (1 << (PostgreSQLParser.KW_STRIP - 316)))) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.KW_SYSID - 348)) | (1 << (PostgreSQLParser.KW_SYSTEM - 348)) | (1 << (PostgreSQLParser.KW_TABLES - 348)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 348)) | (1 << (PostgreSQLParser.KW_TEMP - 348)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 348)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 348)) | (1 << (PostgreSQLParser.KW_TEXT - 348)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 348)) | (1 << (PostgreSQLParser.KW_TRIGGER - 348)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 348)) | (1 << (PostgreSQLParser.KW_TRUSTED - 348)) | (1 << (PostgreSQLParser.KW_TYPE - 348)) | (1 << (PostgreSQLParser.KW_TYPES - 348)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 348)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 348)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 348)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 348)) | (1 << (PostgreSQLParser.KW_UNTIL - 348)) | (1 << (PostgreSQLParser.KW_UPDATE - 348)) | (1 << (PostgreSQLParser.KW_VACUUM - 348)) | (1 << (PostgreSQLParser.KW_VALID - 348)) | (1 << (PostgreSQLParser.KW_VALIDATE - 348)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 348)) | (1 << (PostgreSQLParser.KW_VARYING - 348)) | (1 << (PostgreSQLParser.KW_VERSION - 348)) | (1 << (PostgreSQLParser.KW_VIEW - 348)) | (1 << (PostgreSQLParser.KW_VOLATILE - 348)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 348)) | (1 << (PostgreSQLParser.KW_WITHOUT - 348)))) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.KW_WORK - 380)) | (1 << (PostgreSQLParser.KW_WRAPPER - 380)) | (1 << (PostgreSQLParser.KW_WRITE - 380)) | (1 << (PostgreSQLParser.KW_XML - 380)) | (1 << (PostgreSQLParser.KW_YEAR - 380)) | (1 << (PostgreSQLParser.KW_YES - 380)) | (1 << (PostgreSQLParser.KW_ZONE - 380)) | (1 << (PostgreSQLParser.KW_BETWEEN - 380)) | (1 << (PostgreSQLParser.KW_BIGINT - 380)) | (1 << (PostgreSQLParser.KW_BIT - 380)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 380)) | (1 << (PostgreSQLParser.KW_CHAR - 380)) | (1 << (PostgreSQLParser.KW_CHARACTER - 380)) | (1 << (PostgreSQLParser.KW_COALESCE - 380)) | (1 << (PostgreSQLParser.KW_DEC - 380)) | (1 << (PostgreSQLParser.KW_DECIMAL - 380)) | (1 << (PostgreSQLParser.KW_EXISTS - 380)) | (1 << (PostgreSQLParser.KW_EXTRACT - 380)) | (1 << (PostgreSQLParser.KW_FLOAT - 380)) | (1 << (PostgreSQLParser.KW_GREATEST - 380)) | (1 << (PostgreSQLParser.KW_INOUT - 380)) | (1 << (PostgreSQLParser.KW_INT - 380)) | (1 << (PostgreSQLParser.KW_INTEGER - 380)) | (1 << (PostgreSQLParser.KW_INTERVAL - 380)) | (1 << (PostgreSQLParser.KW_LEAST - 380)) | (1 << (PostgreSQLParser.KW_NATIONAL - 380)) | (1 << (PostgreSQLParser.KW_NCHAR - 380)) | (1 << (PostgreSQLParser.KW_NONE - 380)) | (1 << (PostgreSQLParser.KW_NULLIF - 380)) | (1 << (PostgreSQLParser.KW_NUMERIC - 380)) | (1 << (PostgreSQLParser.KW_OVERLAY - 380)) | (1 << (PostgreSQLParser.KW_POSITION - 380)))) !== 0) || ((((_la - 412)) & ~0x1F) === 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.KW_PRECISION - 412)) | (1 << (PostgreSQLParser.KW_REAL - 412)) | (1 << (PostgreSQLParser.KW_ROW - 412)) | (1 << (PostgreSQLParser.KW_SETOF - 412)) | (1 << (PostgreSQLParser.KW_SMALLINT - 412)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 412)) | (1 << (PostgreSQLParser.KW_TIME - 412)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 412)) | (1 << (PostgreSQLParser.KW_TREAT - 412)) | (1 << (PostgreSQLParser.KW_TRIM - 412)) | (1 << (PostgreSQLParser.KW_VALUES - 412)) | (1 << (PostgreSQLParser.KW_VARCHAR - 412)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 412)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 412)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 412)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 412)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 412)) | (1 << (PostgreSQLParser.KW_XMLPI - 412)) | (1 << (PostgreSQLParser.KW_XMLROOT - 412)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.KW_CALL - 412)) | (1 << (PostgreSQLParser.KW_CURRENT - 412)) | (1 << (PostgreSQLParser.KW_ATTACH - 412)) | (1 << (PostgreSQLParser.KW_DETACH - 412)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 412)) | (1 << (PostgreSQLParser.KW_GENERATED - 412)) | (1 << (PostgreSQLParser.KW_LOGGED - 412)) | (1 << (PostgreSQLParser.KW_STORED - 412)) | (1 << (PostgreSQLParser.KW_INCLUDE - 412)) | (1 << (PostgreSQLParser.KW_ROUTINE - 412)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 412)))) !== 0) || ((((_la - 444)) & ~0x1F) === 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.KW_IMPORT - 444)) | (1 << (PostgreSQLParser.KW_POLICY - 444)) | (1 << (PostgreSQLParser.KW_METHOD - 444)) | (1 << (PostgreSQLParser.KW_REFERENCING - 444)) | (1 << (PostgreSQLParser.KW_NEW - 444)) | (1 << (PostgreSQLParser.KW_OLD - 444)) | (1 << (PostgreSQLParser.KW_VALUE - 444)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 444)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 444)) | (1 << (PostgreSQLParser.KW_OUT - 444)) | (1 << (PostgreSQLParser.KW_ROUTINES - 444)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 444)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 444)) | (1 << (PostgreSQLParser.KW_INPUT - 444)) | (1 << (PostgreSQLParser.KW_SUPPORT - 444)) | (1 << (PostgreSQLParser.KW_PARALLEL - 444)) | (1 << (PostgreSQLParser.KW_SQL - 444)) | (1 << (PostgreSQLParser.KW_DEPENDS - 444)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 444)) | (1 << (PostgreSQLParser.KW_CONFLICT - 444)) | (1 << (PostgreSQLParser.KW_SKIP - 444)) | (1 << (PostgreSQLParser.KW_LOCKED - 444)) | (1 << (PostgreSQLParser.KW_TIES - 444)) | (1 << (PostgreSQLParser.KW_ROLLUP - 444)) | (1 << (PostgreSQLParser.KW_CUBE - 444)) | (1 << (PostgreSQLParser.KW_GROUPING - 444)) | (1 << (PostgreSQLParser.KW_SETS - 444)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 444)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 444)) | (1 << (PostgreSQLParser.KW_COLUMNS - 444)))) !== 0) || ((((_la - 476)) & ~0x1F) === 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.KW_XMLNAMESPACES - 476)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 476)) | (1 << (PostgreSQLParser.KW_WITHIN - 476)) | (1 << (PostgreSQLParser.KW_FILTER - 476)) | (1 << (PostgreSQLParser.KW_GROUPS - 476)) | (1 << (PostgreSQLParser.KW_OTHERS - 476)) | (1 << (PostgreSQLParser.KW_NFC - 476)) | (1 << (PostgreSQLParser.KW_NFD - 476)) | (1 << (PostgreSQLParser.KW_NFKC - 476)) | (1 << (PostgreSQLParser.KW_NFKD - 476)) | (1 << (PostgreSQLParser.KW_UESCAPE - 476)) | (1 << (PostgreSQLParser.KW_VIEWS - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 476)) | (1 << (PostgreSQLParser.KW_DUMP - 476)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.KW_ERROR - 476)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 476)) | (1 << (PostgreSQLParser.KW_ALIAS - 476)) | (1 << (PostgreSQLParser.KW_CONSTANT - 476)) | (1 << (PostgreSQLParser.KW_PERFORM - 476)) | (1 << (PostgreSQLParser.KW_GET - 476)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.KW_STACKED - 476)) | (1 << (PostgreSQLParser.KW_ELSIF - 476)) | (1 << (PostgreSQLParser.KW_REVERSE - 476)) | (1 << (PostgreSQLParser.KW_SLICE - 476)) | (1 << (PostgreSQLParser.KW_EXIT - 476)))) !== 0) || ((((_la - 508)) & ~0x1F) === 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.KW_RETURN - 508)) | (1 << (PostgreSQLParser.KW_QUERY - 508)) | (1 << (PostgreSQLParser.KW_RAISE - 508)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 508)) | (1 << (PostgreSQLParser.KW_DEBUG - 508)) | (1 << (PostgreSQLParser.KW_LOG - 508)) | (1 << (PostgreSQLParser.KW_INFO - 508)) | (1 << (PostgreSQLParser.KW_NOTICE - 508)) | (1 << (PostgreSQLParser.KW_WARNING - 508)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 508)) | (1 << (PostgreSQLParser.KW_ASSERT - 508)) | (1 << (PostgreSQLParser.KW_OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { { - this.state = 5975; + this.state = 6057; this.colid(); - this.state = 5976; + this.state = 6058; this.match(PostgreSQLParser.DOT); } } - this.state = 5982; + this.state = 6064; this._errHandler.sync(this); _la = this._input.LA(1); } - this.state = 5983; + this.state = 6065; this.all_op(); } } @@ -28841,26 +29727,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public operator_with_argtypes_list(): Operator_with_argtypes_listContext { let _localctx: Operator_with_argtypes_listContext = new Operator_with_argtypes_listContext(this._ctx, this.state); - this.enterRule(_localctx, 684, PostgreSQLParser.RULE_operator_with_argtypes_list); + this.enterRule(_localctx, 698, PostgreSQLParser.RULE_operator_with_argtypes_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 5985; + this.state = 6067; this.operator_with_argtypes(); - this.state = 5990; + this.state = 6072; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 5986; + this.state = 6068; this.match(PostgreSQLParser.COMMA); - this.state = 5987; + this.state = 6069; this.operator_with_argtypes(); } } - this.state = 5992; + this.state = 6074; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -28883,13 +29769,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public operator_with_argtypes(): Operator_with_argtypesContext { let _localctx: Operator_with_argtypesContext = new Operator_with_argtypesContext(this._ctx, this.state); - this.enterRule(_localctx, 686, PostgreSQLParser.RULE_operator_with_argtypes); + this.enterRule(_localctx, 700, PostgreSQLParser.RULE_operator_with_argtypes); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5993; + this.state = 6075; this.any_operator(); - this.state = 5994; + this.state = 6076; this.oper_argtypes(); } } @@ -28910,13 +29796,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dostmt(): DostmtContext { let _localctx: DostmtContext = new DostmtContext(this._ctx, this.state); - this.enterRule(_localctx, 688, PostgreSQLParser.RULE_dostmt); + this.enterRule(_localctx, 702, PostgreSQLParser.RULE_dostmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 5996; - this.match(PostgreSQLParser.DO); - this.state = 5997; + this.state = 6078; + this.match(PostgreSQLParser.KW_DO); + this.state = 6079; this.dostmt_opt_list(); } } @@ -28937,25 +29823,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dostmt_opt_list(): Dostmt_opt_listContext { let _localctx: Dostmt_opt_listContext = new Dostmt_opt_listContext(this._ctx, this.state); - this.enterRule(_localctx, 690, PostgreSQLParser.RULE_dostmt_opt_list); + this.enterRule(_localctx, 704, PostgreSQLParser.RULE_dostmt_opt_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 6000; + this.state = 6082; this._errHandler.sync(this); _la = this._input.LA(1); do { { { - this.state = 5999; + this.state = 6081; this.dostmt_opt_item(); } } - this.state = 6002; + this.state = 6084; 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)); + } while (_la === PostgreSQLParser.KW_LANGUAGE || ((((_la - 534)) & ~0x1F) === 0 && ((1 << (_la - 534)) & ((1 << (PostgreSQLParser.StringConstant - 534)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 534)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 534)) | (1 << (PostgreSQLParser.EscapeStringConstant - 534)))) !== 0)); } } catch (re) { @@ -28975,9 +29861,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dostmt_opt_item(): Dostmt_opt_itemContext { let _localctx: Dostmt_opt_itemContext = new Dostmt_opt_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 692, PostgreSQLParser.RULE_dostmt_opt_item); + this.enterRule(_localctx, 706, PostgreSQLParser.RULE_dostmt_opt_item); try { - this.state = 6007; + this.state = 6089; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: @@ -28986,16 +29872,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 6004; + this.state = 6086; this.sconst(); } break; - case PostgreSQLParser.LANGUAGE: + case PostgreSQLParser.KW_LANGUAGE: this.enterOuterAlt(_localctx, 2); { - this.state = 6005; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 6006; + this.state = 6087; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 6088; this.nonreservedword_or_sconst(); } break; @@ -29020,41 +29906,41 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createcaststmt(): CreatecaststmtContext { let _localctx: CreatecaststmtContext = new CreatecaststmtContext(this._ctx, this.state); - this.enterRule(_localctx, 694, PostgreSQLParser.RULE_createcaststmt); + this.enterRule(_localctx, 708, PostgreSQLParser.RULE_createcaststmt); let _la: number; try { - this.state = 6046; + this.state = 6128; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 514, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 526, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 6009; - this.match(PostgreSQLParser.CREATE); - this.state = 6010; - this.match(PostgreSQLParser.CAST); - this.state = 6011; + this.state = 6091; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 6092; + this.match(PostgreSQLParser.KW_CAST); + this.state = 6093; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 6012; + this.state = 6094; this.typename(); - this.state = 6013; - this.match(PostgreSQLParser.AS); - this.state = 6014; + this.state = 6095; + this.match(PostgreSQLParser.KW_AS); + this.state = 6096; this.typename(); - this.state = 6015; + this.state = 6097; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 6016; - this.match(PostgreSQLParser.WITH); - this.state = 6017; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6018; + this.state = 6098; + this.match(PostgreSQLParser.KW_WITH); + this.state = 6099; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6100; this.function_with_argtypes(); - this.state = 6020; + this.state = 6102; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 6019; + this.state = 6101; this.cast_context(); } } @@ -29065,30 +29951,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 6022; - this.match(PostgreSQLParser.CREATE); - this.state = 6023; - this.match(PostgreSQLParser.CAST); - this.state = 6024; + this.state = 6104; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 6105; + this.match(PostgreSQLParser.KW_CAST); + this.state = 6106; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 6025; + this.state = 6107; this.typename(); - this.state = 6026; - this.match(PostgreSQLParser.AS); - this.state = 6027; + this.state = 6108; + this.match(PostgreSQLParser.KW_AS); + this.state = 6109; this.typename(); - this.state = 6028; + this.state = 6110; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 6029; - this.match(PostgreSQLParser.WITHOUT); - this.state = 6030; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6032; + this.state = 6111; + this.match(PostgreSQLParser.KW_WITHOUT); + this.state = 6112; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6114; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 6031; + this.state = 6113; this.cast_context(); } } @@ -29099,30 +29985,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 6034; - this.match(PostgreSQLParser.CREATE); - this.state = 6035; - this.match(PostgreSQLParser.CAST); - this.state = 6036; + this.state = 6116; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 6117; + this.match(PostgreSQLParser.KW_CAST); + this.state = 6118; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 6037; + this.state = 6119; this.typename(); - this.state = 6038; - this.match(PostgreSQLParser.AS); - this.state = 6039; + this.state = 6120; + this.match(PostgreSQLParser.KW_AS); + this.state = 6121; this.typename(); - this.state = 6040; + this.state = 6122; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 6041; - this.match(PostgreSQLParser.WITH); - this.state = 6042; - this.match(PostgreSQLParser.INOUT); - this.state = 6044; + this.state = 6123; + this.match(PostgreSQLParser.KW_WITH); + this.state = 6124; + this.match(PostgreSQLParser.KW_INOUT); + this.state = 6126; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 6043; + this.state = 6125; this.cast_context(); } } @@ -29148,28 +30034,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public cast_context(): Cast_contextContext { let _localctx: Cast_contextContext = new Cast_contextContext(this._ctx, this.state); - this.enterRule(_localctx, 696, PostgreSQLParser.RULE_cast_context); + this.enterRule(_localctx, 710, PostgreSQLParser.RULE_cast_context); try { - this.state = 6052; + this.state = 6134; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 515, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 527, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 6048; - this.match(PostgreSQLParser.AS); - this.state = 6049; - this.match(PostgreSQLParser.IMPLICIT_P); + this.state = 6130; + this.match(PostgreSQLParser.KW_AS); + this.state = 6131; + this.match(PostgreSQLParser.KW_IMPLICIT); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 6050; - this.match(PostgreSQLParser.AS); - this.state = 6051; - this.match(PostgreSQLParser.ASSIGNMENT); + this.state = 6132; + this.match(PostgreSQLParser.KW_AS); + this.state = 6133; + this.match(PostgreSQLParser.KW_ASSIGNMENT); } break; } @@ -29191,41 +30077,41 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dropcaststmt(): DropcaststmtContext { let _localctx: DropcaststmtContext = new DropcaststmtContext(this._ctx, this.state); - this.enterRule(_localctx, 698, PostgreSQLParser.RULE_dropcaststmt); + this.enterRule(_localctx, 712, PostgreSQLParser.RULE_dropcaststmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 6054; - this.match(PostgreSQLParser.DROP); - this.state = 6055; - this.match(PostgreSQLParser.CAST); - this.state = 6057; + this.state = 6136; + this.match(PostgreSQLParser.KW_DROP); + this.state = 6137; + this.match(PostgreSQLParser.KW_CAST); + this.state = 6139; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.IF_P) { + if (_la === PostgreSQLParser.KW_IF) { { - this.state = 6056; + this.state = 6138; this.opt_if_exists(); } } - this.state = 6059; + this.state = 6141; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 6060; + this.state = 6142; this.typename(); - this.state = 6061; - this.match(PostgreSQLParser.AS); - this.state = 6062; + this.state = 6143; + this.match(PostgreSQLParser.KW_AS); + this.state = 6144; this.typename(); - this.state = 6063; + this.state = 6145; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 6065; + this.state = 6147; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 6064; + this.state = 6146; this.opt_drop_behavior(); } } @@ -29249,14 +30135,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_if_exists(): Opt_if_existsContext { let _localctx: Opt_if_existsContext = new Opt_if_existsContext(this._ctx, this.state); - this.enterRule(_localctx, 700, PostgreSQLParser.RULE_opt_if_exists); + this.enterRule(_localctx, 714, PostgreSQLParser.RULE_opt_if_exists); try { this.enterOuterAlt(_localctx, 1); { - this.state = 6067; - this.match(PostgreSQLParser.IF_P); - this.state = 6068; - this.match(PostgreSQLParser.EXISTS); + this.state = 6149; + this.match(PostgreSQLParser.KW_IF); + this.state = 6150; + this.match(PostgreSQLParser.KW_EXISTS); } } catch (re) { @@ -29276,38 +30162,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createtransformstmt(): CreatetransformstmtContext { let _localctx: CreatetransformstmtContext = new CreatetransformstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 702, PostgreSQLParser.RULE_createtransformstmt); + this.enterRule(_localctx, 716, PostgreSQLParser.RULE_createtransformstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 6070; - this.match(PostgreSQLParser.CREATE); - this.state = 6072; + this.state = 6152; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 6154; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OR) { + if (_la === PostgreSQLParser.KW_OR) { { - this.state = 6071; + this.state = 6153; this.opt_or_replace(); } } - this.state = 6074; - this.match(PostgreSQLParser.TRANSFORM); - this.state = 6075; - this.match(PostgreSQLParser.FOR); - this.state = 6076; + this.state = 6156; + this.match(PostgreSQLParser.KW_TRANSFORM); + this.state = 6157; + this.match(PostgreSQLParser.KW_FOR); + this.state = 6158; this.typename(); - this.state = 6077; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 6078; + this.state = 6159; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 6160; this.name(); - this.state = 6079; + this.state = 6161; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 6080; + this.state = 6162; this.transform_element_list(); - this.state = 6081; + this.state = 6163; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -29328,35 +30214,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public transform_element_list(): Transform_element_listContext { let _localctx: Transform_element_listContext = new Transform_element_listContext(this._ctx, this.state); - this.enterRule(_localctx, 704, PostgreSQLParser.RULE_transform_element_list); + this.enterRule(_localctx, 718, PostgreSQLParser.RULE_transform_element_list); try { - this.state = 6117; + this.state = 6199; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 519, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 531, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 6083; - this.match(PostgreSQLParser.FROM); - this.state = 6084; - this.match(PostgreSQLParser.SQL_P); - this.state = 6085; - this.match(PostgreSQLParser.WITH); - this.state = 6086; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6087; + this.state = 6165; + this.match(PostgreSQLParser.KW_FROM); + this.state = 6166; + this.match(PostgreSQLParser.KW_SQL); + this.state = 6167; + this.match(PostgreSQLParser.KW_WITH); + this.state = 6168; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6169; this.function_with_argtypes(); - this.state = 6088; + this.state = 6170; this.match(PostgreSQLParser.COMMA); - this.state = 6089; - this.match(PostgreSQLParser.TO); - this.state = 6090; - this.match(PostgreSQLParser.SQL_P); - this.state = 6091; - this.match(PostgreSQLParser.WITH); - this.state = 6092; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6093; + this.state = 6171; + this.match(PostgreSQLParser.KW_TO); + this.state = 6172; + this.match(PostgreSQLParser.KW_SQL); + this.state = 6173; + this.match(PostgreSQLParser.KW_WITH); + this.state = 6174; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6175; this.function_with_argtypes(); } break; @@ -29364,27 +30250,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 6095; - this.match(PostgreSQLParser.TO); - this.state = 6096; - this.match(PostgreSQLParser.SQL_P); - this.state = 6097; - this.match(PostgreSQLParser.WITH); - this.state = 6098; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6099; + this.state = 6177; + this.match(PostgreSQLParser.KW_TO); + this.state = 6178; + this.match(PostgreSQLParser.KW_SQL); + this.state = 6179; + this.match(PostgreSQLParser.KW_WITH); + this.state = 6180; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6181; this.function_with_argtypes(); - this.state = 6100; + this.state = 6182; this.match(PostgreSQLParser.COMMA); - this.state = 6101; - this.match(PostgreSQLParser.FROM); - this.state = 6102; - this.match(PostgreSQLParser.SQL_P); - this.state = 6103; - this.match(PostgreSQLParser.WITH); - this.state = 6104; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6105; + this.state = 6183; + this.match(PostgreSQLParser.KW_FROM); + this.state = 6184; + this.match(PostgreSQLParser.KW_SQL); + this.state = 6185; + this.match(PostgreSQLParser.KW_WITH); + this.state = 6186; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6187; this.function_with_argtypes(); } break; @@ -29392,15 +30278,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 6107; - this.match(PostgreSQLParser.FROM); - this.state = 6108; - this.match(PostgreSQLParser.SQL_P); - this.state = 6109; - this.match(PostgreSQLParser.WITH); - this.state = 6110; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6111; + this.state = 6189; + this.match(PostgreSQLParser.KW_FROM); + this.state = 6190; + this.match(PostgreSQLParser.KW_SQL); + this.state = 6191; + this.match(PostgreSQLParser.KW_WITH); + this.state = 6192; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6193; this.function_with_argtypes(); } break; @@ -29408,15 +30294,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 6112; - this.match(PostgreSQLParser.TO); - this.state = 6113; - this.match(PostgreSQLParser.SQL_P); - this.state = 6114; - this.match(PostgreSQLParser.WITH); - this.state = 6115; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6116; + this.state = 6194; + this.match(PostgreSQLParser.KW_TO); + this.state = 6195; + this.match(PostgreSQLParser.KW_SQL); + this.state = 6196; + this.match(PostgreSQLParser.KW_WITH); + this.state = 6197; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6198; this.function_with_argtypes(); } break; @@ -29439,39 +30325,39 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public droptransformstmt(): DroptransformstmtContext { let _localctx: DroptransformstmtContext = new DroptransformstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 706, PostgreSQLParser.RULE_droptransformstmt); + this.enterRule(_localctx, 720, PostgreSQLParser.RULE_droptransformstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 6119; - this.match(PostgreSQLParser.DROP); - this.state = 6120; - this.match(PostgreSQLParser.TRANSFORM); - this.state = 6122; + this.state = 6201; + this.match(PostgreSQLParser.KW_DROP); + this.state = 6202; + this.match(PostgreSQLParser.KW_TRANSFORM); + this.state = 6204; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.IF_P) { + if (_la === PostgreSQLParser.KW_IF) { { - this.state = 6121; + this.state = 6203; this.opt_if_exists(); } } - this.state = 6124; - this.match(PostgreSQLParser.FOR); - this.state = 6125; + this.state = 6206; + this.match(PostgreSQLParser.KW_FOR); + this.state = 6207; this.typename(); - this.state = 6126; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 6127; + this.state = 6208; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 6209; this.name(); - this.state = 6129; + this.state = 6211; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 6128; + this.state = 6210; this.opt_drop_behavior(); } } @@ -29495,30 +30381,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public reindexstmt(): ReindexstmtContext { let _localctx: ReindexstmtContext = new ReindexstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 708, PostgreSQLParser.RULE_reindexstmt); + this.enterRule(_localctx, 722, PostgreSQLParser.RULE_reindexstmt); let _la: number; try { - this.state = 6165; + this.state = 6247; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 526, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 538, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 6131; - this.match(PostgreSQLParser.REINDEX); - this.state = 6132; + this.state = 6213; + this.match(PostgreSQLParser.KW_REINDEX); + this.state = 6214; this.reindex_target_type(); - this.state = 6134; + this.state = 6216; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CONCURRENTLY) { + if (_la === PostgreSQLParser.KW_CONCURRENTLY) { { - this.state = 6133; + this.state = 6215; this.opt_concurrently(); } } - this.state = 6136; + this.state = 6218; this.qualified_name(); } break; @@ -29526,21 +30412,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 6138; - this.match(PostgreSQLParser.REINDEX); - this.state = 6139; + this.state = 6220; + this.match(PostgreSQLParser.KW_REINDEX); + this.state = 6221; this.reindex_target_multitable(); - this.state = 6141; + this.state = 6223; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CONCURRENTLY) { + if (_la === PostgreSQLParser.KW_CONCURRENTLY) { { - this.state = 6140; + this.state = 6222; this.opt_concurrently(); } } - this.state = 6143; + this.state = 6225; this.name(); } break; @@ -29548,27 +30434,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 6145; - this.match(PostgreSQLParser.REINDEX); - this.state = 6146; + this.state = 6227; + this.match(PostgreSQLParser.KW_REINDEX); + this.state = 6228; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 6147; + this.state = 6229; this.reindex_option_list(); - this.state = 6148; + this.state = 6230; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 6149; + this.state = 6231; this.reindex_target_type(); - this.state = 6151; + this.state = 6233; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CONCURRENTLY) { + if (_la === PostgreSQLParser.KW_CONCURRENTLY) { { - this.state = 6150; + this.state = 6232; this.opt_concurrently(); } } - this.state = 6153; + this.state = 6235; this.qualified_name(); } break; @@ -29576,27 +30462,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 6155; - this.match(PostgreSQLParser.REINDEX); - this.state = 6156; + this.state = 6237; + this.match(PostgreSQLParser.KW_REINDEX); + this.state = 6238; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 6157; + this.state = 6239; this.reindex_option_list(); - this.state = 6158; + this.state = 6240; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 6159; + this.state = 6241; this.reindex_target_multitable(); - this.state = 6161; + this.state = 6243; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CONCURRENTLY) { + if (_la === PostgreSQLParser.KW_CONCURRENTLY) { { - this.state = 6160; + this.state = 6242; this.opt_concurrently(); } } - this.state = 6163; + this.state = 6245; this.name(); } break; @@ -29619,14 +30505,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public reindex_target_type(): Reindex_target_typeContext { let _localctx: Reindex_target_typeContext = new Reindex_target_typeContext(this._ctx, this.state); - this.enterRule(_localctx, 710, PostgreSQLParser.RULE_reindex_target_type); + this.enterRule(_localctx, 724, PostgreSQLParser.RULE_reindex_target_type); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 6167; + this.state = 6249; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.TABLE || _la === PostgreSQLParser.INDEX)) { + if (!(_la === PostgreSQLParser.KW_TABLE || _la === PostgreSQLParser.KW_INDEX)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -29655,14 +30541,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public reindex_target_multitable(): Reindex_target_multitableContext { let _localctx: Reindex_target_multitableContext = new Reindex_target_multitableContext(this._ctx, this.state); - this.enterRule(_localctx, 712, PostgreSQLParser.RULE_reindex_target_multitable); + this.enterRule(_localctx, 726, PostgreSQLParser.RULE_reindex_target_multitable); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 6169; + this.state = 6251; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.DATABASE || _la === PostgreSQLParser.SCHEMA || _la === PostgreSQLParser.SYSTEM_P)) { + if (!(_la === PostgreSQLParser.KW_DATABASE || _la === PostgreSQLParser.KW_SCHEMA || _la === PostgreSQLParser.KW_SYSTEM)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -29691,26 +30577,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public reindex_option_list(): Reindex_option_listContext { let _localctx: Reindex_option_listContext = new Reindex_option_listContext(this._ctx, this.state); - this.enterRule(_localctx, 714, PostgreSQLParser.RULE_reindex_option_list); + this.enterRule(_localctx, 728, PostgreSQLParser.RULE_reindex_option_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 6171; + this.state = 6253; this.reindex_option_elem(); - this.state = 6176; + this.state = 6258; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 6172; + this.state = 6254; this.match(PostgreSQLParser.COMMA); - this.state = 6173; + this.state = 6255; this.reindex_option_elem(); } } - this.state = 6178; + this.state = 6260; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -29733,12 +30619,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public reindex_option_elem(): Reindex_option_elemContext { let _localctx: Reindex_option_elemContext = new Reindex_option_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 716, PostgreSQLParser.RULE_reindex_option_elem); + this.enterRule(_localctx, 730, PostgreSQLParser.RULE_reindex_option_elem); try { this.enterOuterAlt(_localctx, 1); { - this.state = 6179; - this.match(PostgreSQLParser.VERBOSE); + this.state = 6261; + this.match(PostgreSQLParser.KW_VERBOSE); } } catch (re) { @@ -29758,23 +30644,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public altertblspcstmt(): AltertblspcstmtContext { let _localctx: AltertblspcstmtContext = new AltertblspcstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 718, PostgreSQLParser.RULE_altertblspcstmt); + this.enterRule(_localctx, 732, PostgreSQLParser.RULE_altertblspcstmt); try { - this.state = 6193; + this.state = 6275; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 528, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 540, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 6181; - this.match(PostgreSQLParser.ALTER); - this.state = 6182; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 6183; + this.state = 6263; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6264; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 6265; this.name(); - this.state = 6184; - this.match(PostgreSQLParser.SET); - this.state = 6185; + this.state = 6266; + this.match(PostgreSQLParser.KW_SET); + this.state = 6267; this.reloptions(); } break; @@ -29782,15 +30668,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 6187; - this.match(PostgreSQLParser.ALTER); - this.state = 6188; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 6189; + this.state = 6269; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6270; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 6271; this.name(); - this.state = 6190; - this.match(PostgreSQLParser.RESET); - this.state = 6191; + this.state = 6272; + this.match(PostgreSQLParser.KW_RESET); + this.state = 6273; this.reloptions(); } break; @@ -29813,26 +30699,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public renamestmt(): RenamestmtContext { let _localctx: RenamestmtContext = new RenamestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 720, PostgreSQLParser.RULE_renamestmt); + this.enterRule(_localctx, 734, PostgreSQLParser.RULE_renamestmt); let _la: number; try { - this.state = 6682; + this.state = 6764; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 539, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 551, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 6195; - this.match(PostgreSQLParser.ALTER); - this.state = 6196; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 6197; + this.state = 6277; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6278; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 6279; this.aggregate_with_argtypes(); - this.state = 6198; - this.match(PostgreSQLParser.RENAME); - this.state = 6199; - this.match(PostgreSQLParser.TO); - this.state = 6200; + this.state = 6280; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6281; + this.match(PostgreSQLParser.KW_TO); + this.state = 6282; this.name(); } break; @@ -29840,17 +30726,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 6202; - this.match(PostgreSQLParser.ALTER); - this.state = 6203; - this.match(PostgreSQLParser.COLLATION); - this.state = 6204; + this.state = 6284; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6285; + this.match(PostgreSQLParser.KW_COLLATION); + this.state = 6286; this.any_name(); - this.state = 6205; - this.match(PostgreSQLParser.RENAME); - this.state = 6206; - this.match(PostgreSQLParser.TO); - this.state = 6207; + this.state = 6287; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6288; + this.match(PostgreSQLParser.KW_TO); + this.state = 6289; this.name(); } break; @@ -29858,17 +30744,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 6209; - this.match(PostgreSQLParser.ALTER); - this.state = 6210; - this.match(PostgreSQLParser.CONVERSION_P); - this.state = 6211; + this.state = 6291; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6292; + this.match(PostgreSQLParser.KW_CONVERSION); + this.state = 6293; this.any_name(); - this.state = 6212; - this.match(PostgreSQLParser.RENAME); - this.state = 6213; - this.match(PostgreSQLParser.TO); - this.state = 6214; + this.state = 6294; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6295; + this.match(PostgreSQLParser.KW_TO); + this.state = 6296; this.name(); } break; @@ -29876,17 +30762,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 6216; - this.match(PostgreSQLParser.ALTER); - this.state = 6217; - this.match(PostgreSQLParser.DATABASE); - this.state = 6218; + this.state = 6298; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6299; + this.match(PostgreSQLParser.KW_DATABASE); + this.state = 6300; this.name(); - this.state = 6219; - this.match(PostgreSQLParser.RENAME); - this.state = 6220; - this.match(PostgreSQLParser.TO); - this.state = 6221; + this.state = 6301; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6302; + this.match(PostgreSQLParser.KW_TO); + this.state = 6303; this.name(); } break; @@ -29894,17 +30780,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 6223; - this.match(PostgreSQLParser.ALTER); - this.state = 6224; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 6225; + this.state = 6305; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6306; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 6307; this.any_name(); - this.state = 6226; - this.match(PostgreSQLParser.RENAME); - this.state = 6227; - this.match(PostgreSQLParser.TO); - this.state = 6228; + this.state = 6308; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6309; + this.match(PostgreSQLParser.KW_TO); + this.state = 6310; this.name(); } break; @@ -29912,21 +30798,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 6230; - this.match(PostgreSQLParser.ALTER); - this.state = 6231; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 6232; + this.state = 6312; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6313; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 6314; this.any_name(); - this.state = 6233; - this.match(PostgreSQLParser.RENAME); - this.state = 6234; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 6235; + this.state = 6315; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6316; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 6317; this.name(); - this.state = 6236; - this.match(PostgreSQLParser.TO); - this.state = 6237; + this.state = 6318; + this.match(PostgreSQLParser.KW_TO); + this.state = 6319; this.name(); } break; @@ -29934,21 +30820,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 6239; - this.match(PostgreSQLParser.ALTER); - this.state = 6240; - this.match(PostgreSQLParser.FOREIGN); - this.state = 6241; - this.match(PostgreSQLParser.DATA_P); - this.state = 6242; - this.match(PostgreSQLParser.WRAPPER); - this.state = 6243; + this.state = 6321; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6322; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 6323; + this.match(PostgreSQLParser.KW_DATA); + this.state = 6324; + this.match(PostgreSQLParser.KW_WRAPPER); + this.state = 6325; this.name(); - this.state = 6244; - this.match(PostgreSQLParser.RENAME); - this.state = 6245; - this.match(PostgreSQLParser.TO); - this.state = 6246; + this.state = 6326; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6327; + this.match(PostgreSQLParser.KW_TO); + this.state = 6328; this.name(); } break; @@ -29956,17 +30842,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 6248; - this.match(PostgreSQLParser.ALTER); - this.state = 6249; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6250; + this.state = 6330; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6331; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6332; this.function_with_argtypes(); - this.state = 6251; - this.match(PostgreSQLParser.RENAME); - this.state = 6252; - this.match(PostgreSQLParser.TO); - this.state = 6253; + this.state = 6333; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6334; + this.match(PostgreSQLParser.KW_TO); + this.state = 6335; this.name(); } break; @@ -29974,17 +30860,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 6255; - this.match(PostgreSQLParser.ALTER); - this.state = 6256; - this.match(PostgreSQLParser.GROUP_P); - this.state = 6257; + this.state = 6337; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6338; + this.match(PostgreSQLParser.KW_GROUP); + this.state = 6339; this.roleid(); - this.state = 6258; - this.match(PostgreSQLParser.RENAME); - this.state = 6259; - this.match(PostgreSQLParser.TO); - this.state = 6260; + this.state = 6340; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6341; + this.match(PostgreSQLParser.KW_TO); + this.state = 6342; this.roleid(); } break; @@ -29992,27 +30878,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 6262; - this.match(PostgreSQLParser.ALTER); - this.state = 6264; + this.state = 6344; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6346; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PROCEDURAL) { + if (_la === PostgreSQLParser.KW_PROCEDURAL) { { - this.state = 6263; + this.state = 6345; this.opt_procedural(); } } - this.state = 6266; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 6267; + this.state = 6348; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 6349; this.name(); - this.state = 6268; - this.match(PostgreSQLParser.RENAME); - this.state = 6269; - this.match(PostgreSQLParser.TO); - this.state = 6270; + this.state = 6350; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6351; + this.match(PostgreSQLParser.KW_TO); + this.state = 6352; this.name(); } break; @@ -30020,23 +30906,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 6272; - this.match(PostgreSQLParser.ALTER); - this.state = 6273; - this.match(PostgreSQLParser.OPERATOR); - this.state = 6274; - this.match(PostgreSQLParser.CLASS); - this.state = 6275; + this.state = 6354; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6355; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 6356; + this.match(PostgreSQLParser.KW_CLASS); + this.state = 6357; this.any_name(); - this.state = 6276; - this.match(PostgreSQLParser.USING); - this.state = 6277; + this.state = 6358; + this.match(PostgreSQLParser.KW_USING); + this.state = 6359; this.name(); - this.state = 6278; - this.match(PostgreSQLParser.RENAME); - this.state = 6279; - this.match(PostgreSQLParser.TO); - this.state = 6280; + this.state = 6360; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6361; + this.match(PostgreSQLParser.KW_TO); + this.state = 6362; this.name(); } break; @@ -30044,23 +30930,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 6282; - this.match(PostgreSQLParser.ALTER); - this.state = 6283; - this.match(PostgreSQLParser.OPERATOR); - this.state = 6284; - this.match(PostgreSQLParser.FAMILY); - this.state = 6285; + this.state = 6364; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6365; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 6366; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 6367; this.any_name(); - this.state = 6286; - this.match(PostgreSQLParser.USING); - this.state = 6287; + this.state = 6368; + this.match(PostgreSQLParser.KW_USING); + this.state = 6369; this.name(); - this.state = 6288; - this.match(PostgreSQLParser.RENAME); - this.state = 6289; - this.match(PostgreSQLParser.TO); - this.state = 6290; + this.state = 6370; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6371; + this.match(PostgreSQLParser.KW_TO); + this.state = 6372; this.name(); } break; @@ -30068,21 +30954,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 6292; - this.match(PostgreSQLParser.ALTER); - this.state = 6293; - this.match(PostgreSQLParser.POLICY); - this.state = 6294; + this.state = 6374; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6375; + this.match(PostgreSQLParser.KW_POLICY); + this.state = 6376; this.name(); - this.state = 6295; - this.match(PostgreSQLParser.ON); - this.state = 6296; + this.state = 6377; + this.match(PostgreSQLParser.KW_ON); + this.state = 6378; this.qualified_name(); - this.state = 6297; - this.match(PostgreSQLParser.RENAME); - this.state = 6298; - this.match(PostgreSQLParser.TO); - this.state = 6299; + this.state = 6379; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6380; + this.match(PostgreSQLParser.KW_TO); + this.state = 6381; this.name(); } break; @@ -30090,25 +30976,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 6301; - this.match(PostgreSQLParser.ALTER); - this.state = 6302; - this.match(PostgreSQLParser.POLICY); - this.state = 6303; - this.match(PostgreSQLParser.IF_P); - this.state = 6304; - this.match(PostgreSQLParser.EXISTS); - this.state = 6305; + this.state = 6383; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6384; + this.match(PostgreSQLParser.KW_POLICY); + this.state = 6385; + this.match(PostgreSQLParser.KW_IF); + this.state = 6386; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6387; this.name(); - this.state = 6306; - this.match(PostgreSQLParser.ON); - this.state = 6307; + this.state = 6388; + this.match(PostgreSQLParser.KW_ON); + this.state = 6389; this.qualified_name(); - this.state = 6308; - this.match(PostgreSQLParser.RENAME); - this.state = 6309; - this.match(PostgreSQLParser.TO); - this.state = 6310; + this.state = 6390; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6391; + this.match(PostgreSQLParser.KW_TO); + this.state = 6392; this.name(); } break; @@ -30116,17 +31002,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 6312; - this.match(PostgreSQLParser.ALTER); - this.state = 6313; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 6314; + this.state = 6394; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6395; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 6396; this.function_with_argtypes(); - this.state = 6315; - this.match(PostgreSQLParser.RENAME); - this.state = 6316; - this.match(PostgreSQLParser.TO); - this.state = 6317; + this.state = 6397; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6398; + this.match(PostgreSQLParser.KW_TO); + this.state = 6399; this.name(); } break; @@ -30134,17 +31020,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 6319; - this.match(PostgreSQLParser.ALTER); - this.state = 6320; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 6321; + this.state = 6401; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6402; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 6403; this.name(); - this.state = 6322; - this.match(PostgreSQLParser.RENAME); - this.state = 6323; - this.match(PostgreSQLParser.TO); - this.state = 6324; + this.state = 6404; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6405; + this.match(PostgreSQLParser.KW_TO); + this.state = 6406; this.name(); } break; @@ -30152,17 +31038,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 6326; - this.match(PostgreSQLParser.ALTER); - this.state = 6327; - this.match(PostgreSQLParser.ROUTINE); - this.state = 6328; + this.state = 6408; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6409; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 6410; this.function_with_argtypes(); - this.state = 6329; - this.match(PostgreSQLParser.RENAME); - this.state = 6330; - this.match(PostgreSQLParser.TO); - this.state = 6331; + this.state = 6411; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6412; + this.match(PostgreSQLParser.KW_TO); + this.state = 6413; this.name(); } break; @@ -30170,17 +31056,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 18: this.enterOuterAlt(_localctx, 18); { - this.state = 6333; - this.match(PostgreSQLParser.ALTER); - this.state = 6334; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6335; + this.state = 6415; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6416; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6417; this.name(); - this.state = 6336; - this.match(PostgreSQLParser.RENAME); - this.state = 6337; - this.match(PostgreSQLParser.TO); - this.state = 6338; + this.state = 6418; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6419; + this.match(PostgreSQLParser.KW_TO); + this.state = 6420; this.name(); } break; @@ -30188,17 +31074,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 19: this.enterOuterAlt(_localctx, 19); { - this.state = 6340; - this.match(PostgreSQLParser.ALTER); - this.state = 6341; - this.match(PostgreSQLParser.SERVER); - this.state = 6342; + this.state = 6422; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6423; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 6424; this.name(); - this.state = 6343; - this.match(PostgreSQLParser.RENAME); - this.state = 6344; - this.match(PostgreSQLParser.TO); - this.state = 6345; + this.state = 6425; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6426; + this.match(PostgreSQLParser.KW_TO); + this.state = 6427; this.name(); } break; @@ -30206,17 +31092,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 20: this.enterOuterAlt(_localctx, 20); { - this.state = 6347; - this.match(PostgreSQLParser.ALTER); - this.state = 6348; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 6349; + this.state = 6429; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6430; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 6431; this.name(); - this.state = 6350; - this.match(PostgreSQLParser.RENAME); - this.state = 6351; - this.match(PostgreSQLParser.TO); - this.state = 6352; + this.state = 6432; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6433; + this.match(PostgreSQLParser.KW_TO); + this.state = 6434; this.name(); } break; @@ -30224,17 +31110,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 21: this.enterOuterAlt(_localctx, 21); { - this.state = 6354; - this.match(PostgreSQLParser.ALTER); - this.state = 6355; - this.match(PostgreSQLParser.TABLE); - this.state = 6356; + this.state = 6436; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6437; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6438; this.relation_expr(); - this.state = 6357; - this.match(PostgreSQLParser.RENAME); - this.state = 6358; - this.match(PostgreSQLParser.TO); - this.state = 6359; + this.state = 6439; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6440; + this.match(PostgreSQLParser.KW_TO); + this.state = 6441; this.name(); } break; @@ -30242,21 +31128,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 22: this.enterOuterAlt(_localctx, 22); { - this.state = 6361; - this.match(PostgreSQLParser.ALTER); - this.state = 6362; - this.match(PostgreSQLParser.TABLE); - this.state = 6363; - this.match(PostgreSQLParser.IF_P); - this.state = 6364; - this.match(PostgreSQLParser.EXISTS); - this.state = 6365; + this.state = 6443; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6444; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6445; + this.match(PostgreSQLParser.KW_IF); + this.state = 6446; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6447; this.relation_expr(); - this.state = 6366; - this.match(PostgreSQLParser.RENAME); - this.state = 6367; - this.match(PostgreSQLParser.TO); - this.state = 6368; + this.state = 6448; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6449; + this.match(PostgreSQLParser.KW_TO); + this.state = 6450; this.name(); } break; @@ -30264,17 +31150,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 23: this.enterOuterAlt(_localctx, 23); { - this.state = 6370; - this.match(PostgreSQLParser.ALTER); - this.state = 6371; - this.match(PostgreSQLParser.SEQUENCE); - this.state = 6372; + this.state = 6452; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6453; + this.match(PostgreSQLParser.KW_SEQUENCE); + this.state = 6454; this.qualified_name(); - this.state = 6373; - this.match(PostgreSQLParser.RENAME); - this.state = 6374; - this.match(PostgreSQLParser.TO); - this.state = 6375; + this.state = 6455; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6456; + this.match(PostgreSQLParser.KW_TO); + this.state = 6457; this.name(); } break; @@ -30282,21 +31168,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 24: this.enterOuterAlt(_localctx, 24); { - this.state = 6377; - this.match(PostgreSQLParser.ALTER); - this.state = 6378; - this.match(PostgreSQLParser.SEQUENCE); - this.state = 6379; - this.match(PostgreSQLParser.IF_P); - this.state = 6380; - this.match(PostgreSQLParser.EXISTS); - this.state = 6381; + this.state = 6459; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6460; + this.match(PostgreSQLParser.KW_SEQUENCE); + this.state = 6461; + this.match(PostgreSQLParser.KW_IF); + this.state = 6462; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6463; this.qualified_name(); - this.state = 6382; - this.match(PostgreSQLParser.RENAME); - this.state = 6383; - this.match(PostgreSQLParser.TO); - this.state = 6384; + this.state = 6464; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6465; + this.match(PostgreSQLParser.KW_TO); + this.state = 6466; this.name(); } break; @@ -30304,17 +31190,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 25: this.enterOuterAlt(_localctx, 25); { - this.state = 6386; - this.match(PostgreSQLParser.ALTER); - this.state = 6387; - this.match(PostgreSQLParser.VIEW); - this.state = 6388; + this.state = 6468; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6469; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 6470; this.qualified_name(); - this.state = 6389; - this.match(PostgreSQLParser.RENAME); - this.state = 6390; - this.match(PostgreSQLParser.TO); - this.state = 6391; + this.state = 6471; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6472; + this.match(PostgreSQLParser.KW_TO); + this.state = 6473; this.name(); } break; @@ -30322,21 +31208,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 26: this.enterOuterAlt(_localctx, 26); { - this.state = 6393; - this.match(PostgreSQLParser.ALTER); - this.state = 6394; - this.match(PostgreSQLParser.VIEW); - this.state = 6395; - this.match(PostgreSQLParser.IF_P); - this.state = 6396; - this.match(PostgreSQLParser.EXISTS); - this.state = 6397; + this.state = 6475; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6476; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 6477; + this.match(PostgreSQLParser.KW_IF); + this.state = 6478; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6479; this.qualified_name(); - this.state = 6398; - this.match(PostgreSQLParser.RENAME); - this.state = 6399; - this.match(PostgreSQLParser.TO); - this.state = 6400; + this.state = 6480; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6481; + this.match(PostgreSQLParser.KW_TO); + this.state = 6482; this.name(); } break; @@ -30344,19 +31230,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 27: this.enterOuterAlt(_localctx, 27); { - this.state = 6402; - this.match(PostgreSQLParser.ALTER); - this.state = 6403; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 6404; - this.match(PostgreSQLParser.VIEW); - this.state = 6405; + this.state = 6484; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6485; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 6486; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 6487; this.qualified_name(); - this.state = 6406; - this.match(PostgreSQLParser.RENAME); - this.state = 6407; - this.match(PostgreSQLParser.TO); - this.state = 6408; + this.state = 6488; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6489; + this.match(PostgreSQLParser.KW_TO); + this.state = 6490; this.name(); } break; @@ -30364,23 +31250,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 28: this.enterOuterAlt(_localctx, 28); { - this.state = 6410; - this.match(PostgreSQLParser.ALTER); - this.state = 6411; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 6412; - this.match(PostgreSQLParser.VIEW); - this.state = 6413; - this.match(PostgreSQLParser.IF_P); - this.state = 6414; - this.match(PostgreSQLParser.EXISTS); - this.state = 6415; + this.state = 6492; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6493; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 6494; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 6495; + this.match(PostgreSQLParser.KW_IF); + this.state = 6496; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6497; this.qualified_name(); - this.state = 6416; - this.match(PostgreSQLParser.RENAME); - this.state = 6417; - this.match(PostgreSQLParser.TO); - this.state = 6418; + this.state = 6498; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6499; + this.match(PostgreSQLParser.KW_TO); + this.state = 6500; this.name(); } break; @@ -30388,17 +31274,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 29: this.enterOuterAlt(_localctx, 29); { - this.state = 6420; - this.match(PostgreSQLParser.ALTER); - this.state = 6421; - this.match(PostgreSQLParser.INDEX); - this.state = 6422; + this.state = 6502; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6503; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 6504; this.qualified_name(); - this.state = 6423; - this.match(PostgreSQLParser.RENAME); - this.state = 6424; - this.match(PostgreSQLParser.TO); - this.state = 6425; + this.state = 6505; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6506; + this.match(PostgreSQLParser.KW_TO); + this.state = 6507; this.name(); } break; @@ -30406,21 +31292,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 30: this.enterOuterAlt(_localctx, 30); { - this.state = 6427; - this.match(PostgreSQLParser.ALTER); - this.state = 6428; - this.match(PostgreSQLParser.INDEX); - this.state = 6429; - this.match(PostgreSQLParser.IF_P); - this.state = 6430; - this.match(PostgreSQLParser.EXISTS); - this.state = 6431; + this.state = 6509; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6510; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 6511; + this.match(PostgreSQLParser.KW_IF); + this.state = 6512; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6513; this.qualified_name(); - this.state = 6432; - this.match(PostgreSQLParser.RENAME); - this.state = 6433; - this.match(PostgreSQLParser.TO); - this.state = 6434; + this.state = 6514; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6515; + this.match(PostgreSQLParser.KW_TO); + this.state = 6516; this.name(); } break; @@ -30428,19 +31314,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 31: this.enterOuterAlt(_localctx, 31); { - this.state = 6436; - this.match(PostgreSQLParser.ALTER); - this.state = 6437; - this.match(PostgreSQLParser.FOREIGN); - this.state = 6438; - this.match(PostgreSQLParser.TABLE); - this.state = 6439; + this.state = 6518; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6519; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 6520; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6521; this.relation_expr(); - this.state = 6440; - this.match(PostgreSQLParser.RENAME); - this.state = 6441; - this.match(PostgreSQLParser.TO); - this.state = 6442; + this.state = 6522; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6523; + this.match(PostgreSQLParser.KW_TO); + this.state = 6524; this.name(); } break; @@ -30448,23 +31334,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 32: this.enterOuterAlt(_localctx, 32); { - this.state = 6444; - this.match(PostgreSQLParser.ALTER); - this.state = 6445; - this.match(PostgreSQLParser.FOREIGN); - this.state = 6446; - this.match(PostgreSQLParser.TABLE); - this.state = 6447; - this.match(PostgreSQLParser.IF_P); - this.state = 6448; - this.match(PostgreSQLParser.EXISTS); - this.state = 6449; + this.state = 6526; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6527; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 6528; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6529; + this.match(PostgreSQLParser.KW_IF); + this.state = 6530; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6531; this.relation_expr(); - this.state = 6450; - this.match(PostgreSQLParser.RENAME); - this.state = 6451; - this.match(PostgreSQLParser.TO); - this.state = 6452; + this.state = 6532; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6533; + this.match(PostgreSQLParser.KW_TO); + this.state = 6534; this.name(); } break; @@ -30472,29 +31358,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 33: this.enterOuterAlt(_localctx, 33); { - this.state = 6454; - this.match(PostgreSQLParser.ALTER); - this.state = 6455; - this.match(PostgreSQLParser.TABLE); - this.state = 6456; + this.state = 6536; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6537; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6538; this.relation_expr(); - this.state = 6457; - this.match(PostgreSQLParser.RENAME); - this.state = 6459; + this.state = 6539; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6541; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 530, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 542, this._ctx) ) { case 1: { - this.state = 6458; + this.state = 6540; this.opt_column(); } break; } - this.state = 6461; + this.state = 6543; this.name(); - this.state = 6462; - this.match(PostgreSQLParser.TO); - this.state = 6463; + this.state = 6544; + this.match(PostgreSQLParser.KW_TO); + this.state = 6545; this.name(); } break; @@ -30502,233 +31388,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 34: this.enterOuterAlt(_localctx, 34); { - this.state = 6465; - this.match(PostgreSQLParser.ALTER); - this.state = 6466; - this.match(PostgreSQLParser.TABLE); - this.state = 6467; - this.match(PostgreSQLParser.IF_P); - this.state = 6468; - this.match(PostgreSQLParser.EXISTS); - this.state = 6469; - this.relation_expr(); - this.state = 6470; - this.match(PostgreSQLParser.RENAME); - this.state = 6472; - this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 531, this._ctx) ) { - case 1: - { - this.state = 6471; - this.opt_column(); - } - break; - } - this.state = 6474; - this.name(); - this.state = 6475; - this.match(PostgreSQLParser.TO); - this.state = 6476; - this.name(); - } - break; - - case 35: - this.enterOuterAlt(_localctx, 35); - { - this.state = 6478; - this.match(PostgreSQLParser.ALTER); - this.state = 6479; - this.match(PostgreSQLParser.VIEW); - this.state = 6480; - this.qualified_name(); - this.state = 6481; - this.match(PostgreSQLParser.RENAME); - this.state = 6483; - this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 532, this._ctx) ) { - case 1: - { - this.state = 6482; - this.opt_column(); - } - break; - } - this.state = 6485; - this.name(); - this.state = 6486; - this.match(PostgreSQLParser.TO); - this.state = 6487; - this.name(); - } - break; - - case 36: - this.enterOuterAlt(_localctx, 36); - { - this.state = 6489; - this.match(PostgreSQLParser.ALTER); - this.state = 6490; - this.match(PostgreSQLParser.VIEW); - this.state = 6491; - this.match(PostgreSQLParser.IF_P); - this.state = 6492; - this.match(PostgreSQLParser.EXISTS); - this.state = 6493; - this.qualified_name(); - this.state = 6494; - this.match(PostgreSQLParser.RENAME); - this.state = 6496; - this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 533, this._ctx) ) { - case 1: - { - this.state = 6495; - this.opt_column(); - } - break; - } - this.state = 6498; - this.name(); - this.state = 6499; - this.match(PostgreSQLParser.TO); - this.state = 6500; - this.name(); - } - break; - - case 37: - this.enterOuterAlt(_localctx, 37); - { - this.state = 6502; - this.match(PostgreSQLParser.ALTER); - this.state = 6503; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 6504; - this.match(PostgreSQLParser.VIEW); - this.state = 6505; - this.qualified_name(); - this.state = 6506; - this.match(PostgreSQLParser.RENAME); - this.state = 6508; - this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 534, this._ctx) ) { - case 1: - { - this.state = 6507; - this.opt_column(); - } - break; - } - this.state = 6510; - this.name(); - this.state = 6511; - this.match(PostgreSQLParser.TO); - this.state = 6512; - this.name(); - } - break; - - case 38: - this.enterOuterAlt(_localctx, 38); - { - this.state = 6514; - this.match(PostgreSQLParser.ALTER); - this.state = 6515; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 6516; - this.match(PostgreSQLParser.VIEW); - this.state = 6517; - this.match(PostgreSQLParser.IF_P); - this.state = 6518; - this.match(PostgreSQLParser.EXISTS); - this.state = 6519; - this.qualified_name(); - this.state = 6520; - this.match(PostgreSQLParser.RENAME); - this.state = 6522; - this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 535, this._ctx) ) { - case 1: - { - this.state = 6521; - this.opt_column(); - } - break; - } - this.state = 6524; - this.name(); - this.state = 6525; - this.match(PostgreSQLParser.TO); - this.state = 6526; - this.name(); - } - break; - - case 39: - this.enterOuterAlt(_localctx, 39); - { - this.state = 6528; - this.match(PostgreSQLParser.ALTER); - this.state = 6529; - this.match(PostgreSQLParser.TABLE); - this.state = 6530; - this.relation_expr(); - this.state = 6531; - this.match(PostgreSQLParser.RENAME); - this.state = 6532; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 6533; - this.name(); - this.state = 6534; - this.match(PostgreSQLParser.TO); - this.state = 6535; - this.name(); - } - break; - - case 40: - this.enterOuterAlt(_localctx, 40); - { - this.state = 6537; - this.match(PostgreSQLParser.ALTER); - this.state = 6538; - this.match(PostgreSQLParser.TABLE); - this.state = 6539; - this.match(PostgreSQLParser.IF_P); - this.state = 6540; - this.match(PostgreSQLParser.EXISTS); - this.state = 6541; - this.relation_expr(); - this.state = 6542; - this.match(PostgreSQLParser.RENAME); - this.state = 6543; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 6544; - this.name(); - this.state = 6545; - this.match(PostgreSQLParser.TO); - this.state = 6546; - this.name(); - } - break; - - case 41: - this.enterOuterAlt(_localctx, 41); - { + this.state = 6547; + this.match(PostgreSQLParser.KW_ALTER); this.state = 6548; - this.match(PostgreSQLParser.ALTER); + this.match(PostgreSQLParser.KW_TABLE); this.state = 6549; - this.match(PostgreSQLParser.FOREIGN); + this.match(PostgreSQLParser.KW_IF); this.state = 6550; - this.match(PostgreSQLParser.TABLE); + this.match(PostgreSQLParser.KW_EXISTS); this.state = 6551; this.relation_expr(); this.state = 6552; - this.match(PostgreSQLParser.RENAME); + this.match(PostgreSQLParser.KW_RENAME); this.state = 6554; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 536, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 543, this._ctx) ) { case 1: { this.state = 6553; @@ -30739,44 +31413,256 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this.state = 6556; this.name(); this.state = 6557; - this.match(PostgreSQLParser.TO); + this.match(PostgreSQLParser.KW_TO); this.state = 6558; this.name(); } break; + case 35: + this.enterOuterAlt(_localctx, 35); + { + this.state = 6560; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6561; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 6562; + this.qualified_name(); + this.state = 6563; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6565; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 544, this._ctx) ) { + case 1: + { + this.state = 6564; + this.opt_column(); + } + break; + } + this.state = 6567; + this.name(); + this.state = 6568; + this.match(PostgreSQLParser.KW_TO); + this.state = 6569; + this.name(); + } + break; + + case 36: + this.enterOuterAlt(_localctx, 36); + { + this.state = 6571; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6572; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 6573; + this.match(PostgreSQLParser.KW_IF); + this.state = 6574; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6575; + this.qualified_name(); + this.state = 6576; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6578; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 545, this._ctx) ) { + case 1: + { + this.state = 6577; + this.opt_column(); + } + break; + } + this.state = 6580; + this.name(); + this.state = 6581; + this.match(PostgreSQLParser.KW_TO); + this.state = 6582; + this.name(); + } + break; + + case 37: + this.enterOuterAlt(_localctx, 37); + { + this.state = 6584; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6585; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 6586; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 6587; + this.qualified_name(); + this.state = 6588; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6590; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 546, this._ctx) ) { + case 1: + { + this.state = 6589; + this.opt_column(); + } + break; + } + this.state = 6592; + this.name(); + this.state = 6593; + this.match(PostgreSQLParser.KW_TO); + this.state = 6594; + this.name(); + } + break; + + case 38: + this.enterOuterAlt(_localctx, 38); + { + this.state = 6596; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6597; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 6598; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 6599; + this.match(PostgreSQLParser.KW_IF); + this.state = 6600; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6601; + this.qualified_name(); + this.state = 6602; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6604; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 547, this._ctx) ) { + case 1: + { + this.state = 6603; + this.opt_column(); + } + break; + } + this.state = 6606; + this.name(); + this.state = 6607; + this.match(PostgreSQLParser.KW_TO); + this.state = 6608; + this.name(); + } + break; + + case 39: + this.enterOuterAlt(_localctx, 39); + { + this.state = 6610; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6611; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6612; + this.relation_expr(); + this.state = 6613; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6614; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 6615; + this.name(); + this.state = 6616; + this.match(PostgreSQLParser.KW_TO); + this.state = 6617; + this.name(); + } + break; + + case 40: + this.enterOuterAlt(_localctx, 40); + { + this.state = 6619; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6620; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6621; + this.match(PostgreSQLParser.KW_IF); + this.state = 6622; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6623; + this.relation_expr(); + this.state = 6624; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6625; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 6626; + this.name(); + this.state = 6627; + this.match(PostgreSQLParser.KW_TO); + this.state = 6628; + this.name(); + } + break; + + case 41: + this.enterOuterAlt(_localctx, 41); + { + this.state = 6630; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6631; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 6632; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6633; + this.relation_expr(); + this.state = 6634; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6636; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 548, this._ctx) ) { + case 1: + { + this.state = 6635; + this.opt_column(); + } + break; + } + this.state = 6638; + this.name(); + this.state = 6639; + this.match(PostgreSQLParser.KW_TO); + this.state = 6640; + this.name(); + } + break; + case 42: this.enterOuterAlt(_localctx, 42); { - this.state = 6560; - this.match(PostgreSQLParser.ALTER); - this.state = 6561; - this.match(PostgreSQLParser.FOREIGN); - this.state = 6562; - this.match(PostgreSQLParser.TABLE); - this.state = 6563; - this.match(PostgreSQLParser.IF_P); - this.state = 6564; - this.match(PostgreSQLParser.EXISTS); - this.state = 6565; + this.state = 6642; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6643; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 6644; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6645; + this.match(PostgreSQLParser.KW_IF); + this.state = 6646; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6647; this.relation_expr(); - this.state = 6566; - this.match(PostgreSQLParser.RENAME); - this.state = 6568; + this.state = 6648; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6650; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 537, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 549, this._ctx) ) { case 1: { - this.state = 6567; + this.state = 6649; this.opt_column(); } break; } - this.state = 6570; + this.state = 6652; this.name(); - this.state = 6571; - this.match(PostgreSQLParser.TO); - this.state = 6572; + this.state = 6653; + this.match(PostgreSQLParser.KW_TO); + this.state = 6654; this.name(); } break; @@ -30784,21 +31670,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 43: this.enterOuterAlt(_localctx, 43); { - this.state = 6574; - this.match(PostgreSQLParser.ALTER); - this.state = 6575; - this.match(PostgreSQLParser.RULE); - this.state = 6576; + this.state = 6656; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6657; + this.match(PostgreSQLParser.KW_RULE); + this.state = 6658; this.name(); - this.state = 6577; - this.match(PostgreSQLParser.ON); - this.state = 6578; + this.state = 6659; + this.match(PostgreSQLParser.KW_ON); + this.state = 6660; this.qualified_name(); - this.state = 6579; - this.match(PostgreSQLParser.RENAME); - this.state = 6580; - this.match(PostgreSQLParser.TO); - this.state = 6581; + this.state = 6661; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6662; + this.match(PostgreSQLParser.KW_TO); + this.state = 6663; this.name(); } break; @@ -30806,21 +31692,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 44: this.enterOuterAlt(_localctx, 44); { - this.state = 6583; - this.match(PostgreSQLParser.ALTER); - this.state = 6584; - this.match(PostgreSQLParser.TRIGGER); - this.state = 6585; + this.state = 6665; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6666; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 6667; this.name(); - this.state = 6586; - this.match(PostgreSQLParser.ON); - this.state = 6587; + this.state = 6668; + this.match(PostgreSQLParser.KW_ON); + this.state = 6669; this.qualified_name(); - this.state = 6588; - this.match(PostgreSQLParser.RENAME); - this.state = 6589; - this.match(PostgreSQLParser.TO); - this.state = 6590; + this.state = 6670; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6671; + this.match(PostgreSQLParser.KW_TO); + this.state = 6672; this.name(); } break; @@ -30828,19 +31714,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 45: this.enterOuterAlt(_localctx, 45); { - this.state = 6592; - this.match(PostgreSQLParser.ALTER); - this.state = 6593; - this.match(PostgreSQLParser.EVENT); - this.state = 6594; - this.match(PostgreSQLParser.TRIGGER); - this.state = 6595; + this.state = 6674; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6675; + this.match(PostgreSQLParser.KW_EVENT); + this.state = 6676; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 6677; this.name(); - this.state = 6596; - this.match(PostgreSQLParser.RENAME); - this.state = 6597; - this.match(PostgreSQLParser.TO); - this.state = 6598; + this.state = 6678; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6679; + this.match(PostgreSQLParser.KW_TO); + this.state = 6680; this.name(); } break; @@ -30848,17 +31734,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 46: this.enterOuterAlt(_localctx, 46); { - this.state = 6600; - this.match(PostgreSQLParser.ALTER); - this.state = 6601; - this.match(PostgreSQLParser.ROLE); - this.state = 6602; + this.state = 6682; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6683; + this.match(PostgreSQLParser.KW_ROLE); + this.state = 6684; this.roleid(); - this.state = 6603; - this.match(PostgreSQLParser.RENAME); - this.state = 6604; - this.match(PostgreSQLParser.TO); - this.state = 6605; + this.state = 6685; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6686; + this.match(PostgreSQLParser.KW_TO); + this.state = 6687; this.roleid(); } break; @@ -30866,17 +31752,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 47: this.enterOuterAlt(_localctx, 47); { - this.state = 6607; - this.match(PostgreSQLParser.ALTER); - this.state = 6608; - this.match(PostgreSQLParser.USER); - this.state = 6609; + this.state = 6689; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6690; + this.match(PostgreSQLParser.KW_USER); + this.state = 6691; this.roleid(); - this.state = 6610; - this.match(PostgreSQLParser.RENAME); - this.state = 6611; - this.match(PostgreSQLParser.TO); - this.state = 6612; + this.state = 6692; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6693; + this.match(PostgreSQLParser.KW_TO); + this.state = 6694; this.roleid(); } break; @@ -30884,17 +31770,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 48: this.enterOuterAlt(_localctx, 48); { - this.state = 6614; - this.match(PostgreSQLParser.ALTER); - this.state = 6615; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 6616; + this.state = 6696; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6697; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 6698; this.name(); - this.state = 6617; - this.match(PostgreSQLParser.RENAME); - this.state = 6618; - this.match(PostgreSQLParser.TO); - this.state = 6619; + this.state = 6699; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6700; + this.match(PostgreSQLParser.KW_TO); + this.state = 6701; this.name(); } break; @@ -30902,17 +31788,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 49: this.enterOuterAlt(_localctx, 49); { - this.state = 6621; - this.match(PostgreSQLParser.ALTER); - this.state = 6622; - this.match(PostgreSQLParser.STATISTICS); - this.state = 6623; + this.state = 6703; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6704; + this.match(PostgreSQLParser.KW_STATISTICS); + this.state = 6705; this.any_name(); - this.state = 6624; - this.match(PostgreSQLParser.RENAME); - this.state = 6625; - this.match(PostgreSQLParser.TO); - this.state = 6626; + this.state = 6706; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6707; + this.match(PostgreSQLParser.KW_TO); + this.state = 6708; this.name(); } break; @@ -30920,21 +31806,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 50: this.enterOuterAlt(_localctx, 50); { - this.state = 6628; - this.match(PostgreSQLParser.ALTER); - this.state = 6629; - this.match(PostgreSQLParser.TEXT_P); - this.state = 6630; - this.match(PostgreSQLParser.SEARCH); - this.state = 6631; - this.match(PostgreSQLParser.PARSER); - this.state = 6632; + this.state = 6710; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6711; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 6712; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 6713; + this.match(PostgreSQLParser.KW_PARSER); + this.state = 6714; this.any_name(); - this.state = 6633; - this.match(PostgreSQLParser.RENAME); - this.state = 6634; - this.match(PostgreSQLParser.TO); - this.state = 6635; + this.state = 6715; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6716; + this.match(PostgreSQLParser.KW_TO); + this.state = 6717; this.name(); } break; @@ -30942,21 +31828,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 51: this.enterOuterAlt(_localctx, 51); { - this.state = 6637; - this.match(PostgreSQLParser.ALTER); - this.state = 6638; - this.match(PostgreSQLParser.TEXT_P); - this.state = 6639; - this.match(PostgreSQLParser.SEARCH); - this.state = 6640; - this.match(PostgreSQLParser.DICTIONARY); - this.state = 6641; + this.state = 6719; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6720; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 6721; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 6722; + this.match(PostgreSQLParser.KW_DICTIONARY); + this.state = 6723; this.any_name(); - this.state = 6642; - this.match(PostgreSQLParser.RENAME); - this.state = 6643; - this.match(PostgreSQLParser.TO); - this.state = 6644; + this.state = 6724; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6725; + this.match(PostgreSQLParser.KW_TO); + this.state = 6726; this.name(); } break; @@ -30964,21 +31850,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 52: this.enterOuterAlt(_localctx, 52); { - this.state = 6646; - this.match(PostgreSQLParser.ALTER); - this.state = 6647; - this.match(PostgreSQLParser.TEXT_P); - this.state = 6648; - this.match(PostgreSQLParser.SEARCH); - this.state = 6649; - this.match(PostgreSQLParser.TEMPLATE); - this.state = 6650; + this.state = 6728; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6729; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 6730; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 6731; + this.match(PostgreSQLParser.KW_TEMPLATE); + this.state = 6732; this.any_name(); - this.state = 6651; - this.match(PostgreSQLParser.RENAME); - this.state = 6652; - this.match(PostgreSQLParser.TO); - this.state = 6653; + this.state = 6733; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6734; + this.match(PostgreSQLParser.KW_TO); + this.state = 6735; this.name(); } break; @@ -30986,21 +31872,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 53: this.enterOuterAlt(_localctx, 53); { - this.state = 6655; - this.match(PostgreSQLParser.ALTER); - this.state = 6656; - this.match(PostgreSQLParser.TEXT_P); - this.state = 6657; - this.match(PostgreSQLParser.SEARCH); - this.state = 6658; - this.match(PostgreSQLParser.CONFIGURATION); - this.state = 6659; + this.state = 6737; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6738; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 6739; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 6740; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 6741; this.any_name(); - this.state = 6660; - this.match(PostgreSQLParser.RENAME); - this.state = 6661; - this.match(PostgreSQLParser.TO); - this.state = 6662; + this.state = 6742; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6743; + this.match(PostgreSQLParser.KW_TO); + this.state = 6744; this.name(); } break; @@ -31008,17 +31894,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 54: this.enterOuterAlt(_localctx, 54); { - this.state = 6664; - this.match(PostgreSQLParser.ALTER); - this.state = 6665; - this.match(PostgreSQLParser.TYPE_P); - this.state = 6666; + this.state = 6746; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6747; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 6748; this.any_name(); - this.state = 6667; - this.match(PostgreSQLParser.RENAME); - this.state = 6668; - this.match(PostgreSQLParser.TO); - this.state = 6669; + this.state = 6749; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6750; + this.match(PostgreSQLParser.KW_TO); + this.state = 6751; this.name(); } break; @@ -31026,28 +31912,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 55: this.enterOuterAlt(_localctx, 55); { - this.state = 6671; - this.match(PostgreSQLParser.ALTER); - this.state = 6672; - this.match(PostgreSQLParser.TYPE_P); - this.state = 6673; + this.state = 6753; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6754; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 6755; this.any_name(); - this.state = 6674; - this.match(PostgreSQLParser.RENAME); - this.state = 6675; - this.match(PostgreSQLParser.ATTRIBUTE); - this.state = 6676; + this.state = 6756; + this.match(PostgreSQLParser.KW_RENAME); + this.state = 6757; + this.match(PostgreSQLParser.KW_ATTRIBUTE); + this.state = 6758; this.name(); - this.state = 6677; - this.match(PostgreSQLParser.TO); - this.state = 6678; + this.state = 6759; + this.match(PostgreSQLParser.KW_TO); + this.state = 6760; this.name(); - this.state = 6680; + this.state = 6762; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 6679; + this.state = 6761; this.opt_drop_behavior(); } } @@ -31073,12 +31959,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_column(): Opt_columnContext { let _localctx: Opt_columnContext = new Opt_columnContext(this._ctx, this.state); - this.enterRule(_localctx, 722, PostgreSQLParser.RULE_opt_column); + this.enterRule(_localctx, 736, PostgreSQLParser.RULE_opt_column); try { this.enterOuterAlt(_localctx, 1); { - this.state = 6684; - this.match(PostgreSQLParser.COLUMN); + this.state = 6766; + this.match(PostgreSQLParser.KW_COLUMN); } } catch (re) { @@ -31098,14 +31984,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_set_data(): Opt_set_dataContext { let _localctx: Opt_set_dataContext = new Opt_set_dataContext(this._ctx, this.state); - this.enterRule(_localctx, 724, PostgreSQLParser.RULE_opt_set_data); + this.enterRule(_localctx, 738, PostgreSQLParser.RULE_opt_set_data); try { this.enterOuterAlt(_localctx, 1); { - this.state = 6686; - this.match(PostgreSQLParser.SET); - this.state = 6687; - this.match(PostgreSQLParser.DATA_P); + this.state = 6768; + this.match(PostgreSQLParser.KW_SET); + this.state = 6769; + this.match(PostgreSQLParser.KW_DATA); } } catch (re) { @@ -31125,38 +32011,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterobjectdependsstmt(): AlterobjectdependsstmtContext { let _localctx: AlterobjectdependsstmtContext = new AlterobjectdependsstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 726, PostgreSQLParser.RULE_alterobjectdependsstmt); + this.enterRule(_localctx, 740, PostgreSQLParser.RULE_alterobjectdependsstmt); let _la: number; try { - this.state = 6758; + this.state = 6840; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 546, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 558, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 6689; - this.match(PostgreSQLParser.ALTER); - this.state = 6690; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6691; + this.state = 6771; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6772; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6773; this.function_with_argtypes(); - this.state = 6693; + this.state = 6775; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 6692; + this.state = 6774; this.opt_no(); } } - this.state = 6695; - this.match(PostgreSQLParser.DEPENDS); - this.state = 6696; - this.match(PostgreSQLParser.ON); - this.state = 6697; - this.match(PostgreSQLParser.EXTENSION); - this.state = 6698; + this.state = 6777; + this.match(PostgreSQLParser.KW_DEPENDS); + this.state = 6778; + this.match(PostgreSQLParser.KW_ON); + this.state = 6779; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 6780; this.name(); } break; @@ -31164,29 +32050,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 6700; - this.match(PostgreSQLParser.ALTER); - this.state = 6701; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 6702; + this.state = 6782; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6783; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 6784; this.function_with_argtypes(); - this.state = 6704; + this.state = 6786; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 6703; + this.state = 6785; this.opt_no(); } } - this.state = 6706; - this.match(PostgreSQLParser.DEPENDS); - this.state = 6707; - this.match(PostgreSQLParser.ON); - this.state = 6708; - this.match(PostgreSQLParser.EXTENSION); - this.state = 6709; + this.state = 6788; + this.match(PostgreSQLParser.KW_DEPENDS); + this.state = 6789; + this.match(PostgreSQLParser.KW_ON); + this.state = 6790; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 6791; this.name(); } break; @@ -31194,29 +32080,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 6711; - this.match(PostgreSQLParser.ALTER); - this.state = 6712; - this.match(PostgreSQLParser.ROUTINE); - this.state = 6713; + this.state = 6793; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6794; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 6795; this.function_with_argtypes(); - this.state = 6715; + this.state = 6797; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 6714; + this.state = 6796; this.opt_no(); } } - this.state = 6717; - this.match(PostgreSQLParser.DEPENDS); - this.state = 6718; - this.match(PostgreSQLParser.ON); - this.state = 6719; - this.match(PostgreSQLParser.EXTENSION); - this.state = 6720; + this.state = 6799; + this.match(PostgreSQLParser.KW_DEPENDS); + this.state = 6800; + this.match(PostgreSQLParser.KW_ON); + this.state = 6801; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 6802; this.name(); } break; @@ -31224,33 +32110,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 6722; - this.match(PostgreSQLParser.ALTER); - this.state = 6723; - this.match(PostgreSQLParser.TRIGGER); - this.state = 6724; + this.state = 6804; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6805; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 6806; this.name(); - this.state = 6725; - this.match(PostgreSQLParser.ON); - this.state = 6726; + this.state = 6807; + this.match(PostgreSQLParser.KW_ON); + this.state = 6808; this.qualified_name(); - this.state = 6728; + this.state = 6810; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 6727; + this.state = 6809; this.opt_no(); } } - this.state = 6730; - this.match(PostgreSQLParser.DEPENDS); - this.state = 6731; - this.match(PostgreSQLParser.ON); - this.state = 6732; - this.match(PostgreSQLParser.EXTENSION); - this.state = 6733; + this.state = 6812; + this.match(PostgreSQLParser.KW_DEPENDS); + this.state = 6813; + this.match(PostgreSQLParser.KW_ON); + this.state = 6814; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 6815; this.name(); } break; @@ -31258,31 +32144,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 6735; - this.match(PostgreSQLParser.ALTER); - this.state = 6736; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 6737; - this.match(PostgreSQLParser.VIEW); - this.state = 6738; + this.state = 6817; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6818; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 6819; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 6820; this.qualified_name(); - this.state = 6740; + this.state = 6822; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 6739; + this.state = 6821; this.opt_no(); } } - this.state = 6742; - this.match(PostgreSQLParser.DEPENDS); - this.state = 6743; - this.match(PostgreSQLParser.ON); - this.state = 6744; - this.match(PostgreSQLParser.EXTENSION); - this.state = 6745; + this.state = 6824; + this.match(PostgreSQLParser.KW_DEPENDS); + this.state = 6825; + this.match(PostgreSQLParser.KW_ON); + this.state = 6826; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 6827; this.name(); } break; @@ -31290,29 +32176,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 6747; - this.match(PostgreSQLParser.ALTER); - this.state = 6748; - this.match(PostgreSQLParser.INDEX); - this.state = 6749; + this.state = 6829; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6830; + this.match(PostgreSQLParser.KW_INDEX); + this.state = 6831; this.qualified_name(); - this.state = 6751; + this.state = 6833; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 6750; + this.state = 6832; this.opt_no(); } } - this.state = 6753; - this.match(PostgreSQLParser.DEPENDS); - this.state = 6754; - this.match(PostgreSQLParser.ON); - this.state = 6755; - this.match(PostgreSQLParser.EXTENSION); - this.state = 6756; + this.state = 6835; + this.match(PostgreSQLParser.KW_DEPENDS); + this.state = 6836; + this.match(PostgreSQLParser.KW_ON); + this.state = 6837; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 6838; this.name(); } break; @@ -31335,12 +32221,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_no(): Opt_noContext { let _localctx: Opt_noContext = new Opt_noContext(this._ctx, this.state); - this.enterRule(_localctx, 728, PostgreSQLParser.RULE_opt_no); + this.enterRule(_localctx, 742, PostgreSQLParser.RULE_opt_no); try { this.enterOuterAlt(_localctx, 1); { - this.state = 6760; - this.match(PostgreSQLParser.NO); + this.state = 6842; + this.match(PostgreSQLParser.KW_NO); } } catch (re) { @@ -31360,25 +32246,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterobjectschemastmt(): AlterobjectschemastmtContext { let _localctx: AlterobjectschemastmtContext = new AlterobjectschemastmtContext(this._ctx, this.state); - this.enterRule(_localctx, 730, PostgreSQLParser.RULE_alterobjectschemastmt); + this.enterRule(_localctx, 744, PostgreSQLParser.RULE_alterobjectschemastmt); try { - this.state = 6979; + this.state = 7061; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 547, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 559, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 6762; - this.match(PostgreSQLParser.ALTER); - this.state = 6763; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 6764; + this.state = 6844; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6845; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 6846; this.aggregate_with_argtypes(); - this.state = 6765; - this.match(PostgreSQLParser.SET); - this.state = 6766; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6767; + this.state = 6847; + this.match(PostgreSQLParser.KW_SET); + this.state = 6848; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6849; this.name(); } break; @@ -31386,17 +32272,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 6769; - this.match(PostgreSQLParser.ALTER); - this.state = 6770; - this.match(PostgreSQLParser.COLLATION); - this.state = 6771; + this.state = 6851; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6852; + this.match(PostgreSQLParser.KW_COLLATION); + this.state = 6853; this.any_name(); - this.state = 6772; - this.match(PostgreSQLParser.SET); - this.state = 6773; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6774; + this.state = 6854; + this.match(PostgreSQLParser.KW_SET); + this.state = 6855; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6856; this.name(); } break; @@ -31404,17 +32290,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 6776; - this.match(PostgreSQLParser.ALTER); - this.state = 6777; - this.match(PostgreSQLParser.CONVERSION_P); - this.state = 6778; + this.state = 6858; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6859; + this.match(PostgreSQLParser.KW_CONVERSION); + this.state = 6860; this.any_name(); - this.state = 6779; - this.match(PostgreSQLParser.SET); - this.state = 6780; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6781; + this.state = 6861; + this.match(PostgreSQLParser.KW_SET); + this.state = 6862; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6863; this.name(); } break; @@ -31422,17 +32308,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 6783; - this.match(PostgreSQLParser.ALTER); - this.state = 6784; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 6785; + this.state = 6865; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6866; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 6867; this.any_name(); - this.state = 6786; - this.match(PostgreSQLParser.SET); - this.state = 6787; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6788; + this.state = 6868; + this.match(PostgreSQLParser.KW_SET); + this.state = 6869; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6870; this.name(); } break; @@ -31440,17 +32326,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 6790; - this.match(PostgreSQLParser.ALTER); - this.state = 6791; - this.match(PostgreSQLParser.EXTENSION); - this.state = 6792; + this.state = 6872; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6873; + this.match(PostgreSQLParser.KW_EXTENSION); + this.state = 6874; this.name(); - this.state = 6793; - this.match(PostgreSQLParser.SET); - this.state = 6794; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6795; + this.state = 6875; + this.match(PostgreSQLParser.KW_SET); + this.state = 6876; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6877; this.name(); } break; @@ -31458,17 +32344,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 6797; - this.match(PostgreSQLParser.ALTER); - this.state = 6798; - this.match(PostgreSQLParser.FUNCTION); - this.state = 6799; + this.state = 6879; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6880; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 6881; this.function_with_argtypes(); - this.state = 6800; - this.match(PostgreSQLParser.SET); - this.state = 6801; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6802; + this.state = 6882; + this.match(PostgreSQLParser.KW_SET); + this.state = 6883; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6884; this.name(); } break; @@ -31476,17 +32362,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 6804; - this.match(PostgreSQLParser.ALTER); - this.state = 6805; - this.match(PostgreSQLParser.OPERATOR); - this.state = 6806; + this.state = 6886; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6887; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 6888; this.operator_with_argtypes(); - this.state = 6807; - this.match(PostgreSQLParser.SET); - this.state = 6808; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6809; + this.state = 6889; + this.match(PostgreSQLParser.KW_SET); + this.state = 6890; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6891; this.name(); } break; @@ -31494,23 +32380,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 6811; - this.match(PostgreSQLParser.ALTER); - this.state = 6812; - this.match(PostgreSQLParser.OPERATOR); - this.state = 6813; - this.match(PostgreSQLParser.CLASS); - this.state = 6814; + this.state = 6893; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6894; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 6895; + this.match(PostgreSQLParser.KW_CLASS); + this.state = 6896; this.any_name(); - this.state = 6815; - this.match(PostgreSQLParser.USING); - this.state = 6816; + this.state = 6897; + this.match(PostgreSQLParser.KW_USING); + this.state = 6898; this.name(); - this.state = 6817; - this.match(PostgreSQLParser.SET); - this.state = 6818; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6819; + this.state = 6899; + this.match(PostgreSQLParser.KW_SET); + this.state = 6900; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6901; this.name(); } break; @@ -31518,23 +32404,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 6821; - this.match(PostgreSQLParser.ALTER); - this.state = 6822; - this.match(PostgreSQLParser.OPERATOR); - this.state = 6823; - this.match(PostgreSQLParser.FAMILY); - this.state = 6824; + this.state = 6903; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6904; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 6905; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 6906; this.any_name(); - this.state = 6825; - this.match(PostgreSQLParser.USING); - this.state = 6826; + this.state = 6907; + this.match(PostgreSQLParser.KW_USING); + this.state = 6908; this.name(); - this.state = 6827; - this.match(PostgreSQLParser.SET); - this.state = 6828; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6829; + this.state = 6909; + this.match(PostgreSQLParser.KW_SET); + this.state = 6910; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6911; this.name(); } break; @@ -31542,17 +32428,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 6831; - this.match(PostgreSQLParser.ALTER); - this.state = 6832; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 6833; + this.state = 6913; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6914; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 6915; this.function_with_argtypes(); - this.state = 6834; - this.match(PostgreSQLParser.SET); - this.state = 6835; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6836; + this.state = 6916; + this.match(PostgreSQLParser.KW_SET); + this.state = 6917; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6918; this.name(); } break; @@ -31560,17 +32446,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 6838; - this.match(PostgreSQLParser.ALTER); - this.state = 6839; - this.match(PostgreSQLParser.ROUTINE); - this.state = 6840; + this.state = 6920; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6921; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 6922; this.function_with_argtypes(); - this.state = 6841; - this.match(PostgreSQLParser.SET); - this.state = 6842; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6843; + this.state = 6923; + this.match(PostgreSQLParser.KW_SET); + this.state = 6924; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6925; this.name(); } break; @@ -31578,17 +32464,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 6845; - this.match(PostgreSQLParser.ALTER); - this.state = 6846; - this.match(PostgreSQLParser.TABLE); - this.state = 6847; + this.state = 6927; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6928; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6929; this.relation_expr(); - this.state = 6848; - this.match(PostgreSQLParser.SET); - this.state = 6849; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6850; + this.state = 6930; + this.match(PostgreSQLParser.KW_SET); + this.state = 6931; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6932; this.name(); } break; @@ -31596,21 +32482,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 6852; - this.match(PostgreSQLParser.ALTER); - this.state = 6853; - this.match(PostgreSQLParser.TABLE); - this.state = 6854; - this.match(PostgreSQLParser.IF_P); - this.state = 6855; - this.match(PostgreSQLParser.EXISTS); - this.state = 6856; + this.state = 6934; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6935; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 6936; + this.match(PostgreSQLParser.KW_IF); + this.state = 6937; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6938; this.relation_expr(); - this.state = 6857; - this.match(PostgreSQLParser.SET); - this.state = 6858; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6859; + this.state = 6939; + this.match(PostgreSQLParser.KW_SET); + this.state = 6940; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6941; this.name(); } break; @@ -31618,17 +32504,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 6861; - this.match(PostgreSQLParser.ALTER); - this.state = 6862; - this.match(PostgreSQLParser.STATISTICS); - this.state = 6863; + this.state = 6943; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6944; + this.match(PostgreSQLParser.KW_STATISTICS); + this.state = 6945; this.any_name(); - this.state = 6864; - this.match(PostgreSQLParser.SET); - this.state = 6865; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6866; + this.state = 6946; + this.match(PostgreSQLParser.KW_SET); + this.state = 6947; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6948; this.name(); } break; @@ -31636,21 +32522,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 6868; - this.match(PostgreSQLParser.ALTER); - this.state = 6869; - this.match(PostgreSQLParser.TEXT_P); - this.state = 6870; - this.match(PostgreSQLParser.SEARCH); - this.state = 6871; - this.match(PostgreSQLParser.PARSER); - this.state = 6872; + this.state = 6950; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6951; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 6952; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 6953; + this.match(PostgreSQLParser.KW_PARSER); + this.state = 6954; this.any_name(); - this.state = 6873; - this.match(PostgreSQLParser.SET); - this.state = 6874; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6875; + this.state = 6955; + this.match(PostgreSQLParser.KW_SET); + this.state = 6956; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6957; this.name(); } break; @@ -31658,21 +32544,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 6877; - this.match(PostgreSQLParser.ALTER); - this.state = 6878; - this.match(PostgreSQLParser.TEXT_P); - this.state = 6879; - this.match(PostgreSQLParser.SEARCH); - this.state = 6880; - this.match(PostgreSQLParser.DICTIONARY); - this.state = 6881; + this.state = 6959; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6960; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 6961; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 6962; + this.match(PostgreSQLParser.KW_DICTIONARY); + this.state = 6963; this.any_name(); - this.state = 6882; - this.match(PostgreSQLParser.SET); - this.state = 6883; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6884; + this.state = 6964; + this.match(PostgreSQLParser.KW_SET); + this.state = 6965; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6966; this.name(); } break; @@ -31680,21 +32566,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 6886; - this.match(PostgreSQLParser.ALTER); - this.state = 6887; - this.match(PostgreSQLParser.TEXT_P); - this.state = 6888; - this.match(PostgreSQLParser.SEARCH); - this.state = 6889; - this.match(PostgreSQLParser.TEMPLATE); - this.state = 6890; + this.state = 6968; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6969; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 6970; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 6971; + this.match(PostgreSQLParser.KW_TEMPLATE); + this.state = 6972; this.any_name(); - this.state = 6891; - this.match(PostgreSQLParser.SET); - this.state = 6892; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6893; + this.state = 6973; + this.match(PostgreSQLParser.KW_SET); + this.state = 6974; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6975; this.name(); } break; @@ -31702,21 +32588,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 18: this.enterOuterAlt(_localctx, 18); { - this.state = 6895; - this.match(PostgreSQLParser.ALTER); - this.state = 6896; - this.match(PostgreSQLParser.TEXT_P); - this.state = 6897; - this.match(PostgreSQLParser.SEARCH); - this.state = 6898; - this.match(PostgreSQLParser.CONFIGURATION); - this.state = 6899; + this.state = 6977; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6978; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 6979; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 6980; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 6981; this.any_name(); - this.state = 6900; - this.match(PostgreSQLParser.SET); - this.state = 6901; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6902; + this.state = 6982; + this.match(PostgreSQLParser.KW_SET); + this.state = 6983; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6984; this.name(); } break; @@ -31724,17 +32610,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 19: this.enterOuterAlt(_localctx, 19); { - this.state = 6904; - this.match(PostgreSQLParser.ALTER); - this.state = 6905; - this.match(PostgreSQLParser.SEQUENCE); - this.state = 6906; + this.state = 6986; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6987; + this.match(PostgreSQLParser.KW_SEQUENCE); + this.state = 6988; this.qualified_name(); - this.state = 6907; - this.match(PostgreSQLParser.SET); - this.state = 6908; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6909; + this.state = 6989; + this.match(PostgreSQLParser.KW_SET); + this.state = 6990; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 6991; this.name(); } break; @@ -31742,21 +32628,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 20: this.enterOuterAlt(_localctx, 20); { - this.state = 6911; - this.match(PostgreSQLParser.ALTER); - this.state = 6912; - this.match(PostgreSQLParser.SEQUENCE); - this.state = 6913; - this.match(PostgreSQLParser.IF_P); - this.state = 6914; - this.match(PostgreSQLParser.EXISTS); - this.state = 6915; + this.state = 6993; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 6994; + this.match(PostgreSQLParser.KW_SEQUENCE); + this.state = 6995; + this.match(PostgreSQLParser.KW_IF); + this.state = 6996; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 6997; this.qualified_name(); - this.state = 6916; - this.match(PostgreSQLParser.SET); - this.state = 6917; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6918; + this.state = 6998; + this.match(PostgreSQLParser.KW_SET); + this.state = 6999; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 7000; this.name(); } break; @@ -31764,17 +32650,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 21: this.enterOuterAlt(_localctx, 21); { - this.state = 6920; - this.match(PostgreSQLParser.ALTER); - this.state = 6921; - this.match(PostgreSQLParser.VIEW); - this.state = 6922; + this.state = 7002; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7003; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 7004; this.qualified_name(); - this.state = 6923; - this.match(PostgreSQLParser.SET); - this.state = 6924; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6925; + this.state = 7005; + this.match(PostgreSQLParser.KW_SET); + this.state = 7006; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 7007; this.name(); } break; @@ -31782,21 +32668,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 22: this.enterOuterAlt(_localctx, 22); { - this.state = 6927; - this.match(PostgreSQLParser.ALTER); - this.state = 6928; - this.match(PostgreSQLParser.VIEW); - this.state = 6929; - this.match(PostgreSQLParser.IF_P); - this.state = 6930; - this.match(PostgreSQLParser.EXISTS); - this.state = 6931; + this.state = 7009; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7010; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 7011; + this.match(PostgreSQLParser.KW_IF); + this.state = 7012; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 7013; this.qualified_name(); - this.state = 6932; - this.match(PostgreSQLParser.SET); - this.state = 6933; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6934; + this.state = 7014; + this.match(PostgreSQLParser.KW_SET); + this.state = 7015; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 7016; this.name(); } break; @@ -31804,19 +32690,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 23: this.enterOuterAlt(_localctx, 23); { - this.state = 6936; - this.match(PostgreSQLParser.ALTER); - this.state = 6937; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 6938; - this.match(PostgreSQLParser.VIEW); - this.state = 6939; + this.state = 7018; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7019; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 7020; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 7021; this.qualified_name(); - this.state = 6940; - this.match(PostgreSQLParser.SET); - this.state = 6941; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6942; + this.state = 7022; + this.match(PostgreSQLParser.KW_SET); + this.state = 7023; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 7024; this.name(); } break; @@ -31824,23 +32710,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 24: this.enterOuterAlt(_localctx, 24); { - this.state = 6944; - this.match(PostgreSQLParser.ALTER); - this.state = 6945; - this.match(PostgreSQLParser.MATERIALIZED); - this.state = 6946; - this.match(PostgreSQLParser.VIEW); - this.state = 6947; - this.match(PostgreSQLParser.IF_P); - this.state = 6948; - this.match(PostgreSQLParser.EXISTS); - this.state = 6949; + this.state = 7026; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7027; + this.match(PostgreSQLParser.KW_MATERIALIZED); + this.state = 7028; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 7029; + this.match(PostgreSQLParser.KW_IF); + this.state = 7030; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 7031; this.qualified_name(); - this.state = 6950; - this.match(PostgreSQLParser.SET); - this.state = 6951; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6952; + this.state = 7032; + this.match(PostgreSQLParser.KW_SET); + this.state = 7033; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 7034; this.name(); } break; @@ -31848,19 +32734,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 25: this.enterOuterAlt(_localctx, 25); { - this.state = 6954; - this.match(PostgreSQLParser.ALTER); - this.state = 6955; - this.match(PostgreSQLParser.FOREIGN); - this.state = 6956; - this.match(PostgreSQLParser.TABLE); - this.state = 6957; + this.state = 7036; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7037; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 7038; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 7039; this.relation_expr(); - this.state = 6958; - this.match(PostgreSQLParser.SET); - this.state = 6959; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6960; + this.state = 7040; + this.match(PostgreSQLParser.KW_SET); + this.state = 7041; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 7042; this.name(); } break; @@ -31868,23 +32754,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 26: this.enterOuterAlt(_localctx, 26); { - this.state = 6962; - this.match(PostgreSQLParser.ALTER); - this.state = 6963; - this.match(PostgreSQLParser.FOREIGN); - this.state = 6964; - this.match(PostgreSQLParser.TABLE); - this.state = 6965; - this.match(PostgreSQLParser.IF_P); - this.state = 6966; - this.match(PostgreSQLParser.EXISTS); - this.state = 6967; + this.state = 7044; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7045; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 7046; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 7047; + this.match(PostgreSQLParser.KW_IF); + this.state = 7048; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 7049; this.relation_expr(); - this.state = 6968; - this.match(PostgreSQLParser.SET); - this.state = 6969; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6970; + this.state = 7050; + this.match(PostgreSQLParser.KW_SET); + this.state = 7051; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 7052; this.name(); } break; @@ -31892,17 +32778,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 27: this.enterOuterAlt(_localctx, 27); { - this.state = 6972; - this.match(PostgreSQLParser.ALTER); - this.state = 6973; - this.match(PostgreSQLParser.TYPE_P); - this.state = 6974; + this.state = 7054; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7055; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 7056; this.any_name(); - this.state = 6975; - this.match(PostgreSQLParser.SET); - this.state = 6976; - this.match(PostgreSQLParser.SCHEMA); - this.state = 6977; + this.state = 7057; + this.match(PostgreSQLParser.KW_SET); + this.state = 7058; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 7059; this.name(); } break; @@ -31925,23 +32811,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alteroperatorstmt(): AlteroperatorstmtContext { let _localctx: AlteroperatorstmtContext = new AlteroperatorstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 732, PostgreSQLParser.RULE_alteroperatorstmt); + this.enterRule(_localctx, 746, PostgreSQLParser.RULE_alteroperatorstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 6981; - this.match(PostgreSQLParser.ALTER); - this.state = 6982; - this.match(PostgreSQLParser.OPERATOR); - this.state = 6983; + this.state = 7063; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7064; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 7065; this.operator_with_argtypes(); - this.state = 6984; - this.match(PostgreSQLParser.SET); - this.state = 6985; + this.state = 7066; + this.match(PostgreSQLParser.KW_SET); + this.state = 7067; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 6986; + this.state = 7068; this.operator_def_list(); - this.state = 6987; + this.state = 7069; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -31962,26 +32848,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public operator_def_list(): Operator_def_listContext { let _localctx: Operator_def_listContext = new Operator_def_listContext(this._ctx, this.state); - this.enterRule(_localctx, 734, PostgreSQLParser.RULE_operator_def_list); + this.enterRule(_localctx, 748, PostgreSQLParser.RULE_operator_def_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 6989; + this.state = 7071; this.operator_def_elem(); - this.state = 6994; + this.state = 7076; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 6990; + this.state = 7072; this.match(PostgreSQLParser.COMMA); - this.state = 6991; + this.state = 7073; this.operator_def_elem(); } } - this.state = 6996; + this.state = 7078; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -32004,31 +32890,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public operator_def_elem(): Operator_def_elemContext { let _localctx: Operator_def_elemContext = new Operator_def_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 736, PostgreSQLParser.RULE_operator_def_elem); + this.enterRule(_localctx, 750, PostgreSQLParser.RULE_operator_def_elem); try { - this.state = 7005; + this.state = 7087; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 549, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 561, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 6997; + this.state = 7079; this.collabel(); - this.state = 6998; + this.state = 7080; this.match(PostgreSQLParser.EQUAL); - this.state = 6999; - this.match(PostgreSQLParser.NONE); + this.state = 7081; + this.match(PostgreSQLParser.KW_NONE); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7001; + this.state = 7083; this.collabel(); - this.state = 7002; + this.state = 7084; this.match(PostgreSQLParser.EQUAL); - this.state = 7003; + this.state = 7085; this.operator_def_arg(); } break; @@ -32051,15 +32937,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public operator_def_arg(): Operator_def_argContext { let _localctx: Operator_def_argContext = new Operator_def_argContext(this._ctx, this.state); - this.enterRule(_localctx, 738, PostgreSQLParser.RULE_operator_def_arg); + this.enterRule(_localctx, 752, PostgreSQLParser.RULE_operator_def_arg); try { - this.state = 7012; + this.state = 7094; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 550, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 562, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7007; + this.state = 7089; this.func_type(); } break; @@ -32067,7 +32953,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7008; + this.state = 7090; this.reserved_keyword(); } break; @@ -32075,7 +32961,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7009; + this.state = 7091; this.qual_all_op(); } break; @@ -32083,7 +32969,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7010; + this.state = 7092; this.numericonly(); } break; @@ -32091,7 +32977,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 7011; + this.state = 7093; this.sconst(); } break; @@ -32114,23 +33000,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public altertypestmt(): AltertypestmtContext { let _localctx: AltertypestmtContext = new AltertypestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 740, PostgreSQLParser.RULE_altertypestmt); + this.enterRule(_localctx, 754, PostgreSQLParser.RULE_altertypestmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7014; - this.match(PostgreSQLParser.ALTER); - this.state = 7015; - this.match(PostgreSQLParser.TYPE_P); - this.state = 7016; + this.state = 7096; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7097; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 7098; this.any_name(); - this.state = 7017; - this.match(PostgreSQLParser.SET); - this.state = 7018; + this.state = 7099; + this.match(PostgreSQLParser.KW_SET); + this.state = 7100; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 7019; + this.state = 7101; this.operator_def_list(); - this.state = 7020; + this.state = 7102; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -32151,26 +33037,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterownerstmt(): AlterownerstmtContext { let _localctx: AlterownerstmtContext = new AlterownerstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 742, PostgreSQLParser.RULE_alterownerstmt); + this.enterRule(_localctx, 756, PostgreSQLParser.RULE_alterownerstmt); let _la: number; try { - this.state = 7207; + this.state = 7289; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 552, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 564, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7022; - this.match(PostgreSQLParser.ALTER); - this.state = 7023; - this.match(PostgreSQLParser.AGGREGATE); - this.state = 7024; + this.state = 7104; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7105; + this.match(PostgreSQLParser.KW_AGGREGATE); + this.state = 7106; this.aggregate_with_argtypes(); - this.state = 7025; - this.match(PostgreSQLParser.OWNER); - this.state = 7026; - this.match(PostgreSQLParser.TO); - this.state = 7027; + this.state = 7107; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7108; + this.match(PostgreSQLParser.KW_TO); + this.state = 7109; this.rolespec(); } break; @@ -32178,17 +33064,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7029; - this.match(PostgreSQLParser.ALTER); - this.state = 7030; - this.match(PostgreSQLParser.COLLATION); - this.state = 7031; + this.state = 7111; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7112; + this.match(PostgreSQLParser.KW_COLLATION); + this.state = 7113; this.any_name(); - this.state = 7032; - this.match(PostgreSQLParser.OWNER); - this.state = 7033; - this.match(PostgreSQLParser.TO); - this.state = 7034; + this.state = 7114; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7115; + this.match(PostgreSQLParser.KW_TO); + this.state = 7116; this.rolespec(); } break; @@ -32196,17 +33082,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7036; - this.match(PostgreSQLParser.ALTER); - this.state = 7037; - this.match(PostgreSQLParser.CONVERSION_P); - this.state = 7038; + this.state = 7118; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7119; + this.match(PostgreSQLParser.KW_CONVERSION); + this.state = 7120; this.any_name(); - this.state = 7039; - this.match(PostgreSQLParser.OWNER); - this.state = 7040; - this.match(PostgreSQLParser.TO); - this.state = 7041; + this.state = 7121; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7122; + this.match(PostgreSQLParser.KW_TO); + this.state = 7123; this.rolespec(); } break; @@ -32214,17 +33100,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7043; - this.match(PostgreSQLParser.ALTER); - this.state = 7044; - this.match(PostgreSQLParser.DATABASE); - this.state = 7045; + this.state = 7125; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7126; + this.match(PostgreSQLParser.KW_DATABASE); + this.state = 7127; this.name(); - this.state = 7046; - this.match(PostgreSQLParser.OWNER); - this.state = 7047; - this.match(PostgreSQLParser.TO); - this.state = 7048; + this.state = 7128; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7129; + this.match(PostgreSQLParser.KW_TO); + this.state = 7130; this.rolespec(); } break; @@ -32232,17 +33118,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 7050; - this.match(PostgreSQLParser.ALTER); - this.state = 7051; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 7052; + this.state = 7132; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7133; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 7134; this.any_name(); - this.state = 7053; - this.match(PostgreSQLParser.OWNER); - this.state = 7054; - this.match(PostgreSQLParser.TO); - this.state = 7055; + this.state = 7135; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7136; + this.match(PostgreSQLParser.KW_TO); + this.state = 7137; this.rolespec(); } break; @@ -32250,17 +33136,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 7057; - this.match(PostgreSQLParser.ALTER); - this.state = 7058; - this.match(PostgreSQLParser.FUNCTION); - this.state = 7059; + this.state = 7139; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7140; + this.match(PostgreSQLParser.KW_FUNCTION); + this.state = 7141; this.function_with_argtypes(); - this.state = 7060; - this.match(PostgreSQLParser.OWNER); - this.state = 7061; - this.match(PostgreSQLParser.TO); - this.state = 7062; + this.state = 7142; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7143; + this.match(PostgreSQLParser.KW_TO); + this.state = 7144; this.rolespec(); } break; @@ -32268,27 +33154,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 7064; - this.match(PostgreSQLParser.ALTER); - this.state = 7066; + this.state = 7146; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7148; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PROCEDURAL) { + if (_la === PostgreSQLParser.KW_PROCEDURAL) { { - this.state = 7065; + this.state = 7147; this.opt_procedural(); } } - this.state = 7068; - this.match(PostgreSQLParser.LANGUAGE); - this.state = 7069; + this.state = 7150; + this.match(PostgreSQLParser.KW_LANGUAGE); + this.state = 7151; this.name(); - this.state = 7070; - this.match(PostgreSQLParser.OWNER); - this.state = 7071; - this.match(PostgreSQLParser.TO); - this.state = 7072; + this.state = 7152; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7153; + this.match(PostgreSQLParser.KW_TO); + this.state = 7154; this.rolespec(); } break; @@ -32296,19 +33182,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 7074; - this.match(PostgreSQLParser.ALTER); - this.state = 7075; - this.match(PostgreSQLParser.LARGE_P); - this.state = 7076; - this.match(PostgreSQLParser.OBJECT_P); - this.state = 7077; + this.state = 7156; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7157; + this.match(PostgreSQLParser.KW_LARGE); + this.state = 7158; + this.match(PostgreSQLParser.KW_OBJECT); + this.state = 7159; this.numericonly(); - this.state = 7078; - this.match(PostgreSQLParser.OWNER); - this.state = 7079; - this.match(PostgreSQLParser.TO); - this.state = 7080; + this.state = 7160; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7161; + this.match(PostgreSQLParser.KW_TO); + this.state = 7162; this.rolespec(); } break; @@ -32316,17 +33202,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 7082; - this.match(PostgreSQLParser.ALTER); - this.state = 7083; - this.match(PostgreSQLParser.OPERATOR); - this.state = 7084; + this.state = 7164; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7165; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 7166; this.operator_with_argtypes(); - this.state = 7085; - this.match(PostgreSQLParser.OWNER); - this.state = 7086; - this.match(PostgreSQLParser.TO); - this.state = 7087; + this.state = 7167; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7168; + this.match(PostgreSQLParser.KW_TO); + this.state = 7169; this.rolespec(); } break; @@ -32334,23 +33220,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 7089; - this.match(PostgreSQLParser.ALTER); - this.state = 7090; - this.match(PostgreSQLParser.OPERATOR); - this.state = 7091; - this.match(PostgreSQLParser.CLASS); - this.state = 7092; + this.state = 7171; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7172; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 7173; + this.match(PostgreSQLParser.KW_CLASS); + this.state = 7174; this.any_name(); - this.state = 7093; - this.match(PostgreSQLParser.USING); - this.state = 7094; + this.state = 7175; + this.match(PostgreSQLParser.KW_USING); + this.state = 7176; this.name(); - this.state = 7095; - this.match(PostgreSQLParser.OWNER); - this.state = 7096; - this.match(PostgreSQLParser.TO); - this.state = 7097; + this.state = 7177; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7178; + this.match(PostgreSQLParser.KW_TO); + this.state = 7179; this.rolespec(); } break; @@ -32358,23 +33244,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 7099; - this.match(PostgreSQLParser.ALTER); - this.state = 7100; - this.match(PostgreSQLParser.OPERATOR); - this.state = 7101; - this.match(PostgreSQLParser.FAMILY); - this.state = 7102; + this.state = 7181; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7182; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 7183; + this.match(PostgreSQLParser.KW_FAMILY); + this.state = 7184; this.any_name(); - this.state = 7103; - this.match(PostgreSQLParser.USING); - this.state = 7104; + this.state = 7185; + this.match(PostgreSQLParser.KW_USING); + this.state = 7186; this.name(); - this.state = 7105; - this.match(PostgreSQLParser.OWNER); - this.state = 7106; - this.match(PostgreSQLParser.TO); - this.state = 7107; + this.state = 7187; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7188; + this.match(PostgreSQLParser.KW_TO); + this.state = 7189; this.rolespec(); } break; @@ -32382,17 +33268,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 7109; - this.match(PostgreSQLParser.ALTER); - this.state = 7110; - this.match(PostgreSQLParser.PROCEDURE); - this.state = 7111; + this.state = 7191; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7192; + this.match(PostgreSQLParser.KW_PROCEDURE); + this.state = 7193; this.function_with_argtypes(); - this.state = 7112; - this.match(PostgreSQLParser.OWNER); - this.state = 7113; - this.match(PostgreSQLParser.TO); - this.state = 7114; + this.state = 7194; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7195; + this.match(PostgreSQLParser.KW_TO); + this.state = 7196; this.rolespec(); } break; @@ -32400,17 +33286,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 7116; - this.match(PostgreSQLParser.ALTER); - this.state = 7117; - this.match(PostgreSQLParser.ROUTINE); - this.state = 7118; + this.state = 7198; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7199; + this.match(PostgreSQLParser.KW_ROUTINE); + this.state = 7200; this.function_with_argtypes(); - this.state = 7119; - this.match(PostgreSQLParser.OWNER); - this.state = 7120; - this.match(PostgreSQLParser.TO); - this.state = 7121; + this.state = 7201; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7202; + this.match(PostgreSQLParser.KW_TO); + this.state = 7203; this.rolespec(); } break; @@ -32418,17 +33304,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 7123; - this.match(PostgreSQLParser.ALTER); - this.state = 7124; - this.match(PostgreSQLParser.SCHEMA); - this.state = 7125; + this.state = 7205; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7206; + this.match(PostgreSQLParser.KW_SCHEMA); + this.state = 7207; this.name(); - this.state = 7126; - this.match(PostgreSQLParser.OWNER); - this.state = 7127; - this.match(PostgreSQLParser.TO); - this.state = 7128; + this.state = 7208; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7209; + this.match(PostgreSQLParser.KW_TO); + this.state = 7210; this.rolespec(); } break; @@ -32436,17 +33322,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 7130; - this.match(PostgreSQLParser.ALTER); - this.state = 7131; - this.match(PostgreSQLParser.TYPE_P); - this.state = 7132; + this.state = 7212; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7213; + this.match(PostgreSQLParser.KW_TYPE); + this.state = 7214; this.any_name(); - this.state = 7133; - this.match(PostgreSQLParser.OWNER); - this.state = 7134; - this.match(PostgreSQLParser.TO); - this.state = 7135; + this.state = 7215; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7216; + this.match(PostgreSQLParser.KW_TO); + this.state = 7217; this.rolespec(); } break; @@ -32454,17 +33340,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 7137; - this.match(PostgreSQLParser.ALTER); - this.state = 7138; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 7139; + this.state = 7219; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7220; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 7221; this.name(); - this.state = 7140; - this.match(PostgreSQLParser.OWNER); - this.state = 7141; - this.match(PostgreSQLParser.TO); - this.state = 7142; + this.state = 7222; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7223; + this.match(PostgreSQLParser.KW_TO); + this.state = 7224; this.rolespec(); } break; @@ -32472,17 +33358,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 7144; - this.match(PostgreSQLParser.ALTER); - this.state = 7145; - this.match(PostgreSQLParser.STATISTICS); - this.state = 7146; + this.state = 7226; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7227; + this.match(PostgreSQLParser.KW_STATISTICS); + this.state = 7228; this.any_name(); - this.state = 7147; - this.match(PostgreSQLParser.OWNER); - this.state = 7148; - this.match(PostgreSQLParser.TO); - this.state = 7149; + this.state = 7229; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7230; + this.match(PostgreSQLParser.KW_TO); + this.state = 7231; this.rolespec(); } break; @@ -32490,21 +33376,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 18: this.enterOuterAlt(_localctx, 18); { - this.state = 7151; - this.match(PostgreSQLParser.ALTER); - this.state = 7152; - this.match(PostgreSQLParser.TEXT_P); - this.state = 7153; - this.match(PostgreSQLParser.SEARCH); - this.state = 7154; - this.match(PostgreSQLParser.DICTIONARY); - this.state = 7155; + this.state = 7233; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7234; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 7235; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 7236; + this.match(PostgreSQLParser.KW_DICTIONARY); + this.state = 7237; this.any_name(); - this.state = 7156; - this.match(PostgreSQLParser.OWNER); - this.state = 7157; - this.match(PostgreSQLParser.TO); - this.state = 7158; + this.state = 7238; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7239; + this.match(PostgreSQLParser.KW_TO); + this.state = 7240; this.rolespec(); } break; @@ -32512,21 +33398,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 19: this.enterOuterAlt(_localctx, 19); { - this.state = 7160; - this.match(PostgreSQLParser.ALTER); - this.state = 7161; - this.match(PostgreSQLParser.TEXT_P); - this.state = 7162; - this.match(PostgreSQLParser.SEARCH); - this.state = 7163; - this.match(PostgreSQLParser.CONFIGURATION); - this.state = 7164; + this.state = 7242; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7243; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 7244; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 7245; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 7246; this.any_name(); - this.state = 7165; - this.match(PostgreSQLParser.OWNER); - this.state = 7166; - this.match(PostgreSQLParser.TO); - this.state = 7167; + this.state = 7247; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7248; + this.match(PostgreSQLParser.KW_TO); + this.state = 7249; this.rolespec(); } break; @@ -32534,21 +33420,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 20: this.enterOuterAlt(_localctx, 20); { - this.state = 7169; - this.match(PostgreSQLParser.ALTER); - this.state = 7170; - this.match(PostgreSQLParser.FOREIGN); - this.state = 7171; - this.match(PostgreSQLParser.DATA_P); - this.state = 7172; - this.match(PostgreSQLParser.WRAPPER); - this.state = 7173; + this.state = 7251; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7252; + this.match(PostgreSQLParser.KW_FOREIGN); + this.state = 7253; + this.match(PostgreSQLParser.KW_DATA); + this.state = 7254; + this.match(PostgreSQLParser.KW_WRAPPER); + this.state = 7255; this.name(); - this.state = 7174; - this.match(PostgreSQLParser.OWNER); - this.state = 7175; - this.match(PostgreSQLParser.TO); - this.state = 7176; + this.state = 7256; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7257; + this.match(PostgreSQLParser.KW_TO); + this.state = 7258; this.rolespec(); } break; @@ -32556,17 +33442,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 21: this.enterOuterAlt(_localctx, 21); { - this.state = 7178; - this.match(PostgreSQLParser.ALTER); - this.state = 7179; - this.match(PostgreSQLParser.SERVER); - this.state = 7180; + this.state = 7260; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7261; + this.match(PostgreSQLParser.KW_SERVER); + this.state = 7262; this.name(); - this.state = 7181; - this.match(PostgreSQLParser.OWNER); - this.state = 7182; - this.match(PostgreSQLParser.TO); - this.state = 7183; + this.state = 7263; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7264; + this.match(PostgreSQLParser.KW_TO); + this.state = 7265; this.rolespec(); } break; @@ -32574,19 +33460,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 22: this.enterOuterAlt(_localctx, 22); { - this.state = 7185; - this.match(PostgreSQLParser.ALTER); - this.state = 7186; - this.match(PostgreSQLParser.EVENT); - this.state = 7187; - this.match(PostgreSQLParser.TRIGGER); - this.state = 7188; + this.state = 7267; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7268; + this.match(PostgreSQLParser.KW_EVENT); + this.state = 7269; + this.match(PostgreSQLParser.KW_TRIGGER); + this.state = 7270; this.name(); - this.state = 7189; - this.match(PostgreSQLParser.OWNER); - this.state = 7190; - this.match(PostgreSQLParser.TO); - this.state = 7191; + this.state = 7271; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7272; + this.match(PostgreSQLParser.KW_TO); + this.state = 7273; this.rolespec(); } break; @@ -32594,17 +33480,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 23: this.enterOuterAlt(_localctx, 23); { - this.state = 7193; - this.match(PostgreSQLParser.ALTER); - this.state = 7194; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 7195; + this.state = 7275; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7276; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 7277; this.name(); - this.state = 7196; - this.match(PostgreSQLParser.OWNER); - this.state = 7197; - this.match(PostgreSQLParser.TO); - this.state = 7198; + this.state = 7278; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7279; + this.match(PostgreSQLParser.KW_TO); + this.state = 7280; this.rolespec(); } break; @@ -32612,17 +33498,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 24: this.enterOuterAlt(_localctx, 24); { - this.state = 7200; - this.match(PostgreSQLParser.ALTER); - this.state = 7201; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7202; + this.state = 7282; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7283; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7284; this.name(); - this.state = 7203; - this.match(PostgreSQLParser.OWNER); - this.state = 7204; - this.match(PostgreSQLParser.TO); - this.state = 7205; + this.state = 7285; + this.match(PostgreSQLParser.KW_OWNER); + this.state = 7286; + this.match(PostgreSQLParser.KW_TO); + this.state = 7287; this.rolespec(); } break; @@ -32645,33 +33531,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createpublicationstmt(): CreatepublicationstmtContext { let _localctx: CreatepublicationstmtContext = new CreatepublicationstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 744, PostgreSQLParser.RULE_createpublicationstmt); + this.enterRule(_localctx, 758, PostgreSQLParser.RULE_createpublicationstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7209; - this.match(PostgreSQLParser.CREATE); - this.state = 7210; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 7211; + this.state = 7291; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 7292; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 7293; this.name(); - this.state = 7213; + this.state = 7295; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 7212; + this.state = 7294; this.opt_publication_for_tables(); } } - this.state = 7216; + this.state = 7298; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 554, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 566, this._ctx) ) { case 1: { - this.state = 7215; + this.state = 7297; this.opt_definition(); } break; @@ -32695,11 +33581,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_publication_for_tables(): Opt_publication_for_tablesContext { let _localctx: Opt_publication_for_tablesContext = new Opt_publication_for_tablesContext(this._ctx, this.state); - this.enterRule(_localctx, 746, PostgreSQLParser.RULE_opt_publication_for_tables); + this.enterRule(_localctx, 760, PostgreSQLParser.RULE_opt_publication_for_tables); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7218; + this.state = 7300; this.publication_for_tables(); } } @@ -32720,19 +33606,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public publication_for_tables(): Publication_for_tablesContext { let _localctx: Publication_for_tablesContext = new Publication_for_tablesContext(this._ctx, this.state); - this.enterRule(_localctx, 748, PostgreSQLParser.RULE_publication_for_tables); + this.enterRule(_localctx, 762, PostgreSQLParser.RULE_publication_for_tables); try { - this.state = 7226; + this.state = 7308; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 555, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 567, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7220; - this.match(PostgreSQLParser.FOR); - this.state = 7221; - this.match(PostgreSQLParser.TABLE); - this.state = 7222; + this.state = 7302; + this.match(PostgreSQLParser.KW_FOR); + this.state = 7303; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 7304; this.relation_expr_list(); } break; @@ -32740,12 +33626,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7223; - this.match(PostgreSQLParser.FOR); - this.state = 7224; - this.match(PostgreSQLParser.ALL); - this.state = 7225; - this.match(PostgreSQLParser.TABLES); + this.state = 7305; + this.match(PostgreSQLParser.KW_FOR); + this.state = 7306; + this.match(PostgreSQLParser.KW_ALL); + this.state = 7307; + this.match(PostgreSQLParser.KW_TABLES); } break; } @@ -32767,23 +33653,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterpublicationstmt(): AlterpublicationstmtContext { let _localctx: AlterpublicationstmtContext = new AlterpublicationstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 750, PostgreSQLParser.RULE_alterpublicationstmt); + this.enterRule(_localctx, 764, PostgreSQLParser.RULE_alterpublicationstmt); try { - this.state = 7255; + this.state = 7337; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 556, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 568, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7228; - this.match(PostgreSQLParser.ALTER); - this.state = 7229; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 7230; + this.state = 7310; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7311; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 7312; this.name(); - this.state = 7231; - this.match(PostgreSQLParser.SET); - this.state = 7232; + this.state = 7313; + this.match(PostgreSQLParser.KW_SET); + this.state = 7314; this.definition(); } break; @@ -32791,17 +33677,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7234; - this.match(PostgreSQLParser.ALTER); - this.state = 7235; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 7236; + this.state = 7316; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7317; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 7318; this.name(); - this.state = 7237; - this.match(PostgreSQLParser.ADD_P); - this.state = 7238; - this.match(PostgreSQLParser.TABLE); - this.state = 7239; + this.state = 7319; + this.match(PostgreSQLParser.KW_ADD); + this.state = 7320; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 7321; this.relation_expr_list(); } break; @@ -32809,17 +33695,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7241; - this.match(PostgreSQLParser.ALTER); - this.state = 7242; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 7243; + this.state = 7323; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7324; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 7325; this.name(); - this.state = 7244; - this.match(PostgreSQLParser.SET); - this.state = 7245; - this.match(PostgreSQLParser.TABLE); - this.state = 7246; + this.state = 7326; + this.match(PostgreSQLParser.KW_SET); + this.state = 7327; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 7328; this.relation_expr_list(); } break; @@ -32827,17 +33713,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7248; - this.match(PostgreSQLParser.ALTER); - this.state = 7249; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 7250; + this.state = 7330; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7331; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 7332; this.name(); - this.state = 7251; - this.match(PostgreSQLParser.DROP); - this.state = 7252; - this.match(PostgreSQLParser.TABLE); - this.state = 7253; + this.state = 7333; + this.match(PostgreSQLParser.KW_DROP); + this.state = 7334; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 7335; this.relation_expr_list(); } break; @@ -32860,30 +33746,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createsubscriptionstmt(): CreatesubscriptionstmtContext { let _localctx: CreatesubscriptionstmtContext = new CreatesubscriptionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 752, PostgreSQLParser.RULE_createsubscriptionstmt); + this.enterRule(_localctx, 766, PostgreSQLParser.RULE_createsubscriptionstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7257; - this.match(PostgreSQLParser.CREATE); - this.state = 7258; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7259; + this.state = 7339; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 7340; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7341; this.name(); - this.state = 7260; - this.match(PostgreSQLParser.CONNECTION); - this.state = 7261; + this.state = 7342; + this.match(PostgreSQLParser.KW_CONNECTION); + this.state = 7343; this.sconst(); - this.state = 7262; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 7263; + this.state = 7344; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 7345; this.publication_name_list(); - this.state = 7265; + this.state = 7347; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 557, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 569, this._ctx) ) { case 1: { - this.state = 7264; + this.state = 7346; this.opt_definition(); } break; @@ -32907,26 +33793,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public publication_name_list(): Publication_name_listContext { let _localctx: Publication_name_listContext = new Publication_name_listContext(this._ctx, this.state); - this.enterRule(_localctx, 754, PostgreSQLParser.RULE_publication_name_list); + this.enterRule(_localctx, 768, PostgreSQLParser.RULE_publication_name_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7267; + this.state = 7349; this.publication_name_item(); - this.state = 7272; + this.state = 7354; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 7268; + this.state = 7350; this.match(PostgreSQLParser.COMMA); - this.state = 7269; + this.state = 7351; this.publication_name_item(); } } - this.state = 7274; + this.state = 7356; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -32949,11 +33835,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public publication_name_item(): Publication_name_itemContext { let _localctx: Publication_name_itemContext = new Publication_name_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 756, PostgreSQLParser.RULE_publication_name_item); + this.enterRule(_localctx, 770, PostgreSQLParser.RULE_publication_name_item); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7275; + this.state = 7357; this.collabel(); } } @@ -32974,23 +33860,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public altersubscriptionstmt(): AltersubscriptionstmtContext { let _localctx: AltersubscriptionstmtContext = new AltersubscriptionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 758, PostgreSQLParser.RULE_altersubscriptionstmt); + this.enterRule(_localctx, 772, PostgreSQLParser.RULE_altersubscriptionstmt); try { - this.state = 7316; + this.state = 7398; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 561, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 573, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7277; - this.match(PostgreSQLParser.ALTER); - this.state = 7278; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7279; + this.state = 7359; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7360; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7361; this.name(); - this.state = 7280; - this.match(PostgreSQLParser.SET); - this.state = 7281; + this.state = 7362; + this.match(PostgreSQLParser.KW_SET); + this.state = 7363; this.definition(); } break; @@ -32998,15 +33884,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7283; - this.match(PostgreSQLParser.ALTER); - this.state = 7284; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7285; + this.state = 7365; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7366; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7367; this.name(); - this.state = 7286; - this.match(PostgreSQLParser.CONNECTION); - this.state = 7287; + this.state = 7368; + this.match(PostgreSQLParser.KW_CONNECTION); + this.state = 7369; this.sconst(); } break; @@ -33014,22 +33900,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7289; - this.match(PostgreSQLParser.ALTER); - this.state = 7290; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7291; + this.state = 7371; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7372; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7373; this.name(); - this.state = 7292; - this.match(PostgreSQLParser.REFRESH); - this.state = 7293; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 7295; + this.state = 7374; + this.match(PostgreSQLParser.KW_REFRESH); + this.state = 7375; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 7377; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 559, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 571, this._ctx) ) { case 1: { - this.state = 7294; + this.state = 7376; this.opt_definition(); } break; @@ -33040,24 +33926,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7297; - this.match(PostgreSQLParser.ALTER); - this.state = 7298; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7299; + this.state = 7379; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7380; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7381; this.name(); - this.state = 7300; - this.match(PostgreSQLParser.SET); - this.state = 7301; - this.match(PostgreSQLParser.PUBLICATION); - this.state = 7302; + this.state = 7382; + this.match(PostgreSQLParser.KW_SET); + this.state = 7383; + this.match(PostgreSQLParser.KW_PUBLICATION); + this.state = 7384; this.publication_name_list(); - this.state = 7304; + this.state = 7386; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 560, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 572, this._ctx) ) { case 1: { - this.state = 7303; + this.state = 7385; this.opt_definition(); } break; @@ -33068,28 +33954,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 7306; - this.match(PostgreSQLParser.ALTER); - this.state = 7307; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7308; + this.state = 7388; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7389; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7390; this.name(); - this.state = 7309; - this.match(PostgreSQLParser.ENABLE_P); + this.state = 7391; + this.match(PostgreSQLParser.KW_ENABLE); } break; case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 7311; - this.match(PostgreSQLParser.ALTER); - this.state = 7312; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7313; + this.state = 7393; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7394; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7395; this.name(); - this.state = 7314; - this.match(PostgreSQLParser.DISABLE_P); + this.state = 7396; + this.match(PostgreSQLParser.KW_DISABLE); } break; } @@ -33111,27 +33997,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dropsubscriptionstmt(): DropsubscriptionstmtContext { let _localctx: DropsubscriptionstmtContext = new DropsubscriptionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 760, PostgreSQLParser.RULE_dropsubscriptionstmt); + this.enterRule(_localctx, 774, PostgreSQLParser.RULE_dropsubscriptionstmt); let _la: number; try { - this.state = 7332; + this.state = 7414; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 564, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 576, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7318; - this.match(PostgreSQLParser.DROP); - this.state = 7319; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7320; + this.state = 7400; + this.match(PostgreSQLParser.KW_DROP); + this.state = 7401; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7402; this.name(); - this.state = 7322; + this.state = 7404; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 7321; + this.state = 7403; this.opt_drop_behavior(); } } @@ -33142,22 +34028,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7324; - this.match(PostgreSQLParser.DROP); - this.state = 7325; - this.match(PostgreSQLParser.SUBSCRIPTION); - this.state = 7326; - this.match(PostgreSQLParser.IF_P); - this.state = 7327; - this.match(PostgreSQLParser.EXISTS); - this.state = 7328; + this.state = 7406; + this.match(PostgreSQLParser.KW_DROP); + this.state = 7407; + this.match(PostgreSQLParser.KW_SUBSCRIPTION); + this.state = 7408; + this.match(PostgreSQLParser.KW_IF); + this.state = 7409; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 7410; this.name(); - this.state = 7330; + this.state = 7412; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 7329; + this.state = 7411; this.opt_drop_behavior(); } } @@ -33183,60 +34069,60 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rulestmt(): RulestmtContext { let _localctx: RulestmtContext = new RulestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 762, PostgreSQLParser.RULE_rulestmt); + this.enterRule(_localctx, 776, PostgreSQLParser.RULE_rulestmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7334; - this.match(PostgreSQLParser.CREATE); - this.state = 7336; + this.state = 7416; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 7418; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OR) { + if (_la === PostgreSQLParser.KW_OR) { { - this.state = 7335; + this.state = 7417; this.opt_or_replace(); } } - this.state = 7338; - this.match(PostgreSQLParser.RULE); - this.state = 7339; + this.state = 7420; + this.match(PostgreSQLParser.KW_RULE); + this.state = 7421; this.name(); - this.state = 7340; - this.match(PostgreSQLParser.AS); - this.state = 7341; - this.match(PostgreSQLParser.ON); - this.state = 7342; + this.state = 7422; + this.match(PostgreSQLParser.KW_AS); + this.state = 7423; + this.match(PostgreSQLParser.KW_ON); + this.state = 7424; this.event(); - this.state = 7343; - this.match(PostgreSQLParser.TO); - this.state = 7344; + this.state = 7425; + this.match(PostgreSQLParser.KW_TO); + this.state = 7426; this.qualified_name(); - this.state = 7346; + this.state = 7428; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 7345; + this.state = 7427; this.where_clause(); } } - this.state = 7348; - this.match(PostgreSQLParser.DO); - this.state = 7350; + this.state = 7430; + this.match(PostgreSQLParser.KW_DO); + this.state = 7432; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ALSO || _la === PostgreSQLParser.INSTEAD) { + if (_la === PostgreSQLParser.KW_ALSO || _la === PostgreSQLParser.KW_INSTEAD) { { - this.state = 7349; + this.state = 7431; this.opt_instead(); } } - this.state = 7352; + this.state = 7434; this.ruleactionlist(); } } @@ -33257,23 +34143,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public ruleactionlist(): RuleactionlistContext { let _localctx: RuleactionlistContext = new RuleactionlistContext(this._ctx, this.state); - this.enterRule(_localctx, 764, PostgreSQLParser.RULE_ruleactionlist); + this.enterRule(_localctx, 778, PostgreSQLParser.RULE_ruleactionlist); try { - this.state = 7360; + this.state = 7442; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 568, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 580, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7354; - this.match(PostgreSQLParser.NOTHING); + this.state = 7436; + this.match(PostgreSQLParser.KW_NOTHING); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7355; + this.state = 7437; this.ruleactionstmt(); } break; @@ -33281,11 +34167,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7356; + this.state = 7438; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 7357; + this.state = 7439; this.ruleactionmulti(); - this.state = 7358; + this.state = 7440; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -33308,42 +34194,42 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public ruleactionmulti(): RuleactionmultiContext { let _localctx: RuleactionmultiContext = new RuleactionmultiContext(this._ctx, this.state); - this.enterRule(_localctx, 766, PostgreSQLParser.RULE_ruleactionmulti); + this.enterRule(_localctx, 780, PostgreSQLParser.RULE_ruleactionmulti); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7363; + this.state = 7445; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPEN_PAREN || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & ((1 << (PostgreSQLParser.SELECT - 88)) | (1 << (PostgreSQLParser.TABLE - 88)) | (1 << (PostgreSQLParser.WITH - 88)))) !== 0) || _la === PostgreSQLParser.DELETE_P || _la === PostgreSQLParser.INSERT || _la === PostgreSQLParser.NOTIFY || _la === PostgreSQLParser.UPDATE || _la === PostgreSQLParser.VALUES) { + if (_la === PostgreSQLParser.OPEN_PAREN || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & ((1 << (PostgreSQLParser.KW_SELECT - 88)) | (1 << (PostgreSQLParser.KW_TABLE - 88)) | (1 << (PostgreSQLParser.KW_WITH - 88)))) !== 0) || _la === PostgreSQLParser.KW_DELETE || _la === PostgreSQLParser.KW_INSERT || _la === PostgreSQLParser.KW_NOTIFY || _la === PostgreSQLParser.KW_UPDATE || _la === PostgreSQLParser.KW_VALUES) { { - this.state = 7362; + this.state = 7444; this.ruleactionstmtOrEmpty(); } } - this.state = 7371; + this.state = 7453; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.SEMI) { { { - this.state = 7365; + this.state = 7447; this.match(PostgreSQLParser.SEMI); - this.state = 7367; + this.state = 7449; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPEN_PAREN || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & ((1 << (PostgreSQLParser.SELECT - 88)) | (1 << (PostgreSQLParser.TABLE - 88)) | (1 << (PostgreSQLParser.WITH - 88)))) !== 0) || _la === PostgreSQLParser.DELETE_P || _la === PostgreSQLParser.INSERT || _la === PostgreSQLParser.NOTIFY || _la === PostgreSQLParser.UPDATE || _la === PostgreSQLParser.VALUES) { + if (_la === PostgreSQLParser.OPEN_PAREN || ((((_la - 88)) & ~0x1F) === 0 && ((1 << (_la - 88)) & ((1 << (PostgreSQLParser.KW_SELECT - 88)) | (1 << (PostgreSQLParser.KW_TABLE - 88)) | (1 << (PostgreSQLParser.KW_WITH - 88)))) !== 0) || _la === PostgreSQLParser.KW_DELETE || _la === PostgreSQLParser.KW_INSERT || _la === PostgreSQLParser.KW_NOTIFY || _la === PostgreSQLParser.KW_UPDATE || _la === PostgreSQLParser.KW_VALUES) { { - this.state = 7366; + this.state = 7448; this.ruleactionstmtOrEmpty(); } } } } - this.state = 7373; + this.state = 7455; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -33366,15 +34252,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public ruleactionstmt(): RuleactionstmtContext { let _localctx: RuleactionstmtContext = new RuleactionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 768, PostgreSQLParser.RULE_ruleactionstmt); + this.enterRule(_localctx, 782, PostgreSQLParser.RULE_ruleactionstmt); try { - this.state = 7379; + this.state = 7461; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 572, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 584, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7374; + this.state = 7456; this.selectstmt(); } break; @@ -33382,7 +34268,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7375; + this.state = 7457; this.insertstmt(); } break; @@ -33390,7 +34276,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7376; + this.state = 7458; this.updatestmt(); } break; @@ -33398,7 +34284,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7377; + this.state = 7459; this.deletestmt(); } break; @@ -33406,7 +34292,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 7378; + this.state = 7460; this.notifystmt(); } break; @@ -33429,11 +34315,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public ruleactionstmtOrEmpty(): RuleactionstmtOrEmptyContext { let _localctx: RuleactionstmtOrEmptyContext = new RuleactionstmtOrEmptyContext(this._ctx, this.state); - this.enterRule(_localctx, 770, PostgreSQLParser.RULE_ruleactionstmtOrEmpty); + this.enterRule(_localctx, 784, PostgreSQLParser.RULE_ruleactionstmtOrEmpty); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7381; + this.state = 7463; this.ruleactionstmt(); } } @@ -33454,14 +34340,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public event(): EventContext { let _localctx: EventContext = new EventContext(this._ctx, this.state); - this.enterRule(_localctx, 772, PostgreSQLParser.RULE_event); + this.enterRule(_localctx, 786, PostgreSQLParser.RULE_event); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7383; + this.state = 7465; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.SELECT || _la === PostgreSQLParser.DELETE_P || _la === PostgreSQLParser.INSERT || _la === PostgreSQLParser.UPDATE)) { + if (!(_la === PostgreSQLParser.KW_SELECT || _la === PostgreSQLParser.KW_DELETE || _la === PostgreSQLParser.KW_INSERT || _la === PostgreSQLParser.KW_UPDATE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -33490,14 +34376,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_instead(): Opt_insteadContext { let _localctx: Opt_insteadContext = new Opt_insteadContext(this._ctx, this.state); - this.enterRule(_localctx, 774, PostgreSQLParser.RULE_opt_instead); + this.enterRule(_localctx, 788, PostgreSQLParser.RULE_opt_instead); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7385; + this.state = 7467; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ALSO || _la === PostgreSQLParser.INSTEAD)) { + if (!(_la === PostgreSQLParser.KW_ALSO || _la === PostgreSQLParser.KW_INSTEAD)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -33526,21 +34412,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public notifystmt(): NotifystmtContext { let _localctx: NotifystmtContext = new NotifystmtContext(this._ctx, this.state); - this.enterRule(_localctx, 776, PostgreSQLParser.RULE_notifystmt); + this.enterRule(_localctx, 790, PostgreSQLParser.RULE_notifystmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7387; - this.match(PostgreSQLParser.NOTIFY); - this.state = 7388; + this.state = 7469; + this.match(PostgreSQLParser.KW_NOTIFY); + this.state = 7470; this.colid(); - this.state = 7390; + this.state = 7472; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.COMMA) { { - this.state = 7389; + this.state = 7471; this.notify_payload(); } } @@ -33564,13 +34450,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public notify_payload(): Notify_payloadContext { let _localctx: Notify_payloadContext = new Notify_payloadContext(this._ctx, this.state); - this.enterRule(_localctx, 778, PostgreSQLParser.RULE_notify_payload); + this.enterRule(_localctx, 792, PostgreSQLParser.RULE_notify_payload); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7392; + this.state = 7474; this.match(PostgreSQLParser.COMMA); - this.state = 7393; + this.state = 7475; this.sconst(); } } @@ -33591,13 +34477,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public listenstmt(): ListenstmtContext { let _localctx: ListenstmtContext = new ListenstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 780, PostgreSQLParser.RULE_listenstmt); + this.enterRule(_localctx, 794, PostgreSQLParser.RULE_listenstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7395; - this.match(PostgreSQLParser.LISTEN); - this.state = 7396; + this.state = 7477; + this.match(PostgreSQLParser.KW_LISTEN); + this.state = 7478; this.colid(); } } @@ -33618,17 +34504,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public unlistenstmt(): UnlistenstmtContext { let _localctx: UnlistenstmtContext = new UnlistenstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 782, PostgreSQLParser.RULE_unlistenstmt); + this.enterRule(_localctx, 796, PostgreSQLParser.RULE_unlistenstmt); try { - this.state = 7402; + this.state = 7484; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 574, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 586, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7398; - this.match(PostgreSQLParser.UNLISTEN); - this.state = 7399; + this.state = 7480; + this.match(PostgreSQLParser.KW_UNLISTEN); + this.state = 7481; this.colid(); } break; @@ -33636,9 +34522,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7400; - this.match(PostgreSQLParser.UNLISTEN); - this.state = 7401; + this.state = 7482; + this.match(PostgreSQLParser.KW_UNLISTEN); + this.state = 7483; this.match(PostgreSQLParser.STAR); } break; @@ -33661,33 +34547,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public transactionstmt(): TransactionstmtContext { let _localctx: TransactionstmtContext = new TransactionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 784, PostgreSQLParser.RULE_transactionstmt); + this.enterRule(_localctx, 798, PostgreSQLParser.RULE_transactionstmt); let _la: number; try { - this.state = 7473; + this.state = 7555; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 588, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 600, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7404; - this.match(PostgreSQLParser.ABORT_P); - this.state = 7406; + this.state = 7486; + this.match(PostgreSQLParser.KW_ABORT); + this.state = 7488; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TRANSACTION || _la === PostgreSQLParser.WORK) { + if (_la === PostgreSQLParser.KW_TRANSACTION || _la === PostgreSQLParser.KW_WORK) { { - this.state = 7405; + this.state = 7487; this.opt_transaction(); } } - this.state = 7409; + this.state = 7491; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AND) { + if (_la === PostgreSQLParser.KW_AND) { { - this.state = 7408; + this.state = 7490; this.opt_transaction_chain(); } } @@ -33698,24 +34584,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7411; - this.match(PostgreSQLParser.BEGIN_P); - this.state = 7413; + this.state = 7493; + this.match(PostgreSQLParser.KW_BEGIN); + this.state = 7495; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TRANSACTION || _la === PostgreSQLParser.WORK) { + if (_la === PostgreSQLParser.KW_TRANSACTION || _la === PostgreSQLParser.KW_WORK) { { - this.state = 7412; + this.state = 7494; this.opt_transaction(); } } - this.state = 7416; + this.state = 7498; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.DEFERRABLE || _la === PostgreSQLParser.NOT || _la === PostgreSQLParser.ISOLATION || _la === PostgreSQLParser.READ) { + if (_la === PostgreSQLParser.KW_DEFERRABLE || _la === PostgreSQLParser.KW_NOT || _la === PostgreSQLParser.KW_ISOLATION || _la === PostgreSQLParser.KW_READ) { { - this.state = 7415; + this.state = 7497; this.transaction_mode_list_or_empty(); } } @@ -33726,16 +34612,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7418; - this.match(PostgreSQLParser.START); - this.state = 7419; - this.match(PostgreSQLParser.TRANSACTION); - this.state = 7421; + this.state = 7500; + this.match(PostgreSQLParser.KW_START); + this.state = 7501; + this.match(PostgreSQLParser.KW_TRANSACTION); + this.state = 7503; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.DEFERRABLE || _la === PostgreSQLParser.NOT || _la === PostgreSQLParser.ISOLATION || _la === PostgreSQLParser.READ) { + if (_la === PostgreSQLParser.KW_DEFERRABLE || _la === PostgreSQLParser.KW_NOT || _la === PostgreSQLParser.KW_ISOLATION || _la === PostgreSQLParser.KW_READ) { { - this.state = 7420; + this.state = 7502; this.transaction_mode_list_or_empty(); } } @@ -33746,24 +34632,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7423; - this.match(PostgreSQLParser.COMMIT); - this.state = 7425; + this.state = 7505; + this.match(PostgreSQLParser.KW_COMMIT); + this.state = 7507; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TRANSACTION || _la === PostgreSQLParser.WORK) { + if (_la === PostgreSQLParser.KW_TRANSACTION || _la === PostgreSQLParser.KW_WORK) { { - this.state = 7424; + this.state = 7506; this.opt_transaction(); } } - this.state = 7428; + this.state = 7510; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AND) { + if (_la === PostgreSQLParser.KW_AND) { { - this.state = 7427; + this.state = 7509; this.opt_transaction_chain(); } } @@ -33774,24 +34660,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 7430; - this.match(PostgreSQLParser.END_P); - this.state = 7432; + this.state = 7512; + this.match(PostgreSQLParser.KW_END); + this.state = 7514; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TRANSACTION || _la === PostgreSQLParser.WORK) { + if (_la === PostgreSQLParser.KW_TRANSACTION || _la === PostgreSQLParser.KW_WORK) { { - this.state = 7431; + this.state = 7513; this.opt_transaction(); } } - this.state = 7435; + this.state = 7517; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AND) { + if (_la === PostgreSQLParser.KW_AND) { { - this.state = 7434; + this.state = 7516; this.opt_transaction_chain(); } } @@ -33802,24 +34688,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 7437; - this.match(PostgreSQLParser.ROLLBACK); - this.state = 7439; + this.state = 7519; + this.match(PostgreSQLParser.KW_ROLLBACK); + this.state = 7521; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TRANSACTION || _la === PostgreSQLParser.WORK) { + if (_la === PostgreSQLParser.KW_TRANSACTION || _la === PostgreSQLParser.KW_WORK) { { - this.state = 7438; + this.state = 7520; this.opt_transaction(); } } - this.state = 7442; + this.state = 7524; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AND) { + if (_la === PostgreSQLParser.KW_AND) { { - this.state = 7441; + this.state = 7523; this.opt_transaction_chain(); } } @@ -33830,9 +34716,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 7444; - this.match(PostgreSQLParser.SAVEPOINT); - this.state = 7445; + this.state = 7526; + this.match(PostgreSQLParser.KW_SAVEPOINT); + this.state = 7527; this.colid(); } break; @@ -33840,11 +34726,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 7446; - this.match(PostgreSQLParser.RELEASE); - this.state = 7447; - this.match(PostgreSQLParser.SAVEPOINT); - this.state = 7448; + this.state = 7528; + this.match(PostgreSQLParser.KW_RELEASE); + this.state = 7529; + this.match(PostgreSQLParser.KW_SAVEPOINT); + this.state = 7530; this.colid(); } break; @@ -33852,9 +34738,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 7449; - this.match(PostgreSQLParser.RELEASE); - this.state = 7450; + this.state = 7531; + this.match(PostgreSQLParser.KW_RELEASE); + this.state = 7532; this.colid(); } break; @@ -33862,23 +34748,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 7451; - this.match(PostgreSQLParser.ROLLBACK); - this.state = 7453; + this.state = 7533; + this.match(PostgreSQLParser.KW_ROLLBACK); + this.state = 7535; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TRANSACTION || _la === PostgreSQLParser.WORK) { + if (_la === PostgreSQLParser.KW_TRANSACTION || _la === PostgreSQLParser.KW_WORK) { { - this.state = 7452; + this.state = 7534; this.opt_transaction(); } } - this.state = 7455; - this.match(PostgreSQLParser.TO); - this.state = 7456; - this.match(PostgreSQLParser.SAVEPOINT); - this.state = 7457; + this.state = 7537; + this.match(PostgreSQLParser.KW_TO); + this.state = 7538; + this.match(PostgreSQLParser.KW_SAVEPOINT); + this.state = 7539; this.colid(); } break; @@ -33886,21 +34772,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 7458; - this.match(PostgreSQLParser.ROLLBACK); - this.state = 7460; + this.state = 7540; + this.match(PostgreSQLParser.KW_ROLLBACK); + this.state = 7542; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TRANSACTION || _la === PostgreSQLParser.WORK) { + if (_la === PostgreSQLParser.KW_TRANSACTION || _la === PostgreSQLParser.KW_WORK) { { - this.state = 7459; + this.state = 7541; this.opt_transaction(); } } - this.state = 7462; - this.match(PostgreSQLParser.TO); - this.state = 7463; + this.state = 7544; + this.match(PostgreSQLParser.KW_TO); + this.state = 7545; this.colid(); } break; @@ -33908,11 +34794,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 7464; - this.match(PostgreSQLParser.PREPARE); - this.state = 7465; - this.match(PostgreSQLParser.TRANSACTION); - this.state = 7466; + this.state = 7546; + this.match(PostgreSQLParser.KW_PREPARE); + this.state = 7547; + this.match(PostgreSQLParser.KW_TRANSACTION); + this.state = 7548; this.sconst(); } break; @@ -33920,11 +34806,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 7467; - this.match(PostgreSQLParser.COMMIT); - this.state = 7468; - this.match(PostgreSQLParser.PREPARED); - this.state = 7469; + this.state = 7549; + this.match(PostgreSQLParser.KW_COMMIT); + this.state = 7550; + this.match(PostgreSQLParser.KW_PREPARED); + this.state = 7551; this.sconst(); } break; @@ -33932,11 +34818,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 7470; - this.match(PostgreSQLParser.ROLLBACK); - this.state = 7471; - this.match(PostgreSQLParser.PREPARED); - this.state = 7472; + this.state = 7552; + this.match(PostgreSQLParser.KW_ROLLBACK); + this.state = 7553; + this.match(PostgreSQLParser.KW_PREPARED); + this.state = 7554; this.sconst(); } break; @@ -33959,14 +34845,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_transaction(): Opt_transactionContext { let _localctx: Opt_transactionContext = new Opt_transactionContext(this._ctx, this.state); - this.enterRule(_localctx, 786, PostgreSQLParser.RULE_opt_transaction); + this.enterRule(_localctx, 800, PostgreSQLParser.RULE_opt_transaction); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7475; + this.state = 7557; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.TRANSACTION || _la === PostgreSQLParser.WORK)) { + if (!(_la === PostgreSQLParser.KW_TRANSACTION || _la === PostgreSQLParser.KW_WORK)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -33995,19 +34881,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public transaction_mode_item(): Transaction_mode_itemContext { let _localctx: Transaction_mode_itemContext = new Transaction_mode_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 788, PostgreSQLParser.RULE_transaction_mode_item); + this.enterRule(_localctx, 802, PostgreSQLParser.RULE_transaction_mode_item); try { - this.state = 7487; + this.state = 7569; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 589, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 601, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7477; - this.match(PostgreSQLParser.ISOLATION); - this.state = 7478; - this.match(PostgreSQLParser.LEVEL); - this.state = 7479; + this.state = 7559; + this.match(PostgreSQLParser.KW_ISOLATION); + this.state = 7560; + this.match(PostgreSQLParser.KW_LEVEL); + this.state = 7561; this.iso_level(); } break; @@ -34015,38 +34901,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7480; - this.match(PostgreSQLParser.READ); - this.state = 7481; - this.match(PostgreSQLParser.ONLY); + this.state = 7562; + this.match(PostgreSQLParser.KW_READ); + this.state = 7563; + this.match(PostgreSQLParser.KW_ONLY); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7482; - this.match(PostgreSQLParser.READ); - this.state = 7483; - this.match(PostgreSQLParser.WRITE); + this.state = 7564; + this.match(PostgreSQLParser.KW_READ); + this.state = 7565; + this.match(PostgreSQLParser.KW_WRITE); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7484; - this.match(PostgreSQLParser.DEFERRABLE); + this.state = 7566; + this.match(PostgreSQLParser.KW_DEFERRABLE); } break; case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 7485; - this.match(PostgreSQLParser.NOT); - this.state = 7486; - this.match(PostgreSQLParser.DEFERRABLE); + this.state = 7567; + this.match(PostgreSQLParser.KW_NOT); + this.state = 7568; + this.match(PostgreSQLParser.KW_DEFERRABLE); } break; } @@ -34068,34 +34954,34 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public transaction_mode_list(): Transaction_mode_listContext { let _localctx: Transaction_mode_listContext = new Transaction_mode_listContext(this._ctx, this.state); - this.enterRule(_localctx, 790, PostgreSQLParser.RULE_transaction_mode_list); + this.enterRule(_localctx, 804, PostgreSQLParser.RULE_transaction_mode_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7489; + this.state = 7571; this.transaction_mode_item(); - this.state = 7496; + this.state = 7578; 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) { + while (_la === PostgreSQLParser.COMMA || _la === PostgreSQLParser.KW_DEFERRABLE || _la === PostgreSQLParser.KW_NOT || _la === PostgreSQLParser.KW_ISOLATION || _la === PostgreSQLParser.KW_READ) { { { - this.state = 7491; + this.state = 7573; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.COMMA) { { - this.state = 7490; + this.state = 7572; this.match(PostgreSQLParser.COMMA); } } - this.state = 7493; + this.state = 7575; this.transaction_mode_item(); } } - this.state = 7498; + this.state = 7580; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -34118,11 +35004,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public transaction_mode_list_or_empty(): Transaction_mode_list_or_emptyContext { let _localctx: Transaction_mode_list_or_emptyContext = new Transaction_mode_list_or_emptyContext(this._ctx, this.state); - this.enterRule(_localctx, 792, PostgreSQLParser.RULE_transaction_mode_list_or_empty); + this.enterRule(_localctx, 806, PostgreSQLParser.RULE_transaction_mode_list_or_empty); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7499; + this.state = 7581; this.transaction_mode_list(); } } @@ -34143,25 +35029,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_transaction_chain(): Opt_transaction_chainContext { let _localctx: Opt_transaction_chainContext = new Opt_transaction_chainContext(this._ctx, this.state); - this.enterRule(_localctx, 794, PostgreSQLParser.RULE_opt_transaction_chain); + this.enterRule(_localctx, 808, PostgreSQLParser.RULE_opt_transaction_chain); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7501; - this.match(PostgreSQLParser.AND); - this.state = 7503; + this.state = 7583; + this.match(PostgreSQLParser.KW_AND); + this.state = 7585; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 7502; - this.match(PostgreSQLParser.NO); + this.state = 7584; + this.match(PostgreSQLParser.KW_NO); } } - this.state = 7505; - this.match(PostgreSQLParser.CHAIN); + this.state = 7587; + this.match(PostgreSQLParser.KW_CHAIN); } } catch (re) { @@ -34181,86 +35067,86 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public viewstmt(): ViewstmtContext { let _localctx: ViewstmtContext = new ViewstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 796, PostgreSQLParser.RULE_viewstmt); + this.enterRule(_localctx, 810, PostgreSQLParser.RULE_viewstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7507; - this.match(PostgreSQLParser.CREATE); - this.state = 7510; + this.state = 7589; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 7592; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OR) { + if (_la === PostgreSQLParser.KW_OR) { { - this.state = 7508; - this.match(PostgreSQLParser.OR); - this.state = 7509; - this.match(PostgreSQLParser.REPLACE); + this.state = 7590; + this.match(PostgreSQLParser.KW_OR); + this.state = 7591; + this.match(PostgreSQLParser.KW_REPLACE); } } - this.state = 7513; + this.state = 7595; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GLOBAL || _la === PostgreSQLParser.LOCAL || ((((_la - 343)) & ~0x1F) === 0 && ((1 << (_la - 343)) & ((1 << (PostgreSQLParser.TEMP - 343)) | (1 << (PostgreSQLParser.TEMPORARY - 343)) | (1 << (PostgreSQLParser.UNLOGGED - 343)))) !== 0)) { + if (_la === PostgreSQLParser.KW_GLOBAL || _la === PostgreSQLParser.KW_LOCAL || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & ((1 << (PostgreSQLParser.KW_TEMP - 352)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 352)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 352)))) !== 0)) { { - this.state = 7512; + this.state = 7594; this.opttemp(); } } - this.state = 7532; + this.state = 7614; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.VIEW: + case PostgreSQLParser.KW_VIEW: { - this.state = 7515; - this.match(PostgreSQLParser.VIEW); - this.state = 7516; + this.state = 7597; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 7598; this.qualified_name(); - this.state = 7518; + this.state = 7600; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 7517; + this.state = 7599; this.opt_column_list(); } } - this.state = 7521; + this.state = 7603; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH) { + if (_la === PostgreSQLParser.KW_WITH) { { - this.state = 7520; + this.state = 7602; this.opt_reloptions(); } } } break; - case PostgreSQLParser.RECURSIVE: + case PostgreSQLParser.KW_RECURSIVE: { - this.state = 7523; - this.match(PostgreSQLParser.RECURSIVE); - this.state = 7524; - this.match(PostgreSQLParser.VIEW); - this.state = 7525; + this.state = 7605; + this.match(PostgreSQLParser.KW_RECURSIVE); + this.state = 7606; + this.match(PostgreSQLParser.KW_VIEW); + this.state = 7607; this.qualified_name(); - this.state = 7526; + this.state = 7608; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 7527; + this.state = 7609; this.columnlist(); - this.state = 7528; + this.state = 7610; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 7530; + this.state = 7612; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH) { + if (_la === PostgreSQLParser.KW_WITH) { { - this.state = 7529; + this.state = 7611; this.opt_reloptions(); } } @@ -34270,16 +35156,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 7534; - this.match(PostgreSQLParser.AS); - this.state = 7535; + this.state = 7616; + this.match(PostgreSQLParser.KW_AS); + this.state = 7617; this.selectstmt(); - this.state = 7537; + this.state = 7619; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 599, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 611, this._ctx) ) { case 1: { - this.state = 7536; + this.state = 7618; this.opt_check_option(); } break; @@ -34303,21 +35189,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_check_option(): Opt_check_optionContext { let _localctx: Opt_check_optionContext = new Opt_check_optionContext(this._ctx, this.state); - this.enterRule(_localctx, 798, PostgreSQLParser.RULE_opt_check_option); + this.enterRule(_localctx, 812, PostgreSQLParser.RULE_opt_check_option); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7539; - this.match(PostgreSQLParser.WITH); - this.state = 7541; + this.state = 7621; + this.match(PostgreSQLParser.KW_WITH); + this.state = 7623; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADED || _la === PostgreSQLParser.LOCAL) { + if (_la === PostgreSQLParser.KW_CASCADED || _la === PostgreSQLParser.KW_LOCAL) { { - this.state = 7540; + this.state = 7622; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.CASCADED || _la === PostgreSQLParser.LOCAL)) { + if (!(_la === PostgreSQLParser.KW_CASCADED || _la === PostgreSQLParser.KW_LOCAL)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -34330,10 +35216,10 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } - this.state = 7543; - this.match(PostgreSQLParser.CHECK); - this.state = 7544; - this.match(PostgreSQLParser.OPTION); + this.state = 7625; + this.match(PostgreSQLParser.KW_CHECK); + this.state = 7626; + this.match(PostgreSQLParser.KW_OPTION); } } catch (re) { @@ -34353,13 +35239,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public loadstmt(): LoadstmtContext { let _localctx: LoadstmtContext = new LoadstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 800, PostgreSQLParser.RULE_loadstmt); + this.enterRule(_localctx, 814, PostgreSQLParser.RULE_loadstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7546; - this.match(PostgreSQLParser.LOAD); - this.state = 7547; + this.state = 7628; + this.match(PostgreSQLParser.KW_LOAD); + this.state = 7629; this.file_name(); } } @@ -34380,32 +35266,32 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createdbstmt(): CreatedbstmtContext { let _localctx: CreatedbstmtContext = new CreatedbstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 802, PostgreSQLParser.RULE_createdbstmt); + this.enterRule(_localctx, 816, PostgreSQLParser.RULE_createdbstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7549; - this.match(PostgreSQLParser.CREATE); - this.state = 7550; - this.match(PostgreSQLParser.DATABASE); - this.state = 7551; + this.state = 7631; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 7632; + this.match(PostgreSQLParser.KW_DATABASE); + this.state = 7633; this.name(); - this.state = 7553; + this.state = 7635; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 601, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 613, this._ctx) ) { case 1: { - this.state = 7552; + this.state = 7634; this.opt_with(); } break; } - this.state = 7556; + this.state = 7638; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 602, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 614, this._ctx) ) { case 1: { - this.state = 7555; + this.state = 7637; this.createdb_opt_list(); } break; @@ -34429,11 +35315,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createdb_opt_list(): Createdb_opt_listContext { let _localctx: Createdb_opt_listContext = new Createdb_opt_listContext(this._ctx, this.state); - this.enterRule(_localctx, 804, PostgreSQLParser.RULE_createdb_opt_list); + this.enterRule(_localctx, 818, PostgreSQLParser.RULE_createdb_opt_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7558; + this.state = 7640; this.createdb_opt_items(); } } @@ -34454,12 +35340,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createdb_opt_items(): Createdb_opt_itemsContext { let _localctx: Createdb_opt_itemsContext = new Createdb_opt_itemsContext(this._ctx, this.state); - this.enterRule(_localctx, 806, PostgreSQLParser.RULE_createdb_opt_items); + this.enterRule(_localctx, 820, PostgreSQLParser.RULE_createdb_opt_items); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 7561; + this.state = 7643; this._errHandler.sync(this); _alt = 1; do { @@ -34467,7 +35353,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 1: { { - this.state = 7560; + this.state = 7642; this.createdb_opt_item(); } } @@ -34475,9 +35361,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 7563; + this.state = 7645; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 603, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 615, this._ctx); } while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER); } } @@ -34498,44 +35384,44 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createdb_opt_item(): Createdb_opt_itemContext { let _localctx: Createdb_opt_itemContext = new Createdb_opt_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 808, PostgreSQLParser.RULE_createdb_opt_item); + this.enterRule(_localctx, 822, PostgreSQLParser.RULE_createdb_opt_item); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7565; + this.state = 7647; this.createdb_opt_name(); - this.state = 7567; + this.state = 7649; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.EQUAL) { { - this.state = 7566; + this.state = 7648; this.opt_equal(); } } - this.state = 7572; + this.state = 7654; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 605, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 617, this._ctx) ) { case 1: { - this.state = 7569; + this.state = 7651; this.signediconst(); } break; case 2: { - this.state = 7570; + this.state = 7652; this.opt_boolean_or_string(); } break; case 3: { - this.state = 7571; - this.match(PostgreSQLParser.DEFAULT); + this.state = 7653; + this.match(PostgreSQLParser.KW_DEFAULT); } break; } @@ -34558,76 +35444,76 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createdb_opt_name(): Createdb_opt_nameContext { let _localctx: Createdb_opt_nameContext = new Createdb_opt_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 810, PostgreSQLParser.RULE_createdb_opt_name); + this.enterRule(_localctx, 824, PostgreSQLParser.RULE_createdb_opt_name); try { - this.state = 7582; + this.state = 7664; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -34635,52 +35521,52 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 7574; + this.state = 7656; this.identifier(); } break; - case PostgreSQLParser.CONNECTION: + case PostgreSQLParser.KW_CONNECTION: this.enterOuterAlt(_localctx, 2); { - this.state = 7575; - this.match(PostgreSQLParser.CONNECTION); - this.state = 7576; - this.match(PostgreSQLParser.LIMIT); + this.state = 7657; + this.match(PostgreSQLParser.KW_CONNECTION); + this.state = 7658; + this.match(PostgreSQLParser.KW_LIMIT); } break; - case PostgreSQLParser.ENCODING: + case PostgreSQLParser.KW_ENCODING: this.enterOuterAlt(_localctx, 3); { - this.state = 7577; - this.match(PostgreSQLParser.ENCODING); + this.state = 7659; + this.match(PostgreSQLParser.KW_ENCODING); } break; - case PostgreSQLParser.LOCATION: + case PostgreSQLParser.KW_LOCATION: this.enterOuterAlt(_localctx, 4); { - this.state = 7578; - this.match(PostgreSQLParser.LOCATION); + this.state = 7660; + this.match(PostgreSQLParser.KW_LOCATION); } break; - case PostgreSQLParser.OWNER: + case PostgreSQLParser.KW_OWNER: this.enterOuterAlt(_localctx, 5); { - this.state = 7579; - this.match(PostgreSQLParser.OWNER); + this.state = 7661; + this.match(PostgreSQLParser.KW_OWNER); } break; - case PostgreSQLParser.TABLESPACE: + case PostgreSQLParser.KW_TABLESPACE: this.enterOuterAlt(_localctx, 6); { - this.state = 7580; - this.match(PostgreSQLParser.TABLESPACE); + this.state = 7662; + this.match(PostgreSQLParser.KW_TABLESPACE); } break; - case PostgreSQLParser.TEMPLATE: + case PostgreSQLParser.KW_TEMPLATE: this.enterOuterAlt(_localctx, 7); { - this.state = 7581; - this.match(PostgreSQLParser.TEMPLATE); + this.state = 7663; + this.match(PostgreSQLParser.KW_TEMPLATE); } break; default: @@ -34704,11 +35590,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_equal(): Opt_equalContext { let _localctx: Opt_equalContext = new Opt_equalContext(this._ctx, this.state); - this.enterRule(_localctx, 812, PostgreSQLParser.RULE_opt_equal); + this.enterRule(_localctx, 826, PostgreSQLParser.RULE_opt_equal); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7584; + this.state = 7666; this.match(PostgreSQLParser.EQUAL); } } @@ -34729,29 +35615,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterdatabasestmt(): AlterdatabasestmtContext { let _localctx: AlterdatabasestmtContext = new AlterdatabasestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 814, PostgreSQLParser.RULE_alterdatabasestmt); + this.enterRule(_localctx, 828, PostgreSQLParser.RULE_alterdatabasestmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7586; - this.match(PostgreSQLParser.ALTER); - this.state = 7587; - this.match(PostgreSQLParser.DATABASE); - this.state = 7588; + this.state = 7668; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7669; + this.match(PostgreSQLParser.KW_DATABASE); + this.state = 7670; this.name(); - this.state = 7599; + this.state = 7681; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 609, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 621, this._ctx) ) { case 1: { - this.state = 7589; - this.match(PostgreSQLParser.WITH); - this.state = 7591; + this.state = 7671; + this.match(PostgreSQLParser.KW_WITH); + this.state = 7673; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 607, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 619, this._ctx) ) { case 1: { - this.state = 7590; + this.state = 7672; this.createdb_opt_list(); } break; @@ -34761,12 +35647,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: { - this.state = 7594; + this.state = 7676; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 608, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 620, this._ctx) ) { case 1: { - this.state = 7593; + this.state = 7675; this.createdb_opt_list(); } break; @@ -34776,11 +35662,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: { - this.state = 7596; - this.match(PostgreSQLParser.SET); - this.state = 7597; - this.match(PostgreSQLParser.TABLESPACE); - this.state = 7598; + this.state = 7678; + this.match(PostgreSQLParser.KW_SET); + this.state = 7679; + this.match(PostgreSQLParser.KW_TABLESPACE); + this.state = 7680; this.name(); } break; @@ -34804,17 +35690,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterdatabasesetstmt(): AlterdatabasesetstmtContext { let _localctx: AlterdatabasesetstmtContext = new AlterdatabasesetstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 816, PostgreSQLParser.RULE_alterdatabasesetstmt); + this.enterRule(_localctx, 830, PostgreSQLParser.RULE_alterdatabasesetstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7601; - this.match(PostgreSQLParser.ALTER); - this.state = 7602; - this.match(PostgreSQLParser.DATABASE); - this.state = 7603; + this.state = 7683; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7684; + this.match(PostgreSQLParser.KW_DATABASE); + this.state = 7685; this.name(); - this.state = 7604; + this.state = 7686; this.setresetclause(); } } @@ -34835,49 +35721,49 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public dropdbstmt(): DropdbstmtContext { let _localctx: DropdbstmtContext = new DropdbstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 818, PostgreSQLParser.RULE_dropdbstmt); + this.enterRule(_localctx, 832, PostgreSQLParser.RULE_dropdbstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7606; - this.match(PostgreSQLParser.DROP); - this.state = 7607; - this.match(PostgreSQLParser.DATABASE); - this.state = 7610; + this.state = 7688; + this.match(PostgreSQLParser.KW_DROP); + this.state = 7689; + this.match(PostgreSQLParser.KW_DATABASE); + this.state = 7692; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 610, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 622, this._ctx) ) { case 1: { - this.state = 7608; - this.match(PostgreSQLParser.IF_P); - this.state = 7609; - this.match(PostgreSQLParser.EXISTS); + this.state = 7690; + this.match(PostgreSQLParser.KW_IF); + this.state = 7691; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 7612; + this.state = 7694; this.name(); - this.state = 7620; + this.state = 7702; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 612, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 624, this._ctx) ) { case 1: { - this.state = 7614; + this.state = 7696; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH) { + if (_la === PostgreSQLParser.KW_WITH) { { - this.state = 7613; + this.state = 7695; this.opt_with(); } } - this.state = 7616; + this.state = 7698; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 7617; + this.state = 7699; this.drop_option_list(); - this.state = 7618; + this.state = 7700; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -34901,26 +35787,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public drop_option_list(): Drop_option_listContext { let _localctx: Drop_option_listContext = new Drop_option_listContext(this._ctx, this.state); - this.enterRule(_localctx, 820, PostgreSQLParser.RULE_drop_option_list); + this.enterRule(_localctx, 834, PostgreSQLParser.RULE_drop_option_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7622; + this.state = 7704; this.drop_option(); - this.state = 7627; + this.state = 7709; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 7623; + this.state = 7705; this.match(PostgreSQLParser.COMMA); - this.state = 7624; + this.state = 7706; this.drop_option(); } } - this.state = 7629; + this.state = 7711; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -34943,12 +35829,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public drop_option(): Drop_optionContext { let _localctx: Drop_optionContext = new Drop_optionContext(this._ctx, this.state); - this.enterRule(_localctx, 822, PostgreSQLParser.RULE_drop_option); + this.enterRule(_localctx, 836, PostgreSQLParser.RULE_drop_option); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7630; - this.match(PostgreSQLParser.FORCE); + this.state = 7712; + this.match(PostgreSQLParser.KW_FORCE); } } catch (re) { @@ -34968,20 +35854,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public altercollationstmt(): AltercollationstmtContext { let _localctx: AltercollationstmtContext = new AltercollationstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 824, PostgreSQLParser.RULE_altercollationstmt); + this.enterRule(_localctx, 838, PostgreSQLParser.RULE_altercollationstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7632; - this.match(PostgreSQLParser.ALTER); - this.state = 7633; - this.match(PostgreSQLParser.COLLATION); - this.state = 7634; + this.state = 7714; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7715; + this.match(PostgreSQLParser.KW_COLLATION); + this.state = 7716; this.any_name(); - this.state = 7635; - this.match(PostgreSQLParser.REFRESH); - this.state = 7636; - this.match(PostgreSQLParser.VERSION_P); + this.state = 7717; + this.match(PostgreSQLParser.KW_REFRESH); + this.state = 7718; + this.match(PostgreSQLParser.KW_VERSION); } } catch (re) { @@ -35001,18 +35887,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public altersystemstmt(): AltersystemstmtContext { let _localctx: AltersystemstmtContext = new AltersystemstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 826, PostgreSQLParser.RULE_altersystemstmt); + this.enterRule(_localctx, 840, PostgreSQLParser.RULE_altersystemstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7638; - this.match(PostgreSQLParser.ALTER); - this.state = 7639; - this.match(PostgreSQLParser.SYSTEM_P); - this.state = 7640; + this.state = 7720; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7721; + this.match(PostgreSQLParser.KW_SYSTEM); + this.state = 7722; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.RESET || _la === PostgreSQLParser.SET)) { + if (!(_la === PostgreSQLParser.KW_RESET || _la === PostgreSQLParser.KW_SET)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -35022,7 +35908,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 7641; + this.state = 7723; this.generic_set(); } } @@ -35043,30 +35929,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createdomainstmt(): CreatedomainstmtContext { let _localctx: CreatedomainstmtContext = new CreatedomainstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 828, PostgreSQLParser.RULE_createdomainstmt); + this.enterRule(_localctx, 842, PostgreSQLParser.RULE_createdomainstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7643; - this.match(PostgreSQLParser.CREATE); - this.state = 7644; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 7645; + this.state = 7725; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 7726; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 7727; this.any_name(); - this.state = 7647; + this.state = 7729; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 7646; + this.state = 7728; this.opt_as(); } } - this.state = 7649; + this.state = 7731; this.typename(); - this.state = 7650; + this.state = 7732; this.colquallist(); } } @@ -35087,84 +35973,84 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alterdomainstmt(): AlterdomainstmtContext { let _localctx: AlterdomainstmtContext = new AlterdomainstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 830, PostgreSQLParser.RULE_alterdomainstmt); + this.enterRule(_localctx, 844, PostgreSQLParser.RULE_alterdomainstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7652; - this.match(PostgreSQLParser.ALTER); - this.state = 7653; - this.match(PostgreSQLParser.DOMAIN_P); - this.state = 7654; + this.state = 7734; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7735; + this.match(PostgreSQLParser.KW_DOMAIN); + this.state = 7736; this.any_name(); - this.state = 7677; + this.state = 7759; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 617, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 629, this._ctx) ) { case 1: { - this.state = 7655; + this.state = 7737; this.alter_column_default(); } break; case 2: { - this.state = 7656; - this.match(PostgreSQLParser.DROP); - this.state = 7657; - this.match(PostgreSQLParser.NOT); - this.state = 7658; - this.match(PostgreSQLParser.NULL_P); + this.state = 7738; + this.match(PostgreSQLParser.KW_DROP); + this.state = 7739; + this.match(PostgreSQLParser.KW_NOT); + this.state = 7740; + this.match(PostgreSQLParser.KW_NULL); } break; case 3: { - this.state = 7659; - this.match(PostgreSQLParser.SET); - this.state = 7660; - this.match(PostgreSQLParser.NOT); - this.state = 7661; - this.match(PostgreSQLParser.NULL_P); + this.state = 7741; + this.match(PostgreSQLParser.KW_SET); + this.state = 7742; + this.match(PostgreSQLParser.KW_NOT); + this.state = 7743; + this.match(PostgreSQLParser.KW_NULL); } break; case 4: { - this.state = 7662; - this.match(PostgreSQLParser.ADD_P); - this.state = 7663; + this.state = 7744; + this.match(PostgreSQLParser.KW_ADD); + this.state = 7745; this.tableconstraint(); } break; case 5: { - this.state = 7664; - this.match(PostgreSQLParser.DROP); - this.state = 7665; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 7668; + this.state = 7746; + this.match(PostgreSQLParser.KW_DROP); + this.state = 7747; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 7750; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 615, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 627, this._ctx) ) { case 1: { - this.state = 7666; - this.match(PostgreSQLParser.IF_P); - this.state = 7667; - this.match(PostgreSQLParser.EXISTS); + this.state = 7748; + this.match(PostgreSQLParser.KW_IF); + this.state = 7749; + this.match(PostgreSQLParser.KW_EXISTS); } break; } - this.state = 7670; + this.state = 7752; this.name(); - this.state = 7672; + this.state = 7754; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.CASCADE || _la === PostgreSQLParser.RESTRICT) { + if (_la === PostgreSQLParser.KW_CASCADE || _la === PostgreSQLParser.KW_RESTRICT) { { - this.state = 7671; + this.state = 7753; this.opt_drop_behavior(); } } @@ -35174,11 +36060,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: { - this.state = 7674; - this.match(PostgreSQLParser.VALIDATE); - this.state = 7675; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 7676; + this.state = 7756; + this.match(PostgreSQLParser.KW_VALIDATE); + this.state = 7757; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 7758; this.name(); } break; @@ -35202,12 +36088,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_as(): Opt_asContext { let _localctx: Opt_asContext = new Opt_asContext(this._ctx, this.state); - this.enterRule(_localctx, 832, PostgreSQLParser.RULE_opt_as); + this.enterRule(_localctx, 846, PostgreSQLParser.RULE_opt_as); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7679; - this.match(PostgreSQLParser.AS); + this.state = 7761; + this.match(PostgreSQLParser.KW_AS); } } catch (re) { @@ -35227,21 +36113,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public altertsdictionarystmt(): AltertsdictionarystmtContext { let _localctx: AltertsdictionarystmtContext = new AltertsdictionarystmtContext(this._ctx, this.state); - this.enterRule(_localctx, 834, PostgreSQLParser.RULE_altertsdictionarystmt); + this.enterRule(_localctx, 848, PostgreSQLParser.RULE_altertsdictionarystmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7681; - this.match(PostgreSQLParser.ALTER); - this.state = 7682; - this.match(PostgreSQLParser.TEXT_P); - this.state = 7683; - this.match(PostgreSQLParser.SEARCH); - this.state = 7684; - this.match(PostgreSQLParser.DICTIONARY); - this.state = 7685; + this.state = 7763; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7764; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 7765; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 7766; + this.match(PostgreSQLParser.KW_DICTIONARY); + this.state = 7767; this.any_name(); - this.state = 7686; + this.state = 7768; this.definition(); } } @@ -35262,35 +36148,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public altertsconfigurationstmt(): AltertsconfigurationstmtContext { let _localctx: AltertsconfigurationstmtContext = new AltertsconfigurationstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 836, PostgreSQLParser.RULE_altertsconfigurationstmt); + this.enterRule(_localctx, 850, PostgreSQLParser.RULE_altertsconfigurationstmt); try { - this.state = 7760; + this.state = 7842; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 618, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 630, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7688; - this.match(PostgreSQLParser.ALTER); - this.state = 7689; - this.match(PostgreSQLParser.TEXT_P); - this.state = 7690; - this.match(PostgreSQLParser.SEARCH); - this.state = 7691; - this.match(PostgreSQLParser.CONFIGURATION); - this.state = 7692; + this.state = 7770; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7771; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 7772; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 7773; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 7774; this.any_name(); - this.state = 7693; - this.match(PostgreSQLParser.ADD_P); - this.state = 7694; - this.match(PostgreSQLParser.MAPPING); - this.state = 7695; - this.match(PostgreSQLParser.FOR); - this.state = 7696; + this.state = 7775; + this.match(PostgreSQLParser.KW_ADD); + this.state = 7776; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 7777; + this.match(PostgreSQLParser.KW_FOR); + this.state = 7778; this.name_list(); - this.state = 7697; + this.state = 7779; this.any_with(); - this.state = 7698; + this.state = 7780; this.any_name_list(); } break; @@ -35298,27 +36184,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7700; - this.match(PostgreSQLParser.ALTER); - this.state = 7701; - this.match(PostgreSQLParser.TEXT_P); - this.state = 7702; - this.match(PostgreSQLParser.SEARCH); - this.state = 7703; - this.match(PostgreSQLParser.CONFIGURATION); - this.state = 7704; + this.state = 7782; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7783; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 7784; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 7785; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 7786; this.any_name(); - this.state = 7705; - this.match(PostgreSQLParser.ALTER); - this.state = 7706; - this.match(PostgreSQLParser.MAPPING); - this.state = 7707; - this.match(PostgreSQLParser.FOR); - this.state = 7708; + this.state = 7787; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7788; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 7789; + this.match(PostgreSQLParser.KW_FOR); + this.state = 7790; this.name_list(); - this.state = 7709; + this.state = 7791; this.any_with(); - this.state = 7710; + this.state = 7792; this.any_name_list(); } break; @@ -35326,27 +36212,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7712; - this.match(PostgreSQLParser.ALTER); - this.state = 7713; - this.match(PostgreSQLParser.TEXT_P); - this.state = 7714; - this.match(PostgreSQLParser.SEARCH); - this.state = 7715; - this.match(PostgreSQLParser.CONFIGURATION); - this.state = 7716; + this.state = 7794; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7795; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 7796; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 7797; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 7798; this.any_name(); - this.state = 7717; - this.match(PostgreSQLParser.ALTER); - this.state = 7718; - this.match(PostgreSQLParser.MAPPING); - this.state = 7719; - this.match(PostgreSQLParser.REPLACE); - this.state = 7720; + this.state = 7799; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7800; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 7801; + this.match(PostgreSQLParser.KW_REPLACE); + this.state = 7802; this.any_name(); - this.state = 7721; + this.state = 7803; this.any_with(); - this.state = 7722; + this.state = 7804; this.any_name(); } break; @@ -35354,31 +36240,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7724; - this.match(PostgreSQLParser.ALTER); - this.state = 7725; - this.match(PostgreSQLParser.TEXT_P); - this.state = 7726; - this.match(PostgreSQLParser.SEARCH); - this.state = 7727; - this.match(PostgreSQLParser.CONFIGURATION); - this.state = 7728; + this.state = 7806; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7807; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 7808; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 7809; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 7810; this.any_name(); - this.state = 7729; - this.match(PostgreSQLParser.ALTER); - this.state = 7730; - this.match(PostgreSQLParser.MAPPING); - this.state = 7731; - this.match(PostgreSQLParser.FOR); - this.state = 7732; + this.state = 7811; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7812; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 7813; + this.match(PostgreSQLParser.KW_FOR); + this.state = 7814; this.name_list(); - this.state = 7733; - this.match(PostgreSQLParser.REPLACE); - this.state = 7734; + this.state = 7815; + this.match(PostgreSQLParser.KW_REPLACE); + this.state = 7816; this.any_name(); - this.state = 7735; + this.state = 7817; this.any_with(); - this.state = 7736; + this.state = 7818; this.any_name(); } break; @@ -35386,23 +36272,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 7738; - this.match(PostgreSQLParser.ALTER); - this.state = 7739; - this.match(PostgreSQLParser.TEXT_P); - this.state = 7740; - this.match(PostgreSQLParser.SEARCH); - this.state = 7741; - this.match(PostgreSQLParser.CONFIGURATION); - this.state = 7742; + this.state = 7820; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7821; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 7822; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 7823; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 7824; this.any_name(); - this.state = 7743; - this.match(PostgreSQLParser.DROP); - this.state = 7744; - this.match(PostgreSQLParser.MAPPING); - this.state = 7745; - this.match(PostgreSQLParser.FOR); - this.state = 7746; + this.state = 7825; + this.match(PostgreSQLParser.KW_DROP); + this.state = 7826; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 7827; + this.match(PostgreSQLParser.KW_FOR); + this.state = 7828; this.name_list(); } break; @@ -35410,27 +36296,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 7748; - this.match(PostgreSQLParser.ALTER); - this.state = 7749; - this.match(PostgreSQLParser.TEXT_P); - this.state = 7750; - this.match(PostgreSQLParser.SEARCH); - this.state = 7751; - this.match(PostgreSQLParser.CONFIGURATION); - this.state = 7752; + this.state = 7830; + this.match(PostgreSQLParser.KW_ALTER); + this.state = 7831; + this.match(PostgreSQLParser.KW_TEXT); + this.state = 7832; + this.match(PostgreSQLParser.KW_SEARCH); + this.state = 7833; + this.match(PostgreSQLParser.KW_CONFIGURATION); + this.state = 7834; this.any_name(); - this.state = 7753; - this.match(PostgreSQLParser.DROP); - this.state = 7754; - this.match(PostgreSQLParser.MAPPING); - this.state = 7755; - this.match(PostgreSQLParser.IF_P); - this.state = 7756; - this.match(PostgreSQLParser.EXISTS); - this.state = 7757; - this.match(PostgreSQLParser.FOR); - this.state = 7758; + this.state = 7835; + this.match(PostgreSQLParser.KW_DROP); + this.state = 7836; + this.match(PostgreSQLParser.KW_MAPPING); + this.state = 7837; + this.match(PostgreSQLParser.KW_IF); + this.state = 7838; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 7839; + this.match(PostgreSQLParser.KW_FOR); + this.state = 7840; this.name_list(); } break; @@ -35453,12 +36339,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public any_with(): Any_withContext { let _localctx: Any_withContext = new Any_withContext(this._ctx, this.state); - this.enterRule(_localctx, 838, PostgreSQLParser.RULE_any_with); + this.enterRule(_localctx, 852, PostgreSQLParser.RULE_any_with); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7762; - this.match(PostgreSQLParser.WITH); + this.state = 7844; + this.match(PostgreSQLParser.KW_WITH); } } catch (re) { @@ -35478,38 +36364,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public createconversionstmt(): CreateconversionstmtContext { let _localctx: CreateconversionstmtContext = new CreateconversionstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 840, PostgreSQLParser.RULE_createconversionstmt); + this.enterRule(_localctx, 854, PostgreSQLParser.RULE_createconversionstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7764; - this.match(PostgreSQLParser.CREATE); - this.state = 7766; + this.state = 7846; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 7848; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.DEFAULT) { + if (_la === PostgreSQLParser.KW_DEFAULT) { { - this.state = 7765; + this.state = 7847; this.opt_default(); } } - this.state = 7768; - this.match(PostgreSQLParser.CONVERSION_P); - this.state = 7769; + this.state = 7850; + this.match(PostgreSQLParser.KW_CONVERSION); + this.state = 7851; this.any_name(); - this.state = 7770; - this.match(PostgreSQLParser.FOR); - this.state = 7771; + this.state = 7852; + this.match(PostgreSQLParser.KW_FOR); + this.state = 7853; this.sconst(); - this.state = 7772; - this.match(PostgreSQLParser.TO); - this.state = 7773; + this.state = 7854; + this.match(PostgreSQLParser.KW_TO); + this.state = 7855; this.sconst(); - this.state = 7774; - this.match(PostgreSQLParser.FROM); - this.state = 7775; + this.state = 7856; + this.match(PostgreSQLParser.KW_FROM); + this.state = 7857; this.any_name(); } } @@ -35530,35 +36416,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public clusterstmt(): ClusterstmtContext { let _localctx: ClusterstmtContext = new ClusterstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 842, PostgreSQLParser.RULE_clusterstmt); + this.enterRule(_localctx, 856, PostgreSQLParser.RULE_clusterstmt); let _la: number; try { - this.state = 7797; + this.state = 7879; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 624, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 636, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7777; - this.match(PostgreSQLParser.CLUSTER); - this.state = 7779; + this.state = 7859; + this.match(PostgreSQLParser.KW_CLUSTER); + this.state = 7861; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.VERBOSE) { + if (_la === PostgreSQLParser.KW_VERBOSE) { { - this.state = 7778; + this.state = 7860; this.opt_verbose(); } } - this.state = 7781; + this.state = 7863; this.qualified_name(); - this.state = 7783; + this.state = 7865; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 7782; + this.state = 7864; this.cluster_index_specification(); } } @@ -35569,14 +36455,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7785; - this.match(PostgreSQLParser.CLUSTER); - this.state = 7787; + this.state = 7867; + this.match(PostgreSQLParser.KW_CLUSTER); + this.state = 7869; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.VERBOSE) { + if (_la === PostgreSQLParser.KW_VERBOSE) { { - this.state = 7786; + this.state = 7868; this.opt_verbose(); } } @@ -35587,23 +36473,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7789; - this.match(PostgreSQLParser.CLUSTER); - this.state = 7791; + this.state = 7871; + this.match(PostgreSQLParser.KW_CLUSTER); + this.state = 7873; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.VERBOSE) { + if (_la === PostgreSQLParser.KW_VERBOSE) { { - this.state = 7790; + this.state = 7872; this.opt_verbose(); } } - this.state = 7793; + this.state = 7875; this.name(); - this.state = 7794; - this.match(PostgreSQLParser.ON); - this.state = 7795; + this.state = 7876; + this.match(PostgreSQLParser.KW_ON); + this.state = 7877; this.qualified_name(); } break; @@ -35626,13 +36512,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public cluster_index_specification(): Cluster_index_specificationContext { let _localctx: Cluster_index_specificationContext = new Cluster_index_specificationContext(this._ctx, this.state); - this.enterRule(_localctx, 844, PostgreSQLParser.RULE_cluster_index_specification); + this.enterRule(_localctx, 858, PostgreSQLParser.RULE_cluster_index_specification); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7799; - this.match(PostgreSQLParser.USING); - this.state = 7800; + this.state = 7881; + this.match(PostgreSQLParser.KW_USING); + this.state = 7882; this.name(); } } @@ -35653,63 +36539,63 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public vacuumstmt(): VacuumstmtContext { let _localctx: VacuumstmtContext = new VacuumstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 846, PostgreSQLParser.RULE_vacuumstmt); + this.enterRule(_localctx, 860, PostgreSQLParser.RULE_vacuumstmt); let _la: number; try { - this.state = 7825; + this.state = 7907; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 631, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 643, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7802; - this.match(PostgreSQLParser.VACUUM); - this.state = 7804; + this.state = 7884; + this.match(PostgreSQLParser.KW_VACUUM); + this.state = 7886; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FULL) { + if (_la === PostgreSQLParser.KW_FULL) { { - this.state = 7803; + this.state = 7885; this.opt_full(); } } - this.state = 7807; + this.state = 7889; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FREEZE) { + if (_la === PostgreSQLParser.KW_FREEZE) { { - this.state = 7806; + this.state = 7888; this.opt_freeze(); } } - this.state = 7810; + this.state = 7892; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.VERBOSE) { + if (_la === PostgreSQLParser.KW_VERBOSE) { { - this.state = 7809; + this.state = 7891; this.opt_verbose(); } } - this.state = 7813; + this.state = 7895; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 628, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 640, this._ctx) ) { case 1: { - this.state = 7812; + this.state = 7894; this.opt_analyze(); } break; } - this.state = 7816; + this.state = 7898; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 629, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 641, this._ctx) ) { case 1: { - this.state = 7815; + this.state = 7897; this.opt_vacuum_relation_list(); } break; @@ -35720,20 +36606,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7818; - this.match(PostgreSQLParser.VACUUM); - this.state = 7819; + this.state = 7900; + this.match(PostgreSQLParser.KW_VACUUM); + this.state = 7901; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 7820; + this.state = 7902; this.vac_analyze_option_list(); - this.state = 7821; + this.state = 7903; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 7823; + this.state = 7905; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 630, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 642, this._ctx) ) { case 1: { - this.state = 7822; + this.state = 7904; this.opt_vacuum_relation_list(); } break; @@ -35759,33 +36645,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public analyzestmt(): AnalyzestmtContext { let _localctx: AnalyzestmtContext = new AnalyzestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 848, PostgreSQLParser.RULE_analyzestmt); + this.enterRule(_localctx, 862, PostgreSQLParser.RULE_analyzestmt); let _la: number; try { - this.state = 7841; + this.state = 7923; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 635, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 647, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7827; + this.state = 7909; this.analyze_keyword(); - this.state = 7829; + this.state = 7911; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.VERBOSE) { + if (_la === PostgreSQLParser.KW_VERBOSE) { { - this.state = 7828; + this.state = 7910; this.opt_verbose(); } } - this.state = 7832; + this.state = 7914; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 633, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 645, this._ctx) ) { case 1: { - this.state = 7831; + this.state = 7913; this.opt_vacuum_relation_list(); } break; @@ -35796,20 +36682,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7834; + this.state = 7916; this.analyze_keyword(); - this.state = 7835; + this.state = 7917; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 7836; + this.state = 7918; this.vac_analyze_option_list(); - this.state = 7837; + this.state = 7919; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 7839; + this.state = 7921; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 634, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 646, this._ctx) ) { case 1: { - this.state = 7838; + this.state = 7920; this.opt_vacuum_relation_list(); } break; @@ -35835,26 +36721,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public vac_analyze_option_list(): Vac_analyze_option_listContext { let _localctx: Vac_analyze_option_listContext = new Vac_analyze_option_listContext(this._ctx, this.state); - this.enterRule(_localctx, 850, PostgreSQLParser.RULE_vac_analyze_option_list); + this.enterRule(_localctx, 864, PostgreSQLParser.RULE_vac_analyze_option_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7843; + this.state = 7925; this.vac_analyze_option_elem(); - this.state = 7848; + this.state = 7930; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 7844; + this.state = 7926; this.match(PostgreSQLParser.COMMA); - this.state = 7845; + this.state = 7927; this.vac_analyze_option_elem(); } } - this.state = 7850; + this.state = 7932; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -35877,14 +36763,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public analyze_keyword(): Analyze_keywordContext { let _localctx: Analyze_keywordContext = new Analyze_keywordContext(this._ctx, this.state); - this.enterRule(_localctx, 852, PostgreSQLParser.RULE_analyze_keyword); + this.enterRule(_localctx, 866, PostgreSQLParser.RULE_analyze_keyword); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7851; + this.state = 7933; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ANALYSE || _la === PostgreSQLParser.ANALYZE)) { + if (!(_la === PostgreSQLParser.KW_ANALYSE || _la === PostgreSQLParser.KW_ANALYZE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -35913,19 +36799,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public vac_analyze_option_elem(): Vac_analyze_option_elemContext { let _localctx: Vac_analyze_option_elemContext = new Vac_analyze_option_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 854, PostgreSQLParser.RULE_vac_analyze_option_elem); + this.enterRule(_localctx, 868, PostgreSQLParser.RULE_vac_analyze_option_elem); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7853; + this.state = 7935; this.vac_analyze_option_name(); - this.state = 7855; + this.state = 7937; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS || ((((_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.FALSE_P - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & ((1 << (PostgreSQLParser.ON - 80)) | (1 << (PostgreSQLParser.TABLE - 80)) | (1 << (PostgreSQLParser.TRUE_P - 80)) | (1 << (PostgreSQLParser.AUTHORIZATION - 80)) | (1 << (PostgreSQLParser.BINARY - 80)) | (1 << (PostgreSQLParser.COLLATION - 80)) | (1 << (PostgreSQLParser.CONCURRENTLY - 80)) | (1 << (PostgreSQLParser.CROSS - 80)) | (1 << (PostgreSQLParser.CURRENT_SCHEMA - 80)))) !== 0) || ((((_la - 112)) & ~0x1F) === 0 && ((1 << (_la - 112)) & ((1 << (PostgreSQLParser.FREEZE - 112)) | (1 << (PostgreSQLParser.FULL - 112)) | (1 << (PostgreSQLParser.ILIKE - 112)) | (1 << (PostgreSQLParser.INNER_P - 112)) | (1 << (PostgreSQLParser.IS - 112)) | (1 << (PostgreSQLParser.ISNULL - 112)) | (1 << (PostgreSQLParser.JOIN - 112)) | (1 << (PostgreSQLParser.LEFT - 112)) | (1 << (PostgreSQLParser.LIKE - 112)) | (1 << (PostgreSQLParser.NATURAL - 112)) | (1 << (PostgreSQLParser.NOTNULL - 112)) | (1 << (PostgreSQLParser.OUTER_P - 112)) | (1 << (PostgreSQLParser.OVER - 112)) | (1 << (PostgreSQLParser.OVERLAPS - 112)) | (1 << (PostgreSQLParser.RIGHT - 112)) | (1 << (PostgreSQLParser.SIMILAR - 112)) | (1 << (PostgreSQLParser.VERBOSE - 112)) | (1 << (PostgreSQLParser.ABORT_P - 112)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 112)) | (1 << (PostgreSQLParser.ACCESS - 112)) | (1 << (PostgreSQLParser.ACTION - 112)) | (1 << (PostgreSQLParser.ADD_P - 112)) | (1 << (PostgreSQLParser.ADMIN - 112)) | (1 << (PostgreSQLParser.AFTER - 112)) | (1 << (PostgreSQLParser.AGGREGATE - 112)) | (1 << (PostgreSQLParser.ALSO - 112)) | (1 << (PostgreSQLParser.ALTER - 112)) | (1 << (PostgreSQLParser.ALWAYS - 112)) | (1 << (PostgreSQLParser.ASSERTION - 112)) | (1 << (PostgreSQLParser.ASSIGNMENT - 112)) | (1 << (PostgreSQLParser.AT - 112)) | (1 << (PostgreSQLParser.ATTRIBUTE - 112)))) !== 0) || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & ((1 << (PostgreSQLParser.BACKWARD - 144)) | (1 << (PostgreSQLParser.BEFORE - 144)) | (1 << (PostgreSQLParser.BEGIN_P - 144)) | (1 << (PostgreSQLParser.BY - 144)) | (1 << (PostgreSQLParser.CACHE - 144)) | (1 << (PostgreSQLParser.CALLED - 144)) | (1 << (PostgreSQLParser.CASCADE - 144)) | (1 << (PostgreSQLParser.CASCADED - 144)) | (1 << (PostgreSQLParser.CATALOG - 144)) | (1 << (PostgreSQLParser.CHAIN - 144)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 144)) | (1 << (PostgreSQLParser.CHECKPOINT - 144)) | (1 << (PostgreSQLParser.CLASS - 144)) | (1 << (PostgreSQLParser.CLOSE - 144)) | (1 << (PostgreSQLParser.CLUSTER - 144)) | (1 << (PostgreSQLParser.COMMENT - 144)) | (1 << (PostgreSQLParser.COMMENTS - 144)) | (1 << (PostgreSQLParser.COMMIT - 144)) | (1 << (PostgreSQLParser.COMMITTED - 144)) | (1 << (PostgreSQLParser.CONFIGURATION - 144)) | (1 << (PostgreSQLParser.CONNECTION - 144)) | (1 << (PostgreSQLParser.CONSTRAINTS - 144)) | (1 << (PostgreSQLParser.CONTENT_P - 144)) | (1 << (PostgreSQLParser.CONTINUE_P - 144)) | (1 << (PostgreSQLParser.CONVERSION_P - 144)) | (1 << (PostgreSQLParser.COPY - 144)) | (1 << (PostgreSQLParser.COST - 144)) | (1 << (PostgreSQLParser.CSV - 144)) | (1 << (PostgreSQLParser.CURSOR - 144)) | (1 << (PostgreSQLParser.CYCLE - 144)) | (1 << (PostgreSQLParser.DATA_P - 144)) | (1 << (PostgreSQLParser.DATABASE - 144)))) !== 0) || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (PostgreSQLParser.DAY_P - 176)) | (1 << (PostgreSQLParser.DEALLOCATE - 176)) | (1 << (PostgreSQLParser.DECLARE - 176)) | (1 << (PostgreSQLParser.DEFAULTS - 176)) | (1 << (PostgreSQLParser.DEFERRED - 176)) | (1 << (PostgreSQLParser.DEFINER - 176)) | (1 << (PostgreSQLParser.DELETE_P - 176)) | (1 << (PostgreSQLParser.DELIMITER - 176)) | (1 << (PostgreSQLParser.DELIMITERS - 176)) | (1 << (PostgreSQLParser.DICTIONARY - 176)) | (1 << (PostgreSQLParser.DISABLE_P - 176)) | (1 << (PostgreSQLParser.DISCARD - 176)) | (1 << (PostgreSQLParser.DOCUMENT_P - 176)) | (1 << (PostgreSQLParser.DOMAIN_P - 176)) | (1 << (PostgreSQLParser.DOUBLE_P - 176)) | (1 << (PostgreSQLParser.DROP - 176)) | (1 << (PostgreSQLParser.EACH - 176)) | (1 << (PostgreSQLParser.ENABLE_P - 176)) | (1 << (PostgreSQLParser.ENCODING - 176)) | (1 << (PostgreSQLParser.ENCRYPTED - 176)) | (1 << (PostgreSQLParser.ENUM_P - 176)) | (1 << (PostgreSQLParser.ESCAPE - 176)) | (1 << (PostgreSQLParser.EVENT - 176)) | (1 << (PostgreSQLParser.EXCLUDE - 176)) | (1 << (PostgreSQLParser.EXCLUDING - 176)) | (1 << (PostgreSQLParser.EXCLUSIVE - 176)) | (1 << (PostgreSQLParser.EXECUTE - 176)) | (1 << (PostgreSQLParser.EXPLAIN - 176)) | (1 << (PostgreSQLParser.EXTENSION - 176)) | (1 << (PostgreSQLParser.EXTERNAL - 176)) | (1 << (PostgreSQLParser.FAMILY - 176)) | (1 << (PostgreSQLParser.FIRST_P - 176)))) !== 0) || ((((_la - 208)) & ~0x1F) === 0 && ((1 << (_la - 208)) & ((1 << (PostgreSQLParser.FOLLOWING - 208)) | (1 << (PostgreSQLParser.FORCE - 208)) | (1 << (PostgreSQLParser.FORWARD - 208)) | (1 << (PostgreSQLParser.FUNCTION - 208)) | (1 << (PostgreSQLParser.FUNCTIONS - 208)) | (1 << (PostgreSQLParser.GLOBAL - 208)) | (1 << (PostgreSQLParser.GRANTED - 208)) | (1 << (PostgreSQLParser.HANDLER - 208)) | (1 << (PostgreSQLParser.HEADER_P - 208)) | (1 << (PostgreSQLParser.HOLD - 208)) | (1 << (PostgreSQLParser.HOUR_P - 208)) | (1 << (PostgreSQLParser.IDENTITY_P - 208)) | (1 << (PostgreSQLParser.IF_P - 208)) | (1 << (PostgreSQLParser.IMMEDIATE - 208)) | (1 << (PostgreSQLParser.IMMUTABLE - 208)) | (1 << (PostgreSQLParser.IMPLICIT_P - 208)) | (1 << (PostgreSQLParser.INCLUDING - 208)) | (1 << (PostgreSQLParser.INCREMENT - 208)) | (1 << (PostgreSQLParser.INDEX - 208)) | (1 << (PostgreSQLParser.INDEXES - 208)) | (1 << (PostgreSQLParser.INHERIT - 208)) | (1 << (PostgreSQLParser.INHERITS - 208)) | (1 << (PostgreSQLParser.INLINE_P - 208)) | (1 << (PostgreSQLParser.INSENSITIVE - 208)) | (1 << (PostgreSQLParser.INSERT - 208)) | (1 << (PostgreSQLParser.INSTEAD - 208)) | (1 << (PostgreSQLParser.INVOKER - 208)) | (1 << (PostgreSQLParser.ISOLATION - 208)) | (1 << (PostgreSQLParser.KEY - 208)) | (1 << (PostgreSQLParser.LABEL - 208)) | (1 << (PostgreSQLParser.LANGUAGE - 208)) | (1 << (PostgreSQLParser.LARGE_P - 208)))) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.LAST_P - 240)) | (1 << (PostgreSQLParser.LEAKPROOF - 240)) | (1 << (PostgreSQLParser.LEVEL - 240)) | (1 << (PostgreSQLParser.LISTEN - 240)) | (1 << (PostgreSQLParser.LOAD - 240)) | (1 << (PostgreSQLParser.LOCAL - 240)) | (1 << (PostgreSQLParser.LOCATION - 240)) | (1 << (PostgreSQLParser.LOCK_P - 240)) | (1 << (PostgreSQLParser.MAPPING - 240)) | (1 << (PostgreSQLParser.MATCH - 240)) | (1 << (PostgreSQLParser.MATERIALIZED - 240)) | (1 << (PostgreSQLParser.MAXVALUE - 240)) | (1 << (PostgreSQLParser.MINUTE_P - 240)) | (1 << (PostgreSQLParser.MINVALUE - 240)) | (1 << (PostgreSQLParser.MODE - 240)) | (1 << (PostgreSQLParser.MONTH_P - 240)) | (1 << (PostgreSQLParser.MOVE - 240)) | (1 << (PostgreSQLParser.NAME_P - 240)) | (1 << (PostgreSQLParser.NAMES - 240)) | (1 << (PostgreSQLParser.NEXT - 240)) | (1 << (PostgreSQLParser.NO - 240)) | (1 << (PostgreSQLParser.NOTHING - 240)) | (1 << (PostgreSQLParser.NOTIFY - 240)) | (1 << (PostgreSQLParser.NOWAIT - 240)) | (1 << (PostgreSQLParser.NULLS_P - 240)) | (1 << (PostgreSQLParser.OBJECT_P - 240)) | (1 << (PostgreSQLParser.OF - 240)) | (1 << (PostgreSQLParser.OFF - 240)) | (1 << (PostgreSQLParser.OIDS - 240)) | (1 << (PostgreSQLParser.OPERATOR - 240)) | (1 << (PostgreSQLParser.OPTION - 240)) | (1 << (PostgreSQLParser.OPTIONS - 240)))) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & ((1 << (PostgreSQLParser.OWNED - 272)) | (1 << (PostgreSQLParser.OWNER - 272)) | (1 << (PostgreSQLParser.PARSER - 272)) | (1 << (PostgreSQLParser.PARTIAL - 272)) | (1 << (PostgreSQLParser.PARTITION - 272)) | (1 << (PostgreSQLParser.PASSING - 272)) | (1 << (PostgreSQLParser.PASSWORD - 272)) | (1 << (PostgreSQLParser.PLANS - 272)) | (1 << (PostgreSQLParser.PRECEDING - 272)) | (1 << (PostgreSQLParser.PREPARE - 272)) | (1 << (PostgreSQLParser.PREPARED - 272)) | (1 << (PostgreSQLParser.PRESERVE - 272)) | (1 << (PostgreSQLParser.PRIOR - 272)) | (1 << (PostgreSQLParser.PRIVILEGES - 272)) | (1 << (PostgreSQLParser.PROCEDURAL - 272)) | (1 << (PostgreSQLParser.PROCEDURE - 272)) | (1 << (PostgreSQLParser.PROGRAM - 272)) | (1 << (PostgreSQLParser.QUOTE - 272)) | (1 << (PostgreSQLParser.RANGE - 272)) | (1 << (PostgreSQLParser.READ - 272)) | (1 << (PostgreSQLParser.REASSIGN - 272)) | (1 << (PostgreSQLParser.RECHECK - 272)) | (1 << (PostgreSQLParser.RECURSIVE - 272)) | (1 << (PostgreSQLParser.REF - 272)) | (1 << (PostgreSQLParser.REFRESH - 272)) | (1 << (PostgreSQLParser.REINDEX - 272)) | (1 << (PostgreSQLParser.RELATIVE_P - 272)) | (1 << (PostgreSQLParser.RELEASE - 272)) | (1 << (PostgreSQLParser.RENAME - 272)) | (1 << (PostgreSQLParser.REPEATABLE - 272)) | (1 << (PostgreSQLParser.REPLACE - 272)) | (1 << (PostgreSQLParser.REPLICA - 272)))) !== 0) || ((((_la - 304)) & ~0x1F) === 0 && ((1 << (_la - 304)) & ((1 << (PostgreSQLParser.RESET - 304)) | (1 << (PostgreSQLParser.RESTART - 304)) | (1 << (PostgreSQLParser.RESTRICT - 304)) | (1 << (PostgreSQLParser.RETURNS - 304)) | (1 << (PostgreSQLParser.REVOKE - 304)) | (1 << (PostgreSQLParser.ROLE - 304)) | (1 << (PostgreSQLParser.ROLLBACK - 304)) | (1 << (PostgreSQLParser.ROWS - 304)) | (1 << (PostgreSQLParser.RULE - 304)) | (1 << (PostgreSQLParser.SAVEPOINT - 304)) | (1 << (PostgreSQLParser.SCHEMA - 304)) | (1 << (PostgreSQLParser.SCROLL - 304)) | (1 << (PostgreSQLParser.SEARCH - 304)) | (1 << (PostgreSQLParser.SECOND_P - 304)) | (1 << (PostgreSQLParser.SECURITY - 304)) | (1 << (PostgreSQLParser.SEQUENCE - 304)) | (1 << (PostgreSQLParser.SEQUENCES - 304)) | (1 << (PostgreSQLParser.SERIALIZABLE - 304)) | (1 << (PostgreSQLParser.SERVER - 304)) | (1 << (PostgreSQLParser.SESSION - 304)) | (1 << (PostgreSQLParser.SET - 304)) | (1 << (PostgreSQLParser.SHARE - 304)) | (1 << (PostgreSQLParser.SHOW - 304)) | (1 << (PostgreSQLParser.SIMPLE - 304)) | (1 << (PostgreSQLParser.SNAPSHOT - 304)) | (1 << (PostgreSQLParser.STABLE - 304)) | (1 << (PostgreSQLParser.STANDALONE_P - 304)) | (1 << (PostgreSQLParser.START - 304)) | (1 << (PostgreSQLParser.STATEMENT - 304)) | (1 << (PostgreSQLParser.STATISTICS - 304)) | (1 << (PostgreSQLParser.STDIN - 304)) | (1 << (PostgreSQLParser.STDOUT - 304)))) !== 0) || ((((_la - 336)) & ~0x1F) === 0 && ((1 << (_la - 336)) & ((1 << (PostgreSQLParser.STORAGE - 336)) | (1 << (PostgreSQLParser.STRICT_P - 336)) | (1 << (PostgreSQLParser.STRIP_P - 336)) | (1 << (PostgreSQLParser.SYSID - 336)) | (1 << (PostgreSQLParser.SYSTEM_P - 336)) | (1 << (PostgreSQLParser.TABLES - 336)) | (1 << (PostgreSQLParser.TABLESPACE - 336)) | (1 << (PostgreSQLParser.TEMP - 336)) | (1 << (PostgreSQLParser.TEMPLATE - 336)) | (1 << (PostgreSQLParser.TEMPORARY - 336)) | (1 << (PostgreSQLParser.TEXT_P - 336)) | (1 << (PostgreSQLParser.TRANSACTION - 336)) | (1 << (PostgreSQLParser.TRIGGER - 336)) | (1 << (PostgreSQLParser.TRUNCATE - 336)) | (1 << (PostgreSQLParser.TRUSTED - 336)) | (1 << (PostgreSQLParser.TYPE_P - 336)) | (1 << (PostgreSQLParser.TYPES_P - 336)) | (1 << (PostgreSQLParser.UNBOUNDED - 336)) | (1 << (PostgreSQLParser.UNCOMMITTED - 336)) | (1 << (PostgreSQLParser.UNENCRYPTED - 336)) | (1 << (PostgreSQLParser.UNKNOWN - 336)) | (1 << (PostgreSQLParser.UNLISTEN - 336)) | (1 << (PostgreSQLParser.UNLOGGED - 336)) | (1 << (PostgreSQLParser.UNTIL - 336)) | (1 << (PostgreSQLParser.UPDATE - 336)) | (1 << (PostgreSQLParser.VACUUM - 336)) | (1 << (PostgreSQLParser.VALID - 336)) | (1 << (PostgreSQLParser.VALIDATE - 336)) | (1 << (PostgreSQLParser.VALIDATOR - 336)) | (1 << (PostgreSQLParser.VARYING - 336)) | (1 << (PostgreSQLParser.VERSION_P - 336)) | (1 << (PostgreSQLParser.VIEW - 336)))) !== 0) || ((((_la - 368)) & ~0x1F) === 0 && ((1 << (_la - 368)) & ((1 << (PostgreSQLParser.VOLATILE - 368)) | (1 << (PostgreSQLParser.WHITESPACE_P - 368)) | (1 << (PostgreSQLParser.WITHOUT - 368)) | (1 << (PostgreSQLParser.WORK - 368)) | (1 << (PostgreSQLParser.WRAPPER - 368)) | (1 << (PostgreSQLParser.WRITE - 368)) | (1 << (PostgreSQLParser.XML_P - 368)) | (1 << (PostgreSQLParser.YEAR_P - 368)) | (1 << (PostgreSQLParser.YES_P - 368)) | (1 << (PostgreSQLParser.ZONE - 368)) | (1 << (PostgreSQLParser.BETWEEN - 368)) | (1 << (PostgreSQLParser.BIGINT - 368)) | (1 << (PostgreSQLParser.BIT - 368)) | (1 << (PostgreSQLParser.BOOLEAN_P - 368)) | (1 << (PostgreSQLParser.CHAR_P - 368)) | (1 << (PostgreSQLParser.CHARACTER - 368)) | (1 << (PostgreSQLParser.COALESCE - 368)) | (1 << (PostgreSQLParser.DEC - 368)) | (1 << (PostgreSQLParser.DECIMAL_P - 368)) | (1 << (PostgreSQLParser.EXISTS - 368)) | (1 << (PostgreSQLParser.EXTRACT - 368)) | (1 << (PostgreSQLParser.FLOAT_P - 368)) | (1 << (PostgreSQLParser.GREATEST - 368)) | (1 << (PostgreSQLParser.INOUT - 368)) | (1 << (PostgreSQLParser.INT_P - 368)) | (1 << (PostgreSQLParser.INTEGER - 368)) | (1 << (PostgreSQLParser.INTERVAL - 368)) | (1 << (PostgreSQLParser.LEAST - 368)) | (1 << (PostgreSQLParser.NATIONAL - 368)) | (1 << (PostgreSQLParser.NCHAR - 368)) | (1 << (PostgreSQLParser.NONE - 368)) | (1 << (PostgreSQLParser.NULLIF - 368)))) !== 0) || ((((_la - 400)) & ~0x1F) === 0 && ((1 << (_la - 400)) & ((1 << (PostgreSQLParser.NUMERIC - 400)) | (1 << (PostgreSQLParser.OVERLAY - 400)) | (1 << (PostgreSQLParser.POSITION - 400)) | (1 << (PostgreSQLParser.PRECISION - 400)) | (1 << (PostgreSQLParser.REAL - 400)) | (1 << (PostgreSQLParser.ROW - 400)) | (1 << (PostgreSQLParser.SETOF - 400)) | (1 << (PostgreSQLParser.SMALLINT - 400)) | (1 << (PostgreSQLParser.SUBSTRING - 400)) | (1 << (PostgreSQLParser.TIME - 400)) | (1 << (PostgreSQLParser.TIMESTAMP - 400)) | (1 << (PostgreSQLParser.TREAT - 400)) | (1 << (PostgreSQLParser.TRIM - 400)) | (1 << (PostgreSQLParser.VALUES - 400)) | (1 << (PostgreSQLParser.VARCHAR - 400)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 400)) | (1 << (PostgreSQLParser.XMLCONCAT - 400)) | (1 << (PostgreSQLParser.XMLELEMENT - 400)) | (1 << (PostgreSQLParser.XMLEXISTS - 400)) | (1 << (PostgreSQLParser.XMLFOREST - 400)) | (1 << (PostgreSQLParser.XMLPARSE - 400)) | (1 << (PostgreSQLParser.XMLPI - 400)) | (1 << (PostgreSQLParser.XMLROOT - 400)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 400)) | (1 << (PostgreSQLParser.CALL - 400)) | (1 << (PostgreSQLParser.CURRENT_P - 400)) | (1 << (PostgreSQLParser.ATTACH - 400)) | (1 << (PostgreSQLParser.DETACH - 400)) | (1 << (PostgreSQLParser.EXPRESSION - 400)) | (1 << (PostgreSQLParser.GENERATED - 400)) | (1 << (PostgreSQLParser.LOGGED - 400)) | (1 << (PostgreSQLParser.STORED - 400)))) !== 0) || ((((_la - 432)) & ~0x1F) === 0 && ((1 << (_la - 432)) & ((1 << (PostgreSQLParser.INCLUDE - 432)) | (1 << (PostgreSQLParser.ROUTINE - 432)) | (1 << (PostgreSQLParser.TRANSFORM - 432)) | (1 << (PostgreSQLParser.IMPORT_P - 432)) | (1 << (PostgreSQLParser.POLICY - 432)) | (1 << (PostgreSQLParser.METHOD - 432)) | (1 << (PostgreSQLParser.REFERENCING - 432)) | (1 << (PostgreSQLParser.NEW - 432)) | (1 << (PostgreSQLParser.OLD - 432)) | (1 << (PostgreSQLParser.VALUE_P - 432)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 432)) | (1 << (PostgreSQLParser.PUBLICATION - 432)) | (1 << (PostgreSQLParser.OUT_P - 432)) | (1 << (PostgreSQLParser.ROUTINES - 432)) | (1 << (PostgreSQLParser.SCHEMAS - 432)) | (1 << (PostgreSQLParser.PROCEDURES - 432)) | (1 << (PostgreSQLParser.INPUT_P - 432)) | (1 << (PostgreSQLParser.SUPPORT - 432)) | (1 << (PostgreSQLParser.PARALLEL - 432)) | (1 << (PostgreSQLParser.SQL_P - 432)) | (1 << (PostgreSQLParser.DEPENDS - 432)) | (1 << (PostgreSQLParser.OVERRIDING - 432)) | (1 << (PostgreSQLParser.CONFLICT - 432)) | (1 << (PostgreSQLParser.SKIP_P - 432)) | (1 << (PostgreSQLParser.LOCKED - 432)) | (1 << (PostgreSQLParser.TIES - 432)) | (1 << (PostgreSQLParser.ROLLUP - 432)) | (1 << (PostgreSQLParser.CUBE - 432)) | (1 << (PostgreSQLParser.GROUPING - 432)) | (1 << (PostgreSQLParser.SETS - 432)) | (1 << (PostgreSQLParser.TABLESAMPLE - 432)))) !== 0) || ((((_la - 464)) & ~0x1F) === 0 && ((1 << (_la - 464)) & ((1 << (PostgreSQLParser.ORDINALITY - 464)) | (1 << (PostgreSQLParser.XMLTABLE - 464)) | (1 << (PostgreSQLParser.COLUMNS - 464)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 464)) | (1 << (PostgreSQLParser.ROWTYPE - 464)) | (1 << (PostgreSQLParser.NORMALIZED - 464)) | (1 << (PostgreSQLParser.WITHIN - 464)) | (1 << (PostgreSQLParser.FILTER - 464)) | (1 << (PostgreSQLParser.GROUPS - 464)) | (1 << (PostgreSQLParser.OTHERS - 464)) | (1 << (PostgreSQLParser.NFC - 464)) | (1 << (PostgreSQLParser.NFD - 464)) | (1 << (PostgreSQLParser.NFKC - 464)) | (1 << (PostgreSQLParser.NFKD - 464)) | (1 << (PostgreSQLParser.UESCAPE - 464)) | (1 << (PostgreSQLParser.VIEWS - 464)) | (1 << (PostgreSQLParser.NORMALIZE - 464)) | (1 << (PostgreSQLParser.DUMP - 464)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 464)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 464)) | (1 << (PostgreSQLParser.ERROR - 464)) | (1 << (PostgreSQLParser.USE_VARIABLE - 464)) | (1 << (PostgreSQLParser.USE_COLUMN - 464)) | (1 << (PostgreSQLParser.ALIAS - 464)) | (1 << (PostgreSQLParser.CONSTANT - 464)) | (1 << (PostgreSQLParser.PERFORM - 464)) | (1 << (PostgreSQLParser.GET - 464)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 464)) | (1 << (PostgreSQLParser.STACKED - 464)) | (1 << (PostgreSQLParser.ELSIF - 464)) | (1 << (PostgreSQLParser.REVERSE - 464)))) !== 0) || ((((_la - 497)) & ~0x1F) === 0 && ((1 << (_la - 497)) & ((1 << (PostgreSQLParser.SLICE - 497)) | (1 << (PostgreSQLParser.EXIT - 497)) | (1 << (PostgreSQLParser.RETURN - 497)) | (1 << (PostgreSQLParser.QUERY - 497)) | (1 << (PostgreSQLParser.RAISE - 497)) | (1 << (PostgreSQLParser.SQLSTATE - 497)) | (1 << (PostgreSQLParser.DEBUG - 497)) | (1 << (PostgreSQLParser.LOG - 497)) | (1 << (PostgreSQLParser.INFO - 497)) | (1 << (PostgreSQLParser.NOTICE - 497)) | (1 << (PostgreSQLParser.WARNING - 497)) | (1 << (PostgreSQLParser.EXCEPTION - 497)) | (1 << (PostgreSQLParser.ASSERT - 497)) | (1 << (PostgreSQLParser.OPEN - 497)) | (1 << (PostgreSQLParser.Identifier - 497)) | (1 << (PostgreSQLParser.QuotedIdentifier - 497)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 497)) | (1 << (PostgreSQLParser.StringConstant - 497)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 497)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 497)))) !== 0) || ((((_la - 534)) & ~0x1F) === 0 && ((1 << (_la - 534)) & ((1 << (PostgreSQLParser.Integral - 534)) | (1 << (PostgreSQLParser.Numeric - 534)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 534)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 534)) | (1 << (PostgreSQLParser.EscapeStringConstant - 534)))) !== 0)) { + if (_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & ((1 << (PostgreSQLParser.KW_ON - 80)) | (1 << (PostgreSQLParser.KW_TABLE - 80)) | (1 << (PostgreSQLParser.KW_TRUE - 80)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 80)) | (1 << (PostgreSQLParser.KW_BINARY - 80)) | (1 << (PostgreSQLParser.KW_COLLATION - 80)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 80)) | (1 << (PostgreSQLParser.KW_CROSS - 80)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 80)))) !== 0) || ((((_la - 112)) & ~0x1F) === 0 && ((1 << (_la - 112)) & ((1 << (PostgreSQLParser.KW_FREEZE - 112)) | (1 << (PostgreSQLParser.KW_FULL - 112)) | (1 << (PostgreSQLParser.KW_ILIKE - 112)) | (1 << (PostgreSQLParser.KW_INNER - 112)) | (1 << (PostgreSQLParser.KW_IS - 112)) | (1 << (PostgreSQLParser.KW_ISNULL - 112)) | (1 << (PostgreSQLParser.KW_JOIN - 112)) | (1 << (PostgreSQLParser.KW_LEFT - 112)) | (1 << (PostgreSQLParser.KW_LIKE - 112)) | (1 << (PostgreSQLParser.KW_NATURAL - 112)) | (1 << (PostgreSQLParser.KW_NOTNULL - 112)) | (1 << (PostgreSQLParser.KW_OUTER - 112)) | (1 << (PostgreSQLParser.KW_OVER - 112)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 112)) | (1 << (PostgreSQLParser.KW_RIGHT - 112)) | (1 << (PostgreSQLParser.KW_SIMILAR - 112)) | (1 << (PostgreSQLParser.KW_VERBOSE - 112)) | (1 << (PostgreSQLParser.KW_ABORT - 112)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 112)) | (1 << (PostgreSQLParser.KW_ACCESS - 112)) | (1 << (PostgreSQLParser.KW_ACTION - 112)) | (1 << (PostgreSQLParser.KW_ADD - 112)) | (1 << (PostgreSQLParser.KW_ADMIN - 112)) | (1 << (PostgreSQLParser.KW_AFTER - 112)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 112)) | (1 << (PostgreSQLParser.KW_ALSO - 112)) | (1 << (PostgreSQLParser.KW_ALTER - 112)) | (1 << (PostgreSQLParser.KW_ALWAYS - 112)) | (1 << (PostgreSQLParser.KW_ASSERTION - 112)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 112)) | (1 << (PostgreSQLParser.KW_AT - 112)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 112)))) !== 0) || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & ((1 << (PostgreSQLParser.KW_BACKWARD - 144)) | (1 << (PostgreSQLParser.KW_BEFORE - 144)) | (1 << (PostgreSQLParser.KW_BEGIN - 144)) | (1 << (PostgreSQLParser.KW_BY - 144)) | (1 << (PostgreSQLParser.KW_CACHE - 144)) | (1 << (PostgreSQLParser.KW_CALLED - 144)) | (1 << (PostgreSQLParser.KW_CASCADE - 144)) | (1 << (PostgreSQLParser.KW_CASCADED - 144)) | (1 << (PostgreSQLParser.KW_CATALOG - 144)) | (1 << (PostgreSQLParser.KW_CHAIN - 144)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 144)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 144)) | (1 << (PostgreSQLParser.KW_CLASS - 144)) | (1 << (PostgreSQLParser.KW_CLOSE - 144)) | (1 << (PostgreSQLParser.KW_CLUSTER - 144)) | (1 << (PostgreSQLParser.KW_COMMENT - 144)) | (1 << (PostgreSQLParser.KW_COMMENTS - 144)) | (1 << (PostgreSQLParser.KW_COMMIT - 144)) | (1 << (PostgreSQLParser.KW_COMMITTED - 144)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 144)) | (1 << (PostgreSQLParser.KW_CONNECTION - 144)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 144)) | (1 << (PostgreSQLParser.KW_CONTENT - 144)) | (1 << (PostgreSQLParser.KW_CONTINUE - 144)) | (1 << (PostgreSQLParser.KW_CONVERSION - 144)) | (1 << (PostgreSQLParser.KW_COPY - 144)) | (1 << (PostgreSQLParser.KW_COST - 144)) | (1 << (PostgreSQLParser.KW_CSV - 144)) | (1 << (PostgreSQLParser.KW_CURSOR - 144)) | (1 << (PostgreSQLParser.KW_CYCLE - 144)) | (1 << (PostgreSQLParser.KW_DATA - 144)) | (1 << (PostgreSQLParser.KW_DATABASE - 144)))) !== 0) || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (PostgreSQLParser.KW_DAY - 176)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 176)) | (1 << (PostgreSQLParser.KW_DECLARE - 176)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 176)) | (1 << (PostgreSQLParser.KW_DEFERRED - 176)) | (1 << (PostgreSQLParser.KW_DEFINER - 176)) | (1 << (PostgreSQLParser.KW_DELETE - 176)) | (1 << (PostgreSQLParser.KW_DELIMITER - 176)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 176)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 176)) | (1 << (PostgreSQLParser.KW_DISABLE - 176)) | (1 << (PostgreSQLParser.KW_DISCARD - 176)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 176)) | (1 << (PostgreSQLParser.KW_DOMAIN - 176)) | (1 << (PostgreSQLParser.KW_DOUBLE - 176)) | (1 << (PostgreSQLParser.KW_DROP - 176)) | (1 << (PostgreSQLParser.KW_EACH - 176)) | (1 << (PostgreSQLParser.KW_ENABLE - 176)) | (1 << (PostgreSQLParser.KW_ENCODING - 176)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 176)) | (1 << (PostgreSQLParser.KW_ENUM - 176)) | (1 << (PostgreSQLParser.KW_ESCAPE - 176)) | (1 << (PostgreSQLParser.KW_EVENT - 176)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 176)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 176)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 176)) | (1 << (PostgreSQLParser.KW_EXECUTE - 176)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 176)) | (1 << (PostgreSQLParser.KW_EXTENSION - 176)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 176)) | (1 << (PostgreSQLParser.KW_FAMILY - 176)) | (1 << (PostgreSQLParser.KW_FIRST - 176)))) !== 0) || ((((_la - 208)) & ~0x1F) === 0 && ((1 << (_la - 208)) & ((1 << (PostgreSQLParser.KW_FOLLOWING - 208)) | (1 << (PostgreSQLParser.KW_FORCE - 208)) | (1 << (PostgreSQLParser.KW_FORWARD - 208)) | (1 << (PostgreSQLParser.KW_FUNCTION - 208)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 208)) | (1 << (PostgreSQLParser.KW_GLOBAL - 208)) | (1 << (PostgreSQLParser.KW_GRANTED - 208)) | (1 << (PostgreSQLParser.KW_HANDLER - 208)) | (1 << (PostgreSQLParser.KW_HEADER - 208)) | (1 << (PostgreSQLParser.KW_HOLD - 208)) | (1 << (PostgreSQLParser.KW_HOUR - 208)) | (1 << (PostgreSQLParser.KW_IDENTITY - 208)) | (1 << (PostgreSQLParser.KW_IF - 208)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 208)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 208)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 208)) | (1 << (PostgreSQLParser.KW_INCLUDING - 208)) | (1 << (PostgreSQLParser.KW_INCREMENT - 208)) | (1 << (PostgreSQLParser.KW_INDEX - 208)) | (1 << (PostgreSQLParser.KW_INDEXES - 208)) | (1 << (PostgreSQLParser.KW_INHERIT - 208)) | (1 << (PostgreSQLParser.KW_INHERITS - 208)) | (1 << (PostgreSQLParser.KW_INLINE - 208)))) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.KW_INSENSITIVE - 240)) | (1 << (PostgreSQLParser.KW_INSERT - 240)) | (1 << (PostgreSQLParser.KW_INSTEAD - 240)) | (1 << (PostgreSQLParser.KW_INVOKER - 240)) | (1 << (PostgreSQLParser.KW_ISOLATION - 240)) | (1 << (PostgreSQLParser.KW_KEY - 240)) | (1 << (PostgreSQLParser.KW_LABEL - 240)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 240)) | (1 << (PostgreSQLParser.KW_LARGE - 240)) | (1 << (PostgreSQLParser.KW_LAST - 240)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 240)) | (1 << (PostgreSQLParser.KW_LEVEL - 240)) | (1 << (PostgreSQLParser.KW_LISTEN - 240)) | (1 << (PostgreSQLParser.KW_LOAD - 240)) | (1 << (PostgreSQLParser.KW_LOCAL - 240)) | (1 << (PostgreSQLParser.KW_LOCATION - 240)) | (1 << (PostgreSQLParser.KW_LOCK - 240)) | (1 << (PostgreSQLParser.KW_MAPPING - 240)) | (1 << (PostgreSQLParser.KW_MATCH - 240)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 240)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 240)) | (1 << (PostgreSQLParser.KW_MINUTE - 240)) | (1 << (PostgreSQLParser.KW_MINVALUE - 240)) | (1 << (PostgreSQLParser.KW_MODE - 240)) | (1 << (PostgreSQLParser.KW_MONTH - 240)) | (1 << (PostgreSQLParser.KW_MOVE - 240)) | (1 << (PostgreSQLParser.KW_NAME - 240)) | (1 << (PostgreSQLParser.KW_NAMES - 240)) | (1 << (PostgreSQLParser.KW_NEXT - 240)) | (1 << (PostgreSQLParser.KW_NO - 240)) | (1 << (PostgreSQLParser.KW_NOTHING - 240)) | (1 << (PostgreSQLParser.KW_NOTIFY - 240)))) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & ((1 << (PostgreSQLParser.KW_NOWAIT - 272)) | (1 << (PostgreSQLParser.KW_NULLS - 272)) | (1 << (PostgreSQLParser.KW_OBJECT - 272)) | (1 << (PostgreSQLParser.KW_OF - 272)) | (1 << (PostgreSQLParser.KW_OFF - 272)) | (1 << (PostgreSQLParser.KW_OIDS - 272)) | (1 << (PostgreSQLParser.KW_OPERATOR - 272)) | (1 << (PostgreSQLParser.KW_OPTION - 272)) | (1 << (PostgreSQLParser.KW_OPTIONS - 272)) | (1 << (PostgreSQLParser.KW_OWNED - 272)) | (1 << (PostgreSQLParser.KW_OWNER - 272)) | (1 << (PostgreSQLParser.KW_PARSER - 272)) | (1 << (PostgreSQLParser.KW_PARTIAL - 272)) | (1 << (PostgreSQLParser.KW_PARTITION - 272)) | (1 << (PostgreSQLParser.KW_PASSING - 272)) | (1 << (PostgreSQLParser.KW_PASSWORD - 272)) | (1 << (PostgreSQLParser.KW_PLANS - 272)) | (1 << (PostgreSQLParser.KW_PRECEDING - 272)) | (1 << (PostgreSQLParser.KW_PREPARE - 272)) | (1 << (PostgreSQLParser.KW_PREPARED - 272)) | (1 << (PostgreSQLParser.KW_PRESERVE - 272)) | (1 << (PostgreSQLParser.KW_PRIOR - 272)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 272)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 272)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 272)) | (1 << (PostgreSQLParser.KW_PROGRAM - 272)) | (1 << (PostgreSQLParser.KW_QUOTE - 272)) | (1 << (PostgreSQLParser.KW_RANGE - 272)) | (1 << (PostgreSQLParser.KW_READ - 272)) | (1 << (PostgreSQLParser.KW_REASSIGN - 272)) | (1 << (PostgreSQLParser.KW_RECHECK - 272)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 272)))) !== 0) || ((((_la - 304)) & ~0x1F) === 0 && ((1 << (_la - 304)) & ((1 << (PostgreSQLParser.KW_REF - 304)) | (1 << (PostgreSQLParser.KW_REFRESH - 304)) | (1 << (PostgreSQLParser.KW_REINDEX - 304)) | (1 << (PostgreSQLParser.KW_RELATIVE - 304)) | (1 << (PostgreSQLParser.KW_RELEASE - 304)) | (1 << (PostgreSQLParser.KW_RENAME - 304)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 304)) | (1 << (PostgreSQLParser.KW_REPLACE - 304)) | (1 << (PostgreSQLParser.KW_REPLICA - 304)) | (1 << (PostgreSQLParser.KW_RESET - 304)) | (1 << (PostgreSQLParser.KW_RESTART - 304)) | (1 << (PostgreSQLParser.KW_RESTRICT - 304)) | (1 << (PostgreSQLParser.KW_RETURNS - 304)) | (1 << (PostgreSQLParser.KW_REVOKE - 304)) | (1 << (PostgreSQLParser.KW_ROLE - 304)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 304)) | (1 << (PostgreSQLParser.KW_ROWS - 304)) | (1 << (PostgreSQLParser.KW_RULE - 304)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 304)) | (1 << (PostgreSQLParser.KW_SCHEMA - 304)) | (1 << (PostgreSQLParser.KW_SCROLL - 304)) | (1 << (PostgreSQLParser.KW_SEARCH - 304)) | (1 << (PostgreSQLParser.KW_SECOND - 304)) | (1 << (PostgreSQLParser.KW_SECURITY - 304)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 304)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 304)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 304)) | (1 << (PostgreSQLParser.KW_SERVER - 304)) | (1 << (PostgreSQLParser.KW_SESSION - 304)) | (1 << (PostgreSQLParser.KW_SET - 304)) | (1 << (PostgreSQLParser.KW_SHARE - 304)) | (1 << (PostgreSQLParser.KW_SHOW - 304)))) !== 0) || ((((_la - 336)) & ~0x1F) === 0 && ((1 << (_la - 336)) & ((1 << (PostgreSQLParser.KW_SIMPLE - 336)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 336)) | (1 << (PostgreSQLParser.KW_STABLE - 336)) | (1 << (PostgreSQLParser.KW_STANDALONE - 336)) | (1 << (PostgreSQLParser.KW_START - 336)) | (1 << (PostgreSQLParser.KW_STATEMENT - 336)) | (1 << (PostgreSQLParser.KW_STATISTICS - 336)) | (1 << (PostgreSQLParser.KW_STDIN - 336)) | (1 << (PostgreSQLParser.KW_STDOUT - 336)) | (1 << (PostgreSQLParser.KW_STORAGE - 336)) | (1 << (PostgreSQLParser.KW_STRICT - 336)) | (1 << (PostgreSQLParser.KW_STRIP - 336)) | (1 << (PostgreSQLParser.KW_SYSID - 336)) | (1 << (PostgreSQLParser.KW_SYSTEM - 336)) | (1 << (PostgreSQLParser.KW_TABLES - 336)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 336)) | (1 << (PostgreSQLParser.KW_TEMP - 336)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 336)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 336)) | (1 << (PostgreSQLParser.KW_TEXT - 336)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 336)) | (1 << (PostgreSQLParser.KW_TRIGGER - 336)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 336)) | (1 << (PostgreSQLParser.KW_TRUSTED - 336)) | (1 << (PostgreSQLParser.KW_TYPE - 336)) | (1 << (PostgreSQLParser.KW_TYPES - 336)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 336)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 336)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 336)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 336)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 336)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 336)))) !== 0) || ((((_la - 368)) & ~0x1F) === 0 && ((1 << (_la - 368)) & ((1 << (PostgreSQLParser.KW_UNTIL - 368)) | (1 << (PostgreSQLParser.KW_UPDATE - 368)) | (1 << (PostgreSQLParser.KW_VACUUM - 368)) | (1 << (PostgreSQLParser.KW_VALID - 368)) | (1 << (PostgreSQLParser.KW_VALIDATE - 368)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 368)) | (1 << (PostgreSQLParser.KW_VARYING - 368)) | (1 << (PostgreSQLParser.KW_VERSION - 368)) | (1 << (PostgreSQLParser.KW_VIEW - 368)) | (1 << (PostgreSQLParser.KW_VOLATILE - 368)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 368)) | (1 << (PostgreSQLParser.KW_WITHOUT - 368)) | (1 << (PostgreSQLParser.KW_WORK - 368)) | (1 << (PostgreSQLParser.KW_WRAPPER - 368)) | (1 << (PostgreSQLParser.KW_WRITE - 368)) | (1 << (PostgreSQLParser.KW_XML - 368)) | (1 << (PostgreSQLParser.KW_YEAR - 368)) | (1 << (PostgreSQLParser.KW_YES - 368)) | (1 << (PostgreSQLParser.KW_ZONE - 368)) | (1 << (PostgreSQLParser.KW_BETWEEN - 368)) | (1 << (PostgreSQLParser.KW_BIGINT - 368)) | (1 << (PostgreSQLParser.KW_BIT - 368)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 368)) | (1 << (PostgreSQLParser.KW_CHAR - 368)) | (1 << (PostgreSQLParser.KW_CHARACTER - 368)) | (1 << (PostgreSQLParser.KW_COALESCE - 368)) | (1 << (PostgreSQLParser.KW_DEC - 368)) | (1 << (PostgreSQLParser.KW_DECIMAL - 368)) | (1 << (PostgreSQLParser.KW_EXISTS - 368)) | (1 << (PostgreSQLParser.KW_EXTRACT - 368)) | (1 << (PostgreSQLParser.KW_FLOAT - 368)) | (1 << (PostgreSQLParser.KW_GREATEST - 368)))) !== 0) || ((((_la - 400)) & ~0x1F) === 0 && ((1 << (_la - 400)) & ((1 << (PostgreSQLParser.KW_INOUT - 400)) | (1 << (PostgreSQLParser.KW_INT - 400)) | (1 << (PostgreSQLParser.KW_INTEGER - 400)) | (1 << (PostgreSQLParser.KW_INTERVAL - 400)) | (1 << (PostgreSQLParser.KW_LEAST - 400)) | (1 << (PostgreSQLParser.KW_NATIONAL - 400)) | (1 << (PostgreSQLParser.KW_NCHAR - 400)) | (1 << (PostgreSQLParser.KW_NONE - 400)) | (1 << (PostgreSQLParser.KW_NULLIF - 400)) | (1 << (PostgreSQLParser.KW_NUMERIC - 400)) | (1 << (PostgreSQLParser.KW_OVERLAY - 400)) | (1 << (PostgreSQLParser.KW_POSITION - 400)) | (1 << (PostgreSQLParser.KW_PRECISION - 400)) | (1 << (PostgreSQLParser.KW_REAL - 400)) | (1 << (PostgreSQLParser.KW_ROW - 400)) | (1 << (PostgreSQLParser.KW_SETOF - 400)) | (1 << (PostgreSQLParser.KW_SMALLINT - 400)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 400)) | (1 << (PostgreSQLParser.KW_TIME - 400)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 400)) | (1 << (PostgreSQLParser.KW_TREAT - 400)) | (1 << (PostgreSQLParser.KW_TRIM - 400)) | (1 << (PostgreSQLParser.KW_VALUES - 400)) | (1 << (PostgreSQLParser.KW_VARCHAR - 400)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 400)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 400)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 400)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 400)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 400)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 400)) | (1 << (PostgreSQLParser.KW_XMLPI - 400)) | (1 << (PostgreSQLParser.KW_XMLROOT - 400)))) !== 0) || ((((_la - 432)) & ~0x1F) === 0 && ((1 << (_la - 432)) & ((1 << (PostgreSQLParser.KW_XMLSERIALIZE - 432)) | (1 << (PostgreSQLParser.KW_CALL - 432)) | (1 << (PostgreSQLParser.KW_CURRENT - 432)) | (1 << (PostgreSQLParser.KW_ATTACH - 432)) | (1 << (PostgreSQLParser.KW_DETACH - 432)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 432)) | (1 << (PostgreSQLParser.KW_GENERATED - 432)) | (1 << (PostgreSQLParser.KW_LOGGED - 432)) | (1 << (PostgreSQLParser.KW_STORED - 432)) | (1 << (PostgreSQLParser.KW_INCLUDE - 432)) | (1 << (PostgreSQLParser.KW_ROUTINE - 432)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 432)) | (1 << (PostgreSQLParser.KW_IMPORT - 432)) | (1 << (PostgreSQLParser.KW_POLICY - 432)) | (1 << (PostgreSQLParser.KW_METHOD - 432)) | (1 << (PostgreSQLParser.KW_REFERENCING - 432)) | (1 << (PostgreSQLParser.KW_NEW - 432)) | (1 << (PostgreSQLParser.KW_OLD - 432)) | (1 << (PostgreSQLParser.KW_VALUE - 432)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 432)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 432)) | (1 << (PostgreSQLParser.KW_OUT - 432)) | (1 << (PostgreSQLParser.KW_ROUTINES - 432)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 432)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 432)) | (1 << (PostgreSQLParser.KW_INPUT - 432)) | (1 << (PostgreSQLParser.KW_SUPPORT - 432)) | (1 << (PostgreSQLParser.KW_PARALLEL - 432)) | (1 << (PostgreSQLParser.KW_SQL - 432)) | (1 << (PostgreSQLParser.KW_DEPENDS - 432)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 432)))) !== 0) || ((((_la - 464)) & ~0x1F) === 0 && ((1 << (_la - 464)) & ((1 << (PostgreSQLParser.KW_CONFLICT - 464)) | (1 << (PostgreSQLParser.KW_SKIP - 464)) | (1 << (PostgreSQLParser.KW_LOCKED - 464)) | (1 << (PostgreSQLParser.KW_TIES - 464)) | (1 << (PostgreSQLParser.KW_ROLLUP - 464)) | (1 << (PostgreSQLParser.KW_CUBE - 464)) | (1 << (PostgreSQLParser.KW_GROUPING - 464)) | (1 << (PostgreSQLParser.KW_SETS - 464)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 464)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 464)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 464)) | (1 << (PostgreSQLParser.KW_COLUMNS - 464)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 464)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 464)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 464)) | (1 << (PostgreSQLParser.KW_WITHIN - 464)) | (1 << (PostgreSQLParser.KW_FILTER - 464)) | (1 << (PostgreSQLParser.KW_GROUPS - 464)) | (1 << (PostgreSQLParser.KW_OTHERS - 464)) | (1 << (PostgreSQLParser.KW_NFC - 464)) | (1 << (PostgreSQLParser.KW_NFD - 464)) | (1 << (PostgreSQLParser.KW_NFKC - 464)) | (1 << (PostgreSQLParser.KW_NFKD - 464)) | (1 << (PostgreSQLParser.KW_UESCAPE - 464)) | (1 << (PostgreSQLParser.KW_VIEWS - 464)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 464)) | (1 << (PostgreSQLParser.KW_DUMP - 464)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 464)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 464)) | (1 << (PostgreSQLParser.KW_ERROR - 464)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 464)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 464)))) !== 0) || ((((_la - 496)) & ~0x1F) === 0 && ((1 << (_la - 496)) & ((1 << (PostgreSQLParser.KW_ALIAS - 496)) | (1 << (PostgreSQLParser.KW_CONSTANT - 496)) | (1 << (PostgreSQLParser.KW_PERFORM - 496)) | (1 << (PostgreSQLParser.KW_GET - 496)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 496)) | (1 << (PostgreSQLParser.KW_STACKED - 496)) | (1 << (PostgreSQLParser.KW_ELSIF - 496)) | (1 << (PostgreSQLParser.KW_REVERSE - 496)) | (1 << (PostgreSQLParser.KW_SLICE - 496)) | (1 << (PostgreSQLParser.KW_EXIT - 496)) | (1 << (PostgreSQLParser.KW_RETURN - 496)) | (1 << (PostgreSQLParser.KW_QUERY - 496)) | (1 << (PostgreSQLParser.KW_RAISE - 496)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 496)) | (1 << (PostgreSQLParser.KW_DEBUG - 496)) | (1 << (PostgreSQLParser.KW_LOG - 496)) | (1 << (PostgreSQLParser.KW_INFO - 496)) | (1 << (PostgreSQLParser.KW_NOTICE - 496)) | (1 << (PostgreSQLParser.KW_WARNING - 496)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 496)) | (1 << (PostgreSQLParser.KW_ASSERT - 496)) | (1 << (PostgreSQLParser.KW_OPEN - 496)) | (1 << (PostgreSQLParser.Identifier - 496)) | (1 << (PostgreSQLParser.QuotedIdentifier - 496)))) !== 0) || ((((_la - 530)) & ~0x1F) === 0 && ((1 << (_la - 530)) & ((1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 530)) | (1 << (PostgreSQLParser.StringConstant - 530)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 530)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 530)) | (1 << (PostgreSQLParser.Integral - 530)) | (1 << (PostgreSQLParser.Numeric - 530)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 530)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 530)) | (1 << (PostgreSQLParser.EscapeStringConstant - 530)))) !== 0)) { { - this.state = 7854; + this.state = 7936; this.vac_analyze_option_arg(); } } @@ -35949,422 +36835,422 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public vac_analyze_option_name(): Vac_analyze_option_nameContext { let _localctx: Vac_analyze_option_nameContext = new Vac_analyze_option_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 856, PostgreSQLParser.RULE_vac_analyze_option_name); + this.enterRule(_localctx, 870, PostgreSQLParser.RULE_vac_analyze_option_name); try { - this.state = 7859; + this.state = 7941; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -36372,15 +37258,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 7857; + this.state = 7939; this.nonreservedword(); } break; - case PostgreSQLParser.ANALYSE: - case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.KW_ANALYSE: + case PostgreSQLParser.KW_ANALYZE: this.enterOuterAlt(_localctx, 2); { - this.state = 7858; + this.state = 7940; this.analyze_keyword(); } break; @@ -36405,425 +37291,425 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public vac_analyze_option_arg(): Vac_analyze_option_argContext { let _localctx: Vac_analyze_option_argContext = new Vac_analyze_option_argContext(this._ctx, this.state); - this.enterRule(_localctx, 858, PostgreSQLParser.RULE_vac_analyze_option_arg); + this.enterRule(_localctx, 872, PostgreSQLParser.RULE_vac_analyze_option_arg); try { - this.state = 7863; + this.state = 7945; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_ON: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -36835,7 +37721,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 7861; + this.state = 7943; this.opt_boolean_or_string(); } break; @@ -36845,7 +37731,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.Numeric: this.enterOuterAlt(_localctx, 2); { - this.state = 7862; + this.state = 7944; this.numericonly(); } break; @@ -36870,11 +37756,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_analyze(): Opt_analyzeContext { let _localctx: Opt_analyzeContext = new Opt_analyzeContext(this._ctx, this.state); - this.enterRule(_localctx, 860, PostgreSQLParser.RULE_opt_analyze); + this.enterRule(_localctx, 874, PostgreSQLParser.RULE_opt_analyze); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7865; + this.state = 7947; this.analyze_keyword(); } } @@ -36895,12 +37781,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_verbose(): Opt_verboseContext { let _localctx: Opt_verboseContext = new Opt_verboseContext(this._ctx, this.state); - this.enterRule(_localctx, 862, PostgreSQLParser.RULE_opt_verbose); + this.enterRule(_localctx, 876, PostgreSQLParser.RULE_opt_verbose); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7867; - this.match(PostgreSQLParser.VERBOSE); + this.state = 7949; + this.match(PostgreSQLParser.KW_VERBOSE); } } catch (re) { @@ -36920,12 +37806,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_full(): Opt_fullContext { let _localctx: Opt_fullContext = new Opt_fullContext(this._ctx, this.state); - this.enterRule(_localctx, 864, PostgreSQLParser.RULE_opt_full); + this.enterRule(_localctx, 878, PostgreSQLParser.RULE_opt_full); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7869; - this.match(PostgreSQLParser.FULL); + this.state = 7951; + this.match(PostgreSQLParser.KW_FULL); } } catch (re) { @@ -36945,12 +37831,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_freeze(): Opt_freezeContext { let _localctx: Opt_freezeContext = new Opt_freezeContext(this._ctx, this.state); - this.enterRule(_localctx, 866, PostgreSQLParser.RULE_opt_freeze); + this.enterRule(_localctx, 880, PostgreSQLParser.RULE_opt_freeze); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7871; - this.match(PostgreSQLParser.FREEZE); + this.state = 7953; + this.match(PostgreSQLParser.KW_FREEZE); } } catch (re) { @@ -36970,15 +37856,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_name_list(): Opt_name_listContext { let _localctx: Opt_name_listContext = new Opt_name_listContext(this._ctx, this.state); - this.enterRule(_localctx, 868, PostgreSQLParser.RULE_opt_name_list); + this.enterRule(_localctx, 882, PostgreSQLParser.RULE_opt_name_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7873; + this.state = 7955; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 7874; + this.state = 7956; this.name_list(); - this.state = 7875; + this.state = 7957; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -36999,18 +37885,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public vacuum_relation(): Vacuum_relationContext { let _localctx: Vacuum_relationContext = new Vacuum_relationContext(this._ctx, this.state); - this.enterRule(_localctx, 870, PostgreSQLParser.RULE_vacuum_relation); + this.enterRule(_localctx, 884, PostgreSQLParser.RULE_vacuum_relation); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7877; + this.state = 7959; this.qualified_name(); - this.state = 7879; + this.state = 7961; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 640, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 652, this._ctx) ) { case 1: { - this.state = 7878; + this.state = 7960; this.opt_name_list(); } break; @@ -37034,26 +37920,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public vacuum_relation_list(): Vacuum_relation_listContext { let _localctx: Vacuum_relation_listContext = new Vacuum_relation_listContext(this._ctx, this.state); - this.enterRule(_localctx, 872, PostgreSQLParser.RULE_vacuum_relation_list); + this.enterRule(_localctx, 886, PostgreSQLParser.RULE_vacuum_relation_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7881; + this.state = 7963; this.vacuum_relation(); - this.state = 7886; + this.state = 7968; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 7882; + this.state = 7964; this.match(PostgreSQLParser.COMMA); - this.state = 7883; + this.state = 7965; this.vacuum_relation(); } } - this.state = 7888; + this.state = 7970; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -37076,11 +37962,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_vacuum_relation_list(): Opt_vacuum_relation_listContext { let _localctx: Opt_vacuum_relation_listContext = new Opt_vacuum_relation_listContext(this._ctx, this.state); - this.enterRule(_localctx, 874, PostgreSQLParser.RULE_opt_vacuum_relation_list); + this.enterRule(_localctx, 888, PostgreSQLParser.RULE_opt_vacuum_relation_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7889; + this.state = 7971; this.vacuum_relation_list(); } } @@ -37101,18 +37987,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public explainstmt(): ExplainstmtContext { let _localctx: ExplainstmtContext = new ExplainstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 876, PostgreSQLParser.RULE_explainstmt); + this.enterRule(_localctx, 890, PostgreSQLParser.RULE_explainstmt); let _la: number; try { - this.state = 7909; + this.state = 7991; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 643, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 655, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7891; - this.match(PostgreSQLParser.EXPLAIN); - this.state = 7892; + this.state = 7973; + this.match(PostgreSQLParser.KW_EXPLAIN); + this.state = 7974; this.explainablestmt(); } break; @@ -37120,21 +38006,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7893; - this.match(PostgreSQLParser.EXPLAIN); - this.state = 7894; + this.state = 7975; + this.match(PostgreSQLParser.KW_EXPLAIN); + this.state = 7976; this.analyze_keyword(); - this.state = 7896; + this.state = 7978; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.VERBOSE) { + if (_la === PostgreSQLParser.KW_VERBOSE) { { - this.state = 7895; + this.state = 7977; this.opt_verbose(); } } - this.state = 7898; + this.state = 7980; this.explainablestmt(); } break; @@ -37142,11 +38028,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7900; - this.match(PostgreSQLParser.EXPLAIN); - this.state = 7901; - this.match(PostgreSQLParser.VERBOSE); - this.state = 7902; + this.state = 7982; + this.match(PostgreSQLParser.KW_EXPLAIN); + this.state = 7983; + this.match(PostgreSQLParser.KW_VERBOSE); + this.state = 7984; this.explainablestmt(); } break; @@ -37154,15 +38040,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7903; - this.match(PostgreSQLParser.EXPLAIN); - this.state = 7904; + this.state = 7985; + this.match(PostgreSQLParser.KW_EXPLAIN); + this.state = 7986; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 7905; + this.state = 7987; this.explain_option_list(); - this.state = 7906; + this.state = 7988; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 7907; + this.state = 7989; this.explainablestmt(); } break; @@ -37185,15 +38071,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public explainablestmt(): ExplainablestmtContext { let _localctx: ExplainablestmtContext = new ExplainablestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 878, PostgreSQLParser.RULE_explainablestmt); + this.enterRule(_localctx, 892, PostgreSQLParser.RULE_explainablestmt); try { - this.state = 7920; + this.state = 8002; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 644, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 656, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7911; + this.state = 7993; this.selectstmt(); } break; @@ -37201,7 +38087,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7912; + this.state = 7994; this.insertstmt(); } break; @@ -37209,7 +38095,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7913; + this.state = 7995; this.updatestmt(); } break; @@ -37217,7 +38103,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7914; + this.state = 7996; this.deletestmt(); } break; @@ -37225,7 +38111,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 7915; + this.state = 7997; this.declarecursorstmt(); } break; @@ -37233,7 +38119,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 7916; + this.state = 7998; this.createasstmt(); } break; @@ -37241,7 +38127,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 7917; + this.state = 7999; this.creatematviewstmt(); } break; @@ -37249,7 +38135,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 7918; + this.state = 8000; this.refreshmatviewstmt(); } break; @@ -37257,7 +38143,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 7919; + this.state = 8001; this.executestmt(); } break; @@ -37280,26 +38166,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public explain_option_list(): Explain_option_listContext { let _localctx: Explain_option_listContext = new Explain_option_listContext(this._ctx, this.state); - this.enterRule(_localctx, 880, PostgreSQLParser.RULE_explain_option_list); + this.enterRule(_localctx, 894, PostgreSQLParser.RULE_explain_option_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7922; + this.state = 8004; this.explain_option_elem(); - this.state = 7927; + this.state = 8009; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 7923; + this.state = 8005; this.match(PostgreSQLParser.COMMA); - this.state = 7924; + this.state = 8006; this.explain_option_elem(); } } - this.state = 7929; + this.state = 8011; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -37322,19 +38208,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public explain_option_elem(): Explain_option_elemContext { let _localctx: Explain_option_elemContext = new Explain_option_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 882, PostgreSQLParser.RULE_explain_option_elem); + this.enterRule(_localctx, 896, PostgreSQLParser.RULE_explain_option_elem); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7930; + this.state = 8012; this.explain_option_name(); - this.state = 7932; + this.state = 8014; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS || ((((_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.FALSE_P - 33)) | (1 << (PostgreSQLParser.FETCH - 33)))) !== 0) || ((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & ((1 << (PostgreSQLParser.ON - 80)) | (1 << (PostgreSQLParser.TABLE - 80)) | (1 << (PostgreSQLParser.TRUE_P - 80)) | (1 << (PostgreSQLParser.AUTHORIZATION - 80)) | (1 << (PostgreSQLParser.BINARY - 80)) | (1 << (PostgreSQLParser.COLLATION - 80)) | (1 << (PostgreSQLParser.CONCURRENTLY - 80)) | (1 << (PostgreSQLParser.CROSS - 80)) | (1 << (PostgreSQLParser.CURRENT_SCHEMA - 80)))) !== 0) || ((((_la - 112)) & ~0x1F) === 0 && ((1 << (_la - 112)) & ((1 << (PostgreSQLParser.FREEZE - 112)) | (1 << (PostgreSQLParser.FULL - 112)) | (1 << (PostgreSQLParser.ILIKE - 112)) | (1 << (PostgreSQLParser.INNER_P - 112)) | (1 << (PostgreSQLParser.IS - 112)) | (1 << (PostgreSQLParser.ISNULL - 112)) | (1 << (PostgreSQLParser.JOIN - 112)) | (1 << (PostgreSQLParser.LEFT - 112)) | (1 << (PostgreSQLParser.LIKE - 112)) | (1 << (PostgreSQLParser.NATURAL - 112)) | (1 << (PostgreSQLParser.NOTNULL - 112)) | (1 << (PostgreSQLParser.OUTER_P - 112)) | (1 << (PostgreSQLParser.OVER - 112)) | (1 << (PostgreSQLParser.OVERLAPS - 112)) | (1 << (PostgreSQLParser.RIGHT - 112)) | (1 << (PostgreSQLParser.SIMILAR - 112)) | (1 << (PostgreSQLParser.VERBOSE - 112)) | (1 << (PostgreSQLParser.ABORT_P - 112)) | (1 << (PostgreSQLParser.ABSOLUTE_P - 112)) | (1 << (PostgreSQLParser.ACCESS - 112)) | (1 << (PostgreSQLParser.ACTION - 112)) | (1 << (PostgreSQLParser.ADD_P - 112)) | (1 << (PostgreSQLParser.ADMIN - 112)) | (1 << (PostgreSQLParser.AFTER - 112)) | (1 << (PostgreSQLParser.AGGREGATE - 112)) | (1 << (PostgreSQLParser.ALSO - 112)) | (1 << (PostgreSQLParser.ALTER - 112)) | (1 << (PostgreSQLParser.ALWAYS - 112)) | (1 << (PostgreSQLParser.ASSERTION - 112)) | (1 << (PostgreSQLParser.ASSIGNMENT - 112)) | (1 << (PostgreSQLParser.AT - 112)) | (1 << (PostgreSQLParser.ATTRIBUTE - 112)))) !== 0) || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & ((1 << (PostgreSQLParser.BACKWARD - 144)) | (1 << (PostgreSQLParser.BEFORE - 144)) | (1 << (PostgreSQLParser.BEGIN_P - 144)) | (1 << (PostgreSQLParser.BY - 144)) | (1 << (PostgreSQLParser.CACHE - 144)) | (1 << (PostgreSQLParser.CALLED - 144)) | (1 << (PostgreSQLParser.CASCADE - 144)) | (1 << (PostgreSQLParser.CASCADED - 144)) | (1 << (PostgreSQLParser.CATALOG - 144)) | (1 << (PostgreSQLParser.CHAIN - 144)) | (1 << (PostgreSQLParser.CHARACTERISTICS - 144)) | (1 << (PostgreSQLParser.CHECKPOINT - 144)) | (1 << (PostgreSQLParser.CLASS - 144)) | (1 << (PostgreSQLParser.CLOSE - 144)) | (1 << (PostgreSQLParser.CLUSTER - 144)) | (1 << (PostgreSQLParser.COMMENT - 144)) | (1 << (PostgreSQLParser.COMMENTS - 144)) | (1 << (PostgreSQLParser.COMMIT - 144)) | (1 << (PostgreSQLParser.COMMITTED - 144)) | (1 << (PostgreSQLParser.CONFIGURATION - 144)) | (1 << (PostgreSQLParser.CONNECTION - 144)) | (1 << (PostgreSQLParser.CONSTRAINTS - 144)) | (1 << (PostgreSQLParser.CONTENT_P - 144)) | (1 << (PostgreSQLParser.CONTINUE_P - 144)) | (1 << (PostgreSQLParser.CONVERSION_P - 144)) | (1 << (PostgreSQLParser.COPY - 144)) | (1 << (PostgreSQLParser.COST - 144)) | (1 << (PostgreSQLParser.CSV - 144)) | (1 << (PostgreSQLParser.CURSOR - 144)) | (1 << (PostgreSQLParser.CYCLE - 144)) | (1 << (PostgreSQLParser.DATA_P - 144)) | (1 << (PostgreSQLParser.DATABASE - 144)))) !== 0) || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (PostgreSQLParser.DAY_P - 176)) | (1 << (PostgreSQLParser.DEALLOCATE - 176)) | (1 << (PostgreSQLParser.DECLARE - 176)) | (1 << (PostgreSQLParser.DEFAULTS - 176)) | (1 << (PostgreSQLParser.DEFERRED - 176)) | (1 << (PostgreSQLParser.DEFINER - 176)) | (1 << (PostgreSQLParser.DELETE_P - 176)) | (1 << (PostgreSQLParser.DELIMITER - 176)) | (1 << (PostgreSQLParser.DELIMITERS - 176)) | (1 << (PostgreSQLParser.DICTIONARY - 176)) | (1 << (PostgreSQLParser.DISABLE_P - 176)) | (1 << (PostgreSQLParser.DISCARD - 176)) | (1 << (PostgreSQLParser.DOCUMENT_P - 176)) | (1 << (PostgreSQLParser.DOMAIN_P - 176)) | (1 << (PostgreSQLParser.DOUBLE_P - 176)) | (1 << (PostgreSQLParser.DROP - 176)) | (1 << (PostgreSQLParser.EACH - 176)) | (1 << (PostgreSQLParser.ENABLE_P - 176)) | (1 << (PostgreSQLParser.ENCODING - 176)) | (1 << (PostgreSQLParser.ENCRYPTED - 176)) | (1 << (PostgreSQLParser.ENUM_P - 176)) | (1 << (PostgreSQLParser.ESCAPE - 176)) | (1 << (PostgreSQLParser.EVENT - 176)) | (1 << (PostgreSQLParser.EXCLUDE - 176)) | (1 << (PostgreSQLParser.EXCLUDING - 176)) | (1 << (PostgreSQLParser.EXCLUSIVE - 176)) | (1 << (PostgreSQLParser.EXECUTE - 176)) | (1 << (PostgreSQLParser.EXPLAIN - 176)) | (1 << (PostgreSQLParser.EXTENSION - 176)) | (1 << (PostgreSQLParser.EXTERNAL - 176)) | (1 << (PostgreSQLParser.FAMILY - 176)) | (1 << (PostgreSQLParser.FIRST_P - 176)))) !== 0) || ((((_la - 208)) & ~0x1F) === 0 && ((1 << (_la - 208)) & ((1 << (PostgreSQLParser.FOLLOWING - 208)) | (1 << (PostgreSQLParser.FORCE - 208)) | (1 << (PostgreSQLParser.FORWARD - 208)) | (1 << (PostgreSQLParser.FUNCTION - 208)) | (1 << (PostgreSQLParser.FUNCTIONS - 208)) | (1 << (PostgreSQLParser.GLOBAL - 208)) | (1 << (PostgreSQLParser.GRANTED - 208)) | (1 << (PostgreSQLParser.HANDLER - 208)) | (1 << (PostgreSQLParser.HEADER_P - 208)) | (1 << (PostgreSQLParser.HOLD - 208)) | (1 << (PostgreSQLParser.HOUR_P - 208)) | (1 << (PostgreSQLParser.IDENTITY_P - 208)) | (1 << (PostgreSQLParser.IF_P - 208)) | (1 << (PostgreSQLParser.IMMEDIATE - 208)) | (1 << (PostgreSQLParser.IMMUTABLE - 208)) | (1 << (PostgreSQLParser.IMPLICIT_P - 208)) | (1 << (PostgreSQLParser.INCLUDING - 208)) | (1 << (PostgreSQLParser.INCREMENT - 208)) | (1 << (PostgreSQLParser.INDEX - 208)) | (1 << (PostgreSQLParser.INDEXES - 208)) | (1 << (PostgreSQLParser.INHERIT - 208)) | (1 << (PostgreSQLParser.INHERITS - 208)) | (1 << (PostgreSQLParser.INLINE_P - 208)) | (1 << (PostgreSQLParser.INSENSITIVE - 208)) | (1 << (PostgreSQLParser.INSERT - 208)) | (1 << (PostgreSQLParser.INSTEAD - 208)) | (1 << (PostgreSQLParser.INVOKER - 208)) | (1 << (PostgreSQLParser.ISOLATION - 208)) | (1 << (PostgreSQLParser.KEY - 208)) | (1 << (PostgreSQLParser.LABEL - 208)) | (1 << (PostgreSQLParser.LANGUAGE - 208)) | (1 << (PostgreSQLParser.LARGE_P - 208)))) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.LAST_P - 240)) | (1 << (PostgreSQLParser.LEAKPROOF - 240)) | (1 << (PostgreSQLParser.LEVEL - 240)) | (1 << (PostgreSQLParser.LISTEN - 240)) | (1 << (PostgreSQLParser.LOAD - 240)) | (1 << (PostgreSQLParser.LOCAL - 240)) | (1 << (PostgreSQLParser.LOCATION - 240)) | (1 << (PostgreSQLParser.LOCK_P - 240)) | (1 << (PostgreSQLParser.MAPPING - 240)) | (1 << (PostgreSQLParser.MATCH - 240)) | (1 << (PostgreSQLParser.MATERIALIZED - 240)) | (1 << (PostgreSQLParser.MAXVALUE - 240)) | (1 << (PostgreSQLParser.MINUTE_P - 240)) | (1 << (PostgreSQLParser.MINVALUE - 240)) | (1 << (PostgreSQLParser.MODE - 240)) | (1 << (PostgreSQLParser.MONTH_P - 240)) | (1 << (PostgreSQLParser.MOVE - 240)) | (1 << (PostgreSQLParser.NAME_P - 240)) | (1 << (PostgreSQLParser.NAMES - 240)) | (1 << (PostgreSQLParser.NEXT - 240)) | (1 << (PostgreSQLParser.NO - 240)) | (1 << (PostgreSQLParser.NOTHING - 240)) | (1 << (PostgreSQLParser.NOTIFY - 240)) | (1 << (PostgreSQLParser.NOWAIT - 240)) | (1 << (PostgreSQLParser.NULLS_P - 240)) | (1 << (PostgreSQLParser.OBJECT_P - 240)) | (1 << (PostgreSQLParser.OF - 240)) | (1 << (PostgreSQLParser.OFF - 240)) | (1 << (PostgreSQLParser.OIDS - 240)) | (1 << (PostgreSQLParser.OPERATOR - 240)) | (1 << (PostgreSQLParser.OPTION - 240)) | (1 << (PostgreSQLParser.OPTIONS - 240)))) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & ((1 << (PostgreSQLParser.OWNED - 272)) | (1 << (PostgreSQLParser.OWNER - 272)) | (1 << (PostgreSQLParser.PARSER - 272)) | (1 << (PostgreSQLParser.PARTIAL - 272)) | (1 << (PostgreSQLParser.PARTITION - 272)) | (1 << (PostgreSQLParser.PASSING - 272)) | (1 << (PostgreSQLParser.PASSWORD - 272)) | (1 << (PostgreSQLParser.PLANS - 272)) | (1 << (PostgreSQLParser.PRECEDING - 272)) | (1 << (PostgreSQLParser.PREPARE - 272)) | (1 << (PostgreSQLParser.PREPARED - 272)) | (1 << (PostgreSQLParser.PRESERVE - 272)) | (1 << (PostgreSQLParser.PRIOR - 272)) | (1 << (PostgreSQLParser.PRIVILEGES - 272)) | (1 << (PostgreSQLParser.PROCEDURAL - 272)) | (1 << (PostgreSQLParser.PROCEDURE - 272)) | (1 << (PostgreSQLParser.PROGRAM - 272)) | (1 << (PostgreSQLParser.QUOTE - 272)) | (1 << (PostgreSQLParser.RANGE - 272)) | (1 << (PostgreSQLParser.READ - 272)) | (1 << (PostgreSQLParser.REASSIGN - 272)) | (1 << (PostgreSQLParser.RECHECK - 272)) | (1 << (PostgreSQLParser.RECURSIVE - 272)) | (1 << (PostgreSQLParser.REF - 272)) | (1 << (PostgreSQLParser.REFRESH - 272)) | (1 << (PostgreSQLParser.REINDEX - 272)) | (1 << (PostgreSQLParser.RELATIVE_P - 272)) | (1 << (PostgreSQLParser.RELEASE - 272)) | (1 << (PostgreSQLParser.RENAME - 272)) | (1 << (PostgreSQLParser.REPEATABLE - 272)) | (1 << (PostgreSQLParser.REPLACE - 272)) | (1 << (PostgreSQLParser.REPLICA - 272)))) !== 0) || ((((_la - 304)) & ~0x1F) === 0 && ((1 << (_la - 304)) & ((1 << (PostgreSQLParser.RESET - 304)) | (1 << (PostgreSQLParser.RESTART - 304)) | (1 << (PostgreSQLParser.RESTRICT - 304)) | (1 << (PostgreSQLParser.RETURNS - 304)) | (1 << (PostgreSQLParser.REVOKE - 304)) | (1 << (PostgreSQLParser.ROLE - 304)) | (1 << (PostgreSQLParser.ROLLBACK - 304)) | (1 << (PostgreSQLParser.ROWS - 304)) | (1 << (PostgreSQLParser.RULE - 304)) | (1 << (PostgreSQLParser.SAVEPOINT - 304)) | (1 << (PostgreSQLParser.SCHEMA - 304)) | (1 << (PostgreSQLParser.SCROLL - 304)) | (1 << (PostgreSQLParser.SEARCH - 304)) | (1 << (PostgreSQLParser.SECOND_P - 304)) | (1 << (PostgreSQLParser.SECURITY - 304)) | (1 << (PostgreSQLParser.SEQUENCE - 304)) | (1 << (PostgreSQLParser.SEQUENCES - 304)) | (1 << (PostgreSQLParser.SERIALIZABLE - 304)) | (1 << (PostgreSQLParser.SERVER - 304)) | (1 << (PostgreSQLParser.SESSION - 304)) | (1 << (PostgreSQLParser.SET - 304)) | (1 << (PostgreSQLParser.SHARE - 304)) | (1 << (PostgreSQLParser.SHOW - 304)) | (1 << (PostgreSQLParser.SIMPLE - 304)) | (1 << (PostgreSQLParser.SNAPSHOT - 304)) | (1 << (PostgreSQLParser.STABLE - 304)) | (1 << (PostgreSQLParser.STANDALONE_P - 304)) | (1 << (PostgreSQLParser.START - 304)) | (1 << (PostgreSQLParser.STATEMENT - 304)) | (1 << (PostgreSQLParser.STATISTICS - 304)) | (1 << (PostgreSQLParser.STDIN - 304)) | (1 << (PostgreSQLParser.STDOUT - 304)))) !== 0) || ((((_la - 336)) & ~0x1F) === 0 && ((1 << (_la - 336)) & ((1 << (PostgreSQLParser.STORAGE - 336)) | (1 << (PostgreSQLParser.STRICT_P - 336)) | (1 << (PostgreSQLParser.STRIP_P - 336)) | (1 << (PostgreSQLParser.SYSID - 336)) | (1 << (PostgreSQLParser.SYSTEM_P - 336)) | (1 << (PostgreSQLParser.TABLES - 336)) | (1 << (PostgreSQLParser.TABLESPACE - 336)) | (1 << (PostgreSQLParser.TEMP - 336)) | (1 << (PostgreSQLParser.TEMPLATE - 336)) | (1 << (PostgreSQLParser.TEMPORARY - 336)) | (1 << (PostgreSQLParser.TEXT_P - 336)) | (1 << (PostgreSQLParser.TRANSACTION - 336)) | (1 << (PostgreSQLParser.TRIGGER - 336)) | (1 << (PostgreSQLParser.TRUNCATE - 336)) | (1 << (PostgreSQLParser.TRUSTED - 336)) | (1 << (PostgreSQLParser.TYPE_P - 336)) | (1 << (PostgreSQLParser.TYPES_P - 336)) | (1 << (PostgreSQLParser.UNBOUNDED - 336)) | (1 << (PostgreSQLParser.UNCOMMITTED - 336)) | (1 << (PostgreSQLParser.UNENCRYPTED - 336)) | (1 << (PostgreSQLParser.UNKNOWN - 336)) | (1 << (PostgreSQLParser.UNLISTEN - 336)) | (1 << (PostgreSQLParser.UNLOGGED - 336)) | (1 << (PostgreSQLParser.UNTIL - 336)) | (1 << (PostgreSQLParser.UPDATE - 336)) | (1 << (PostgreSQLParser.VACUUM - 336)) | (1 << (PostgreSQLParser.VALID - 336)) | (1 << (PostgreSQLParser.VALIDATE - 336)) | (1 << (PostgreSQLParser.VALIDATOR - 336)) | (1 << (PostgreSQLParser.VARYING - 336)) | (1 << (PostgreSQLParser.VERSION_P - 336)) | (1 << (PostgreSQLParser.VIEW - 336)))) !== 0) || ((((_la - 368)) & ~0x1F) === 0 && ((1 << (_la - 368)) & ((1 << (PostgreSQLParser.VOLATILE - 368)) | (1 << (PostgreSQLParser.WHITESPACE_P - 368)) | (1 << (PostgreSQLParser.WITHOUT - 368)) | (1 << (PostgreSQLParser.WORK - 368)) | (1 << (PostgreSQLParser.WRAPPER - 368)) | (1 << (PostgreSQLParser.WRITE - 368)) | (1 << (PostgreSQLParser.XML_P - 368)) | (1 << (PostgreSQLParser.YEAR_P - 368)) | (1 << (PostgreSQLParser.YES_P - 368)) | (1 << (PostgreSQLParser.ZONE - 368)) | (1 << (PostgreSQLParser.BETWEEN - 368)) | (1 << (PostgreSQLParser.BIGINT - 368)) | (1 << (PostgreSQLParser.BIT - 368)) | (1 << (PostgreSQLParser.BOOLEAN_P - 368)) | (1 << (PostgreSQLParser.CHAR_P - 368)) | (1 << (PostgreSQLParser.CHARACTER - 368)) | (1 << (PostgreSQLParser.COALESCE - 368)) | (1 << (PostgreSQLParser.DEC - 368)) | (1 << (PostgreSQLParser.DECIMAL_P - 368)) | (1 << (PostgreSQLParser.EXISTS - 368)) | (1 << (PostgreSQLParser.EXTRACT - 368)) | (1 << (PostgreSQLParser.FLOAT_P - 368)) | (1 << (PostgreSQLParser.GREATEST - 368)) | (1 << (PostgreSQLParser.INOUT - 368)) | (1 << (PostgreSQLParser.INT_P - 368)) | (1 << (PostgreSQLParser.INTEGER - 368)) | (1 << (PostgreSQLParser.INTERVAL - 368)) | (1 << (PostgreSQLParser.LEAST - 368)) | (1 << (PostgreSQLParser.NATIONAL - 368)) | (1 << (PostgreSQLParser.NCHAR - 368)) | (1 << (PostgreSQLParser.NONE - 368)) | (1 << (PostgreSQLParser.NULLIF - 368)))) !== 0) || ((((_la - 400)) & ~0x1F) === 0 && ((1 << (_la - 400)) & ((1 << (PostgreSQLParser.NUMERIC - 400)) | (1 << (PostgreSQLParser.OVERLAY - 400)) | (1 << (PostgreSQLParser.POSITION - 400)) | (1 << (PostgreSQLParser.PRECISION - 400)) | (1 << (PostgreSQLParser.REAL - 400)) | (1 << (PostgreSQLParser.ROW - 400)) | (1 << (PostgreSQLParser.SETOF - 400)) | (1 << (PostgreSQLParser.SMALLINT - 400)) | (1 << (PostgreSQLParser.SUBSTRING - 400)) | (1 << (PostgreSQLParser.TIME - 400)) | (1 << (PostgreSQLParser.TIMESTAMP - 400)) | (1 << (PostgreSQLParser.TREAT - 400)) | (1 << (PostgreSQLParser.TRIM - 400)) | (1 << (PostgreSQLParser.VALUES - 400)) | (1 << (PostgreSQLParser.VARCHAR - 400)) | (1 << (PostgreSQLParser.XMLATTRIBUTES - 400)) | (1 << (PostgreSQLParser.XMLCONCAT - 400)) | (1 << (PostgreSQLParser.XMLELEMENT - 400)) | (1 << (PostgreSQLParser.XMLEXISTS - 400)) | (1 << (PostgreSQLParser.XMLFOREST - 400)) | (1 << (PostgreSQLParser.XMLPARSE - 400)) | (1 << (PostgreSQLParser.XMLPI - 400)) | (1 << (PostgreSQLParser.XMLROOT - 400)) | (1 << (PostgreSQLParser.XMLSERIALIZE - 400)) | (1 << (PostgreSQLParser.CALL - 400)) | (1 << (PostgreSQLParser.CURRENT_P - 400)) | (1 << (PostgreSQLParser.ATTACH - 400)) | (1 << (PostgreSQLParser.DETACH - 400)) | (1 << (PostgreSQLParser.EXPRESSION - 400)) | (1 << (PostgreSQLParser.GENERATED - 400)) | (1 << (PostgreSQLParser.LOGGED - 400)) | (1 << (PostgreSQLParser.STORED - 400)))) !== 0) || ((((_la - 432)) & ~0x1F) === 0 && ((1 << (_la - 432)) & ((1 << (PostgreSQLParser.INCLUDE - 432)) | (1 << (PostgreSQLParser.ROUTINE - 432)) | (1 << (PostgreSQLParser.TRANSFORM - 432)) | (1 << (PostgreSQLParser.IMPORT_P - 432)) | (1 << (PostgreSQLParser.POLICY - 432)) | (1 << (PostgreSQLParser.METHOD - 432)) | (1 << (PostgreSQLParser.REFERENCING - 432)) | (1 << (PostgreSQLParser.NEW - 432)) | (1 << (PostgreSQLParser.OLD - 432)) | (1 << (PostgreSQLParser.VALUE_P - 432)) | (1 << (PostgreSQLParser.SUBSCRIPTION - 432)) | (1 << (PostgreSQLParser.PUBLICATION - 432)) | (1 << (PostgreSQLParser.OUT_P - 432)) | (1 << (PostgreSQLParser.ROUTINES - 432)) | (1 << (PostgreSQLParser.SCHEMAS - 432)) | (1 << (PostgreSQLParser.PROCEDURES - 432)) | (1 << (PostgreSQLParser.INPUT_P - 432)) | (1 << (PostgreSQLParser.SUPPORT - 432)) | (1 << (PostgreSQLParser.PARALLEL - 432)) | (1 << (PostgreSQLParser.SQL_P - 432)) | (1 << (PostgreSQLParser.DEPENDS - 432)) | (1 << (PostgreSQLParser.OVERRIDING - 432)) | (1 << (PostgreSQLParser.CONFLICT - 432)) | (1 << (PostgreSQLParser.SKIP_P - 432)) | (1 << (PostgreSQLParser.LOCKED - 432)) | (1 << (PostgreSQLParser.TIES - 432)) | (1 << (PostgreSQLParser.ROLLUP - 432)) | (1 << (PostgreSQLParser.CUBE - 432)) | (1 << (PostgreSQLParser.GROUPING - 432)) | (1 << (PostgreSQLParser.SETS - 432)) | (1 << (PostgreSQLParser.TABLESAMPLE - 432)))) !== 0) || ((((_la - 464)) & ~0x1F) === 0 && ((1 << (_la - 464)) & ((1 << (PostgreSQLParser.ORDINALITY - 464)) | (1 << (PostgreSQLParser.XMLTABLE - 464)) | (1 << (PostgreSQLParser.COLUMNS - 464)) | (1 << (PostgreSQLParser.XMLNAMESPACES - 464)) | (1 << (PostgreSQLParser.ROWTYPE - 464)) | (1 << (PostgreSQLParser.NORMALIZED - 464)) | (1 << (PostgreSQLParser.WITHIN - 464)) | (1 << (PostgreSQLParser.FILTER - 464)) | (1 << (PostgreSQLParser.GROUPS - 464)) | (1 << (PostgreSQLParser.OTHERS - 464)) | (1 << (PostgreSQLParser.NFC - 464)) | (1 << (PostgreSQLParser.NFD - 464)) | (1 << (PostgreSQLParser.NFKC - 464)) | (1 << (PostgreSQLParser.NFKD - 464)) | (1 << (PostgreSQLParser.UESCAPE - 464)) | (1 << (PostgreSQLParser.VIEWS - 464)) | (1 << (PostgreSQLParser.NORMALIZE - 464)) | (1 << (PostgreSQLParser.DUMP - 464)) | (1 << (PostgreSQLParser.PRINT_STRICT_PARAMS - 464)) | (1 << (PostgreSQLParser.VARIABLE_CONFLICT - 464)) | (1 << (PostgreSQLParser.ERROR - 464)) | (1 << (PostgreSQLParser.USE_VARIABLE - 464)) | (1 << (PostgreSQLParser.USE_COLUMN - 464)) | (1 << (PostgreSQLParser.ALIAS - 464)) | (1 << (PostgreSQLParser.CONSTANT - 464)) | (1 << (PostgreSQLParser.PERFORM - 464)) | (1 << (PostgreSQLParser.GET - 464)) | (1 << (PostgreSQLParser.DIAGNOSTICS - 464)) | (1 << (PostgreSQLParser.STACKED - 464)) | (1 << (PostgreSQLParser.ELSIF - 464)) | (1 << (PostgreSQLParser.REVERSE - 464)))) !== 0) || ((((_la - 497)) & ~0x1F) === 0 && ((1 << (_la - 497)) & ((1 << (PostgreSQLParser.SLICE - 497)) | (1 << (PostgreSQLParser.EXIT - 497)) | (1 << (PostgreSQLParser.RETURN - 497)) | (1 << (PostgreSQLParser.QUERY - 497)) | (1 << (PostgreSQLParser.RAISE - 497)) | (1 << (PostgreSQLParser.SQLSTATE - 497)) | (1 << (PostgreSQLParser.DEBUG - 497)) | (1 << (PostgreSQLParser.LOG - 497)) | (1 << (PostgreSQLParser.INFO - 497)) | (1 << (PostgreSQLParser.NOTICE - 497)) | (1 << (PostgreSQLParser.WARNING - 497)) | (1 << (PostgreSQLParser.EXCEPTION - 497)) | (1 << (PostgreSQLParser.ASSERT - 497)) | (1 << (PostgreSQLParser.OPEN - 497)) | (1 << (PostgreSQLParser.Identifier - 497)) | (1 << (PostgreSQLParser.QuotedIdentifier - 497)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 497)) | (1 << (PostgreSQLParser.StringConstant - 497)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 497)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 497)))) !== 0) || ((((_la - 534)) & ~0x1F) === 0 && ((1 << (_la - 534)) & ((1 << (PostgreSQLParser.Integral - 534)) | (1 << (PostgreSQLParser.Numeric - 534)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 534)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 534)) | (1 << (PostgreSQLParser.EscapeStringConstant - 534)))) !== 0)) { + if (_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 80)) & ~0x1F) === 0 && ((1 << (_la - 80)) & ((1 << (PostgreSQLParser.KW_ON - 80)) | (1 << (PostgreSQLParser.KW_TABLE - 80)) | (1 << (PostgreSQLParser.KW_TRUE - 80)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 80)) | (1 << (PostgreSQLParser.KW_BINARY - 80)) | (1 << (PostgreSQLParser.KW_COLLATION - 80)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 80)) | (1 << (PostgreSQLParser.KW_CROSS - 80)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 80)))) !== 0) || ((((_la - 112)) & ~0x1F) === 0 && ((1 << (_la - 112)) & ((1 << (PostgreSQLParser.KW_FREEZE - 112)) | (1 << (PostgreSQLParser.KW_FULL - 112)) | (1 << (PostgreSQLParser.KW_ILIKE - 112)) | (1 << (PostgreSQLParser.KW_INNER - 112)) | (1 << (PostgreSQLParser.KW_IS - 112)) | (1 << (PostgreSQLParser.KW_ISNULL - 112)) | (1 << (PostgreSQLParser.KW_JOIN - 112)) | (1 << (PostgreSQLParser.KW_LEFT - 112)) | (1 << (PostgreSQLParser.KW_LIKE - 112)) | (1 << (PostgreSQLParser.KW_NATURAL - 112)) | (1 << (PostgreSQLParser.KW_NOTNULL - 112)) | (1 << (PostgreSQLParser.KW_OUTER - 112)) | (1 << (PostgreSQLParser.KW_OVER - 112)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 112)) | (1 << (PostgreSQLParser.KW_RIGHT - 112)) | (1 << (PostgreSQLParser.KW_SIMILAR - 112)) | (1 << (PostgreSQLParser.KW_VERBOSE - 112)) | (1 << (PostgreSQLParser.KW_ABORT - 112)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 112)) | (1 << (PostgreSQLParser.KW_ACCESS - 112)) | (1 << (PostgreSQLParser.KW_ACTION - 112)) | (1 << (PostgreSQLParser.KW_ADD - 112)) | (1 << (PostgreSQLParser.KW_ADMIN - 112)) | (1 << (PostgreSQLParser.KW_AFTER - 112)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 112)) | (1 << (PostgreSQLParser.KW_ALSO - 112)) | (1 << (PostgreSQLParser.KW_ALTER - 112)) | (1 << (PostgreSQLParser.KW_ALWAYS - 112)) | (1 << (PostgreSQLParser.KW_ASSERTION - 112)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 112)) | (1 << (PostgreSQLParser.KW_AT - 112)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 112)))) !== 0) || ((((_la - 144)) & ~0x1F) === 0 && ((1 << (_la - 144)) & ((1 << (PostgreSQLParser.KW_BACKWARD - 144)) | (1 << (PostgreSQLParser.KW_BEFORE - 144)) | (1 << (PostgreSQLParser.KW_BEGIN - 144)) | (1 << (PostgreSQLParser.KW_BY - 144)) | (1 << (PostgreSQLParser.KW_CACHE - 144)) | (1 << (PostgreSQLParser.KW_CALLED - 144)) | (1 << (PostgreSQLParser.KW_CASCADE - 144)) | (1 << (PostgreSQLParser.KW_CASCADED - 144)) | (1 << (PostgreSQLParser.KW_CATALOG - 144)) | (1 << (PostgreSQLParser.KW_CHAIN - 144)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 144)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 144)) | (1 << (PostgreSQLParser.KW_CLASS - 144)) | (1 << (PostgreSQLParser.KW_CLOSE - 144)) | (1 << (PostgreSQLParser.KW_CLUSTER - 144)) | (1 << (PostgreSQLParser.KW_COMMENT - 144)) | (1 << (PostgreSQLParser.KW_COMMENTS - 144)) | (1 << (PostgreSQLParser.KW_COMMIT - 144)) | (1 << (PostgreSQLParser.KW_COMMITTED - 144)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 144)) | (1 << (PostgreSQLParser.KW_CONNECTION - 144)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 144)) | (1 << (PostgreSQLParser.KW_CONTENT - 144)) | (1 << (PostgreSQLParser.KW_CONTINUE - 144)) | (1 << (PostgreSQLParser.KW_CONVERSION - 144)) | (1 << (PostgreSQLParser.KW_COPY - 144)) | (1 << (PostgreSQLParser.KW_COST - 144)) | (1 << (PostgreSQLParser.KW_CSV - 144)) | (1 << (PostgreSQLParser.KW_CURSOR - 144)) | (1 << (PostgreSQLParser.KW_CYCLE - 144)) | (1 << (PostgreSQLParser.KW_DATA - 144)) | (1 << (PostgreSQLParser.KW_DATABASE - 144)))) !== 0) || ((((_la - 176)) & ~0x1F) === 0 && ((1 << (_la - 176)) & ((1 << (PostgreSQLParser.KW_DAY - 176)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 176)) | (1 << (PostgreSQLParser.KW_DECLARE - 176)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 176)) | (1 << (PostgreSQLParser.KW_DEFERRED - 176)) | (1 << (PostgreSQLParser.KW_DEFINER - 176)) | (1 << (PostgreSQLParser.KW_DELETE - 176)) | (1 << (PostgreSQLParser.KW_DELIMITER - 176)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 176)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 176)) | (1 << (PostgreSQLParser.KW_DISABLE - 176)) | (1 << (PostgreSQLParser.KW_DISCARD - 176)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 176)) | (1 << (PostgreSQLParser.KW_DOMAIN - 176)) | (1 << (PostgreSQLParser.KW_DOUBLE - 176)) | (1 << (PostgreSQLParser.KW_DROP - 176)) | (1 << (PostgreSQLParser.KW_EACH - 176)) | (1 << (PostgreSQLParser.KW_ENABLE - 176)) | (1 << (PostgreSQLParser.KW_ENCODING - 176)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 176)) | (1 << (PostgreSQLParser.KW_ENUM - 176)) | (1 << (PostgreSQLParser.KW_ESCAPE - 176)) | (1 << (PostgreSQLParser.KW_EVENT - 176)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 176)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 176)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 176)) | (1 << (PostgreSQLParser.KW_EXECUTE - 176)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 176)) | (1 << (PostgreSQLParser.KW_EXTENSION - 176)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 176)) | (1 << (PostgreSQLParser.KW_FAMILY - 176)) | (1 << (PostgreSQLParser.KW_FIRST - 176)))) !== 0) || ((((_la - 208)) & ~0x1F) === 0 && ((1 << (_la - 208)) & ((1 << (PostgreSQLParser.KW_FOLLOWING - 208)) | (1 << (PostgreSQLParser.KW_FORCE - 208)) | (1 << (PostgreSQLParser.KW_FORWARD - 208)) | (1 << (PostgreSQLParser.KW_FUNCTION - 208)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 208)) | (1 << (PostgreSQLParser.KW_GLOBAL - 208)) | (1 << (PostgreSQLParser.KW_GRANTED - 208)) | (1 << (PostgreSQLParser.KW_HANDLER - 208)) | (1 << (PostgreSQLParser.KW_HEADER - 208)) | (1 << (PostgreSQLParser.KW_HOLD - 208)) | (1 << (PostgreSQLParser.KW_HOUR - 208)) | (1 << (PostgreSQLParser.KW_IDENTITY - 208)) | (1 << (PostgreSQLParser.KW_IF - 208)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 208)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 208)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 208)) | (1 << (PostgreSQLParser.KW_INCLUDING - 208)) | (1 << (PostgreSQLParser.KW_INCREMENT - 208)) | (1 << (PostgreSQLParser.KW_INDEX - 208)) | (1 << (PostgreSQLParser.KW_INDEXES - 208)) | (1 << (PostgreSQLParser.KW_INHERIT - 208)) | (1 << (PostgreSQLParser.KW_INHERITS - 208)) | (1 << (PostgreSQLParser.KW_INLINE - 208)))) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.KW_INSENSITIVE - 240)) | (1 << (PostgreSQLParser.KW_INSERT - 240)) | (1 << (PostgreSQLParser.KW_INSTEAD - 240)) | (1 << (PostgreSQLParser.KW_INVOKER - 240)) | (1 << (PostgreSQLParser.KW_ISOLATION - 240)) | (1 << (PostgreSQLParser.KW_KEY - 240)) | (1 << (PostgreSQLParser.KW_LABEL - 240)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 240)) | (1 << (PostgreSQLParser.KW_LARGE - 240)) | (1 << (PostgreSQLParser.KW_LAST - 240)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 240)) | (1 << (PostgreSQLParser.KW_LEVEL - 240)) | (1 << (PostgreSQLParser.KW_LISTEN - 240)) | (1 << (PostgreSQLParser.KW_LOAD - 240)) | (1 << (PostgreSQLParser.KW_LOCAL - 240)) | (1 << (PostgreSQLParser.KW_LOCATION - 240)) | (1 << (PostgreSQLParser.KW_LOCK - 240)) | (1 << (PostgreSQLParser.KW_MAPPING - 240)) | (1 << (PostgreSQLParser.KW_MATCH - 240)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 240)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 240)) | (1 << (PostgreSQLParser.KW_MINUTE - 240)) | (1 << (PostgreSQLParser.KW_MINVALUE - 240)) | (1 << (PostgreSQLParser.KW_MODE - 240)) | (1 << (PostgreSQLParser.KW_MONTH - 240)) | (1 << (PostgreSQLParser.KW_MOVE - 240)) | (1 << (PostgreSQLParser.KW_NAME - 240)) | (1 << (PostgreSQLParser.KW_NAMES - 240)) | (1 << (PostgreSQLParser.KW_NEXT - 240)) | (1 << (PostgreSQLParser.KW_NO - 240)) | (1 << (PostgreSQLParser.KW_NOTHING - 240)) | (1 << (PostgreSQLParser.KW_NOTIFY - 240)))) !== 0) || ((((_la - 272)) & ~0x1F) === 0 && ((1 << (_la - 272)) & ((1 << (PostgreSQLParser.KW_NOWAIT - 272)) | (1 << (PostgreSQLParser.KW_NULLS - 272)) | (1 << (PostgreSQLParser.KW_OBJECT - 272)) | (1 << (PostgreSQLParser.KW_OF - 272)) | (1 << (PostgreSQLParser.KW_OFF - 272)) | (1 << (PostgreSQLParser.KW_OIDS - 272)) | (1 << (PostgreSQLParser.KW_OPERATOR - 272)) | (1 << (PostgreSQLParser.KW_OPTION - 272)) | (1 << (PostgreSQLParser.KW_OPTIONS - 272)) | (1 << (PostgreSQLParser.KW_OWNED - 272)) | (1 << (PostgreSQLParser.KW_OWNER - 272)) | (1 << (PostgreSQLParser.KW_PARSER - 272)) | (1 << (PostgreSQLParser.KW_PARTIAL - 272)) | (1 << (PostgreSQLParser.KW_PARTITION - 272)) | (1 << (PostgreSQLParser.KW_PASSING - 272)) | (1 << (PostgreSQLParser.KW_PASSWORD - 272)) | (1 << (PostgreSQLParser.KW_PLANS - 272)) | (1 << (PostgreSQLParser.KW_PRECEDING - 272)) | (1 << (PostgreSQLParser.KW_PREPARE - 272)) | (1 << (PostgreSQLParser.KW_PREPARED - 272)) | (1 << (PostgreSQLParser.KW_PRESERVE - 272)) | (1 << (PostgreSQLParser.KW_PRIOR - 272)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 272)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 272)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 272)) | (1 << (PostgreSQLParser.KW_PROGRAM - 272)) | (1 << (PostgreSQLParser.KW_QUOTE - 272)) | (1 << (PostgreSQLParser.KW_RANGE - 272)) | (1 << (PostgreSQLParser.KW_READ - 272)) | (1 << (PostgreSQLParser.KW_REASSIGN - 272)) | (1 << (PostgreSQLParser.KW_RECHECK - 272)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 272)))) !== 0) || ((((_la - 304)) & ~0x1F) === 0 && ((1 << (_la - 304)) & ((1 << (PostgreSQLParser.KW_REF - 304)) | (1 << (PostgreSQLParser.KW_REFRESH - 304)) | (1 << (PostgreSQLParser.KW_REINDEX - 304)) | (1 << (PostgreSQLParser.KW_RELATIVE - 304)) | (1 << (PostgreSQLParser.KW_RELEASE - 304)) | (1 << (PostgreSQLParser.KW_RENAME - 304)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 304)) | (1 << (PostgreSQLParser.KW_REPLACE - 304)) | (1 << (PostgreSQLParser.KW_REPLICA - 304)) | (1 << (PostgreSQLParser.KW_RESET - 304)) | (1 << (PostgreSQLParser.KW_RESTART - 304)) | (1 << (PostgreSQLParser.KW_RESTRICT - 304)) | (1 << (PostgreSQLParser.KW_RETURNS - 304)) | (1 << (PostgreSQLParser.KW_REVOKE - 304)) | (1 << (PostgreSQLParser.KW_ROLE - 304)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 304)) | (1 << (PostgreSQLParser.KW_ROWS - 304)) | (1 << (PostgreSQLParser.KW_RULE - 304)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 304)) | (1 << (PostgreSQLParser.KW_SCHEMA - 304)) | (1 << (PostgreSQLParser.KW_SCROLL - 304)) | (1 << (PostgreSQLParser.KW_SEARCH - 304)) | (1 << (PostgreSQLParser.KW_SECOND - 304)) | (1 << (PostgreSQLParser.KW_SECURITY - 304)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 304)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 304)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 304)) | (1 << (PostgreSQLParser.KW_SERVER - 304)) | (1 << (PostgreSQLParser.KW_SESSION - 304)) | (1 << (PostgreSQLParser.KW_SET - 304)) | (1 << (PostgreSQLParser.KW_SHARE - 304)) | (1 << (PostgreSQLParser.KW_SHOW - 304)))) !== 0) || ((((_la - 336)) & ~0x1F) === 0 && ((1 << (_la - 336)) & ((1 << (PostgreSQLParser.KW_SIMPLE - 336)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 336)) | (1 << (PostgreSQLParser.KW_STABLE - 336)) | (1 << (PostgreSQLParser.KW_STANDALONE - 336)) | (1 << (PostgreSQLParser.KW_START - 336)) | (1 << (PostgreSQLParser.KW_STATEMENT - 336)) | (1 << (PostgreSQLParser.KW_STATISTICS - 336)) | (1 << (PostgreSQLParser.KW_STDIN - 336)) | (1 << (PostgreSQLParser.KW_STDOUT - 336)) | (1 << (PostgreSQLParser.KW_STORAGE - 336)) | (1 << (PostgreSQLParser.KW_STRICT - 336)) | (1 << (PostgreSQLParser.KW_STRIP - 336)) | (1 << (PostgreSQLParser.KW_SYSID - 336)) | (1 << (PostgreSQLParser.KW_SYSTEM - 336)) | (1 << (PostgreSQLParser.KW_TABLES - 336)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 336)) | (1 << (PostgreSQLParser.KW_TEMP - 336)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 336)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 336)) | (1 << (PostgreSQLParser.KW_TEXT - 336)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 336)) | (1 << (PostgreSQLParser.KW_TRIGGER - 336)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 336)) | (1 << (PostgreSQLParser.KW_TRUSTED - 336)) | (1 << (PostgreSQLParser.KW_TYPE - 336)) | (1 << (PostgreSQLParser.KW_TYPES - 336)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 336)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 336)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 336)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 336)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 336)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 336)))) !== 0) || ((((_la - 368)) & ~0x1F) === 0 && ((1 << (_la - 368)) & ((1 << (PostgreSQLParser.KW_UNTIL - 368)) | (1 << (PostgreSQLParser.KW_UPDATE - 368)) | (1 << (PostgreSQLParser.KW_VACUUM - 368)) | (1 << (PostgreSQLParser.KW_VALID - 368)) | (1 << (PostgreSQLParser.KW_VALIDATE - 368)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 368)) | (1 << (PostgreSQLParser.KW_VARYING - 368)) | (1 << (PostgreSQLParser.KW_VERSION - 368)) | (1 << (PostgreSQLParser.KW_VIEW - 368)) | (1 << (PostgreSQLParser.KW_VOLATILE - 368)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 368)) | (1 << (PostgreSQLParser.KW_WITHOUT - 368)) | (1 << (PostgreSQLParser.KW_WORK - 368)) | (1 << (PostgreSQLParser.KW_WRAPPER - 368)) | (1 << (PostgreSQLParser.KW_WRITE - 368)) | (1 << (PostgreSQLParser.KW_XML - 368)) | (1 << (PostgreSQLParser.KW_YEAR - 368)) | (1 << (PostgreSQLParser.KW_YES - 368)) | (1 << (PostgreSQLParser.KW_ZONE - 368)) | (1 << (PostgreSQLParser.KW_BETWEEN - 368)) | (1 << (PostgreSQLParser.KW_BIGINT - 368)) | (1 << (PostgreSQLParser.KW_BIT - 368)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 368)) | (1 << (PostgreSQLParser.KW_CHAR - 368)) | (1 << (PostgreSQLParser.KW_CHARACTER - 368)) | (1 << (PostgreSQLParser.KW_COALESCE - 368)) | (1 << (PostgreSQLParser.KW_DEC - 368)) | (1 << (PostgreSQLParser.KW_DECIMAL - 368)) | (1 << (PostgreSQLParser.KW_EXISTS - 368)) | (1 << (PostgreSQLParser.KW_EXTRACT - 368)) | (1 << (PostgreSQLParser.KW_FLOAT - 368)) | (1 << (PostgreSQLParser.KW_GREATEST - 368)))) !== 0) || ((((_la - 400)) & ~0x1F) === 0 && ((1 << (_la - 400)) & ((1 << (PostgreSQLParser.KW_INOUT - 400)) | (1 << (PostgreSQLParser.KW_INT - 400)) | (1 << (PostgreSQLParser.KW_INTEGER - 400)) | (1 << (PostgreSQLParser.KW_INTERVAL - 400)) | (1 << (PostgreSQLParser.KW_LEAST - 400)) | (1 << (PostgreSQLParser.KW_NATIONAL - 400)) | (1 << (PostgreSQLParser.KW_NCHAR - 400)) | (1 << (PostgreSQLParser.KW_NONE - 400)) | (1 << (PostgreSQLParser.KW_NULLIF - 400)) | (1 << (PostgreSQLParser.KW_NUMERIC - 400)) | (1 << (PostgreSQLParser.KW_OVERLAY - 400)) | (1 << (PostgreSQLParser.KW_POSITION - 400)) | (1 << (PostgreSQLParser.KW_PRECISION - 400)) | (1 << (PostgreSQLParser.KW_REAL - 400)) | (1 << (PostgreSQLParser.KW_ROW - 400)) | (1 << (PostgreSQLParser.KW_SETOF - 400)) | (1 << (PostgreSQLParser.KW_SMALLINT - 400)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 400)) | (1 << (PostgreSQLParser.KW_TIME - 400)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 400)) | (1 << (PostgreSQLParser.KW_TREAT - 400)) | (1 << (PostgreSQLParser.KW_TRIM - 400)) | (1 << (PostgreSQLParser.KW_VALUES - 400)) | (1 << (PostgreSQLParser.KW_VARCHAR - 400)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 400)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 400)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 400)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 400)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 400)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 400)) | (1 << (PostgreSQLParser.KW_XMLPI - 400)) | (1 << (PostgreSQLParser.KW_XMLROOT - 400)))) !== 0) || ((((_la - 432)) & ~0x1F) === 0 && ((1 << (_la - 432)) & ((1 << (PostgreSQLParser.KW_XMLSERIALIZE - 432)) | (1 << (PostgreSQLParser.KW_CALL - 432)) | (1 << (PostgreSQLParser.KW_CURRENT - 432)) | (1 << (PostgreSQLParser.KW_ATTACH - 432)) | (1 << (PostgreSQLParser.KW_DETACH - 432)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 432)) | (1 << (PostgreSQLParser.KW_GENERATED - 432)) | (1 << (PostgreSQLParser.KW_LOGGED - 432)) | (1 << (PostgreSQLParser.KW_STORED - 432)) | (1 << (PostgreSQLParser.KW_INCLUDE - 432)) | (1 << (PostgreSQLParser.KW_ROUTINE - 432)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 432)) | (1 << (PostgreSQLParser.KW_IMPORT - 432)) | (1 << (PostgreSQLParser.KW_POLICY - 432)) | (1 << (PostgreSQLParser.KW_METHOD - 432)) | (1 << (PostgreSQLParser.KW_REFERENCING - 432)) | (1 << (PostgreSQLParser.KW_NEW - 432)) | (1 << (PostgreSQLParser.KW_OLD - 432)) | (1 << (PostgreSQLParser.KW_VALUE - 432)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 432)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 432)) | (1 << (PostgreSQLParser.KW_OUT - 432)) | (1 << (PostgreSQLParser.KW_ROUTINES - 432)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 432)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 432)) | (1 << (PostgreSQLParser.KW_INPUT - 432)) | (1 << (PostgreSQLParser.KW_SUPPORT - 432)) | (1 << (PostgreSQLParser.KW_PARALLEL - 432)) | (1 << (PostgreSQLParser.KW_SQL - 432)) | (1 << (PostgreSQLParser.KW_DEPENDS - 432)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 432)))) !== 0) || ((((_la - 464)) & ~0x1F) === 0 && ((1 << (_la - 464)) & ((1 << (PostgreSQLParser.KW_CONFLICT - 464)) | (1 << (PostgreSQLParser.KW_SKIP - 464)) | (1 << (PostgreSQLParser.KW_LOCKED - 464)) | (1 << (PostgreSQLParser.KW_TIES - 464)) | (1 << (PostgreSQLParser.KW_ROLLUP - 464)) | (1 << (PostgreSQLParser.KW_CUBE - 464)) | (1 << (PostgreSQLParser.KW_GROUPING - 464)) | (1 << (PostgreSQLParser.KW_SETS - 464)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 464)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 464)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 464)) | (1 << (PostgreSQLParser.KW_COLUMNS - 464)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 464)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 464)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 464)) | (1 << (PostgreSQLParser.KW_WITHIN - 464)) | (1 << (PostgreSQLParser.KW_FILTER - 464)) | (1 << (PostgreSQLParser.KW_GROUPS - 464)) | (1 << (PostgreSQLParser.KW_OTHERS - 464)) | (1 << (PostgreSQLParser.KW_NFC - 464)) | (1 << (PostgreSQLParser.KW_NFD - 464)) | (1 << (PostgreSQLParser.KW_NFKC - 464)) | (1 << (PostgreSQLParser.KW_NFKD - 464)) | (1 << (PostgreSQLParser.KW_UESCAPE - 464)) | (1 << (PostgreSQLParser.KW_VIEWS - 464)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 464)) | (1 << (PostgreSQLParser.KW_DUMP - 464)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 464)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 464)) | (1 << (PostgreSQLParser.KW_ERROR - 464)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 464)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 464)))) !== 0) || ((((_la - 496)) & ~0x1F) === 0 && ((1 << (_la - 496)) & ((1 << (PostgreSQLParser.KW_ALIAS - 496)) | (1 << (PostgreSQLParser.KW_CONSTANT - 496)) | (1 << (PostgreSQLParser.KW_PERFORM - 496)) | (1 << (PostgreSQLParser.KW_GET - 496)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 496)) | (1 << (PostgreSQLParser.KW_STACKED - 496)) | (1 << (PostgreSQLParser.KW_ELSIF - 496)) | (1 << (PostgreSQLParser.KW_REVERSE - 496)) | (1 << (PostgreSQLParser.KW_SLICE - 496)) | (1 << (PostgreSQLParser.KW_EXIT - 496)) | (1 << (PostgreSQLParser.KW_RETURN - 496)) | (1 << (PostgreSQLParser.KW_QUERY - 496)) | (1 << (PostgreSQLParser.KW_RAISE - 496)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 496)) | (1 << (PostgreSQLParser.KW_DEBUG - 496)) | (1 << (PostgreSQLParser.KW_LOG - 496)) | (1 << (PostgreSQLParser.KW_INFO - 496)) | (1 << (PostgreSQLParser.KW_NOTICE - 496)) | (1 << (PostgreSQLParser.KW_WARNING - 496)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 496)) | (1 << (PostgreSQLParser.KW_ASSERT - 496)) | (1 << (PostgreSQLParser.KW_OPEN - 496)) | (1 << (PostgreSQLParser.Identifier - 496)) | (1 << (PostgreSQLParser.QuotedIdentifier - 496)))) !== 0) || ((((_la - 530)) & ~0x1F) === 0 && ((1 << (_la - 530)) & ((1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 530)) | (1 << (PostgreSQLParser.StringConstant - 530)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 530)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 530)) | (1 << (PostgreSQLParser.Integral - 530)) | (1 << (PostgreSQLParser.Numeric - 530)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 530)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 530)) | (1 << (PostgreSQLParser.EscapeStringConstant - 530)))) !== 0)) { { - this.state = 7931; + this.state = 8013; this.explain_option_arg(); } } @@ -37358,422 +38244,422 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public explain_option_name(): Explain_option_nameContext { let _localctx: Explain_option_nameContext = new Explain_option_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 884, PostgreSQLParser.RULE_explain_option_name); + this.enterRule(_localctx, 898, PostgreSQLParser.RULE_explain_option_name); try { - this.state = 7936; + this.state = 8018; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -37781,15 +38667,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 7934; + this.state = 8016; this.nonreservedword(); } break; - case PostgreSQLParser.ANALYSE: - case PostgreSQLParser.ANALYZE: + case PostgreSQLParser.KW_ANALYSE: + case PostgreSQLParser.KW_ANALYZE: this.enterOuterAlt(_localctx, 2); { - this.state = 7935; + this.state = 8017; this.analyze_keyword(); } break; @@ -37814,425 +38700,425 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public explain_option_arg(): Explain_option_argContext { let _localctx: Explain_option_argContext = new Explain_option_argContext(this._ctx, this.state); - this.enterRule(_localctx, 886, PostgreSQLParser.RULE_explain_option_arg); + this.enterRule(_localctx, 900, PostgreSQLParser.RULE_explain_option_arg); try { - this.state = 7940; + this.state = 8022; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_ON: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -38244,7 +39130,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 7938; + this.state = 8020; this.opt_boolean_or_string(); } break; @@ -38254,7 +39140,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.Numeric: this.enterOuterAlt(_localctx, 2); { - this.state = 7939; + this.state = 8021; this.numericonly(); } break; @@ -38279,28 +39165,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public preparestmt(): PreparestmtContext { let _localctx: PreparestmtContext = new PreparestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 888, PostgreSQLParser.RULE_preparestmt); + this.enterRule(_localctx, 902, PostgreSQLParser.RULE_preparestmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 7942; - this.match(PostgreSQLParser.PREPARE); - this.state = 7943; + this.state = 8024; + this.match(PostgreSQLParser.KW_PREPARE); + this.state = 8025; this.name(); - this.state = 7945; + this.state = 8027; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 7944; + this.state = 8026; this.prep_type_clause(); } } - this.state = 7947; - this.match(PostgreSQLParser.AS); - this.state = 7948; + this.state = 8029; + this.match(PostgreSQLParser.KW_AS); + this.state = 8030; this.preparablestmt(); } } @@ -38321,15 +39207,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public prep_type_clause(): Prep_type_clauseContext { let _localctx: Prep_type_clauseContext = new Prep_type_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 890, PostgreSQLParser.RULE_prep_type_clause); + this.enterRule(_localctx, 904, PostgreSQLParser.RULE_prep_type_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 7950; + this.state = 8032; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 7951; + this.state = 8033; this.type_list(); - this.state = 7952; + this.state = 8034; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -38350,15 +39236,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public preparablestmt(): PreparablestmtContext { let _localctx: PreparablestmtContext = new PreparablestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 892, PostgreSQLParser.RULE_preparablestmt); + this.enterRule(_localctx, 906, PostgreSQLParser.RULE_preparablestmt); try { - this.state = 7958; + this.state = 8040; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 650, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 662, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7954; + this.state = 8036; this.selectstmt(); } break; @@ -38366,7 +39252,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7955; + this.state = 8037; this.insertstmt(); } break; @@ -38374,7 +39260,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7956; + this.state = 8038; this.updatestmt(); } break; @@ -38382,7 +39268,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 7957; + this.state = 8039; this.deletestmt(); } break; @@ -38405,25 +39291,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public executestmt(): ExecutestmtContext { let _localctx: ExecutestmtContext = new ExecutestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 894, PostgreSQLParser.RULE_executestmt); + this.enterRule(_localctx, 908, PostgreSQLParser.RULE_executestmt); let _la: number; try { - this.state = 7998; + this.state = 8080; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 658, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 670, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 7960; - this.match(PostgreSQLParser.EXECUTE); - this.state = 7961; + this.state = 8042; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 8043; this.name(); - this.state = 7963; + this.state = 8045; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 651, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 663, this._ctx) ) { case 1: { - this.state = 7962; + this.state = 8044; this.execute_param_clause(); } break; @@ -38434,44 +39320,44 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 7965; - this.match(PostgreSQLParser.CREATE); - this.state = 7967; + this.state = 8047; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 8049; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GLOBAL || _la === PostgreSQLParser.LOCAL || ((((_la - 343)) & ~0x1F) === 0 && ((1 << (_la - 343)) & ((1 << (PostgreSQLParser.TEMP - 343)) | (1 << (PostgreSQLParser.TEMPORARY - 343)) | (1 << (PostgreSQLParser.UNLOGGED - 343)))) !== 0)) { + if (_la === PostgreSQLParser.KW_GLOBAL || _la === PostgreSQLParser.KW_LOCAL || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & ((1 << (PostgreSQLParser.KW_TEMP - 352)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 352)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 352)))) !== 0)) { { - this.state = 7966; + this.state = 8048; this.opttemp(); } } - this.state = 7969; - this.match(PostgreSQLParser.TABLE); - this.state = 7970; + this.state = 8051; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 8052; this.create_as_target(); - this.state = 7971; - this.match(PostgreSQLParser.AS); - this.state = 7972; - this.match(PostgreSQLParser.EXECUTE); - this.state = 7973; + this.state = 8053; + this.match(PostgreSQLParser.KW_AS); + this.state = 8054; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 8055; this.name(); - this.state = 7975; + this.state = 8057; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 653, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 665, this._ctx) ) { case 1: { - this.state = 7974; + this.state = 8056; this.execute_param_clause(); } break; } - this.state = 7978; + this.state = 8060; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 654, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 666, this._ctx) ) { case 1: { - this.state = 7977; + this.state = 8059; this.opt_with_data(); } break; @@ -38482,50 +39368,50 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 7980; - this.match(PostgreSQLParser.CREATE); - this.state = 7982; + this.state = 8062; + this.match(PostgreSQLParser.KW_CREATE); + this.state = 8064; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GLOBAL || _la === PostgreSQLParser.LOCAL || ((((_la - 343)) & ~0x1F) === 0 && ((1 << (_la - 343)) & ((1 << (PostgreSQLParser.TEMP - 343)) | (1 << (PostgreSQLParser.TEMPORARY - 343)) | (1 << (PostgreSQLParser.UNLOGGED - 343)))) !== 0)) { + if (_la === PostgreSQLParser.KW_GLOBAL || _la === PostgreSQLParser.KW_LOCAL || ((((_la - 352)) & ~0x1F) === 0 && ((1 << (_la - 352)) & ((1 << (PostgreSQLParser.KW_TEMP - 352)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 352)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 352)))) !== 0)) { { - this.state = 7981; + this.state = 8063; this.opttemp(); } } - this.state = 7984; - this.match(PostgreSQLParser.TABLE); - this.state = 7985; - this.match(PostgreSQLParser.IF_P); - this.state = 7986; - this.match(PostgreSQLParser.NOT); - this.state = 7987; - this.match(PostgreSQLParser.EXISTS); - this.state = 7988; + this.state = 8066; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 8067; + this.match(PostgreSQLParser.KW_IF); + this.state = 8068; + this.match(PostgreSQLParser.KW_NOT); + this.state = 8069; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 8070; this.create_as_target(); - this.state = 7989; - this.match(PostgreSQLParser.AS); - this.state = 7990; - this.match(PostgreSQLParser.EXECUTE); - this.state = 7991; + this.state = 8071; + this.match(PostgreSQLParser.KW_AS); + this.state = 8072; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 8073; this.name(); - this.state = 7993; + this.state = 8075; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 656, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 668, this._ctx) ) { case 1: { - this.state = 7992; + this.state = 8074; this.execute_param_clause(); } break; } - this.state = 7996; + this.state = 8078; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 657, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 669, this._ctx) ) { case 1: { - this.state = 7995; + this.state = 8077; this.opt_with_data(); } break; @@ -38551,15 +39437,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public execute_param_clause(): Execute_param_clauseContext { let _localctx: Execute_param_clauseContext = new Execute_param_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 896, PostgreSQLParser.RULE_execute_param_clause); + this.enterRule(_localctx, 910, PostgreSQLParser.RULE_execute_param_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8000; + this.state = 8082; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8001; + this.state = 8083; this.expr_list(); - this.state = 8002; + this.state = 8084; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -38580,17 +39466,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public deallocatestmt(): DeallocatestmtContext { let _localctx: DeallocatestmtContext = new DeallocatestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 898, PostgreSQLParser.RULE_deallocatestmt); + this.enterRule(_localctx, 912, PostgreSQLParser.RULE_deallocatestmt); try { - this.state = 8014; + this.state = 8096; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 659, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 671, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8004; - this.match(PostgreSQLParser.DEALLOCATE); - this.state = 8005; + this.state = 8086; + this.match(PostgreSQLParser.KW_DEALLOCATE); + this.state = 8087; this.name(); } break; @@ -38598,11 +39484,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8006; - this.match(PostgreSQLParser.DEALLOCATE); - this.state = 8007; - this.match(PostgreSQLParser.PREPARE); - this.state = 8008; + this.state = 8088; + this.match(PostgreSQLParser.KW_DEALLOCATE); + this.state = 8089; + this.match(PostgreSQLParser.KW_PREPARE); + this.state = 8090; this.name(); } break; @@ -38610,22 +39496,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 8009; - this.match(PostgreSQLParser.DEALLOCATE); - this.state = 8010; - this.match(PostgreSQLParser.ALL); + this.state = 8091; + this.match(PostgreSQLParser.KW_DEALLOCATE); + this.state = 8092; + this.match(PostgreSQLParser.KW_ALL); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 8011; - this.match(PostgreSQLParser.DEALLOCATE); - this.state = 8012; - this.match(PostgreSQLParser.PREPARE); - this.state = 8013; - this.match(PostgreSQLParser.ALL); + this.state = 8093; + this.match(PostgreSQLParser.KW_DEALLOCATE); + this.state = 8094; + this.match(PostgreSQLParser.KW_PREPARE); + this.state = 8095; + this.match(PostgreSQLParser.KW_ALL); } break; } @@ -38647,45 +39533,45 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public insertstmt(): InsertstmtContext { let _localctx: InsertstmtContext = new InsertstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 900, PostgreSQLParser.RULE_insertstmt); + this.enterRule(_localctx, 914, PostgreSQLParser.RULE_insertstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8017; + this.state = 8099; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH) { + if (_la === PostgreSQLParser.KW_WITH) { { - this.state = 8016; + this.state = 8098; this.opt_with_clause(); } } - this.state = 8019; - this.match(PostgreSQLParser.INSERT); - this.state = 8020; - this.match(PostgreSQLParser.INTO); - this.state = 8021; + this.state = 8101; + this.match(PostgreSQLParser.KW_INSERT); + this.state = 8102; + this.match(PostgreSQLParser.KW_INTO); + this.state = 8103; this.insert_target(); - this.state = 8022; + this.state = 8104; this.insert_rest(); - this.state = 8024; + this.state = 8106; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ON) { + if (_la === PostgreSQLParser.KW_ON) { { - this.state = 8023; + this.state = 8105; this.opt_on_conflict(); } } - this.state = 8027; + this.state = 8109; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.RETURNING) { + if (_la === PostgreSQLParser.KW_RETURNING) { { - this.state = 8026; + this.state = 8108; this.returning_clause(); } } @@ -38709,21 +39595,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public insert_target(): Insert_targetContext { let _localctx: Insert_targetContext = new Insert_targetContext(this._ctx, this.state); - this.enterRule(_localctx, 902, PostgreSQLParser.RULE_insert_target); + this.enterRule(_localctx, 916, PostgreSQLParser.RULE_insert_target); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8029; + this.state = 8111; this.qualified_name(); - this.state = 8032; + this.state = 8114; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 8030; - this.match(PostgreSQLParser.AS); - this.state = 8031; + this.state = 8112; + this.match(PostgreSQLParser.KW_AS); + this.state = 8113; this.colid(); } } @@ -38747,16 +39633,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public insert_rest(): Insert_restContext { let _localctx: Insert_restContext = new Insert_restContext(this._ctx, this.state); - this.enterRule(_localctx, 904, PostgreSQLParser.RULE_insert_rest); + this.enterRule(_localctx, 918, PostgreSQLParser.RULE_insert_rest); let _la: number; try { - this.state = 8053; + this.state = 8135; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 665, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 677, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8034; + this.state = 8116; this.selectstmt(); } break; @@ -38764,13 +39650,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8035; - this.match(PostgreSQLParser.OVERRIDING); - this.state = 8036; + this.state = 8117; + this.match(PostgreSQLParser.KW_OVERRIDING); + this.state = 8118; this.override_kind(); - this.state = 8037; - this.match(PostgreSQLParser.VALUE_P); - this.state = 8038; + this.state = 8119; + this.match(PostgreSQLParser.KW_VALUE); + this.state = 8120; this.selectstmt(); } break; @@ -38778,27 +39664,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 8040; + this.state = 8122; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8041; + this.state = 8123; this.insert_column_list(); - this.state = 8042; + this.state = 8124; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 8047; + this.state = 8129; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OVERRIDING) { + if (_la === PostgreSQLParser.KW_OVERRIDING) { { - this.state = 8043; - this.match(PostgreSQLParser.OVERRIDING); - this.state = 8044; + this.state = 8125; + this.match(PostgreSQLParser.KW_OVERRIDING); + this.state = 8126; this.override_kind(); - this.state = 8045; - this.match(PostgreSQLParser.VALUE_P); + this.state = 8127; + this.match(PostgreSQLParser.KW_VALUE); } } - this.state = 8049; + this.state = 8131; this.selectstmt(); } break; @@ -38806,10 +39692,10 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 8051; - this.match(PostgreSQLParser.DEFAULT); - this.state = 8052; - this.match(PostgreSQLParser.VALUES); + this.state = 8133; + this.match(PostgreSQLParser.KW_DEFAULT); + this.state = 8134; + this.match(PostgreSQLParser.KW_VALUES); } break; } @@ -38831,14 +39717,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public override_kind(): Override_kindContext { let _localctx: Override_kindContext = new Override_kindContext(this._ctx, this.state); - this.enterRule(_localctx, 906, PostgreSQLParser.RULE_override_kind); + this.enterRule(_localctx, 920, PostgreSQLParser.RULE_override_kind); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8055; + this.state = 8137; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.USER || _la === PostgreSQLParser.SYSTEM_P)) { + if (!(_la === PostgreSQLParser.KW_USER || _la === PostgreSQLParser.KW_SYSTEM)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -38867,26 +39753,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public insert_column_list(): Insert_column_listContext { let _localctx: Insert_column_listContext = new Insert_column_listContext(this._ctx, this.state); - this.enterRule(_localctx, 908, PostgreSQLParser.RULE_insert_column_list); + this.enterRule(_localctx, 922, PostgreSQLParser.RULE_insert_column_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8057; + this.state = 8139; this.insert_column_item(); - this.state = 8062; + this.state = 8144; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8058; + this.state = 8140; this.match(PostgreSQLParser.COMMA); - this.state = 8059; + this.state = 8141; this.insert_column_item(); } } - this.state = 8064; + this.state = 8146; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -38909,13 +39795,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public insert_column_item(): Insert_column_itemContext { let _localctx: Insert_column_itemContext = new Insert_column_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 910, PostgreSQLParser.RULE_insert_column_item); + this.enterRule(_localctx, 924, PostgreSQLParser.RULE_insert_column_item); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8065; + this.state = 8147; this.colid(); - this.state = 8066; + this.state = 8148; this.opt_indirection(); } } @@ -38936,54 +39822,54 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_on_conflict(): Opt_on_conflictContext { let _localctx: Opt_on_conflictContext = new Opt_on_conflictContext(this._ctx, this.state); - this.enterRule(_localctx, 912, PostgreSQLParser.RULE_opt_on_conflict); + this.enterRule(_localctx, 926, PostgreSQLParser.RULE_opt_on_conflict); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8068; - this.match(PostgreSQLParser.ON); - this.state = 8069; - this.match(PostgreSQLParser.CONFLICT); - this.state = 8071; + this.state = 8150; + this.match(PostgreSQLParser.KW_ON); + this.state = 8151; + this.match(PostgreSQLParser.KW_CONFLICT); + this.state = 8153; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OPEN_PAREN || _la === PostgreSQLParser.ON) { + if (_la === PostgreSQLParser.OPEN_PAREN || _la === PostgreSQLParser.KW_ON) { { - this.state = 8070; + this.state = 8152; this.opt_conf_expr(); } } - this.state = 8073; - this.match(PostgreSQLParser.DO); - this.state = 8081; + this.state = 8155; + this.match(PostgreSQLParser.KW_DO); + this.state = 8163; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.UPDATE: + case PostgreSQLParser.KW_UPDATE: { - this.state = 8074; - this.match(PostgreSQLParser.UPDATE); - this.state = 8075; - this.match(PostgreSQLParser.SET); - this.state = 8076; + this.state = 8156; + this.match(PostgreSQLParser.KW_UPDATE); + this.state = 8157; + this.match(PostgreSQLParser.KW_SET); + this.state = 8158; this.set_clause_list(); - this.state = 8078; + this.state = 8160; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 8077; + this.state = 8159; this.where_clause(); } } } break; - case PostgreSQLParser.NOTHING: + case PostgreSQLParser.KW_NOTHING: { - this.state = 8080; - this.match(PostgreSQLParser.NOTHING); + this.state = 8162; + this.match(PostgreSQLParser.KW_NOTHING); } break; default: @@ -39008,41 +39894,41 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_conf_expr(): Opt_conf_exprContext { let _localctx: Opt_conf_exprContext = new Opt_conf_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 914, PostgreSQLParser.RULE_opt_conf_expr); + this.enterRule(_localctx, 928, PostgreSQLParser.RULE_opt_conf_expr); let _la: number; try { - this.state = 8092; + this.state = 8174; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: this.enterOuterAlt(_localctx, 1); { - this.state = 8083; + this.state = 8165; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8084; + this.state = 8166; this.index_params(); - this.state = 8085; + this.state = 8167; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 8087; + this.state = 8169; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 8086; + this.state = 8168; this.where_clause(); } } } break; - case PostgreSQLParser.ON: + case PostgreSQLParser.KW_ON: this.enterOuterAlt(_localctx, 2); { - this.state = 8089; - this.match(PostgreSQLParser.ON); - this.state = 8090; - this.match(PostgreSQLParser.CONSTRAINT); - this.state = 8091; + this.state = 8171; + this.match(PostgreSQLParser.KW_ON); + this.state = 8172; + this.match(PostgreSQLParser.KW_CONSTRAINT); + this.state = 8173; this.name(); } break; @@ -39067,13 +39953,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public returning_clause(): Returning_clauseContext { let _localctx: Returning_clauseContext = new Returning_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 916, PostgreSQLParser.RULE_returning_clause); + this.enterRule(_localctx, 930, PostgreSQLParser.RULE_returning_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8094; - this.match(PostgreSQLParser.RETURNING); - this.state = 8095; + this.state = 8176; + this.match(PostgreSQLParser.KW_RETURNING); + this.state = 8177; this.target_list(); } } @@ -39094,53 +39980,53 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public deletestmt(): DeletestmtContext { let _localctx: DeletestmtContext = new DeletestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 918, PostgreSQLParser.RULE_deletestmt); + this.enterRule(_localctx, 932, PostgreSQLParser.RULE_deletestmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8098; + this.state = 8180; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH) { + if (_la === PostgreSQLParser.KW_WITH) { { - this.state = 8097; + this.state = 8179; this.opt_with_clause(); } } - this.state = 8100; - this.match(PostgreSQLParser.DELETE_P); - this.state = 8101; - this.match(PostgreSQLParser.FROM); - this.state = 8102; + this.state = 8182; + this.match(PostgreSQLParser.KW_DELETE); + this.state = 8183; + this.match(PostgreSQLParser.KW_FROM); + this.state = 8184; this.relation_expr_opt_alias(); - this.state = 8104; + this.state = 8186; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.USING) { + if (_la === PostgreSQLParser.KW_USING) { { - this.state = 8103; + this.state = 8185; this.using_clause(); } } - this.state = 8107; + this.state = 8189; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 8106; + this.state = 8188; this.where_or_current_clause(); } } - this.state = 8110; + this.state = 8192; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.RETURNING) { + if (_la === PostgreSQLParser.KW_RETURNING) { { - this.state = 8109; + this.state = 8191; this.returning_clause(); } } @@ -39164,13 +40050,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public using_clause(): Using_clauseContext { let _localctx: Using_clauseContext = new Using_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 920, PostgreSQLParser.RULE_using_clause); + this.enterRule(_localctx, 934, PostgreSQLParser.RULE_using_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8112; - this.match(PostgreSQLParser.USING); - this.state = 8113; + this.state = 8194; + this.match(PostgreSQLParser.KW_USING); + this.state = 8195; this.from_list(); } } @@ -39191,41 +40077,41 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public lockstmt(): LockstmtContext { let _localctx: LockstmtContext = new LockstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 922, PostgreSQLParser.RULE_lockstmt); + this.enterRule(_localctx, 936, PostgreSQLParser.RULE_lockstmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8115; - this.match(PostgreSQLParser.LOCK_P); - this.state = 8117; + this.state = 8197; + this.match(PostgreSQLParser.KW_LOCK); + this.state = 8199; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 676, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 688, this._ctx) ) { case 1: { - this.state = 8116; + this.state = 8198; this.opt_table(); } break; } - this.state = 8119; + this.state = 8201; this.relation_expr_list(); - this.state = 8121; + this.state = 8203; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.IN_P) { + if (_la === PostgreSQLParser.KW_IN) { { - this.state = 8120; + this.state = 8202; this.opt_lock(); } } - this.state = 8124; + this.state = 8206; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOWAIT) { + if (_la === PostgreSQLParser.KW_NOWAIT) { { - this.state = 8123; + this.state = 8205; this.opt_nowait(); } } @@ -39249,16 +40135,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_lock(): Opt_lockContext { let _localctx: Opt_lockContext = new Opt_lockContext(this._ctx, this.state); - this.enterRule(_localctx, 924, PostgreSQLParser.RULE_opt_lock); + this.enterRule(_localctx, 938, PostgreSQLParser.RULE_opt_lock); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8126; - this.match(PostgreSQLParser.IN_P); - this.state = 8127; + this.state = 8208; + this.match(PostgreSQLParser.KW_IN); + this.state = 8209; this.lock_type(); - this.state = 8128; - this.match(PostgreSQLParser.MODE); + this.state = 8210; + this.match(PostgreSQLParser.KW_MODE); } } catch (re) { @@ -39278,20 +40164,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public lock_type(): Lock_typeContext { let _localctx: Lock_typeContext = new Lock_typeContext(this._ctx, this.state); - this.enterRule(_localctx, 926, PostgreSQLParser.RULE_lock_type); + this.enterRule(_localctx, 940, PostgreSQLParser.RULE_lock_type); let _la: number; try { - this.state = 8142; + this.state = 8224; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.ACCESS: + case PostgreSQLParser.KW_ACCESS: this.enterOuterAlt(_localctx, 1); { - this.state = 8130; - this.match(PostgreSQLParser.ACCESS); - this.state = 8131; + this.state = 8212; + this.match(PostgreSQLParser.KW_ACCESS); + this.state = 8213; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.EXCLUSIVE || _la === PostgreSQLParser.SHARE)) { + if (!(_la === PostgreSQLParser.KW_EXCLUSIVE || _la === PostgreSQLParser.KW_SHARE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -39303,14 +40189,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.ROW: + case PostgreSQLParser.KW_ROW: this.enterOuterAlt(_localctx, 2); { - this.state = 8132; - this.match(PostgreSQLParser.ROW); - this.state = 8133; + this.state = 8214; + this.match(PostgreSQLParser.KW_ROW); + this.state = 8215; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.EXCLUSIVE || _la === PostgreSQLParser.SHARE)) { + if (!(_la === PostgreSQLParser.KW_EXCLUSIVE || _la === PostgreSQLParser.KW_SHARE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -39322,42 +40208,42 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.SHARE: + case PostgreSQLParser.KW_SHARE: this.enterOuterAlt(_localctx, 3); { - this.state = 8134; - this.match(PostgreSQLParser.SHARE); - this.state = 8139; + this.state = 8216; + this.match(PostgreSQLParser.KW_SHARE); + this.state = 8221; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.UPDATE: + case PostgreSQLParser.KW_UPDATE: { - this.state = 8135; - this.match(PostgreSQLParser.UPDATE); - this.state = 8136; - this.match(PostgreSQLParser.EXCLUSIVE); + this.state = 8217; + this.match(PostgreSQLParser.KW_UPDATE); + this.state = 8218; + this.match(PostgreSQLParser.KW_EXCLUSIVE); } break; - case PostgreSQLParser.ROW: + case PostgreSQLParser.KW_ROW: { - this.state = 8137; - this.match(PostgreSQLParser.ROW); - this.state = 8138; - this.match(PostgreSQLParser.EXCLUSIVE); + this.state = 8219; + this.match(PostgreSQLParser.KW_ROW); + this.state = 8220; + this.match(PostgreSQLParser.KW_EXCLUSIVE); } break; - case PostgreSQLParser.MODE: + case PostgreSQLParser.KW_MODE: break; default: break; } } break; - case PostgreSQLParser.EXCLUSIVE: + case PostgreSQLParser.KW_EXCLUSIVE: this.enterOuterAlt(_localctx, 4); { - this.state = 8141; - this.match(PostgreSQLParser.EXCLUSIVE); + this.state = 8223; + this.match(PostgreSQLParser.KW_EXCLUSIVE); } break; default: @@ -39381,12 +40267,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_nowait(): Opt_nowaitContext { let _localctx: Opt_nowaitContext = new Opt_nowaitContext(this._ctx, this.state); - this.enterRule(_localctx, 928, PostgreSQLParser.RULE_opt_nowait); + this.enterRule(_localctx, 942, PostgreSQLParser.RULE_opt_nowait); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8144; - this.match(PostgreSQLParser.NOWAIT); + this.state = 8226; + this.match(PostgreSQLParser.KW_NOWAIT); } } catch (re) { @@ -39406,25 +40292,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_nowait_or_skip(): Opt_nowait_or_skipContext { let _localctx: Opt_nowait_or_skipContext = new Opt_nowait_or_skipContext(this._ctx, this.state); - this.enterRule(_localctx, 930, PostgreSQLParser.RULE_opt_nowait_or_skip); + this.enterRule(_localctx, 944, PostgreSQLParser.RULE_opt_nowait_or_skip); try { - this.state = 8149; + this.state = 8231; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.NOWAIT: + case PostgreSQLParser.KW_NOWAIT: this.enterOuterAlt(_localctx, 1); { - this.state = 8146; - this.match(PostgreSQLParser.NOWAIT); + this.state = 8228; + this.match(PostgreSQLParser.KW_NOWAIT); } break; - case PostgreSQLParser.SKIP_P: + case PostgreSQLParser.KW_SKIP: this.enterOuterAlt(_localctx, 2); { - this.state = 8147; - this.match(PostgreSQLParser.SKIP_P); - this.state = 8148; - this.match(PostgreSQLParser.LOCKED); + this.state = 8229; + this.match(PostgreSQLParser.KW_SKIP); + this.state = 8230; + this.match(PostgreSQLParser.KW_LOCKED); } break; default: @@ -39448,55 +40334,55 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public updatestmt(): UpdatestmtContext { let _localctx: UpdatestmtContext = new UpdatestmtContext(this._ctx, this.state); - this.enterRule(_localctx, 932, PostgreSQLParser.RULE_updatestmt); + this.enterRule(_localctx, 946, PostgreSQLParser.RULE_updatestmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8152; + this.state = 8234; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WITH) { + if (_la === PostgreSQLParser.KW_WITH) { { - this.state = 8151; + this.state = 8233; this.opt_with_clause(); } } - this.state = 8154; - this.match(PostgreSQLParser.UPDATE); - this.state = 8155; + this.state = 8236; + this.match(PostgreSQLParser.KW_UPDATE); + this.state = 8237; this.relation_expr_opt_alias(); - this.state = 8156; - this.match(PostgreSQLParser.SET); - this.state = 8157; + this.state = 8238; + this.match(PostgreSQLParser.KW_SET); + this.state = 8239; this.set_clause_list(); - this.state = 8159; + this.state = 8241; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM) { + if (_la === PostgreSQLParser.KW_FROM) { { - this.state = 8158; + this.state = 8240; this.from_clause(); } } - this.state = 8162; + this.state = 8244; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 8161; + this.state = 8243; this.where_or_current_clause(); } } - this.state = 8165; + this.state = 8247; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.RETURNING) { + if (_la === PostgreSQLParser.KW_RETURNING) { { - this.state = 8164; + this.state = 8246; this.returning_clause(); } } @@ -39520,26 +40406,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public set_clause_list(): Set_clause_listContext { let _localctx: Set_clause_listContext = new Set_clause_listContext(this._ctx, this.state); - this.enterRule(_localctx, 934, PostgreSQLParser.RULE_set_clause_list); + this.enterRule(_localctx, 948, PostgreSQLParser.RULE_set_clause_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8167; + this.state = 8249; this.set_clause(); - this.state = 8172; + this.state = 8254; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8168; + this.state = 8250; this.match(PostgreSQLParser.COMMA); - this.state = 8169; + this.state = 8251; this.set_clause(); } } - this.state = 8174; + this.state = 8256; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -39562,401 +40448,401 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public set_clause(): Set_clauseContext { let _localctx: Set_clauseContext = new Set_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 936, PostgreSQLParser.RULE_set_clause); + this.enterRule(_localctx, 950, PostgreSQLParser.RULE_set_clause); try { - this.state = 8185; + this.state = 8267; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -39964,26 +40850,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 8175; + this.state = 8257; this.set_target(); - this.state = 8176; + this.state = 8258; this.match(PostgreSQLParser.EQUAL); - this.state = 8177; + this.state = 8259; this.a_expr(); } break; case PostgreSQLParser.OPEN_PAREN: this.enterOuterAlt(_localctx, 2); { - this.state = 8179; + this.state = 8261; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8180; + this.state = 8262; this.set_target_list(); - this.state = 8181; + this.state = 8263; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 8182; + this.state = 8264; this.match(PostgreSQLParser.EQUAL); - this.state = 8183; + this.state = 8265; this.a_expr(); } break; @@ -40008,13 +40894,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public set_target(): Set_targetContext { let _localctx: Set_targetContext = new Set_targetContext(this._ctx, this.state); - this.enterRule(_localctx, 938, PostgreSQLParser.RULE_set_target); + this.enterRule(_localctx, 952, PostgreSQLParser.RULE_set_target); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8187; + this.state = 8269; this.colid(); - this.state = 8188; + this.state = 8270; this.opt_indirection(); } } @@ -40035,26 +40921,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public set_target_list(): Set_target_listContext { let _localctx: Set_target_listContext = new Set_target_listContext(this._ctx, this.state); - this.enterRule(_localctx, 940, PostgreSQLParser.RULE_set_target_list); + this.enterRule(_localctx, 954, PostgreSQLParser.RULE_set_target_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8190; + this.state = 8272; this.set_target(); - this.state = 8195; + this.state = 8277; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8191; + this.state = 8273; this.match(PostgreSQLParser.COMMA); - this.state = 8192; + this.state = 8274; this.set_target(); } } - this.state = 8197; + this.state = 8279; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -40077,23 +40963,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public declarecursorstmt(): DeclarecursorstmtContext { let _localctx: DeclarecursorstmtContext = new DeclarecursorstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 942, PostgreSQLParser.RULE_declarecursorstmt); + this.enterRule(_localctx, 956, PostgreSQLParser.RULE_declarecursorstmt); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8198; - this.match(PostgreSQLParser.DECLARE); - this.state = 8199; + this.state = 8280; + this.match(PostgreSQLParser.KW_DECLARE); + this.state = 8281; this.cursor_name(); - this.state = 8200; + this.state = 8282; this.cursor_options(); - this.state = 8201; - this.match(PostgreSQLParser.CURSOR); - this.state = 8202; + this.state = 8283; + this.match(PostgreSQLParser.KW_CURSOR); + this.state = 8284; this.opt_hold(); - this.state = 8203; - this.match(PostgreSQLParser.FOR); - this.state = 8204; + this.state = 8285; + this.match(PostgreSQLParser.KW_FOR); + this.state = 8286; this.selectstmt(); } } @@ -40114,11 +41000,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public cursor_name(): Cursor_nameContext { let _localctx: Cursor_nameContext = new Cursor_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 944, PostgreSQLParser.RULE_cursor_name); + this.enterRule(_localctx, 958, PostgreSQLParser.RULE_cursor_name); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8206; + this.state = 8288; this.name(); } } @@ -40139,50 +41025,50 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public cursor_options(): Cursor_optionsContext { let _localctx: Cursor_optionsContext = new Cursor_optionsContext(this._ctx, this.state); - this.enterRule(_localctx, 946, PostgreSQLParser.RULE_cursor_options); + this.enterRule(_localctx, 960, PostgreSQLParser.RULE_cursor_options); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8215; + this.state = 8297; this._errHandler.sync(this); _la = this._input.LA(1); - while (_la === PostgreSQLParser.BINARY || _la === PostgreSQLParser.INSENSITIVE || _la === PostgreSQLParser.NO || _la === PostgreSQLParser.SCROLL) { + while (_la === PostgreSQLParser.KW_BINARY || _la === PostgreSQLParser.KW_INSENSITIVE || _la === PostgreSQLParser.KW_NO || _la === PostgreSQLParser.KW_SCROLL) { { - this.state = 8213; + this.state = 8295; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.NO: + case PostgreSQLParser.KW_NO: { - this.state = 8208; - this.match(PostgreSQLParser.NO); - this.state = 8209; - this.match(PostgreSQLParser.SCROLL); + this.state = 8290; + this.match(PostgreSQLParser.KW_NO); + this.state = 8291; + this.match(PostgreSQLParser.KW_SCROLL); } break; - case PostgreSQLParser.SCROLL: + case PostgreSQLParser.KW_SCROLL: { - this.state = 8210; - this.match(PostgreSQLParser.SCROLL); + this.state = 8292; + this.match(PostgreSQLParser.KW_SCROLL); } break; - case PostgreSQLParser.BINARY: + case PostgreSQLParser.KW_BINARY: { - this.state = 8211; - this.match(PostgreSQLParser.BINARY); + this.state = 8293; + this.match(PostgreSQLParser.KW_BINARY); } break; - case PostgreSQLParser.INSENSITIVE: + case PostgreSQLParser.KW_INSENSITIVE: { - this.state = 8212; - this.match(PostgreSQLParser.INSENSITIVE); + this.state = 8294; + this.match(PostgreSQLParser.KW_INSENSITIVE); } break; default: throw new NoViableAltException(this); } } - this.state = 8217; + this.state = 8299; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -40205,33 +41091,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_hold(): Opt_holdContext { let _localctx: Opt_holdContext = new Opt_holdContext(this._ctx, this.state); - this.enterRule(_localctx, 948, PostgreSQLParser.RULE_opt_hold); + this.enterRule(_localctx, 962, PostgreSQLParser.RULE_opt_hold); try { - this.state = 8223; + this.state = 8305; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.FOR: + case PostgreSQLParser.KW_FOR: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.WITH: + case PostgreSQLParser.KW_WITH: this.enterOuterAlt(_localctx, 2); { - this.state = 8219; - this.match(PostgreSQLParser.WITH); - this.state = 8220; - this.match(PostgreSQLParser.HOLD); + this.state = 8301; + this.match(PostgreSQLParser.KW_WITH); + this.state = 8302; + this.match(PostgreSQLParser.KW_HOLD); } break; - case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.KW_WITHOUT: this.enterOuterAlt(_localctx, 3); { - this.state = 8221; - this.match(PostgreSQLParser.WITHOUT); - this.state = 8222; - this.match(PostgreSQLParser.HOLD); + this.state = 8303; + this.match(PostgreSQLParser.KW_WITHOUT); + this.state = 8304; + this.match(PostgreSQLParser.KW_HOLD); } break; default: @@ -40255,15 +41141,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public selectstmt(): SelectstmtContext { let _localctx: SelectstmtContext = new SelectstmtContext(this._ctx, this.state); - this.enterRule(_localctx, 950, PostgreSQLParser.RULE_selectstmt); + this.enterRule(_localctx, 964, PostgreSQLParser.RULE_selectstmt); try { - this.state = 8227; + this.state = 8309; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 692, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 704, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8225; + this.state = 8307; this.select_no_parens(); } break; @@ -40271,7 +41157,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8226; + this.state = 8308; this.select_with_parens(); } break; @@ -40294,19 +41180,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public select_with_parens(): Select_with_parensContext { let _localctx: Select_with_parensContext = new Select_with_parensContext(this._ctx, this.state); - this.enterRule(_localctx, 952, PostgreSQLParser.RULE_select_with_parens); + this.enterRule(_localctx, 966, PostgreSQLParser.RULE_select_with_parens); try { - this.state = 8237; + this.state = 8319; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 693, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 705, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8229; + this.state = 8311; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8230; + this.state = 8312; this.select_no_parens(); - this.state = 8231; + this.state = 8313; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -40314,11 +41200,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8233; + this.state = 8315; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8234; + this.state = 8316; this.select_with_parens(); - this.state = 8235; + this.state = 8317; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -40341,43 +41227,43 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public select_no_parens(): Select_no_parensContext { let _localctx: Select_no_parensContext = new Select_no_parensContext(this._ctx, this.state); - this.enterRule(_localctx, 954, PostgreSQLParser.RULE_select_no_parens); + this.enterRule(_localctx, 968, PostgreSQLParser.RULE_select_no_parens); let _la: number; try { - this.state = 8268; + this.state = 8350; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: - case PostgreSQLParser.SELECT: - case PostgreSQLParser.TABLE: - case PostgreSQLParser.VALUES: + case PostgreSQLParser.KW_SELECT: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_VALUES: this.enterOuterAlt(_localctx, 1); { - this.state = 8239; + this.state = 8321; this.select_clause(); - this.state = 8241; + this.state = 8323; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ORDER) { + if (_la === PostgreSQLParser.KW_ORDER) { { - this.state = 8240; + this.state = 8322; this.opt_sort_clause(); } } - this.state = 8251; + this.state = 8333; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 697, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 709, this._ctx) ) { case 1: { - this.state = 8243; + this.state = 8325; this.for_locking_clause(); - this.state = 8245; + this.state = 8327; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 695, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 707, this._ctx) ) { case 1: { - this.state = 8244; + this.state = 8326; this.opt_select_limit(); } break; @@ -40387,14 +41273,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: { - this.state = 8247; + this.state = 8329; this.select_limit(); - this.state = 8249; + this.state = 8331; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 8248; + this.state = 8330; this.opt_for_locking_clause(); } } @@ -40404,36 +41290,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - case PostgreSQLParser.WITH: + case PostgreSQLParser.KW_WITH: this.enterOuterAlt(_localctx, 2); { - this.state = 8253; + this.state = 8335; this.with_clause(); - this.state = 8254; + this.state = 8336; this.select_clause(); - this.state = 8256; + this.state = 8338; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ORDER) { + if (_la === PostgreSQLParser.KW_ORDER) { { - this.state = 8255; + this.state = 8337; this.opt_sort_clause(); } } - this.state = 8266; + this.state = 8348; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 701, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 713, this._ctx) ) { case 1: { - this.state = 8258; + this.state = 8340; this.for_locking_clause(); - this.state = 8260; + this.state = 8342; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 699, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 711, this._ctx) ) { case 1: { - this.state = 8259; + this.state = 8341; this.opt_select_limit(); } break; @@ -40443,14 +41329,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: { - this.state = 8262; + this.state = 8344; this.select_limit(); - this.state = 8264; + this.state = 8346; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 8263; + this.state = 8345; this.opt_for_locking_clause(); } } @@ -40481,15 +41367,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public select_clause(): Select_clauseContext { let _localctx: Select_clauseContext = new Select_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 956, PostgreSQLParser.RULE_select_clause); + this.enterRule(_localctx, 970, PostgreSQLParser.RULE_select_clause); try { - this.state = 8272; + this.state = 8354; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 703, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 715, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8270; + this.state = 8352; this.simple_select(); } break; @@ -40497,7 +41383,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8271; + this.state = 8353; this.select_with_parens(); } break; @@ -40520,636 +41406,177 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public simple_select(): Simple_selectContext { let _localctx: Simple_selectContext = new Simple_selectContext(this._ctx, this.state); - this.enterRule(_localctx, 958, PostgreSQLParser.RULE_simple_select); + this.enterRule(_localctx, 972, PostgreSQLParser.RULE_simple_select); let _la: number; try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 8316; + this.state = 8401; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.SELECT: + case PostgreSQLParser.KW_SELECT: { - this.state = 8274; - this.match(PostgreSQLParser.SELECT); - this.state = 8287; + this.state = 8356; + this.match(PostgreSQLParser.KW_SELECT); + this.state = 8372; 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: + switch ( this.interpreter.adaptivePredict(this._input, 721, this._ctx) ) { + case 1: { - this.state = 8276; + this.state = 8358; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ALL) { + if (_la === PostgreSQLParser.KW_ALL) { { - this.state = 8275; + this.state = 8357; this.opt_all_clause(); } } - this.state = 8279; + this.state = 8361; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 705, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 717, this._ctx) ) { case 1: { - this.state = 8278; + this.state = 8360; this.into_clause(); } break; } - this.state = 8282; + this.state = 8364; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 706, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 718, this._ctx) ) { case 1: { - this.state = 8281; + this.state = 8363; this.opt_target_list(); } break; } } break; - case PostgreSQLParser.DISTINCT: + + case 2: { - this.state = 8284; - this.distinct_clause(); - this.state = 8285; - this.target_list(); + this.state = 8367; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_DISTINCT) { + { + this.state = 8366; + this.distinct_clause(); + } + } + + this.state = 8370; + this._errHandler.sync(this); + switch ( this.interpreter.adaptivePredict(this._input, 720, this._ctx) ) { + case 1: + { + this.state = 8369; + this.target_list(); + } + break; + } } break; - default: - throw new NoViableAltException(this); } - this.state = 8290; + this.state = 8375; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 708, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 722, this._ctx) ) { case 1: { - this.state = 8289; + this.state = 8374; this.into_clause(); } break; } - this.state = 8293; + this.state = 8378; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM) { + if (_la === PostgreSQLParser.KW_FROM) { { - this.state = 8292; + this.state = 8377; this.from_clause(); } } - this.state = 8296; + this.state = 8381; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 8295; + this.state = 8380; this.where_clause(); } } - this.state = 8299; + this.state = 8384; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GROUP_P) { + if (_la === PostgreSQLParser.KW_GROUP) { { - this.state = 8298; + this.state = 8383; this.group_clause(); } } - this.state = 8302; + this.state = 8387; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.HAVING) { + if (_la === PostgreSQLParser.KW_HAVING) { { - this.state = 8301; + this.state = 8386; this.having_clause(); } } - this.state = 8305; + this.state = 8390; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WINDOW) { + if (_la === PostgreSQLParser.KW_WINDOW) { { - this.state = 8304; + this.state = 8389; this.window_clause(); } } } break; - case PostgreSQLParser.VALUES: + case PostgreSQLParser.KW_VALUES: { - this.state = 8307; + this.state = 8392; this.values_clause(); } break; - case PostgreSQLParser.TABLE: + case PostgreSQLParser.KW_TABLE: { - this.state = 8308; - this.match(PostgreSQLParser.TABLE); - this.state = 8309; + this.state = 8393; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 8394; this.relation_expr(); } break; case PostgreSQLParser.OPEN_PAREN: { - this.state = 8310; + this.state = 8395; this.select_with_parens(); - this.state = 8311; + this.state = 8396; this.set_operator_with_all_or_distinct(); - this.state = 8314; + this.state = 8399; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 714, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 728, this._ctx) ) { case 1: { - this.state = 8312; + this.state = 8397; this.simple_select(); } break; case 2: { - this.state = 8313; + this.state = 8398; this.select_with_parens(); } break; @@ -41159,28 +41586,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 8325; + this.state = 8410; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 717, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 731, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 8318; + this.state = 8403; this.set_operator_with_all_or_distinct(); - this.state = 8321; + this.state = 8406; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 716, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 730, this._ctx) ) { case 1: { - this.state = 8319; + this.state = 8404; this.simple_select(); } break; case 2: { - this.state = 8320; + this.state = 8405; this.select_with_parens(); } break; @@ -41188,9 +41615,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } } - this.state = 8327; + this.state = 8412; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 717, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 731, this._ctx); } } } @@ -41211,33 +41638,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public set_operator(): Set_operatorContext { let _localctx: Set_operatorContext = new Set_operatorContext(this._ctx, this.state); - this.enterRule(_localctx, 960, PostgreSQLParser.RULE_set_operator); + this.enterRule(_localctx, 974, PostgreSQLParser.RULE_set_operator); try { - this.state = 8331; + this.state = 8416; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.UNION: + case PostgreSQLParser.KW_UNION: _localctx = new UnionContext(_localctx); this.enterOuterAlt(_localctx, 1); { - this.state = 8328; - this.match(PostgreSQLParser.UNION); + this.state = 8413; + this.match(PostgreSQLParser.KW_UNION); } break; - case PostgreSQLParser.INTERSECT: + case PostgreSQLParser.KW_INTERSECT: _localctx = new IntersectContext(_localctx); this.enterOuterAlt(_localctx, 2); { - this.state = 8329; - this.match(PostgreSQLParser.INTERSECT); + this.state = 8414; + this.match(PostgreSQLParser.KW_INTERSECT); } break; - case PostgreSQLParser.EXCEPT: + case PostgreSQLParser.KW_EXCEPT: _localctx = new ExceptContext(_localctx); this.enterOuterAlt(_localctx, 3); { - this.state = 8330; - this.match(PostgreSQLParser.EXCEPT); + this.state = 8415; + this.match(PostgreSQLParser.KW_EXCEPT); } break; default: @@ -41261,19 +41688,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public set_operator_with_all_or_distinct(): Set_operator_with_all_or_distinctContext { let _localctx: Set_operator_with_all_or_distinctContext = new Set_operator_with_all_or_distinctContext(this._ctx, this.state); - this.enterRule(_localctx, 962, PostgreSQLParser.RULE_set_operator_with_all_or_distinct); + this.enterRule(_localctx, 976, PostgreSQLParser.RULE_set_operator_with_all_or_distinct); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8333; + this.state = 8418; this.set_operator(); - this.state = 8335; + this.state = 8420; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ALL || _la === PostgreSQLParser.DISTINCT) { + if (_la === PostgreSQLParser.KW_ALL || _la === PostgreSQLParser.KW_DISTINCT) { { - this.state = 8334; + this.state = 8419; this.all_or_distinct(); } } @@ -41297,23 +41724,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public with_clause(): With_clauseContext { let _localctx: With_clauseContext = new With_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 964, PostgreSQLParser.RULE_with_clause); + this.enterRule(_localctx, 978, PostgreSQLParser.RULE_with_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8337; - this.match(PostgreSQLParser.WITH); - this.state = 8339; + this.state = 8422; + this.match(PostgreSQLParser.KW_WITH); + this.state = 8424; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 720, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 734, this._ctx) ) { case 1: { - this.state = 8338; - this.match(PostgreSQLParser.RECURSIVE); + this.state = 8423; + this.match(PostgreSQLParser.KW_RECURSIVE); } break; } - this.state = 8341; + this.state = 8426; this.cte_list(); } } @@ -41334,26 +41761,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public cte_list(): Cte_listContext { let _localctx: Cte_listContext = new Cte_listContext(this._ctx, this.state); - this.enterRule(_localctx, 966, PostgreSQLParser.RULE_cte_list); + this.enterRule(_localctx, 980, PostgreSQLParser.RULE_cte_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8343; + this.state = 8428; this.common_table_expr(); - this.state = 8348; + this.state = 8433; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8344; + this.state = 8429; this.match(PostgreSQLParser.COMMA); - this.state = 8345; + this.state = 8430; this.common_table_expr(); } } - this.state = 8350; + this.state = 8435; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -41376,40 +41803,40 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public common_table_expr(): Common_table_exprContext { let _localctx: Common_table_exprContext = new Common_table_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 968, PostgreSQLParser.RULE_common_table_expr); + this.enterRule(_localctx, 982, PostgreSQLParser.RULE_common_table_expr); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8351; + this.state = 8436; this.name(); - this.state = 8353; + this.state = 8438; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 8352; + this.state = 8437; this.opt_name_list(); } } - this.state = 8355; - this.match(PostgreSQLParser.AS); - this.state = 8357; + this.state = 8440; + this.match(PostgreSQLParser.KW_AS); + this.state = 8442; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOT || _la === PostgreSQLParser.MATERIALIZED) { + if (_la === PostgreSQLParser.KW_NOT || _la === PostgreSQLParser.KW_MATERIALIZED) { { - this.state = 8356; + this.state = 8441; this.opt_materialized(); } } - this.state = 8359; + this.state = 8444; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8360; + this.state = 8445; this.preparablestmt(); - this.state = 8361; + this.state = 8446; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -41430,25 +41857,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_materialized(): Opt_materializedContext { let _localctx: Opt_materializedContext = new Opt_materializedContext(this._ctx, this.state); - this.enterRule(_localctx, 970, PostgreSQLParser.RULE_opt_materialized); + this.enterRule(_localctx, 984, PostgreSQLParser.RULE_opt_materialized); try { - this.state = 8366; + this.state = 8451; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.MATERIALIZED: + case PostgreSQLParser.KW_MATERIALIZED: this.enterOuterAlt(_localctx, 1); { - this.state = 8363; - this.match(PostgreSQLParser.MATERIALIZED); + this.state = 8448; + this.match(PostgreSQLParser.KW_MATERIALIZED); } break; - case PostgreSQLParser.NOT: + case PostgreSQLParser.KW_NOT: this.enterOuterAlt(_localctx, 2); { - this.state = 8364; - this.match(PostgreSQLParser.NOT); - this.state = 8365; - this.match(PostgreSQLParser.MATERIALIZED); + this.state = 8449; + this.match(PostgreSQLParser.KW_NOT); + this.state = 8450; + this.match(PostgreSQLParser.KW_MATERIALIZED); } break; default: @@ -41472,11 +41899,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_with_clause(): Opt_with_clauseContext { let _localctx: Opt_with_clauseContext = new Opt_with_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 972, PostgreSQLParser.RULE_opt_with_clause); + this.enterRule(_localctx, 986, PostgreSQLParser.RULE_opt_with_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8368; + this.state = 8453; this.with_clause(); } } @@ -41497,27 +41924,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public into_clause(): Into_clauseContext { let _localctx: Into_clauseContext = new Into_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 974, PostgreSQLParser.RULE_into_clause); + this.enterRule(_localctx, 988, PostgreSQLParser.RULE_into_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8370; - this.match(PostgreSQLParser.INTO); - this.state = 8375; + this.state = 8455; + this.match(PostgreSQLParser.KW_INTO); + this.state = 8460; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 725, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 739, this._ctx) ) { case 1: { - this.state = 8371; + this.state = 8456; this.opt_strict(); - this.state = 8372; + this.state = 8457; this.opttempTableName(); } break; case 2: { - this.state = 8374; + this.state = 8459; this.into_target(); } break; @@ -41541,11 +41968,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_strict(): Opt_strictContext { let _localctx: Opt_strictContext = new Opt_strictContext(this._ctx, this.state); - this.enterRule(_localctx, 976, PostgreSQLParser.RULE_opt_strict); + this.enterRule(_localctx, 990, PostgreSQLParser.RULE_opt_strict); try { - this.state = 8379; + this.state = 8464; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 726, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 740, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty @@ -41556,8 +41983,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8378; - this.match(PostgreSQLParser.STRICT_P); + this.state = 8463; + this.match(PostgreSQLParser.KW_STRICT); } break; } @@ -41579,23 +42006,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opttempTableName(): OpttempTableNameContext { let _localctx: OpttempTableNameContext = new OpttempTableNameContext(this._ctx, this.state); - this.enterRule(_localctx, 978, PostgreSQLParser.RULE_opttempTableName); + this.enterRule(_localctx, 992, PostgreSQLParser.RULE_opttempTableName); let _la: number; try { - this.state = 8397; + this.state = 8482; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 730, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 744, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8382; + this.state = 8467; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GLOBAL || _la === PostgreSQLParser.LOCAL) { + if (_la === PostgreSQLParser.KW_GLOBAL || _la === PostgreSQLParser.KW_LOCAL) { { - this.state = 8381; + this.state = 8466; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.GLOBAL || _la === PostgreSQLParser.LOCAL)) { + if (!(_la === PostgreSQLParser.KW_GLOBAL || _la === PostgreSQLParser.KW_LOCAL)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -41608,9 +42035,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } - this.state = 8384; + this.state = 8469; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.TEMP || _la === PostgreSQLParser.TEMPORARY)) { + if (!(_la === PostgreSQLParser.KW_TEMP || _la === PostgreSQLParser.KW_TEMPORARY)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -41620,17 +42047,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 8386; + this.state = 8471; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 728, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 742, this._ctx) ) { case 1: { - this.state = 8385; + this.state = 8470; this.opt_table(); } break; } - this.state = 8388; + this.state = 8473; this.qualified_name(); } break; @@ -41638,19 +42065,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8389; - this.match(PostgreSQLParser.UNLOGGED); - this.state = 8391; + this.state = 8474; + this.match(PostgreSQLParser.KW_UNLOGGED); + this.state = 8476; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 729, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 743, this._ctx) ) { case 1: { - this.state = 8390; + this.state = 8475; this.opt_table(); } break; } - this.state = 8393; + this.state = 8478; this.qualified_name(); } break; @@ -41658,9 +42085,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 8394; - this.match(PostgreSQLParser.TABLE); - this.state = 8395; + this.state = 8479; + this.match(PostgreSQLParser.KW_TABLE); + this.state = 8480; this.qualified_name(); } break; @@ -41668,7 +42095,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 8396; + this.state = 8481; this.qualified_name(); } break; @@ -41691,12 +42118,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_table(): Opt_tableContext { let _localctx: Opt_tableContext = new Opt_tableContext(this._ctx, this.state); - this.enterRule(_localctx, 980, PostgreSQLParser.RULE_opt_table); + this.enterRule(_localctx, 994, PostgreSQLParser.RULE_opt_table); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8399; - this.match(PostgreSQLParser.TABLE); + this.state = 8484; + this.match(PostgreSQLParser.KW_TABLE); } } catch (re) { @@ -41716,14 +42143,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public all_or_distinct(): All_or_distinctContext { let _localctx: All_or_distinctContext = new All_or_distinctContext(this._ctx, this.state); - this.enterRule(_localctx, 982, PostgreSQLParser.RULE_all_or_distinct); + this.enterRule(_localctx, 996, PostgreSQLParser.RULE_all_or_distinct); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8401; + this.state = 8486; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ALL || _la === PostgreSQLParser.DISTINCT)) { + if (!(_la === PostgreSQLParser.KW_ALL || _la === PostgreSQLParser.KW_DISTINCT)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -41752,29 +42179,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public distinct_clause(): Distinct_clauseContext { let _localctx: Distinct_clauseContext = new Distinct_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 984, PostgreSQLParser.RULE_distinct_clause); - let _la: number; + this.enterRule(_localctx, 998, PostgreSQLParser.RULE_distinct_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8403; - this.match(PostgreSQLParser.DISTINCT); - this.state = 8409; + this.state = 8488; + this.match(PostgreSQLParser.KW_DISTINCT); + this.state = 8494; this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.ON) { + switch ( this.interpreter.adaptivePredict(this._input, 745, this._ctx) ) { + case 1: { - this.state = 8404; - this.match(PostgreSQLParser.ON); - this.state = 8405; + this.state = 8489; + this.match(PostgreSQLParser.KW_ON); + this.state = 8490; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8406; + this.state = 8491; this.expr_list(); - this.state = 8407; + this.state = 8492; this.match(PostgreSQLParser.CLOSE_PAREN); } + break; } - } } catch (re) { @@ -41794,12 +42220,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_all_clause(): Opt_all_clauseContext { let _localctx: Opt_all_clauseContext = new Opt_all_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 986, PostgreSQLParser.RULE_opt_all_clause); + this.enterRule(_localctx, 1000, PostgreSQLParser.RULE_opt_all_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8411; - this.match(PostgreSQLParser.ALL); + this.state = 8496; + this.match(PostgreSQLParser.KW_ALL); } } catch (re) { @@ -41819,11 +42245,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_sort_clause(): Opt_sort_clauseContext { let _localctx: Opt_sort_clauseContext = new Opt_sort_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 988, PostgreSQLParser.RULE_opt_sort_clause); + this.enterRule(_localctx, 1002, PostgreSQLParser.RULE_opt_sort_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8413; + this.state = 8498; this.sort_clause(); } } @@ -41844,15 +42270,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public sort_clause(): Sort_clauseContext { let _localctx: Sort_clauseContext = new Sort_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 990, PostgreSQLParser.RULE_sort_clause); + this.enterRule(_localctx, 1004, PostgreSQLParser.RULE_sort_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8415; - this.match(PostgreSQLParser.ORDER); - this.state = 8416; - this.match(PostgreSQLParser.BY); - this.state = 8417; + this.state = 8500; + this.match(PostgreSQLParser.KW_ORDER); + this.state = 8501; + this.match(PostgreSQLParser.KW_BY); + this.state = 8502; this.sortby_list(); } } @@ -41873,26 +42299,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public sortby_list(): Sortby_listContext { let _localctx: Sortby_listContext = new Sortby_listContext(this._ctx, this.state); - this.enterRule(_localctx, 992, PostgreSQLParser.RULE_sortby_list); + this.enterRule(_localctx, 1006, PostgreSQLParser.RULE_sortby_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8419; + this.state = 8504; this.sortby(); - this.state = 8424; + this.state = 8509; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8420; + this.state = 8505; this.match(PostgreSQLParser.COMMA); - this.state = 8421; + this.state = 8506; this.sortby(); } } - this.state = 8426; + this.state = 8511; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -41915,117 +42341,110 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public sortby(): SortbyContext { let _localctx: SortbyContext = new SortbyContext(this._ctx, this.state); - this.enterRule(_localctx, 994, PostgreSQLParser.RULE_sortby); + this.enterRule(_localctx, 1008, PostgreSQLParser.RULE_sortby); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8427; + this.state = 8512; this.a_expr(); - this.state = 8433; + this.state = 8516; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.USING: + case PostgreSQLParser.KW_USING: { - this.state = 8428; - this.match(PostgreSQLParser.USING); - this.state = 8429; + this.state = 8513; + this.match(PostgreSQLParser.KW_USING); + this.state = 8514; this.qual_all_op(); } break; + case PostgreSQLParser.KW_ASC: + case PostgreSQLParser.KW_DESC: + { + this.state = 8515; + this.opt_asc_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.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.KW_ANALYSE: + case PostgreSQLParser.KW_ANALYZE: + case PostgreSQLParser.KW_CREATE: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_FOR: + case PostgreSQLParser.KW_GRANT: + case PostgreSQLParser.KW_INTO: + case PostgreSQLParser.KW_LIMIT: + case PostgreSQLParser.KW_OFFSET: + case PostgreSQLParser.KW_ON: + case PostgreSQLParser.KW_RETURNING: + case PostgreSQLParser.KW_SELECT: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_WITH: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_END: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_LOOP: case PostgreSQLParser.MetaCommand: - { - this.state = 8431; - this._errHandler.sync(this); - _la = this._input.LA(1); - if (_la === PostgreSQLParser.ASC || _la === PostgreSQLParser.DESC) { - { - this.state = 8430; - this.opt_asc_desc(); - } - } - - } break; default: - throw new NoViableAltException(this); + break; } - this.state = 8436; + this.state = 8519; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NULLS_P) { + if (_la === PostgreSQLParser.KW_NULLS) { { - this.state = 8435; + this.state = 8518; this.opt_nulls_order(); } } @@ -42049,41 +42468,41 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public select_limit(): Select_limitContext { let _localctx: Select_limitContext = new Select_limitContext(this._ctx, this.state); - this.enterRule(_localctx, 996, PostgreSQLParser.RULE_select_limit); + this.enterRule(_localctx, 1010, PostgreSQLParser.RULE_select_limit); let _la: number; try { - this.state = 8446; + this.state = 8529; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.FETCH: - case PostgreSQLParser.LIMIT: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_LIMIT: this.enterOuterAlt(_localctx, 1); { - this.state = 8438; + this.state = 8521; this.limit_clause(); - this.state = 8440; + this.state = 8523; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OFFSET) { + if (_la === PostgreSQLParser.KW_OFFSET) { { - this.state = 8439; + this.state = 8522; this.offset_clause(); } } } break; - case PostgreSQLParser.OFFSET: + case PostgreSQLParser.KW_OFFSET: this.enterOuterAlt(_localctx, 2); { - this.state = 8442; + this.state = 8525; this.offset_clause(); - this.state = 8444; + this.state = 8527; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 737, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 750, this._ctx) ) { case 1: { - this.state = 8443; + this.state = 8526; this.limit_clause(); } break; @@ -42111,11 +42530,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_select_limit(): Opt_select_limitContext { let _localctx: Opt_select_limitContext = new Opt_select_limitContext(this._ctx, this.state); - this.enterRule(_localctx, 998, PostgreSQLParser.RULE_opt_select_limit); + this.enterRule(_localctx, 1012, PostgreSQLParser.RULE_opt_select_limit); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8448; + this.state = 8531; this.select_limit(); } } @@ -42136,64 +42555,64 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public limit_clause(): Limit_clauseContext { let _localctx: Limit_clauseContext = new Limit_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1000, PostgreSQLParser.RULE_limit_clause); + this.enterRule(_localctx, 1014, PostgreSQLParser.RULE_limit_clause); let _la: number; try { - this.state = 8473; + this.state = 8556; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.LIMIT: + case PostgreSQLParser.KW_LIMIT: this.enterOuterAlt(_localctx, 1); { - this.state = 8450; - this.match(PostgreSQLParser.LIMIT); - this.state = 8451; + this.state = 8533; + this.match(PostgreSQLParser.KW_LIMIT); + this.state = 8534; this.select_limit_value(); - this.state = 8454; + this.state = 8537; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.COMMA) { { - this.state = 8452; + this.state = 8535; this.match(PostgreSQLParser.COMMA); - this.state = 8453; + this.state = 8536; this.select_offset_value(); } } } break; - case PostgreSQLParser.FETCH: + case PostgreSQLParser.KW_FETCH: this.enterOuterAlt(_localctx, 2); { - this.state = 8456; - this.match(PostgreSQLParser.FETCH); - this.state = 8457; + this.state = 8539; + this.match(PostgreSQLParser.KW_FETCH); + this.state = 8540; this.first_or_next(); - this.state = 8471; + this.state = 8554; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 742, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 755, this._ctx) ) { case 1: { - this.state = 8458; + this.state = 8541; this.select_fetch_first_value(); - this.state = 8459; + this.state = 8542; this.row_or_rows(); - this.state = 8463; + this.state = 8546; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.ONLY: + case PostgreSQLParser.KW_ONLY: { - this.state = 8460; - this.match(PostgreSQLParser.ONLY); + this.state = 8543; + this.match(PostgreSQLParser.KW_ONLY); } break; - case PostgreSQLParser.WITH: + case PostgreSQLParser.KW_WITH: { - this.state = 8461; - this.match(PostgreSQLParser.WITH); - this.state = 8462; - this.match(PostgreSQLParser.TIES); + this.state = 8544; + this.match(PostgreSQLParser.KW_WITH); + this.state = 8545; + this.match(PostgreSQLParser.KW_TIES); } break; default: @@ -42204,23 +42623,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: { - this.state = 8465; + this.state = 8548; this.row_or_rows(); - this.state = 8469; + this.state = 8552; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.ONLY: + case PostgreSQLParser.KW_ONLY: { - this.state = 8466; - this.match(PostgreSQLParser.ONLY); + this.state = 8549; + this.match(PostgreSQLParser.KW_ONLY); } break; - case PostgreSQLParser.WITH: + case PostgreSQLParser.KW_WITH: { - this.state = 8467; - this.match(PostgreSQLParser.WITH); - this.state = 8468; - this.match(PostgreSQLParser.TIES); + this.state = 8550; + this.match(PostgreSQLParser.KW_WITH); + this.state = 8551; + this.match(PostgreSQLParser.KW_TIES); } break; default: @@ -42252,27 +42671,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public offset_clause(): Offset_clauseContext { let _localctx: Offset_clauseContext = new Offset_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1002, PostgreSQLParser.RULE_offset_clause); + this.enterRule(_localctx, 1016, PostgreSQLParser.RULE_offset_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8475; - this.match(PostgreSQLParser.OFFSET); - this.state = 8480; + this.state = 8558; + this.match(PostgreSQLParser.KW_OFFSET); + this.state = 8563; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 744, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 757, this._ctx) ) { case 1: { - this.state = 8476; + this.state = 8559; this.select_offset_value(); } break; case 2: { - this.state = 8477; + this.state = 8560; this.select_fetch_first_value(); - this.state = 8478; + this.state = 8561; this.row_or_rows(); } break; @@ -42296,9 +42715,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public select_limit_value(): Select_limit_valueContext { let _localctx: Select_limit_valueContext = new Select_limit_valueContext(this._ctx, this.state); - this.enterRule(_localctx, 1004, PostgreSQLParser.RULE_select_limit_value); + this.enterRule(_localctx, 1018, PostgreSQLParser.RULE_select_limit_value); try { - this.state = 8484; + this.state = 8567; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: @@ -42306,434 +42725,434 @@ export class PostgreSQLParser extends PostgreSQLParserBase { 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_CASE: + case PostgreSQLParser.KW_CAST: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_LOCALTIME: + case PostgreSQLParser.KW_LOCALTIMESTAMP: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_NULL: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -42749,15 +43168,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 8482; + this.state = 8565; this.a_expr(); } break; - case PostgreSQLParser.ALL: + case PostgreSQLParser.KW_ALL: this.enterOuterAlt(_localctx, 2); { - this.state = 8483; - this.match(PostgreSQLParser.ALL); + this.state = 8566; + this.match(PostgreSQLParser.KW_ALL); } break; default: @@ -42781,11 +43200,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public select_offset_value(): Select_offset_valueContext { let _localctx: Select_offset_valueContext = new Select_offset_valueContext(this._ctx, this.state); - this.enterRule(_localctx, 1006, PostgreSQLParser.RULE_select_offset_value); + this.enterRule(_localctx, 1020, PostgreSQLParser.RULE_select_offset_value); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8486; + this.state = 8569; this.a_expr(); } } @@ -42806,440 +43225,440 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public select_fetch_first_value(): Select_fetch_first_valueContext { let _localctx: Select_fetch_first_valueContext = new Select_fetch_first_valueContext(this._ctx, this.state); - this.enterRule(_localctx, 1008, PostgreSQLParser.RULE_select_fetch_first_value); + this.enterRule(_localctx, 1022, PostgreSQLParser.RULE_select_fetch_first_value); try { - this.state = 8493; + this.state = 8576; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_CASE: + case PostgreSQLParser.KW_CAST: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_LOCALTIME: + case PostgreSQLParser.KW_LOCALTIMESTAMP: + case PostgreSQLParser.KW_NULL: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -43255,25 +43674,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 8488; + this.state = 8571; this.c_expr(); } break; case PostgreSQLParser.PLUS: this.enterOuterAlt(_localctx, 2); { - this.state = 8489; + this.state = 8572; this.match(PostgreSQLParser.PLUS); - this.state = 8490; + this.state = 8573; this.i_or_f_const(); } break; case PostgreSQLParser.MINUS: this.enterOuterAlt(_localctx, 3); { - this.state = 8491; + this.state = 8574; this.match(PostgreSQLParser.MINUS); - this.state = 8492; + this.state = 8575; this.i_or_f_const(); } break; @@ -43298,22 +43717,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public i_or_f_const(): I_or_f_constContext { let _localctx: I_or_f_constContext = new I_or_f_constContext(this._ctx, this.state); - this.enterRule(_localctx, 1010, PostgreSQLParser.RULE_i_or_f_const); + this.enterRule(_localctx, 1024, PostgreSQLParser.RULE_i_or_f_const); try { - this.state = 8497; + this.state = 8580; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.Integral: this.enterOuterAlt(_localctx, 1); { - this.state = 8495; + this.state = 8578; this.iconst(); } break; case PostgreSQLParser.Numeric: this.enterOuterAlt(_localctx, 2); { - this.state = 8496; + this.state = 8579; this.fconst(); } break; @@ -43338,14 +43757,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public row_or_rows(): Row_or_rowsContext { let _localctx: Row_or_rowsContext = new Row_or_rowsContext(this._ctx, this.state); - this.enterRule(_localctx, 1012, PostgreSQLParser.RULE_row_or_rows); + this.enterRule(_localctx, 1026, PostgreSQLParser.RULE_row_or_rows); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8499; + this.state = 8582; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ROWS || _la === PostgreSQLParser.ROW)) { + if (!(_la === PostgreSQLParser.KW_ROWS || _la === PostgreSQLParser.KW_ROW)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -43374,14 +43793,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public first_or_next(): First_or_nextContext { let _localctx: First_or_nextContext = new First_or_nextContext(this._ctx, this.state); - this.enterRule(_localctx, 1014, PostgreSQLParser.RULE_first_or_next); + this.enterRule(_localctx, 1028, PostgreSQLParser.RULE_first_or_next); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8501; + this.state = 8584; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FIRST_P || _la === PostgreSQLParser.NEXT)) { + if (!(_la === PostgreSQLParser.KW_FIRST || _la === PostgreSQLParser.KW_NEXT)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -43410,15 +43829,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public group_clause(): Group_clauseContext { let _localctx: Group_clauseContext = new Group_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1016, PostgreSQLParser.RULE_group_clause); + this.enterRule(_localctx, 1030, PostgreSQLParser.RULE_group_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8503; - this.match(PostgreSQLParser.GROUP_P); - this.state = 8504; - this.match(PostgreSQLParser.BY); - this.state = 8505; + this.state = 8586; + this.match(PostgreSQLParser.KW_GROUP); + this.state = 8587; + this.match(PostgreSQLParser.KW_BY); + this.state = 8588; this.group_by_list(); } } @@ -43439,30 +43858,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public group_by_list(): Group_by_listContext { let _localctx: Group_by_listContext = new Group_by_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1018, PostgreSQLParser.RULE_group_by_list); + this.enterRule(_localctx, 1032, PostgreSQLParser.RULE_group_by_list); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 8507; + this.state = 8590; this.group_by_item(); - this.state = 8512; + this.state = 8595; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 748, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 761, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 8508; + this.state = 8591; this.match(PostgreSQLParser.COMMA); - this.state = 8509; + this.state = 8592; this.group_by_item(); } } } - this.state = 8514; + this.state = 8597; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 748, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 761, this._ctx); } } } @@ -43483,15 +43902,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public group_by_item(): Group_by_itemContext { let _localctx: Group_by_itemContext = new Group_by_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 1020, PostgreSQLParser.RULE_group_by_item); + this.enterRule(_localctx, 1034, PostgreSQLParser.RULE_group_by_item); try { - this.state = 8520; + this.state = 8603; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 749, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 762, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8515; + this.state = 8598; this.a_expr(); } break; @@ -43499,7 +43918,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8516; + this.state = 8599; this.empty_grouping_set(); } break; @@ -43507,7 +43926,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 8517; + this.state = 8600; this.cube_clause(); } break; @@ -43515,7 +43934,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 8518; + this.state = 8601; this.rollup_clause(); } break; @@ -43523,7 +43942,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 8519; + this.state = 8602; this.grouping_sets_clause(); } break; @@ -43546,13 +43965,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public empty_grouping_set(): Empty_grouping_setContext { let _localctx: Empty_grouping_setContext = new Empty_grouping_setContext(this._ctx, this.state); - this.enterRule(_localctx, 1022, PostgreSQLParser.RULE_empty_grouping_set); + this.enterRule(_localctx, 1036, PostgreSQLParser.RULE_empty_grouping_set); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8522; + this.state = 8605; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8523; + this.state = 8606; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -43573,17 +43992,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rollup_clause(): Rollup_clauseContext { let _localctx: Rollup_clauseContext = new Rollup_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1024, PostgreSQLParser.RULE_rollup_clause); + this.enterRule(_localctx, 1038, PostgreSQLParser.RULE_rollup_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8525; - this.match(PostgreSQLParser.ROLLUP); - this.state = 8526; + this.state = 8608; + this.match(PostgreSQLParser.KW_ROLLUP); + this.state = 8609; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8527; + this.state = 8610; this.expr_list(); - this.state = 8528; + this.state = 8611; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -43604,17 +44023,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public cube_clause(): Cube_clauseContext { let _localctx: Cube_clauseContext = new Cube_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1026, PostgreSQLParser.RULE_cube_clause); + this.enterRule(_localctx, 1040, PostgreSQLParser.RULE_cube_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8530; - this.match(PostgreSQLParser.CUBE); - this.state = 8531; + this.state = 8613; + this.match(PostgreSQLParser.KW_CUBE); + this.state = 8614; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8532; + this.state = 8615; this.expr_list(); - this.state = 8533; + this.state = 8616; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -43635,19 +44054,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public grouping_sets_clause(): Grouping_sets_clauseContext { let _localctx: Grouping_sets_clauseContext = new Grouping_sets_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1028, PostgreSQLParser.RULE_grouping_sets_clause); + this.enterRule(_localctx, 1042, PostgreSQLParser.RULE_grouping_sets_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8535; - this.match(PostgreSQLParser.GROUPING); - this.state = 8536; - this.match(PostgreSQLParser.SETS); - this.state = 8537; + this.state = 8618; + this.match(PostgreSQLParser.KW_GROUPING); + this.state = 8619; + this.match(PostgreSQLParser.KW_SETS); + this.state = 8620; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8538; + this.state = 8621; this.group_by_list(); - this.state = 8539; + this.state = 8622; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -43668,13 +44087,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public having_clause(): Having_clauseContext { let _localctx: Having_clauseContext = new Having_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1030, PostgreSQLParser.RULE_having_clause); + this.enterRule(_localctx, 1044, PostgreSQLParser.RULE_having_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8541; - this.match(PostgreSQLParser.HAVING); - this.state = 8542; + this.state = 8624; + this.match(PostgreSQLParser.KW_HAVING); + this.state = 8625; this.a_expr(); } } @@ -43695,15 +44114,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public for_locking_clause(): For_locking_clauseContext { let _localctx: For_locking_clauseContext = new For_locking_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1032, PostgreSQLParser.RULE_for_locking_clause); + this.enterRule(_localctx, 1046, PostgreSQLParser.RULE_for_locking_clause); try { - this.state = 8548; + this.state = 8631; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 750, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 763, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8544; + this.state = 8627; this.for_locking_items(); } break; @@ -43711,12 +44130,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8545; - this.match(PostgreSQLParser.FOR); - this.state = 8546; - this.match(PostgreSQLParser.READ); - this.state = 8547; - this.match(PostgreSQLParser.ONLY); + this.state = 8628; + this.match(PostgreSQLParser.KW_FOR); + this.state = 8629; + this.match(PostgreSQLParser.KW_READ); + this.state = 8630; + this.match(PostgreSQLParser.KW_ONLY); } break; } @@ -43738,11 +44157,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_for_locking_clause(): Opt_for_locking_clauseContext { let _localctx: Opt_for_locking_clauseContext = new Opt_for_locking_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1034, PostgreSQLParser.RULE_opt_for_locking_clause); + this.enterRule(_localctx, 1048, PostgreSQLParser.RULE_opt_for_locking_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8550; + this.state = 8633; this.for_locking_clause(); } } @@ -43763,25 +44182,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public for_locking_items(): For_locking_itemsContext { let _localctx: For_locking_itemsContext = new For_locking_itemsContext(this._ctx, this.state); - this.enterRule(_localctx, 1036, PostgreSQLParser.RULE_for_locking_items); + this.enterRule(_localctx, 1050, PostgreSQLParser.RULE_for_locking_items); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8553; + this.state = 8636; this._errHandler.sync(this); _la = this._input.LA(1); do { { { - this.state = 8552; + this.state = 8635; this.for_locking_item(); } } - this.state = 8555; + this.state = 8638; this._errHandler.sync(this); _la = this._input.LA(1); - } while (_la === PostgreSQLParser.FOR); + } while (_la === PostgreSQLParser.KW_FOR); } } catch (re) { @@ -43801,29 +44220,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public for_locking_item(): For_locking_itemContext { let _localctx: For_locking_itemContext = new For_locking_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 1038, PostgreSQLParser.RULE_for_locking_item); + this.enterRule(_localctx, 1052, PostgreSQLParser.RULE_for_locking_item); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8557; + this.state = 8640; this.for_locking_strength(); - this.state = 8559; + this.state = 8642; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OF) { + if (_la === PostgreSQLParser.KW_OF) { { - this.state = 8558; + this.state = 8641; this.locked_rels_list(); } } - this.state = 8562; + this.state = 8645; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOWAIT || _la === PostgreSQLParser.SKIP_P) { + if (_la === PostgreSQLParser.KW_NOWAIT || _la === PostgreSQLParser.KW_SKIP) { { - this.state = 8561; + this.state = 8644; this.opt_nowait_or_skip(); } } @@ -43847,50 +44266,50 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public for_locking_strength(): For_locking_strengthContext { let _localctx: For_locking_strengthContext = new For_locking_strengthContext(this._ctx, this.state); - this.enterRule(_localctx, 1040, PostgreSQLParser.RULE_for_locking_strength); + this.enterRule(_localctx, 1054, PostgreSQLParser.RULE_for_locking_strength); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8564; - this.match(PostgreSQLParser.FOR); - this.state = 8574; + this.state = 8647; + this.match(PostgreSQLParser.KW_FOR); + this.state = 8657; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.NO: - case PostgreSQLParser.UPDATE: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_UPDATE: { - this.state = 8567; + this.state = 8650; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 8565; - this.match(PostgreSQLParser.NO); - this.state = 8566; - this.match(PostgreSQLParser.KEY); + this.state = 8648; + this.match(PostgreSQLParser.KW_NO); + this.state = 8649; + this.match(PostgreSQLParser.KW_KEY); } } - this.state = 8569; - this.match(PostgreSQLParser.UPDATE); + this.state = 8652; + this.match(PostgreSQLParser.KW_UPDATE); } break; - case PostgreSQLParser.KEY: - case PostgreSQLParser.SHARE: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_SHARE: { - this.state = 8571; + this.state = 8654; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.KEY) { + if (_la === PostgreSQLParser.KW_KEY) { { - this.state = 8570; - this.match(PostgreSQLParser.KEY); + this.state = 8653; + this.match(PostgreSQLParser.KW_KEY); } } - this.state = 8573; - this.match(PostgreSQLParser.SHARE); + this.state = 8656; + this.match(PostgreSQLParser.KW_SHARE); } break; default: @@ -43915,13 +44334,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public locked_rels_list(): Locked_rels_listContext { let _localctx: Locked_rels_listContext = new Locked_rels_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1042, PostgreSQLParser.RULE_locked_rels_list); + this.enterRule(_localctx, 1056, PostgreSQLParser.RULE_locked_rels_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8576; - this.match(PostgreSQLParser.OF); - this.state = 8577; + this.state = 8659; + this.match(PostgreSQLParser.KW_OF); + this.state = 8660; this.qualified_name_list(); } } @@ -43942,36 +44361,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public values_clause(): Values_clauseContext { let _localctx: Values_clauseContext = new Values_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1044, PostgreSQLParser.RULE_values_clause); + this.enterRule(_localctx, 1058, PostgreSQLParser.RULE_values_clause); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8579; - this.match(PostgreSQLParser.VALUES); - this.state = 8580; + this.state = 8662; + this.match(PostgreSQLParser.KW_VALUES); + this.state = 8663; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8581; + this.state = 8664; this.expr_list(); - this.state = 8582; + this.state = 8665; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 8590; + this.state = 8673; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8583; + this.state = 8666; this.match(PostgreSQLParser.COMMA); - this.state = 8584; + this.state = 8667; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8585; + this.state = 8668; this.expr_list(); - this.state = 8586; + this.state = 8669; this.match(PostgreSQLParser.CLOSE_PAREN); } } - this.state = 8592; + this.state = 8675; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -43994,13 +44413,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public from_clause(): From_clauseContext { let _localctx: From_clauseContext = new From_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1046, PostgreSQLParser.RULE_from_clause); + this.enterRule(_localctx, 1060, PostgreSQLParser.RULE_from_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8593; - this.match(PostgreSQLParser.FROM); - this.state = 8594; + this.state = 8676; + this.match(PostgreSQLParser.KW_FROM); + this.state = 8677; this.from_list(); } } @@ -44021,30 +44440,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public from_list(): From_listContext { let _localctx: From_listContext = new From_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1048, PostgreSQLParser.RULE_from_list); + this.enterRule(_localctx, 1062, PostgreSQLParser.RULE_from_list); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 8596; + this.state = 8679; this.table_ref(); - this.state = 8601; + this.state = 8684; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 758, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 771, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 8597; + this.state = 8680; this.match(PostgreSQLParser.COMMA); - this.state = 8598; + this.state = 8681; this.table_ref(); } } } - this.state = 8603; + this.state = 8686; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 758, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 771, this._ctx); } } } @@ -44065,35 +44484,35 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public table_ref(): Table_refContext { let _localctx: Table_refContext = new Table_refContext(this._ctx, this.state); - this.enterRule(_localctx, 1050, PostgreSQLParser.RULE_table_ref); + this.enterRule(_localctx, 1064, PostgreSQLParser.RULE_table_ref); let _la: number; try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 8662; + this.state = 8745; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 772, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 785, this._ctx) ) { case 1: { - this.state = 8604; + this.state = 8687; this.relation_expr(); - this.state = 8606; + this.state = 8689; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 759, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 772, this._ctx) ) { case 1: { - this.state = 8605; + this.state = 8688; this.opt_alias_clause(); } break; } - this.state = 8609; + this.state = 8692; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.TABLESAMPLE) { + if (_la === PostgreSQLParser.KW_TABLESAMPLE) { { - this.state = 8608; + this.state = 8691; this.tablesample_clause(); } } @@ -44103,14 +44522,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: { - this.state = 8611; + this.state = 8694; this.func_table(); - this.state = 8613; + this.state = 8696; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 761, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 774, this._ctx) ) { case 1: { - this.state = 8612; + this.state = 8695; this.func_alias_clause(); } break; @@ -44120,14 +44539,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: { - this.state = 8615; + this.state = 8698; this.xmltable(); - this.state = 8617; + this.state = 8700; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 762, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 775, this._ctx) ) { case 1: { - this.state = 8616; + this.state = 8699; this.opt_alias_clause(); } break; @@ -44137,14 +44556,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: { - this.state = 8619; + this.state = 8702; this.select_with_parens(); - this.state = 8621; + this.state = 8704; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 763, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 776, this._ctx) ) { case 1: { - this.state = 8620; + this.state = 8703; this.opt_alias_clause(); } break; @@ -44154,21 +44573,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: { - this.state = 8623; - this.match(PostgreSQLParser.LATERAL_P); - this.state = 8636; + this.state = 8706; + this.match(PostgreSQLParser.KW_LATERAL); + this.state = 8719; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 767, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 780, this._ctx) ) { case 1: { - this.state = 8624; + this.state = 8707; this.xmltable(); - this.state = 8626; + this.state = 8709; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 764, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 777, this._ctx) ) { case 1: { - this.state = 8625; + this.state = 8708; this.opt_alias_clause(); } break; @@ -44178,14 +44597,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: { - this.state = 8628; + this.state = 8711; this.func_table(); - this.state = 8630; + this.state = 8713; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 765, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 778, this._ctx) ) { case 1: { - this.state = 8629; + this.state = 8712; this.func_alias_clause(); } break; @@ -44195,14 +44614,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: { - this.state = 8632; + this.state = 8715; this.select_with_parens(); - this.state = 8634; + this.state = 8717; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 766, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 779, this._ctx) ) { case 1: { - this.state = 8633; + this.state = 8716; this.opt_alias_clause(); } break; @@ -44215,64 +44634,64 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: { - this.state = 8638; + this.state = 8721; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8639; + this.state = 8722; this.table_ref(); - this.state = 8656; + this.state = 8739; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.CROSS: + case PostgreSQLParser.KW_CROSS: { - this.state = 8640; - this.match(PostgreSQLParser.CROSS); - this.state = 8641; - this.match(PostgreSQLParser.JOIN); - this.state = 8642; + this.state = 8723; + this.match(PostgreSQLParser.KW_CROSS); + this.state = 8724; + this.match(PostgreSQLParser.KW_JOIN); + this.state = 8725; this.table_ref(); } break; - case PostgreSQLParser.NATURAL: + case PostgreSQLParser.KW_NATURAL: { - this.state = 8643; - this.match(PostgreSQLParser.NATURAL); - this.state = 8645; + this.state = 8726; + this.match(PostgreSQLParser.KW_NATURAL); + this.state = 8728; 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)) { + if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.KW_FULL - 113)) | (1 << (PostgreSQLParser.KW_INNER - 113)) | (1 << (PostgreSQLParser.KW_LEFT - 113)) | (1 << (PostgreSQLParser.KW_RIGHT - 113)))) !== 0)) { { - this.state = 8644; + this.state = 8727; this.join_type(); } } - this.state = 8647; - this.match(PostgreSQLParser.JOIN); - this.state = 8648; + this.state = 8730; + this.match(PostgreSQLParser.KW_JOIN); + this.state = 8731; this.table_ref(); } break; - case PostgreSQLParser.FULL: - case PostgreSQLParser.INNER_P: - case PostgreSQLParser.JOIN: - case PostgreSQLParser.LEFT: - case PostgreSQLParser.RIGHT: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_RIGHT: { - this.state = 8650; + this.state = 8733; 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)) { + if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.KW_FULL - 113)) | (1 << (PostgreSQLParser.KW_INNER - 113)) | (1 << (PostgreSQLParser.KW_LEFT - 113)) | (1 << (PostgreSQLParser.KW_RIGHT - 113)))) !== 0)) { { - this.state = 8649; + this.state = 8732; this.join_type(); } } - this.state = 8652; - this.match(PostgreSQLParser.JOIN); - this.state = 8653; + this.state = 8735; + this.match(PostgreSQLParser.KW_JOIN); + this.state = 8736; this.table_ref(); - this.state = 8654; + this.state = 8737; this.join_qual(); } break; @@ -44281,14 +44700,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: break; } - this.state = 8658; + this.state = 8741; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 8660; + this.state = 8743; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 771, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 784, this._ctx) ) { case 1: { - this.state = 8659; + this.state = 8742; this.opt_alias_clause(); } break; @@ -44296,66 +44715,66 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } break; } - this.state = 8682; + this.state = 8765; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 776, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 789, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { - this.state = 8680; + this.state = 8763; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.CROSS: + case PostgreSQLParser.KW_CROSS: { - this.state = 8664; - this.match(PostgreSQLParser.CROSS); - this.state = 8665; - this.match(PostgreSQLParser.JOIN); - this.state = 8666; + this.state = 8747; + this.match(PostgreSQLParser.KW_CROSS); + this.state = 8748; + this.match(PostgreSQLParser.KW_JOIN); + this.state = 8749; this.table_ref(); } break; - case PostgreSQLParser.NATURAL: + case PostgreSQLParser.KW_NATURAL: { - this.state = 8667; - this.match(PostgreSQLParser.NATURAL); - this.state = 8669; + this.state = 8750; + this.match(PostgreSQLParser.KW_NATURAL); + this.state = 8752; 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)) { + if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.KW_FULL - 113)) | (1 << (PostgreSQLParser.KW_INNER - 113)) | (1 << (PostgreSQLParser.KW_LEFT - 113)) | (1 << (PostgreSQLParser.KW_RIGHT - 113)))) !== 0)) { { - this.state = 8668; + this.state = 8751; this.join_type(); } } - this.state = 8671; - this.match(PostgreSQLParser.JOIN); - this.state = 8672; + this.state = 8754; + this.match(PostgreSQLParser.KW_JOIN); + this.state = 8755; this.table_ref(); } break; - case PostgreSQLParser.FULL: - case PostgreSQLParser.INNER_P: - case PostgreSQLParser.JOIN: - case PostgreSQLParser.LEFT: - case PostgreSQLParser.RIGHT: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_RIGHT: { - this.state = 8674; + this.state = 8757; 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)) { + if (((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.KW_FULL - 113)) | (1 << (PostgreSQLParser.KW_INNER - 113)) | (1 << (PostgreSQLParser.KW_LEFT - 113)) | (1 << (PostgreSQLParser.KW_RIGHT - 113)))) !== 0)) { { - this.state = 8673; + this.state = 8756; this.join_type(); } } - this.state = 8676; - this.match(PostgreSQLParser.JOIN); - this.state = 8677; + this.state = 8759; + this.match(PostgreSQLParser.KW_JOIN); + this.state = 8760; this.table_ref(); - this.state = 8678; + this.state = 8761; this.join_qual(); } break; @@ -44364,9 +44783,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } } - this.state = 8684; + this.state = 8767; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 776, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 789, this._ctx); } } } @@ -44387,33 +44806,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public alias_clause(): Alias_clauseContext { let _localctx: Alias_clauseContext = new Alias_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1052, PostgreSQLParser.RULE_alias_clause); + this.enterRule(_localctx, 1066, PostgreSQLParser.RULE_alias_clause); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8686; + this.state = 8769; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 8685; - this.match(PostgreSQLParser.AS); + this.state = 8768; + this.match(PostgreSQLParser.KW_AS); } } - this.state = 8688; + this.state = 8771; this.colid(); - this.state = 8693; + this.state = 8776; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 778, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 791, this._ctx) ) { case 1: { - this.state = 8689; + this.state = 8772; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8690; + this.state = 8773; this.name_list(); - this.state = 8691; + this.state = 8774; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -44437,11 +44856,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_alias_clause(): Opt_alias_clauseContext { let _localctx: Opt_alias_clauseContext = new Opt_alias_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1054, PostgreSQLParser.RULE_opt_alias_clause); + this.enterRule(_localctx, 1068, PostgreSQLParser.RULE_opt_alias_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8695; + this.state = 8778; this.alias_clause(); } } @@ -44462,16 +44881,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_alias_clause(): Func_alias_clauseContext { let _localctx: Func_alias_clauseContext = new Func_alias_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1056, PostgreSQLParser.RULE_func_alias_clause); + this.enterRule(_localctx, 1070, PostgreSQLParser.RULE_func_alias_clause); let _la: number; try { - this.state = 8709; + this.state = 8792; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 781, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 794, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8697; + this.state = 8780; this.alias_clause(); } break; @@ -44479,433 +44898,433 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8703; + this.state = 8786; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.AS: + case PostgreSQLParser.KW_AS: { - this.state = 8698; - this.match(PostgreSQLParser.AS); - this.state = 8700; + this.state = 8781; + this.match(PostgreSQLParser.KW_AS); + this.state = 8783; 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)) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.KW_OVER - 124)) | (1 << (PostgreSQLParser.KW_ABORT - 124)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 124)) | (1 << (PostgreSQLParser.KW_ACCESS - 124)) | (1 << (PostgreSQLParser.KW_ACTION - 124)) | (1 << (PostgreSQLParser.KW_ADD - 124)) | (1 << (PostgreSQLParser.KW_ADMIN - 124)) | (1 << (PostgreSQLParser.KW_AFTER - 124)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 124)) | (1 << (PostgreSQLParser.KW_ALSO - 124)) | (1 << (PostgreSQLParser.KW_ALTER - 124)) | (1 << (PostgreSQLParser.KW_ALWAYS - 124)) | (1 << (PostgreSQLParser.KW_ASSERTION - 124)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.KW_AT - 124)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.KW_BACKWARD - 124)) | (1 << (PostgreSQLParser.KW_BEFORE - 124)) | (1 << (PostgreSQLParser.KW_BEGIN - 124)) | (1 << (PostgreSQLParser.KW_BY - 124)) | (1 << (PostgreSQLParser.KW_CACHE - 124)) | (1 << (PostgreSQLParser.KW_CALLED - 124)) | (1 << (PostgreSQLParser.KW_CASCADE - 124)) | (1 << (PostgreSQLParser.KW_CASCADED - 124)) | (1 << (PostgreSQLParser.KW_CATALOG - 124)) | (1 << (PostgreSQLParser.KW_CHAIN - 124)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.KW_CLASS - 156)) | (1 << (PostgreSQLParser.KW_CLOSE - 156)) | (1 << (PostgreSQLParser.KW_CLUSTER - 156)) | (1 << (PostgreSQLParser.KW_COMMENT - 156)) | (1 << (PostgreSQLParser.KW_COMMENTS - 156)) | (1 << (PostgreSQLParser.KW_COMMIT - 156)) | (1 << (PostgreSQLParser.KW_COMMITTED - 156)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 156)) | (1 << (PostgreSQLParser.KW_CONNECTION - 156)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.KW_CONTENT - 156)) | (1 << (PostgreSQLParser.KW_CONTINUE - 156)) | (1 << (PostgreSQLParser.KW_CONVERSION - 156)) | (1 << (PostgreSQLParser.KW_COPY - 156)) | (1 << (PostgreSQLParser.KW_COST - 156)) | (1 << (PostgreSQLParser.KW_CSV - 156)) | (1 << (PostgreSQLParser.KW_CURSOR - 156)) | (1 << (PostgreSQLParser.KW_CYCLE - 156)) | (1 << (PostgreSQLParser.KW_DATA - 156)) | (1 << (PostgreSQLParser.KW_DATABASE - 156)) | (1 << (PostgreSQLParser.KW_DAY - 156)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 156)) | (1 << (PostgreSQLParser.KW_DECLARE - 156)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 156)) | (1 << (PostgreSQLParser.KW_DEFERRED - 156)) | (1 << (PostgreSQLParser.KW_DEFINER - 156)) | (1 << (PostgreSQLParser.KW_DELETE - 156)) | (1 << (PostgreSQLParser.KW_DELIMITER - 156)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 156)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 156)) | (1 << (PostgreSQLParser.KW_DISABLE - 156)) | (1 << (PostgreSQLParser.KW_DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.KW_DOCUMENT - 188)) | (1 << (PostgreSQLParser.KW_DOMAIN - 188)) | (1 << (PostgreSQLParser.KW_DOUBLE - 188)) | (1 << (PostgreSQLParser.KW_DROP - 188)) | (1 << (PostgreSQLParser.KW_EACH - 188)) | (1 << (PostgreSQLParser.KW_ENABLE - 188)) | (1 << (PostgreSQLParser.KW_ENCODING - 188)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 188)) | (1 << (PostgreSQLParser.KW_ENUM - 188)) | (1 << (PostgreSQLParser.KW_ESCAPE - 188)) | (1 << (PostgreSQLParser.KW_EVENT - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 188)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.KW_EXECUTE - 188)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 188)) | (1 << (PostgreSQLParser.KW_EXTENSION - 188)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 188)) | (1 << (PostgreSQLParser.KW_FAMILY - 188)) | (1 << (PostgreSQLParser.KW_FIRST - 188)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 188)) | (1 << (PostgreSQLParser.KW_FORCE - 188)) | (1 << (PostgreSQLParser.KW_FORWARD - 188)) | (1 << (PostgreSQLParser.KW_FUNCTION - 188)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 188)) | (1 << (PostgreSQLParser.KW_GLOBAL - 188)) | (1 << (PostgreSQLParser.KW_GRANTED - 188)) | (1 << (PostgreSQLParser.KW_HANDLER - 188)) | (1 << (PostgreSQLParser.KW_HEADER - 188)) | (1 << (PostgreSQLParser.KW_HOLD - 188)) | (1 << (PostgreSQLParser.KW_HOUR - 188)) | (1 << (PostgreSQLParser.KW_IDENTITY - 188)))) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.KW_IF - 220)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 220)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 220)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 220)) | (1 << (PostgreSQLParser.KW_INCLUDING - 220)) | (1 << (PostgreSQLParser.KW_INCREMENT - 220)) | (1 << (PostgreSQLParser.KW_INDEX - 220)) | (1 << (PostgreSQLParser.KW_INDEXES - 220)) | (1 << (PostgreSQLParser.KW_INHERIT - 220)) | (1 << (PostgreSQLParser.KW_INHERITS - 220)) | (1 << (PostgreSQLParser.KW_INLINE - 220)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 220)) | (1 << (PostgreSQLParser.KW_INSERT - 220)) | (1 << (PostgreSQLParser.KW_INSTEAD - 220)) | (1 << (PostgreSQLParser.KW_INVOKER - 220)) | (1 << (PostgreSQLParser.KW_ISOLATION - 220)) | (1 << (PostgreSQLParser.KW_KEY - 220)) | (1 << (PostgreSQLParser.KW_LABEL - 220)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 220)) | (1 << (PostgreSQLParser.KW_LARGE - 220)) | (1 << (PostgreSQLParser.KW_LAST - 220)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 220)) | (1 << (PostgreSQLParser.KW_LEVEL - 220)))) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.KW_LISTEN - 252)) | (1 << (PostgreSQLParser.KW_LOAD - 252)) | (1 << (PostgreSQLParser.KW_LOCAL - 252)) | (1 << (PostgreSQLParser.KW_LOCATION - 252)) | (1 << (PostgreSQLParser.KW_LOCK - 252)) | (1 << (PostgreSQLParser.KW_MAPPING - 252)) | (1 << (PostgreSQLParser.KW_MATCH - 252)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 252)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 252)) | (1 << (PostgreSQLParser.KW_MINUTE - 252)) | (1 << (PostgreSQLParser.KW_MINVALUE - 252)) | (1 << (PostgreSQLParser.KW_MODE - 252)) | (1 << (PostgreSQLParser.KW_MONTH - 252)) | (1 << (PostgreSQLParser.KW_MOVE - 252)) | (1 << (PostgreSQLParser.KW_NAME - 252)) | (1 << (PostgreSQLParser.KW_NAMES - 252)) | (1 << (PostgreSQLParser.KW_NEXT - 252)) | (1 << (PostgreSQLParser.KW_NO - 252)) | (1 << (PostgreSQLParser.KW_NOTHING - 252)) | (1 << (PostgreSQLParser.KW_NOTIFY - 252)) | (1 << (PostgreSQLParser.KW_NOWAIT - 252)) | (1 << (PostgreSQLParser.KW_NULLS - 252)) | (1 << (PostgreSQLParser.KW_OBJECT - 252)) | (1 << (PostgreSQLParser.KW_OF - 252)) | (1 << (PostgreSQLParser.KW_OFF - 252)) | (1 << (PostgreSQLParser.KW_OIDS - 252)) | (1 << (PostgreSQLParser.KW_OPERATOR - 252)) | (1 << (PostgreSQLParser.KW_OPTION - 252)) | (1 << (PostgreSQLParser.KW_OPTIONS - 252)) | (1 << (PostgreSQLParser.KW_OWNED - 252)) | (1 << (PostgreSQLParser.KW_OWNER - 252)) | (1 << (PostgreSQLParser.KW_PARSER - 252)))) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.KW_PARTIAL - 284)) | (1 << (PostgreSQLParser.KW_PARTITION - 284)) | (1 << (PostgreSQLParser.KW_PASSING - 284)) | (1 << (PostgreSQLParser.KW_PASSWORD - 284)) | (1 << (PostgreSQLParser.KW_PLANS - 284)) | (1 << (PostgreSQLParser.KW_PRECEDING - 284)) | (1 << (PostgreSQLParser.KW_PREPARE - 284)) | (1 << (PostgreSQLParser.KW_PREPARED - 284)) | (1 << (PostgreSQLParser.KW_PRESERVE - 284)) | (1 << (PostgreSQLParser.KW_PRIOR - 284)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 284)) | (1 << (PostgreSQLParser.KW_PROGRAM - 284)) | (1 << (PostgreSQLParser.KW_QUOTE - 284)) | (1 << (PostgreSQLParser.KW_RANGE - 284)) | (1 << (PostgreSQLParser.KW_READ - 284)) | (1 << (PostgreSQLParser.KW_REASSIGN - 284)) | (1 << (PostgreSQLParser.KW_RECHECK - 284)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 284)) | (1 << (PostgreSQLParser.KW_REF - 284)) | (1 << (PostgreSQLParser.KW_REFRESH - 284)) | (1 << (PostgreSQLParser.KW_REINDEX - 284)) | (1 << (PostgreSQLParser.KW_RELATIVE - 284)) | (1 << (PostgreSQLParser.KW_RELEASE - 284)) | (1 << (PostgreSQLParser.KW_RENAME - 284)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 284)) | (1 << (PostgreSQLParser.KW_REPLACE - 284)) | (1 << (PostgreSQLParser.KW_REPLICA - 284)) | (1 << (PostgreSQLParser.KW_RESET - 284)) | (1 << (PostgreSQLParser.KW_RESTART - 284)) | (1 << (PostgreSQLParser.KW_RESTRICT - 284)))) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.KW_RETURNS - 316)) | (1 << (PostgreSQLParser.KW_REVOKE - 316)) | (1 << (PostgreSQLParser.KW_ROLE - 316)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 316)) | (1 << (PostgreSQLParser.KW_ROWS - 316)) | (1 << (PostgreSQLParser.KW_RULE - 316)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 316)) | (1 << (PostgreSQLParser.KW_SCHEMA - 316)) | (1 << (PostgreSQLParser.KW_SCROLL - 316)) | (1 << (PostgreSQLParser.KW_SEARCH - 316)) | (1 << (PostgreSQLParser.KW_SECOND - 316)) | (1 << (PostgreSQLParser.KW_SECURITY - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 316)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.KW_SERVER - 316)) | (1 << (PostgreSQLParser.KW_SESSION - 316)) | (1 << (PostgreSQLParser.KW_SET - 316)) | (1 << (PostgreSQLParser.KW_SHARE - 316)) | (1 << (PostgreSQLParser.KW_SHOW - 316)) | (1 << (PostgreSQLParser.KW_SIMPLE - 316)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 316)) | (1 << (PostgreSQLParser.KW_STABLE - 316)) | (1 << (PostgreSQLParser.KW_STANDALONE - 316)) | (1 << (PostgreSQLParser.KW_START - 316)) | (1 << (PostgreSQLParser.KW_STATEMENT - 316)) | (1 << (PostgreSQLParser.KW_STATISTICS - 316)) | (1 << (PostgreSQLParser.KW_STDIN - 316)) | (1 << (PostgreSQLParser.KW_STDOUT - 316)) | (1 << (PostgreSQLParser.KW_STORAGE - 316)) | (1 << (PostgreSQLParser.KW_STRICT - 316)) | (1 << (PostgreSQLParser.KW_STRIP - 316)))) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.KW_SYSID - 348)) | (1 << (PostgreSQLParser.KW_SYSTEM - 348)) | (1 << (PostgreSQLParser.KW_TABLES - 348)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 348)) | (1 << (PostgreSQLParser.KW_TEMP - 348)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 348)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 348)) | (1 << (PostgreSQLParser.KW_TEXT - 348)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 348)) | (1 << (PostgreSQLParser.KW_TRIGGER - 348)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 348)) | (1 << (PostgreSQLParser.KW_TRUSTED - 348)) | (1 << (PostgreSQLParser.KW_TYPE - 348)) | (1 << (PostgreSQLParser.KW_TYPES - 348)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 348)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 348)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 348)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 348)) | (1 << (PostgreSQLParser.KW_UNTIL - 348)) | (1 << (PostgreSQLParser.KW_UPDATE - 348)) | (1 << (PostgreSQLParser.KW_VACUUM - 348)) | (1 << (PostgreSQLParser.KW_VALID - 348)) | (1 << (PostgreSQLParser.KW_VALIDATE - 348)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 348)) | (1 << (PostgreSQLParser.KW_VARYING - 348)) | (1 << (PostgreSQLParser.KW_VERSION - 348)) | (1 << (PostgreSQLParser.KW_VIEW - 348)) | (1 << (PostgreSQLParser.KW_VOLATILE - 348)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 348)) | (1 << (PostgreSQLParser.KW_WITHOUT - 348)))) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.KW_WORK - 380)) | (1 << (PostgreSQLParser.KW_WRAPPER - 380)) | (1 << (PostgreSQLParser.KW_WRITE - 380)) | (1 << (PostgreSQLParser.KW_XML - 380)) | (1 << (PostgreSQLParser.KW_YEAR - 380)) | (1 << (PostgreSQLParser.KW_YES - 380)) | (1 << (PostgreSQLParser.KW_ZONE - 380)) | (1 << (PostgreSQLParser.KW_BETWEEN - 380)) | (1 << (PostgreSQLParser.KW_BIGINT - 380)) | (1 << (PostgreSQLParser.KW_BIT - 380)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 380)) | (1 << (PostgreSQLParser.KW_CHAR - 380)) | (1 << (PostgreSQLParser.KW_CHARACTER - 380)) | (1 << (PostgreSQLParser.KW_COALESCE - 380)) | (1 << (PostgreSQLParser.KW_DEC - 380)) | (1 << (PostgreSQLParser.KW_DECIMAL - 380)) | (1 << (PostgreSQLParser.KW_EXISTS - 380)) | (1 << (PostgreSQLParser.KW_EXTRACT - 380)) | (1 << (PostgreSQLParser.KW_FLOAT - 380)) | (1 << (PostgreSQLParser.KW_GREATEST - 380)) | (1 << (PostgreSQLParser.KW_INOUT - 380)) | (1 << (PostgreSQLParser.KW_INT - 380)) | (1 << (PostgreSQLParser.KW_INTEGER - 380)) | (1 << (PostgreSQLParser.KW_INTERVAL - 380)) | (1 << (PostgreSQLParser.KW_LEAST - 380)) | (1 << (PostgreSQLParser.KW_NATIONAL - 380)) | (1 << (PostgreSQLParser.KW_NCHAR - 380)) | (1 << (PostgreSQLParser.KW_NONE - 380)) | (1 << (PostgreSQLParser.KW_NULLIF - 380)) | (1 << (PostgreSQLParser.KW_NUMERIC - 380)) | (1 << (PostgreSQLParser.KW_OVERLAY - 380)) | (1 << (PostgreSQLParser.KW_POSITION - 380)))) !== 0) || ((((_la - 412)) & ~0x1F) === 0 && ((1 << (_la - 412)) & ((1 << (PostgreSQLParser.KW_PRECISION - 412)) | (1 << (PostgreSQLParser.KW_REAL - 412)) | (1 << (PostgreSQLParser.KW_ROW - 412)) | (1 << (PostgreSQLParser.KW_SETOF - 412)) | (1 << (PostgreSQLParser.KW_SMALLINT - 412)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 412)) | (1 << (PostgreSQLParser.KW_TIME - 412)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 412)) | (1 << (PostgreSQLParser.KW_TREAT - 412)) | (1 << (PostgreSQLParser.KW_TRIM - 412)) | (1 << (PostgreSQLParser.KW_VALUES - 412)) | (1 << (PostgreSQLParser.KW_VARCHAR - 412)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 412)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 412)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 412)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 412)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 412)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 412)) | (1 << (PostgreSQLParser.KW_XMLPI - 412)) | (1 << (PostgreSQLParser.KW_XMLROOT - 412)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 412)) | (1 << (PostgreSQLParser.KW_CALL - 412)) | (1 << (PostgreSQLParser.KW_CURRENT - 412)) | (1 << (PostgreSQLParser.KW_ATTACH - 412)) | (1 << (PostgreSQLParser.KW_DETACH - 412)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 412)) | (1 << (PostgreSQLParser.KW_GENERATED - 412)) | (1 << (PostgreSQLParser.KW_LOGGED - 412)) | (1 << (PostgreSQLParser.KW_STORED - 412)) | (1 << (PostgreSQLParser.KW_INCLUDE - 412)) | (1 << (PostgreSQLParser.KW_ROUTINE - 412)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 412)))) !== 0) || ((((_la - 444)) & ~0x1F) === 0 && ((1 << (_la - 444)) & ((1 << (PostgreSQLParser.KW_IMPORT - 444)) | (1 << (PostgreSQLParser.KW_POLICY - 444)) | (1 << (PostgreSQLParser.KW_METHOD - 444)) | (1 << (PostgreSQLParser.KW_REFERENCING - 444)) | (1 << (PostgreSQLParser.KW_NEW - 444)) | (1 << (PostgreSQLParser.KW_OLD - 444)) | (1 << (PostgreSQLParser.KW_VALUE - 444)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 444)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 444)) | (1 << (PostgreSQLParser.KW_OUT - 444)) | (1 << (PostgreSQLParser.KW_ROUTINES - 444)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 444)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 444)) | (1 << (PostgreSQLParser.KW_INPUT - 444)) | (1 << (PostgreSQLParser.KW_SUPPORT - 444)) | (1 << (PostgreSQLParser.KW_PARALLEL - 444)) | (1 << (PostgreSQLParser.KW_SQL - 444)) | (1 << (PostgreSQLParser.KW_DEPENDS - 444)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 444)) | (1 << (PostgreSQLParser.KW_CONFLICT - 444)) | (1 << (PostgreSQLParser.KW_SKIP - 444)) | (1 << (PostgreSQLParser.KW_LOCKED - 444)) | (1 << (PostgreSQLParser.KW_TIES - 444)) | (1 << (PostgreSQLParser.KW_ROLLUP - 444)) | (1 << (PostgreSQLParser.KW_CUBE - 444)) | (1 << (PostgreSQLParser.KW_GROUPING - 444)) | (1 << (PostgreSQLParser.KW_SETS - 444)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 444)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 444)) | (1 << (PostgreSQLParser.KW_COLUMNS - 444)))) !== 0) || ((((_la - 476)) & ~0x1F) === 0 && ((1 << (_la - 476)) & ((1 << (PostgreSQLParser.KW_XMLNAMESPACES - 476)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 476)) | (1 << (PostgreSQLParser.KW_WITHIN - 476)) | (1 << (PostgreSQLParser.KW_FILTER - 476)) | (1 << (PostgreSQLParser.KW_GROUPS - 476)) | (1 << (PostgreSQLParser.KW_OTHERS - 476)) | (1 << (PostgreSQLParser.KW_NFC - 476)) | (1 << (PostgreSQLParser.KW_NFD - 476)) | (1 << (PostgreSQLParser.KW_NFKC - 476)) | (1 << (PostgreSQLParser.KW_NFKD - 476)) | (1 << (PostgreSQLParser.KW_UESCAPE - 476)) | (1 << (PostgreSQLParser.KW_VIEWS - 476)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 476)) | (1 << (PostgreSQLParser.KW_DUMP - 476)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 476)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 476)) | (1 << (PostgreSQLParser.KW_ERROR - 476)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 476)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 476)) | (1 << (PostgreSQLParser.KW_ALIAS - 476)) | (1 << (PostgreSQLParser.KW_CONSTANT - 476)) | (1 << (PostgreSQLParser.KW_PERFORM - 476)) | (1 << (PostgreSQLParser.KW_GET - 476)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 476)) | (1 << (PostgreSQLParser.KW_STACKED - 476)) | (1 << (PostgreSQLParser.KW_ELSIF - 476)) | (1 << (PostgreSQLParser.KW_REVERSE - 476)) | (1 << (PostgreSQLParser.KW_SLICE - 476)) | (1 << (PostgreSQLParser.KW_EXIT - 476)))) !== 0) || ((((_la - 508)) & ~0x1F) === 0 && ((1 << (_la - 508)) & ((1 << (PostgreSQLParser.KW_RETURN - 508)) | (1 << (PostgreSQLParser.KW_QUERY - 508)) | (1 << (PostgreSQLParser.KW_RAISE - 508)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 508)) | (1 << (PostgreSQLParser.KW_DEBUG - 508)) | (1 << (PostgreSQLParser.KW_LOG - 508)) | (1 << (PostgreSQLParser.KW_INFO - 508)) | (1 << (PostgreSQLParser.KW_NOTICE - 508)) | (1 << (PostgreSQLParser.KW_WARNING - 508)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 508)) | (1 << (PostgreSQLParser.KW_ASSERT - 508)) | (1 << (PostgreSQLParser.KW_OPEN - 508)) | (1 << (PostgreSQLParser.Identifier - 508)) | (1 << (PostgreSQLParser.QuotedIdentifier - 508)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 508)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 8699; + this.state = 8782; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: case PostgreSQLParser.PLSQLVARIABLENAME: case PostgreSQLParser.PLSQLIDENTIFIER: { - this.state = 8702; + this.state = 8785; this.colid(); } break; default: throw new NoViableAltException(this); } - this.state = 8705; + this.state = 8788; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8706; + this.state = 8789; this.tablefuncelementlist(); - this.state = 8707; + this.state = 8790; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -44928,14 +45347,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public join_type(): Join_typeContext { let _localctx: Join_typeContext = new Join_typeContext(this._ctx, this.state); - this.enterRule(_localctx, 1058, PostgreSQLParser.RULE_join_type); + this.enterRule(_localctx, 1072, PostgreSQLParser.RULE_join_type); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8711; + this.state = 8794; _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))) { + if (!(((((_la - 113)) & ~0x1F) === 0 && ((1 << (_la - 113)) & ((1 << (PostgreSQLParser.KW_FULL - 113)) | (1 << (PostgreSQLParser.KW_INNER - 113)) | (1 << (PostgreSQLParser.KW_LEFT - 113)) | (1 << (PostgreSQLParser.KW_RIGHT - 113)))) !== 0))) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -44945,13 +45364,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 8713; + this.state = 8796; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.OUTER_P) { + if (_la === PostgreSQLParser.KW_OUTER) { { - this.state = 8712; - this.match(PostgreSQLParser.OUTER_P); + this.state = 8795; + this.match(PostgreSQLParser.KW_OUTER); } } @@ -44974,30 +45393,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public join_qual(): Join_qualContext { let _localctx: Join_qualContext = new Join_qualContext(this._ctx, this.state); - this.enterRule(_localctx, 1060, PostgreSQLParser.RULE_join_qual); + this.enterRule(_localctx, 1074, PostgreSQLParser.RULE_join_qual); try { - this.state = 8722; + this.state = 8805; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.USING: + case PostgreSQLParser.KW_USING: this.enterOuterAlt(_localctx, 1); { - this.state = 8715; - this.match(PostgreSQLParser.USING); - this.state = 8716; + this.state = 8798; + this.match(PostgreSQLParser.KW_USING); + this.state = 8799; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8717; + this.state = 8800; this.name_list(); - this.state = 8718; + this.state = 8801; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.ON: + case PostgreSQLParser.KW_ON: this.enterOuterAlt(_localctx, 2); { - this.state = 8720; - this.match(PostgreSQLParser.ON); - this.state = 8721; + this.state = 8803; + this.match(PostgreSQLParser.KW_ON); + this.state = 8804; this.a_expr(); } break; @@ -45022,838 +45441,455 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public relation_expr(): Relation_exprContext { let _localctx: Relation_exprContext = new Relation_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 1062, PostgreSQLParser.RULE_relation_expr); + this.enterRule(_localctx, 1076, PostgreSQLParser.RULE_relation_expr); let _la: number; try { - this.state = 8736; + this.state = 8822; 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: + switch ( this.interpreter.adaptivePredict(this._input, 800, this._ctx) ) { + case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8724; + this.state = 8808; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_ONLY) { + { + this.state = 8807; + this.match(PostgreSQLParser.KW_ONLY); + } + } + + this.state = 8810; this.qualified_name(); - this.state = 8726; + this.state = 8812; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.STAR) { { - this.state = 8725; + this.state = 8811; this.match(PostgreSQLParser.STAR); } } } break; - case PostgreSQLParser.ONLY: + + case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8728; - this.match(PostgreSQLParser.ONLY); - this.state = 8734; + this.state = 8814; + this.match(PostgreSQLParser.KW_ONLY); + this.state = 8820; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: case PostgreSQLParser.PLSQLVARIABLENAME: case PostgreSQLParser.PLSQLIDENTIFIER: { - this.state = 8729; + this.state = 8815; this.qualified_name(); } break; case PostgreSQLParser.OPEN_PAREN: { - this.state = 8730; + this.state = 8816; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8731; + this.state = 8817; this.qualified_name(); - this.state = 8732; + this.state = 8818; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -45862,8 +45898,6 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } break; - default: - throw new NoViableAltException(this); } } catch (re) { @@ -45883,26 +45917,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public relation_expr_list(): Relation_expr_listContext { let _localctx: Relation_expr_listContext = new Relation_expr_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1064, PostgreSQLParser.RULE_relation_expr_list); + this.enterRule(_localctx, 1078, PostgreSQLParser.RULE_relation_expr_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8738; + this.state = 8824; this.relation_expr(); - this.state = 8743; + this.state = 8829; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8739; + this.state = 8825; this.match(PostgreSQLParser.COMMA); - this.state = 8740; + this.state = 8826; this.relation_expr(); } } - this.state = 8745; + this.state = 8831; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -45925,29 +45959,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public relation_expr_opt_alias(): Relation_expr_opt_aliasContext { let _localctx: Relation_expr_opt_aliasContext = new Relation_expr_opt_aliasContext(this._ctx, this.state); - this.enterRule(_localctx, 1066, PostgreSQLParser.RULE_relation_expr_opt_alias); + this.enterRule(_localctx, 1080, PostgreSQLParser.RULE_relation_expr_opt_alias); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8746; + this.state = 8832; this.relation_expr(); - this.state = 8751; + this.state = 8837; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 789, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 803, this._ctx) ) { case 1: { - this.state = 8748; + this.state = 8834; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 8747; - this.match(PostgreSQLParser.AS); + this.state = 8833; + this.match(PostgreSQLParser.KW_AS); } } - this.state = 8750; + this.state = 8836; this.colid(); } break; @@ -45971,27 +46005,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public tablesample_clause(): Tablesample_clauseContext { let _localctx: Tablesample_clauseContext = new Tablesample_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1068, PostgreSQLParser.RULE_tablesample_clause); + this.enterRule(_localctx, 1082, PostgreSQLParser.RULE_tablesample_clause); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8753; - this.match(PostgreSQLParser.TABLESAMPLE); - this.state = 8754; + this.state = 8839; + this.match(PostgreSQLParser.KW_TABLESAMPLE); + this.state = 8840; this.func_name(); - this.state = 8755; + this.state = 8841; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8756; + this.state = 8842; this.expr_list(); - this.state = 8757; + this.state = 8843; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 8759; + this.state = 8845; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.REPEATABLE) { + if (_la === PostgreSQLParser.KW_REPEATABLE) { { - this.state = 8758; + this.state = 8844; this.opt_repeatable_clause(); } } @@ -46015,17 +46049,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_repeatable_clause(): Opt_repeatable_clauseContext { let _localctx: Opt_repeatable_clauseContext = new Opt_repeatable_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1070, PostgreSQLParser.RULE_opt_repeatable_clause); + this.enterRule(_localctx, 1084, PostgreSQLParser.RULE_opt_repeatable_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8761; - this.match(PostgreSQLParser.REPEATABLE); - this.state = 8762; + this.state = 8847; + this.match(PostgreSQLParser.KW_REPEATABLE); + this.state = 8848; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8763; + this.state = 8849; this.a_expr(); - this.state = 8764; + this.state = 8850; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -46046,22 +46080,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_table(): Func_tableContext { let _localctx: Func_tableContext = new Func_tableContext(this._ctx, this.state); - this.enterRule(_localctx, 1072, PostgreSQLParser.RULE_func_table); + this.enterRule(_localctx, 1086, PostgreSQLParser.RULE_func_table); try { - this.state = 8778; + this.state = 8864; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 793, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 807, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8766; + this.state = 8852; this.func_expr_windowless(); - this.state = 8768; + this.state = 8854; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 791, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 805, this._ctx) ) { case 1: { - this.state = 8767; + this.state = 8853; this.opt_ordinality(); } break; @@ -46072,22 +46106,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8770; - this.match(PostgreSQLParser.ROWS); - this.state = 8771; - this.match(PostgreSQLParser.FROM); - this.state = 8772; + this.state = 8856; + this.match(PostgreSQLParser.KW_ROWS); + this.state = 8857; + this.match(PostgreSQLParser.KW_FROM); + this.state = 8858; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8773; + this.state = 8859; this.rowsfrom_list(); - this.state = 8774; + this.state = 8860; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 8776; + this.state = 8862; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 792, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 806, this._ctx) ) { case 1: { - this.state = 8775; + this.state = 8861; this.opt_ordinality(); } break; @@ -46113,19 +46147,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rowsfrom_item(): Rowsfrom_itemContext { let _localctx: Rowsfrom_itemContext = new Rowsfrom_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 1074, PostgreSQLParser.RULE_rowsfrom_item); + this.enterRule(_localctx, 1088, PostgreSQLParser.RULE_rowsfrom_item); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8780; + this.state = 8866; this.func_expr_windowless(); - this.state = 8782; + this.state = 8868; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 8781; + this.state = 8867; this.opt_col_def_list(); } } @@ -46149,26 +46183,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rowsfrom_list(): Rowsfrom_listContext { let _localctx: Rowsfrom_listContext = new Rowsfrom_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1076, PostgreSQLParser.RULE_rowsfrom_list); + this.enterRule(_localctx, 1090, PostgreSQLParser.RULE_rowsfrom_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8784; + this.state = 8870; this.rowsfrom_item(); - this.state = 8789; + this.state = 8875; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8785; + this.state = 8871; this.match(PostgreSQLParser.COMMA); - this.state = 8786; + this.state = 8872; this.rowsfrom_item(); } } - this.state = 8791; + this.state = 8877; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -46191,17 +46225,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_col_def_list(): Opt_col_def_listContext { let _localctx: Opt_col_def_listContext = new Opt_col_def_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1078, PostgreSQLParser.RULE_opt_col_def_list); + this.enterRule(_localctx, 1092, PostgreSQLParser.RULE_opt_col_def_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8792; - this.match(PostgreSQLParser.AS); - this.state = 8793; + this.state = 8878; + this.match(PostgreSQLParser.KW_AS); + this.state = 8879; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8794; + this.state = 8880; this.tablefuncelementlist(); - this.state = 8795; + this.state = 8881; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -46222,14 +46256,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_ordinality(): Opt_ordinalityContext { let _localctx: Opt_ordinalityContext = new Opt_ordinalityContext(this._ctx, this.state); - this.enterRule(_localctx, 1080, PostgreSQLParser.RULE_opt_ordinality); + this.enterRule(_localctx, 1094, PostgreSQLParser.RULE_opt_ordinality); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8797; - this.match(PostgreSQLParser.WITH); - this.state = 8798; - this.match(PostgreSQLParser.ORDINALITY); + this.state = 8883; + this.match(PostgreSQLParser.KW_WITH); + this.state = 8884; + this.match(PostgreSQLParser.KW_ORDINALITY); } } catch (re) { @@ -46249,13 +46283,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public where_clause(): Where_clauseContext { let _localctx: Where_clauseContext = new Where_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1082, PostgreSQLParser.RULE_where_clause); + this.enterRule(_localctx, 1096, PostgreSQLParser.RULE_where_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8800; - this.match(PostgreSQLParser.WHERE); - this.state = 8801; + this.state = 8886; + this.match(PostgreSQLParser.KW_WHERE); + this.state = 8887; this.a_expr(); } } @@ -46276,29 +46310,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public where_or_current_clause(): Where_or_current_clauseContext { let _localctx: Where_or_current_clauseContext = new Where_or_current_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1084, PostgreSQLParser.RULE_where_or_current_clause); + this.enterRule(_localctx, 1098, PostgreSQLParser.RULE_where_or_current_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8803; - this.match(PostgreSQLParser.WHERE); - this.state = 8808; + this.state = 8889; + this.match(PostgreSQLParser.KW_WHERE); + this.state = 8894; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 796, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 810, this._ctx) ) { case 1: { - this.state = 8804; - this.match(PostgreSQLParser.CURRENT_P); - this.state = 8805; - this.match(PostgreSQLParser.OF); - this.state = 8806; + this.state = 8890; + this.match(PostgreSQLParser.KW_CURRENT); + this.state = 8891; + this.match(PostgreSQLParser.KW_OF); + this.state = 8892; this.cursor_name(); } break; case 2: { - this.state = 8807; + this.state = 8893; this.a_expr(); } break; @@ -46322,11 +46356,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opttablefuncelementlist(): OpttablefuncelementlistContext { let _localctx: OpttablefuncelementlistContext = new OpttablefuncelementlistContext(this._ctx, this.state); - this.enterRule(_localctx, 1086, PostgreSQLParser.RULE_opttablefuncelementlist); + this.enterRule(_localctx, 1100, PostgreSQLParser.RULE_opttablefuncelementlist); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8810; + this.state = 8896; this.tablefuncelementlist(); } } @@ -46347,26 +46381,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public tablefuncelementlist(): TablefuncelementlistContext { let _localctx: TablefuncelementlistContext = new TablefuncelementlistContext(this._ctx, this.state); - this.enterRule(_localctx, 1088, PostgreSQLParser.RULE_tablefuncelementlist); + this.enterRule(_localctx, 1102, PostgreSQLParser.RULE_tablefuncelementlist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8812; + this.state = 8898; this.tablefuncelement(); - this.state = 8817; + this.state = 8903; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8813; + this.state = 8899; this.match(PostgreSQLParser.COMMA); - this.state = 8814; + this.state = 8900; this.tablefuncelement(); } } - this.state = 8819; + this.state = 8905; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -46389,21 +46423,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public tablefuncelement(): TablefuncelementContext { let _localctx: TablefuncelementContext = new TablefuncelementContext(this._ctx, this.state); - this.enterRule(_localctx, 1090, PostgreSQLParser.RULE_tablefuncelement); + this.enterRule(_localctx, 1104, PostgreSQLParser.RULE_tablefuncelement); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8820; + this.state = 8906; this.colid(); - this.state = 8821; + this.state = 8907; this.typename(); - this.state = 8823; + this.state = 8909; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.COLLATE) { + if (_la === PostgreSQLParser.KW_COLLATE) { { - this.state = 8822; + this.state = 8908; this.opt_collate_clause(); } } @@ -46427,54 +46461,54 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xmltable(): XmltableContext { let _localctx: XmltableContext = new XmltableContext(this._ctx, this.state); - this.enterRule(_localctx, 1092, PostgreSQLParser.RULE_xmltable); + this.enterRule(_localctx, 1106, PostgreSQLParser.RULE_xmltable); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8825; - this.match(PostgreSQLParser.XMLTABLE); - this.state = 8826; + this.state = 8911; + this.match(PostgreSQLParser.KW_XMLTABLE); + this.state = 8912; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8842; + this.state = 8928; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 799, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 813, this._ctx) ) { case 1: { - this.state = 8827; + this.state = 8913; this.c_expr(); - this.state = 8828; + this.state = 8914; this.xmlexists_argument(); - this.state = 8829; - this.match(PostgreSQLParser.COLUMNS); - this.state = 8830; + this.state = 8915; + this.match(PostgreSQLParser.KW_COLUMNS); + this.state = 8916; this.xmltable_column_list(); } break; case 2: { - this.state = 8832; - this.match(PostgreSQLParser.XMLNAMESPACES); - this.state = 8833; + this.state = 8918; + this.match(PostgreSQLParser.KW_XMLNAMESPACES); + this.state = 8919; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8834; + this.state = 8920; this.xml_namespace_list(); - this.state = 8835; + this.state = 8921; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 8836; + this.state = 8922; this.match(PostgreSQLParser.COMMA); - this.state = 8837; + this.state = 8923; this.c_expr(); - this.state = 8838; + this.state = 8924; this.xmlexists_argument(); - this.state = 8839; - this.match(PostgreSQLParser.COLUMNS); - this.state = 8840; + this.state = 8925; + this.match(PostgreSQLParser.KW_COLUMNS); + this.state = 8926; this.xmltable_column_list(); } break; } - this.state = 8844; + this.state = 8930; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -46495,26 +46529,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xmltable_column_list(): Xmltable_column_listContext { let _localctx: Xmltable_column_listContext = new Xmltable_column_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1094, PostgreSQLParser.RULE_xmltable_column_list); + this.enterRule(_localctx, 1108, PostgreSQLParser.RULE_xmltable_column_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8846; + this.state = 8932; this.xmltable_column_el(); - this.state = 8851; + this.state = 8937; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8847; + this.state = 8933; this.match(PostgreSQLParser.COMMA); - this.state = 8848; + this.state = 8934; this.xmltable_column_el(); } } - this.state = 8853; + this.state = 8939; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -46537,453 +46571,453 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xmltable_column_el(): Xmltable_column_elContext { let _localctx: Xmltable_column_elContext = new Xmltable_column_elContext(this._ctx, this.state); - this.enterRule(_localctx, 1096, PostgreSQLParser.RULE_xmltable_column_el); + this.enterRule(_localctx, 1110, PostgreSQLParser.RULE_xmltable_column_el); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8854; + this.state = 8940; this.colid(); - this.state = 8861; + this.state = 8947; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: case PostgreSQLParser.PLSQLVARIABLENAME: case PostgreSQLParser.PLSQLIDENTIFIER: { - this.state = 8855; + this.state = 8941; this.typename(); - this.state = 8857; + this.state = 8943; 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) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 77)) & ~0x1F) === 0 && ((1 << (_la - 77)) & ((1 << (PostgreSQLParser.KW_NOT - 77)) | (1 << (PostgreSQLParser.KW_NULL - 77)) | (1 << (PostgreSQLParser.KW_TABLE - 77)))) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & ((1 << (PostgreSQLParser.KW_IS - 116)) | (1 << (PostgreSQLParser.KW_OUTER - 116)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 116)) | (1 << (PostgreSQLParser.KW_BACKWARD - 116)))) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & ((1 << (PostgreSQLParser.KW_CHAIN - 153)) | (1 << (PostgreSQLParser.KW_CLOSE - 153)) | (1 << (PostgreSQLParser.KW_COMMIT - 153)) | (1 << (PostgreSQLParser.KW_CONTINUE - 153)) | (1 << (PostgreSQLParser.KW_CURSOR - 153)))) !== 0) || _la === PostgreSQLParser.KW_FIRST || _la === PostgreSQLParser.KW_FORWARD || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & ((1 << (PostgreSQLParser.KW_INSERT - 241)) | (1 << (PostgreSQLParser.KW_LAST - 241)) | (1 << (PostgreSQLParser.KW_MOVE - 241)) | (1 << (PostgreSQLParser.KW_NEXT - 241)) | (1 << (PostgreSQLParser.KW_NO - 241)))) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & ((1 << (PostgreSQLParser.KW_OPTION - 279)) | (1 << (PostgreSQLParser.KW_PRIOR - 279)) | (1 << (PostgreSQLParser.KW_RELATIVE - 279)))) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & ((1 << (PostgreSQLParser.KW_RESET - 313)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 313)) | (1 << (PostgreSQLParser.KW_SCHEMA - 313)) | (1 << (PostgreSQLParser.KW_SCROLL - 313)) | (1 << (PostgreSQLParser.KW_SET - 313)))) !== 0) || _la === PostgreSQLParser.KW_TYPE || _la === PostgreSQLParser.KW_CALL || _la === PostgreSQLParser.KW_CURRENT || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & ((1 << (PostgreSQLParser.KW_ROWTYPE - 477)) | (1 << (PostgreSQLParser.KW_DUMP - 477)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 477)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 477)) | (1 << (PostgreSQLParser.KW_ERROR - 477)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 477)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 477)) | (1 << (PostgreSQLParser.KW_ALIAS - 477)) | (1 << (PostgreSQLParser.KW_CONSTANT - 477)) | (1 << (PostgreSQLParser.KW_PERFORM - 477)) | (1 << (PostgreSQLParser.KW_GET - 477)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 477)) | (1 << (PostgreSQLParser.KW_STACKED - 477)) | (1 << (PostgreSQLParser.KW_ELSIF - 477)) | (1 << (PostgreSQLParser.KW_REVERSE - 477)) | (1 << (PostgreSQLParser.KW_SLICE - 477)) | (1 << (PostgreSQLParser.KW_EXIT - 477)) | (1 << (PostgreSQLParser.KW_RETURN - 477)))) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & ((1 << (PostgreSQLParser.KW_QUERY - 509)) | (1 << (PostgreSQLParser.KW_RAISE - 509)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 509)) | (1 << (PostgreSQLParser.KW_DEBUG - 509)) | (1 << (PostgreSQLParser.KW_LOG - 509)) | (1 << (PostgreSQLParser.KW_INFO - 509)) | (1 << (PostgreSQLParser.KW_NOTICE - 509)) | (1 << (PostgreSQLParser.KW_WARNING - 509)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 509)) | (1 << (PostgreSQLParser.KW_ASSERT - 509)) | (1 << (PostgreSQLParser.KW_OPEN - 509)) | (1 << (PostgreSQLParser.Identifier - 509)) | (1 << (PostgreSQLParser.QuotedIdentifier - 509)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 509)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER) { { - this.state = 8856; + this.state = 8942; this.xmltable_column_option_list(); } } } break; - case PostgreSQLParser.FOR: + case PostgreSQLParser.KW_FOR: { - this.state = 8859; - this.match(PostgreSQLParser.FOR); - this.state = 8860; - this.match(PostgreSQLParser.ORDINALITY); + this.state = 8945; + this.match(PostgreSQLParser.KW_FOR); + this.state = 8946; + this.match(PostgreSQLParser.KW_ORDINALITY); } break; default: @@ -47008,25 +47042,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xmltable_column_option_list(): Xmltable_column_option_listContext { let _localctx: Xmltable_column_option_listContext = new Xmltable_column_option_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1098, PostgreSQLParser.RULE_xmltable_column_option_list); + this.enterRule(_localctx, 1112, PostgreSQLParser.RULE_xmltable_column_option_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8864; + this.state = 8950; this._errHandler.sync(this); _la = this._input.LA(1); do { { { - this.state = 8863; + this.state = 8949; this.xmltable_column_option_el(); } } - this.state = 8866; + this.state = 8952; 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); + } while (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 77)) & ~0x1F) === 0 && ((1 << (_la - 77)) & ((1 << (PostgreSQLParser.KW_NOT - 77)) | (1 << (PostgreSQLParser.KW_NULL - 77)) | (1 << (PostgreSQLParser.KW_TABLE - 77)))) !== 0) || ((((_la - 116)) & ~0x1F) === 0 && ((1 << (_la - 116)) & ((1 << (PostgreSQLParser.KW_IS - 116)) | (1 << (PostgreSQLParser.KW_OUTER - 116)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 116)) | (1 << (PostgreSQLParser.KW_BACKWARD - 116)))) !== 0) || ((((_la - 153)) & ~0x1F) === 0 && ((1 << (_la - 153)) & ((1 << (PostgreSQLParser.KW_CHAIN - 153)) | (1 << (PostgreSQLParser.KW_CLOSE - 153)) | (1 << (PostgreSQLParser.KW_COMMIT - 153)) | (1 << (PostgreSQLParser.KW_CONTINUE - 153)) | (1 << (PostgreSQLParser.KW_CURSOR - 153)))) !== 0) || _la === PostgreSQLParser.KW_FIRST || _la === PostgreSQLParser.KW_FORWARD || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & ((1 << (PostgreSQLParser.KW_INSERT - 241)) | (1 << (PostgreSQLParser.KW_LAST - 241)) | (1 << (PostgreSQLParser.KW_MOVE - 241)) | (1 << (PostgreSQLParser.KW_NEXT - 241)) | (1 << (PostgreSQLParser.KW_NO - 241)))) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & ((1 << (PostgreSQLParser.KW_OPTION - 279)) | (1 << (PostgreSQLParser.KW_PRIOR - 279)) | (1 << (PostgreSQLParser.KW_RELATIVE - 279)))) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & ((1 << (PostgreSQLParser.KW_RESET - 313)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 313)) | (1 << (PostgreSQLParser.KW_SCHEMA - 313)) | (1 << (PostgreSQLParser.KW_SCROLL - 313)) | (1 << (PostgreSQLParser.KW_SET - 313)))) !== 0) || _la === PostgreSQLParser.KW_TYPE || _la === PostgreSQLParser.KW_CALL || _la === PostgreSQLParser.KW_CURRENT || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & ((1 << (PostgreSQLParser.KW_ROWTYPE - 477)) | (1 << (PostgreSQLParser.KW_DUMP - 477)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 477)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 477)) | (1 << (PostgreSQLParser.KW_ERROR - 477)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 477)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 477)) | (1 << (PostgreSQLParser.KW_ALIAS - 477)) | (1 << (PostgreSQLParser.KW_CONSTANT - 477)) | (1 << (PostgreSQLParser.KW_PERFORM - 477)) | (1 << (PostgreSQLParser.KW_GET - 477)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 477)) | (1 << (PostgreSQLParser.KW_STACKED - 477)) | (1 << (PostgreSQLParser.KW_ELSIF - 477)) | (1 << (PostgreSQLParser.KW_REVERSE - 477)) | (1 << (PostgreSQLParser.KW_SLICE - 477)) | (1 << (PostgreSQLParser.KW_EXIT - 477)) | (1 << (PostgreSQLParser.KW_RETURN - 477)))) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & ((1 << (PostgreSQLParser.KW_QUERY - 509)) | (1 << (PostgreSQLParser.KW_RAISE - 509)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 509)) | (1 << (PostgreSQLParser.KW_DEBUG - 509)) | (1 << (PostgreSQLParser.KW_LOG - 509)) | (1 << (PostgreSQLParser.KW_INFO - 509)) | (1 << (PostgreSQLParser.KW_NOTICE - 509)) | (1 << (PostgreSQLParser.KW_WARNING - 509)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 509)) | (1 << (PostgreSQLParser.KW_ASSERT - 509)) | (1 << (PostgreSQLParser.KW_OPEN - 509)) | (1 << (PostgreSQLParser.Identifier - 509)) | (1 << (PostgreSQLParser.QuotedIdentifier - 509)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 509)))) !== 0) || _la === PostgreSQLParser.PLSQLVARIABLENAME || _la === PostgreSQLParser.PLSQLIDENTIFIER); } } catch (re) { @@ -47046,17 +47080,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xmltable_column_option_el(): Xmltable_column_option_elContext { let _localctx: Xmltable_column_option_elContext = new Xmltable_column_option_elContext(this._ctx, this.state); - this.enterRule(_localctx, 1100, PostgreSQLParser.RULE_xmltable_column_option_el); + this.enterRule(_localctx, 1114, PostgreSQLParser.RULE_xmltable_column_option_el); try { - this.state = 8876; + this.state = 8962; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 804, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 818, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8868; - this.match(PostgreSQLParser.DEFAULT); - this.state = 8869; + this.state = 8954; + this.match(PostgreSQLParser.KW_DEFAULT); + this.state = 8955; this.a_expr(); } break; @@ -47064,9 +47098,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8870; + this.state = 8956; this.identifier(); - this.state = 8871; + this.state = 8957; this.a_expr(); } break; @@ -47074,18 +47108,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 8873; - this.match(PostgreSQLParser.NOT); - this.state = 8874; - this.match(PostgreSQLParser.NULL_P); + this.state = 8959; + this.match(PostgreSQLParser.KW_NOT); + this.state = 8960; + this.match(PostgreSQLParser.KW_NULL); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 8875; - this.match(PostgreSQLParser.NULL_P); + this.state = 8961; + this.match(PostgreSQLParser.KW_NULL); } break; } @@ -47107,26 +47141,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xml_namespace_list(): Xml_namespace_listContext { let _localctx: Xml_namespace_listContext = new Xml_namespace_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1102, PostgreSQLParser.RULE_xml_namespace_list); + this.enterRule(_localctx, 1116, PostgreSQLParser.RULE_xml_namespace_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8878; + this.state = 8964; this.xml_namespace_el(); - this.state = 8883; + this.state = 8969; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 8879; + this.state = 8965; this.match(PostgreSQLParser.COMMA); - this.state = 8880; + this.state = 8966; this.xml_namespace_el(); } } - this.state = 8885; + this.state = 8971; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -47149,19 +47183,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xml_namespace_el(): Xml_namespace_elContext { let _localctx: Xml_namespace_elContext = new Xml_namespace_elContext(this._ctx, this.state); - this.enterRule(_localctx, 1104, PostgreSQLParser.RULE_xml_namespace_el); + this.enterRule(_localctx, 1118, PostgreSQLParser.RULE_xml_namespace_el); try { - this.state = 8892; + this.state = 8978; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 806, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 820, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8886; + this.state = 8972; this.b_expr(0); - this.state = 8887; - this.match(PostgreSQLParser.AS); - this.state = 8888; + this.state = 8973; + this.match(PostgreSQLParser.KW_AS); + this.state = 8974; this.collabel(); } break; @@ -47169,9 +47203,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8890; - this.match(PostgreSQLParser.DEFAULT); - this.state = 8891; + this.state = 8976; + this.match(PostgreSQLParser.KW_DEFAULT); + this.state = 8977; this.b_expr(0); } break; @@ -47194,51 +47228,51 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public typename(): TypenameContext { let _localctx: TypenameContext = new TypenameContext(this._ctx, this.state); - this.enterRule(_localctx, 1106, PostgreSQLParser.RULE_typename); + this.enterRule(_localctx, 1120, PostgreSQLParser.RULE_typename); let _la: number; try { - this.state = 8912; + this.state = 8998; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 810, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 824, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8895; + this.state = 8981; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.SETOF) { + if (_la === PostgreSQLParser.KW_SETOF) { { - this.state = 8894; - this.match(PostgreSQLParser.SETOF); + this.state = 8980; + this.match(PostgreSQLParser.KW_SETOF); } } - this.state = 8897; + this.state = 8983; this.simpletypename(); - this.state = 8906; + this.state = 8992; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 809, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 823, this._ctx) ) { case 1: { - this.state = 8898; + this.state = 8984; this.opt_array_bounds(); } break; case 2: { - this.state = 8899; - this.match(PostgreSQLParser.ARRAY); - this.state = 8904; + this.state = 8985; + this.match(PostgreSQLParser.KW_ARRAY); + this.state = 8990; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 808, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 822, this._ctx) ) { case 1: { - this.state = 8900; + this.state = 8986; this.match(PostgreSQLParser.OPEN_BRACKET); - this.state = 8901; + this.state = 8987; this.iconst(); - this.state = 8902; + this.state = 8988; this.match(PostgreSQLParser.CLOSE_BRACKET); } break; @@ -47252,13 +47286,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8908; + this.state = 8994; this.qualified_name(); - this.state = 8909; + this.state = 8995; this.match(PostgreSQLParser.PERCENT); - this.state = 8910; + this.state = 8996; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.TYPE_P || _la === PostgreSQLParser.ROWTYPE)) { + if (!(_la === PostgreSQLParser.KW_TYPE || _la === PostgreSQLParser.KW_ROWTYPE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -47289,39 +47323,39 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_array_bounds(): Opt_array_boundsContext { let _localctx: Opt_array_boundsContext = new Opt_array_boundsContext(this._ctx, this.state); - this.enterRule(_localctx, 1108, PostgreSQLParser.RULE_opt_array_bounds); + this.enterRule(_localctx, 1122, PostgreSQLParser.RULE_opt_array_bounds); let _la: number; try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 8921; + this.state = 9007; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 812, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 826, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 8914; + this.state = 9000; this.match(PostgreSQLParser.OPEN_BRACKET); - this.state = 8916; + this.state = 9002; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.Integral) { { - this.state = 8915; + this.state = 9001; this.iconst(); } } - this.state = 8918; + this.state = 9004; this.match(PostgreSQLParser.CLOSE_BRACKET); } } } - this.state = 8923; + this.state = 9009; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 812, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 826, this._ctx); } } } @@ -47342,15 +47376,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public simpletypename(): SimpletypenameContext { let _localctx: SimpletypenameContext = new SimpletypenameContext(this._ctx, this.state); - this.enterRule(_localctx, 1110, PostgreSQLParser.RULE_simpletypename); + this.enterRule(_localctx, 1124, PostgreSQLParser.RULE_simpletypename); try { - this.state = 8939; + this.state = 9025; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 815, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 829, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8924; + this.state = 9010; this.generictype(); } break; @@ -47358,7 +47392,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8925; + this.state = 9011; this.numeric(); } break; @@ -47366,7 +47400,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 8926; + this.state = 9012; this.bit(); } break; @@ -47374,7 +47408,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 8927; + this.state = 9013; this.character(); } break; @@ -47382,7 +47416,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 8928; + this.state = 9014; this.constdatetime(); } break; @@ -47390,19 +47424,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 8929; + this.state = 9015; this.constinterval(); - this.state = 8937; + this.state = 9023; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 814, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 828, this._ctx) ) { case 1: { - this.state = 8931; + this.state = 9017; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 813, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 827, this._ctx) ) { case 1: { - this.state = 8930; + this.state = 9016; this.opt_interval(); } break; @@ -47412,11 +47446,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: { - this.state = 8933; + this.state = 9019; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8934; + this.state = 9020; this.iconst(); - this.state = 8935; + this.state = 9021; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -47442,51 +47476,51 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public consttypename(): ConsttypenameContext { let _localctx: ConsttypenameContext = new ConsttypenameContext(this._ctx, this.state); - this.enterRule(_localctx, 1112, PostgreSQLParser.RULE_consttypename); + this.enterRule(_localctx, 1126, PostgreSQLParser.RULE_consttypename); try { - this.state = 8945; + this.state = 9031; 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: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_SMALLINT: this.enterOuterAlt(_localctx, 1); { - this.state = 8941; + this.state = 9027; this.numeric(); } break; - case PostgreSQLParser.BIT: + case PostgreSQLParser.KW_BIT: this.enterOuterAlt(_localctx, 2); { - this.state = 8942; + this.state = 9028; this.constbit(); } break; - case PostgreSQLParser.CHAR_P: - case PostgreSQLParser.CHARACTER: - case PostgreSQLParser.NATIONAL: - case PostgreSQLParser.NCHAR: - case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_VARCHAR: this.enterOuterAlt(_localctx, 3); { - this.state = 8943; + this.state = 9029; this.constcharacter(); } break; - case PostgreSQLParser.TIME: - case PostgreSQLParser.TIMESTAMP: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: this.enterOuterAlt(_localctx, 4); { - this.state = 8944; + this.state = 9030; this.constdatetime(); } break; @@ -47511,28 +47545,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public generictype(): GenerictypeContext { let _localctx: GenerictypeContext = new GenerictypeContext(this._ctx, this.state); - this.enterRule(_localctx, 1114, PostgreSQLParser.RULE_generictype); + this.enterRule(_localctx, 1128, PostgreSQLParser.RULE_generictype); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8947; + this.state = 9033; this.type_function_name(); - this.state = 8949; + this.state = 9035; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 817, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 831, this._ctx) ) { case 1: { - this.state = 8948; + this.state = 9034; this.attrs(); } break; } - this.state = 8952; + this.state = 9038; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 818, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 832, this._ctx) ) { case 1: { - this.state = 8951; + this.state = 9037; this.opt_type_modifiers(); } break; @@ -47556,15 +47590,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_type_modifiers(): Opt_type_modifiersContext { let _localctx: Opt_type_modifiersContext = new Opt_type_modifiersContext(this._ctx, this.state); - this.enterRule(_localctx, 1116, PostgreSQLParser.RULE_opt_type_modifiers); + this.enterRule(_localctx, 1130, PostgreSQLParser.RULE_opt_type_modifiers); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8954; + this.state = 9040; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8955; + this.state = 9041; this.expr_list(); - this.state = 8956; + this.state = 9042; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -47585,128 +47619,128 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public numeric(): NumericContext { let _localctx: NumericContext = new NumericContext(this._ctx, this.state); - this.enterRule(_localctx, 1118, PostgreSQLParser.RULE_numeric); + this.enterRule(_localctx, 1132, PostgreSQLParser.RULE_numeric); try { - this.state = 8982; + this.state = 9068; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.INT_P: + case PostgreSQLParser.KW_INT: this.enterOuterAlt(_localctx, 1); { - this.state = 8958; - this.match(PostgreSQLParser.INT_P); + this.state = 9044; + this.match(PostgreSQLParser.KW_INT); } break; - case PostgreSQLParser.INTEGER: + case PostgreSQLParser.KW_INTEGER: this.enterOuterAlt(_localctx, 2); { - this.state = 8959; - this.match(PostgreSQLParser.INTEGER); + this.state = 9045; + this.match(PostgreSQLParser.KW_INTEGER); } break; - case PostgreSQLParser.SMALLINT: + case PostgreSQLParser.KW_SMALLINT: this.enterOuterAlt(_localctx, 3); { - this.state = 8960; - this.match(PostgreSQLParser.SMALLINT); + this.state = 9046; + this.match(PostgreSQLParser.KW_SMALLINT); } break; - case PostgreSQLParser.BIGINT: + case PostgreSQLParser.KW_BIGINT: this.enterOuterAlt(_localctx, 4); { - this.state = 8961; - this.match(PostgreSQLParser.BIGINT); + this.state = 9047; + this.match(PostgreSQLParser.KW_BIGINT); } break; - case PostgreSQLParser.REAL: + case PostgreSQLParser.KW_REAL: this.enterOuterAlt(_localctx, 5); { - this.state = 8962; - this.match(PostgreSQLParser.REAL); + this.state = 9048; + this.match(PostgreSQLParser.KW_REAL); } break; - case PostgreSQLParser.FLOAT_P: + case PostgreSQLParser.KW_FLOAT: this.enterOuterAlt(_localctx, 6); { - this.state = 8963; - this.match(PostgreSQLParser.FLOAT_P); - this.state = 8965; + this.state = 9049; + this.match(PostgreSQLParser.KW_FLOAT); + this.state = 9051; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 819, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 833, this._ctx) ) { case 1: { - this.state = 8964; + this.state = 9050; this.opt_float(); } break; } } break; - case PostgreSQLParser.DOUBLE_P: + case PostgreSQLParser.KW_DOUBLE: this.enterOuterAlt(_localctx, 7); { - this.state = 8967; - this.match(PostgreSQLParser.DOUBLE_P); - this.state = 8968; - this.match(PostgreSQLParser.PRECISION); + this.state = 9053; + this.match(PostgreSQLParser.KW_DOUBLE); + this.state = 9054; + this.match(PostgreSQLParser.KW_PRECISION); } break; - case PostgreSQLParser.DECIMAL_P: + case PostgreSQLParser.KW_DECIMAL: this.enterOuterAlt(_localctx, 8); { - this.state = 8969; - this.match(PostgreSQLParser.DECIMAL_P); - this.state = 8971; + this.state = 9055; + this.match(PostgreSQLParser.KW_DECIMAL); + this.state = 9057; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 820, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 834, this._ctx) ) { case 1: { - this.state = 8970; + this.state = 9056; this.opt_type_modifiers(); } break; } } break; - case PostgreSQLParser.DEC: + case PostgreSQLParser.KW_DEC: this.enterOuterAlt(_localctx, 9); { - this.state = 8973; - this.match(PostgreSQLParser.DEC); - this.state = 8975; + this.state = 9059; + this.match(PostgreSQLParser.KW_DEC); + this.state = 9061; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 821, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 835, this._ctx) ) { case 1: { - this.state = 8974; + this.state = 9060; this.opt_type_modifiers(); } break; } } break; - case PostgreSQLParser.NUMERIC: + case PostgreSQLParser.KW_NUMERIC: this.enterOuterAlt(_localctx, 10); { - this.state = 8977; - this.match(PostgreSQLParser.NUMERIC); - this.state = 8979; + this.state = 9063; + this.match(PostgreSQLParser.KW_NUMERIC); + this.state = 9065; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 822, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 836, this._ctx) ) { case 1: { - this.state = 8978; + this.state = 9064; this.opt_type_modifiers(); } break; } } break; - case PostgreSQLParser.BOOLEAN_P: + case PostgreSQLParser.KW_BOOLEAN: this.enterOuterAlt(_localctx, 11); { - this.state = 8981; - this.match(PostgreSQLParser.BOOLEAN_P); + this.state = 9067; + this.match(PostgreSQLParser.KW_BOOLEAN); } break; default: @@ -47730,15 +47764,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_float(): Opt_floatContext { let _localctx: Opt_floatContext = new Opt_floatContext(this._ctx, this.state); - this.enterRule(_localctx, 1120, PostgreSQLParser.RULE_opt_float); + this.enterRule(_localctx, 1134, PostgreSQLParser.RULE_opt_float); try { this.enterOuterAlt(_localctx, 1); { - this.state = 8984; + this.state = 9070; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 8985; + this.state = 9071; this.iconst(); - this.state = 8986; + this.state = 9072; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -47759,15 +47793,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public bit(): BitContext { let _localctx: BitContext = new BitContext(this._ctx, this.state); - this.enterRule(_localctx, 1122, PostgreSQLParser.RULE_bit); + this.enterRule(_localctx, 1136, PostgreSQLParser.RULE_bit); try { - this.state = 8990; + this.state = 9076; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 824, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 838, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8988; + this.state = 9074; this.bitwithlength(); } break; @@ -47775,7 +47809,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8989; + this.state = 9075; this.bitwithoutlength(); } break; @@ -47798,15 +47832,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public constbit(): ConstbitContext { let _localctx: ConstbitContext = new ConstbitContext(this._ctx, this.state); - this.enterRule(_localctx, 1124, PostgreSQLParser.RULE_constbit); + this.enterRule(_localctx, 1138, PostgreSQLParser.RULE_constbit); try { - this.state = 8994; + this.state = 9080; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 825, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 839, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 8992; + this.state = 9078; this.bitwithlength(); } break; @@ -47814,7 +47848,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 8993; + this.state = 9079; this.bitwithoutlength(); } break; @@ -47837,28 +47871,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public bitwithlength(): BitwithlengthContext { let _localctx: BitwithlengthContext = new BitwithlengthContext(this._ctx, this.state); - this.enterRule(_localctx, 1126, PostgreSQLParser.RULE_bitwithlength); + this.enterRule(_localctx, 1140, PostgreSQLParser.RULE_bitwithlength); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 8996; - this.match(PostgreSQLParser.BIT); - this.state = 8998; + this.state = 9082; + this.match(PostgreSQLParser.KW_BIT); + this.state = 9084; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.VARYING) { + if (_la === PostgreSQLParser.KW_VARYING) { { - this.state = 8997; + this.state = 9083; this.opt_varying(); } } - this.state = 9000; + this.state = 9086; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9001; + this.state = 9087; this.expr_list(); - this.state = 9002; + this.state = 9088; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -47879,18 +47913,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public bitwithoutlength(): BitwithoutlengthContext { let _localctx: BitwithoutlengthContext = new BitwithoutlengthContext(this._ctx, this.state); - this.enterRule(_localctx, 1128, PostgreSQLParser.RULE_bitwithoutlength); + this.enterRule(_localctx, 1142, PostgreSQLParser.RULE_bitwithoutlength); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9004; - this.match(PostgreSQLParser.BIT); - this.state = 9006; + this.state = 9090; + this.match(PostgreSQLParser.KW_BIT); + this.state = 9092; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 827, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 841, this._ctx) ) { case 1: { - this.state = 9005; + this.state = 9091; this.opt_varying(); } break; @@ -47914,22 +47948,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public character(): CharacterContext { let _localctx: CharacterContext = new CharacterContext(this._ctx, this.state); - this.enterRule(_localctx, 1130, PostgreSQLParser.RULE_character); + this.enterRule(_localctx, 1144, PostgreSQLParser.RULE_character); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9008; + this.state = 9094; this.character_c(); - this.state = 9013; + this.state = 9099; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 828, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 842, this._ctx) ) { case 1: { - this.state = 9009; + this.state = 9095; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9010; + this.state = 9096; this.iconst(); - this.state = 9011; + this.state = 9097; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -47953,23 +47987,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public constcharacter(): ConstcharacterContext { let _localctx: ConstcharacterContext = new ConstcharacterContext(this._ctx, this.state); - this.enterRule(_localctx, 1132, PostgreSQLParser.RULE_constcharacter); + this.enterRule(_localctx, 1146, PostgreSQLParser.RULE_constcharacter); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9015; + this.state = 9101; this.character_c(); - this.state = 9020; + this.state = 9106; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 9016; + this.state = 9102; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9017; + this.state = 9103; this.iconst(); - this.state = 9018; + this.state = 9104; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -47993,20 +48027,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public character_c(): Character_cContext { let _localctx: Character_cContext = new Character_cContext(this._ctx, this.state); - this.enterRule(_localctx, 1134, PostgreSQLParser.RULE_character_c); + this.enterRule(_localctx, 1148, PostgreSQLParser.RULE_character_c); let _la: number; try { - this.state = 9032; + this.state = 9118; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.CHAR_P: - case PostgreSQLParser.CHARACTER: - case PostgreSQLParser.NCHAR: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_NCHAR: this.enterOuterAlt(_localctx, 1); { - this.state = 9022; + this.state = 9108; _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))) { + if (!(((((_la - 391)) & ~0x1F) === 0 && ((1 << (_la - 391)) & ((1 << (PostgreSQLParser.KW_CHAR - 391)) | (1 << (PostgreSQLParser.KW_CHARACTER - 391)) | (1 << (PostgreSQLParser.KW_NCHAR - 391)))) !== 0))) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -48016,33 +48050,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9024; + this.state = 9110; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 830, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 844, this._ctx) ) { case 1: { - this.state = 9023; + this.state = 9109; this.opt_varying(); } break; } } break; - case PostgreSQLParser.VARCHAR: + case PostgreSQLParser.KW_VARCHAR: this.enterOuterAlt(_localctx, 2); { - this.state = 9026; - this.match(PostgreSQLParser.VARCHAR); + this.state = 9112; + this.match(PostgreSQLParser.KW_VARCHAR); } break; - case PostgreSQLParser.NATIONAL: + case PostgreSQLParser.KW_NATIONAL: this.enterOuterAlt(_localctx, 3); { - this.state = 9027; - this.match(PostgreSQLParser.NATIONAL); - this.state = 9028; + this.state = 9113; + this.match(PostgreSQLParser.KW_NATIONAL); + this.state = 9114; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.CHAR_P || _la === PostgreSQLParser.CHARACTER)) { + if (!(_la === PostgreSQLParser.KW_CHAR || _la === PostgreSQLParser.KW_CHARACTER)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -48052,12 +48086,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9030; + this.state = 9116; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 831, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 845, this._ctx) ) { case 1: { - this.state = 9029; + this.state = 9115; this.opt_varying(); } break; @@ -48085,12 +48119,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_varying(): Opt_varyingContext { let _localctx: Opt_varyingContext = new Opt_varyingContext(this._ctx, this.state); - this.enterRule(_localctx, 1136, PostgreSQLParser.RULE_opt_varying); + this.enterRule(_localctx, 1150, PostgreSQLParser.RULE_opt_varying); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9034; - this.match(PostgreSQLParser.VARYING); + this.state = 9120; + this.match(PostgreSQLParser.KW_VARYING); } } catch (re) { @@ -48110,14 +48144,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public constdatetime(): ConstdatetimeContext { let _localctx: ConstdatetimeContext = new ConstdatetimeContext(this._ctx, this.state); - this.enterRule(_localctx, 1138, PostgreSQLParser.RULE_constdatetime); + this.enterRule(_localctx, 1152, PostgreSQLParser.RULE_constdatetime); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9036; + this.state = 9122; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.TIME || _la === PostgreSQLParser.TIMESTAMP)) { + if (!(_la === PostgreSQLParser.KW_TIME || _la === PostgreSQLParser.KW_TIMESTAMP)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -48127,26 +48161,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9041; + this.state = 9127; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 833, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 847, this._ctx) ) { case 1: { - this.state = 9037; + this.state = 9123; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9038; + this.state = 9124; this.iconst(); - this.state = 9039; + this.state = 9125; this.match(PostgreSQLParser.CLOSE_PAREN); } break; } - this.state = 9044; + this.state = 9130; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 834, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 848, this._ctx) ) { case 1: { - this.state = 9043; + this.state = 9129; this.opt_timezone(); } break; @@ -48170,12 +48204,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public constinterval(): ConstintervalContext { let _localctx: ConstintervalContext = new ConstintervalContext(this._ctx, this.state); - this.enterRule(_localctx, 1140, PostgreSQLParser.RULE_constinterval); + this.enterRule(_localctx, 1154, PostgreSQLParser.RULE_constinterval); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9046; - this.match(PostgreSQLParser.INTERVAL); + this.state = 9132; + this.match(PostgreSQLParser.KW_INTERVAL); } } catch (re) { @@ -48195,31 +48229,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_timezone(): Opt_timezoneContext { let _localctx: Opt_timezoneContext = new Opt_timezoneContext(this._ctx, this.state); - this.enterRule(_localctx, 1142, PostgreSQLParser.RULE_opt_timezone); + this.enterRule(_localctx, 1156, PostgreSQLParser.RULE_opt_timezone); try { - this.state = 9054; + this.state = 9140; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.WITH: + case PostgreSQLParser.KW_WITH: this.enterOuterAlt(_localctx, 1); { - this.state = 9048; - this.match(PostgreSQLParser.WITH); - this.state = 9049; - this.match(PostgreSQLParser.TIME); - this.state = 9050; - this.match(PostgreSQLParser.ZONE); + this.state = 9134; + this.match(PostgreSQLParser.KW_WITH); + this.state = 9135; + this.match(PostgreSQLParser.KW_TIME); + this.state = 9136; + this.match(PostgreSQLParser.KW_ZONE); } break; - case PostgreSQLParser.WITHOUT: + case PostgreSQLParser.KW_WITHOUT: this.enterOuterAlt(_localctx, 2); { - this.state = 9051; - this.match(PostgreSQLParser.WITHOUT); - this.state = 9052; - this.match(PostgreSQLParser.TIME); - this.state = 9053; - this.match(PostgreSQLParser.ZONE); + this.state = 9137; + this.match(PostgreSQLParser.KW_WITHOUT); + this.state = 9138; + this.match(PostgreSQLParser.KW_TIME); + this.state = 9139; + this.match(PostgreSQLParser.KW_ZONE); } break; default: @@ -48243,55 +48277,55 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_interval(): Opt_intervalContext { let _localctx: Opt_intervalContext = new Opt_intervalContext(this._ctx, this.state); - this.enterRule(_localctx, 1144, PostgreSQLParser.RULE_opt_interval); + this.enterRule(_localctx, 1158, PostgreSQLParser.RULE_opt_interval); try { - this.state = 9081; + this.state = 9167; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 838, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 852, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9056; - this.match(PostgreSQLParser.YEAR_P); + this.state = 9142; + this.match(PostgreSQLParser.KW_YEAR); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9057; - this.match(PostgreSQLParser.MONTH_P); + this.state = 9143; + this.match(PostgreSQLParser.KW_MONTH); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 9058; - this.match(PostgreSQLParser.DAY_P); + this.state = 9144; + this.match(PostgreSQLParser.KW_DAY); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 9059; - this.match(PostgreSQLParser.HOUR_P); + this.state = 9145; + this.match(PostgreSQLParser.KW_HOUR); } break; case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 9060; - this.match(PostgreSQLParser.MINUTE_P); + this.state = 9146; + this.match(PostgreSQLParser.KW_MINUTE); } break; case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 9061; + this.state = 9147; this.interval_second(); } break; @@ -48299,40 +48333,40 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 9062; - this.match(PostgreSQLParser.YEAR_P); - this.state = 9063; - this.match(PostgreSQLParser.TO); - this.state = 9064; - this.match(PostgreSQLParser.MONTH_P); + this.state = 9148; + this.match(PostgreSQLParser.KW_YEAR); + this.state = 9149; + this.match(PostgreSQLParser.KW_TO); + this.state = 9150; + this.match(PostgreSQLParser.KW_MONTH); } break; case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 9065; - this.match(PostgreSQLParser.DAY_P); - this.state = 9066; - this.match(PostgreSQLParser.TO); - this.state = 9070; + this.state = 9151; + this.match(PostgreSQLParser.KW_DAY); + this.state = 9152; + this.match(PostgreSQLParser.KW_TO); + this.state = 9156; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.KW_HOUR: { - this.state = 9067; - this.match(PostgreSQLParser.HOUR_P); + this.state = 9153; + this.match(PostgreSQLParser.KW_HOUR); } break; - case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.KW_MINUTE: { - this.state = 9068; - this.match(PostgreSQLParser.MINUTE_P); + this.state = 9154; + this.match(PostgreSQLParser.KW_MINUTE); } break; - case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.KW_SECOND: { - this.state = 9069; + this.state = 9155; this.interval_second(); } break; @@ -48345,22 +48379,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 9072; - this.match(PostgreSQLParser.HOUR_P); - this.state = 9073; - this.match(PostgreSQLParser.TO); - this.state = 9076; + this.state = 9158; + this.match(PostgreSQLParser.KW_HOUR); + this.state = 9159; + this.match(PostgreSQLParser.KW_TO); + this.state = 9162; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.KW_MINUTE: { - this.state = 9074; - this.match(PostgreSQLParser.MINUTE_P); + this.state = 9160; + this.match(PostgreSQLParser.KW_MINUTE); } break; - case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.KW_SECOND: { - this.state = 9075; + this.state = 9161; this.interval_second(); } break; @@ -48373,11 +48407,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 9078; - this.match(PostgreSQLParser.MINUTE_P); - this.state = 9079; - this.match(PostgreSQLParser.TO); - this.state = 9080; + this.state = 9164; + this.match(PostgreSQLParser.KW_MINUTE); + this.state = 9165; + this.match(PostgreSQLParser.KW_TO); + this.state = 9166; this.interval_second(); } break; @@ -48400,22 +48434,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public interval_second(): Interval_secondContext { let _localctx: Interval_secondContext = new Interval_secondContext(this._ctx, this.state); - this.enterRule(_localctx, 1146, PostgreSQLParser.RULE_interval_second); + this.enterRule(_localctx, 1160, PostgreSQLParser.RULE_interval_second); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9083; - this.match(PostgreSQLParser.SECOND_P); - this.state = 9088; + this.state = 9169; + this.match(PostgreSQLParser.KW_SECOND); + this.state = 9174; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 839, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 853, this._ctx) ) { case 1: { - this.state = 9084; + this.state = 9170; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9085; + this.state = 9171; this.iconst(); - this.state = 9086; + this.state = 9172; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -48439,13 +48473,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_escape(): Opt_escapeContext { let _localctx: Opt_escapeContext = new Opt_escapeContext(this._ctx, this.state); - this.enterRule(_localctx, 1148, PostgreSQLParser.RULE_opt_escape); + this.enterRule(_localctx, 1162, PostgreSQLParser.RULE_opt_escape); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9090; - this.match(PostgreSQLParser.ESCAPE); - this.state = 9091; + this.state = 9176; + this.match(PostgreSQLParser.KW_ESCAPE); + this.state = 9177; this.a_expr(); } } @@ -48466,11 +48500,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr(): A_exprContext { let _localctx: A_exprContext = new A_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 1150, PostgreSQLParser.RULE_a_expr); + this.enterRule(_localctx, 1164, PostgreSQLParser.RULE_a_expr); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9093; + this.state = 9179; this.a_expr_qual(); } } @@ -48491,18 +48525,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_qual(): A_expr_qualContext { let _localctx: A_expr_qualContext = new A_expr_qualContext(this._ctx, this.state); - this.enterRule(_localctx, 1152, PostgreSQLParser.RULE_a_expr_qual); + this.enterRule(_localctx, 1166, PostgreSQLParser.RULE_a_expr_qual); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9095; + this.state = 9181; this.a_expr_lessless(); - this.state = 9097; + this.state = 9183; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 840, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 854, this._ctx) ) { case 1: { - this.state = 9096; + this.state = 9182; this.qual_op(); } break; @@ -48526,22 +48560,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_lessless(): A_expr_lesslessContext { let _localctx: A_expr_lesslessContext = new A_expr_lesslessContext(this._ctx, this.state); - this.enterRule(_localctx, 1154, PostgreSQLParser.RULE_a_expr_lessless); + this.enterRule(_localctx, 1168, PostgreSQLParser.RULE_a_expr_lessless); let _la: number; try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9099; + this.state = 9185; this.a_expr_or(); - this.state = 9104; + this.state = 9190; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 841, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 855, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9100; + this.state = 9186; _la = this._input.LA(1); if (!(_la === PostgreSQLParser.LESS_LESS || _la === PostgreSQLParser.GREATER_GREATER)) { this._errHandler.recoverInline(this); @@ -48553,14 +48587,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9101; + this.state = 9187; this.a_expr_or(); } } } - this.state = 9106; + this.state = 9192; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 841, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 855, this._ctx); } } } @@ -48581,30 +48615,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_or(): A_expr_orContext { let _localctx: A_expr_orContext = new A_expr_orContext(this._ctx, this.state); - this.enterRule(_localctx, 1156, PostgreSQLParser.RULE_a_expr_or); + this.enterRule(_localctx, 1170, PostgreSQLParser.RULE_a_expr_or); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9107; + this.state = 9193; this.a_expr_and(); - this.state = 9112; + this.state = 9198; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 842, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 856, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9108; - this.match(PostgreSQLParser.OR); - this.state = 9109; + this.state = 9194; + this.match(PostgreSQLParser.KW_OR); + this.state = 9195; this.a_expr_and(); } } } - this.state = 9114; + this.state = 9200; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 842, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 856, this._ctx); } } } @@ -48625,30 +48659,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_and(): A_expr_andContext { let _localctx: A_expr_andContext = new A_expr_andContext(this._ctx, this.state); - this.enterRule(_localctx, 1158, PostgreSQLParser.RULE_a_expr_and); + this.enterRule(_localctx, 1172, PostgreSQLParser.RULE_a_expr_and); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9115; + this.state = 9201; this.a_expr_in(); - this.state = 9120; + this.state = 9206; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 843, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 857, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9116; - this.match(PostgreSQLParser.AND); - this.state = 9117; + this.state = 9202; + this.match(PostgreSQLParser.KW_AND); + this.state = 9203; this.a_expr_in(); } } } - this.state = 9122; + this.state = 9208; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 843, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 857, this._ctx); } } } @@ -48669,31 +48703,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_in(): A_expr_inContext { let _localctx: A_expr_inContext = new A_expr_inContext(this._ctx, this.state); - this.enterRule(_localctx, 1160, PostgreSQLParser.RULE_a_expr_in); + this.enterRule(_localctx, 1174, PostgreSQLParser.RULE_a_expr_in); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9123; + this.state = 9209; this.a_expr_unary_not(); - this.state = 9129; + this.state = 9215; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 845, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 859, this._ctx) ) { case 1: { - this.state = 9125; + this.state = 9211; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOT) { + if (_la === PostgreSQLParser.KW_NOT) { { - this.state = 9124; - this.match(PostgreSQLParser.NOT); + this.state = 9210; + this.match(PostgreSQLParser.KW_NOT); } } - this.state = 9127; - this.match(PostgreSQLParser.IN_P); - this.state = 9128; + this.state = 9213; + this.match(PostgreSQLParser.KW_IN); + this.state = 9214; this.in_expr(); } break; @@ -48717,22 +48751,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_unary_not(): A_expr_unary_notContext { let _localctx: A_expr_unary_notContext = new A_expr_unary_notContext(this._ctx, this.state); - this.enterRule(_localctx, 1162, PostgreSQLParser.RULE_a_expr_unary_not); + this.enterRule(_localctx, 1176, PostgreSQLParser.RULE_a_expr_unary_not); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9132; + this.state = 9218; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOT) { + if (_la === PostgreSQLParser.KW_NOT) { { - this.state = 9131; - this.match(PostgreSQLParser.NOT); + this.state = 9217; + this.match(PostgreSQLParser.KW_NOT); } } - this.state = 9134; + this.state = 9220; this.a_expr_isnull(); } } @@ -48753,21 +48787,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_isnull(): A_expr_isnullContext { let _localctx: A_expr_isnullContext = new A_expr_isnullContext(this._ctx, this.state); - this.enterRule(_localctx, 1164, PostgreSQLParser.RULE_a_expr_isnull); + this.enterRule(_localctx, 1178, PostgreSQLParser.RULE_a_expr_isnull); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9136; + this.state = 9222; this.a_expr_is_not(); - this.state = 9138; + this.state = 9224; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 847, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 861, this._ctx) ) { case 1: { - this.state = 9137; + this.state = 9223; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ISNULL || _la === PostgreSQLParser.NOTNULL)) { + if (!(_la === PostgreSQLParser.KW_ISNULL || _la === PostgreSQLParser.KW_NOTNULL)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -48799,103 +48833,103 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_is_not(): A_expr_is_notContext { let _localctx: A_expr_is_notContext = new A_expr_is_notContext(this._ctx, this.state); - this.enterRule(_localctx, 1166, PostgreSQLParser.RULE_a_expr_is_not); + this.enterRule(_localctx, 1180, PostgreSQLParser.RULE_a_expr_is_not); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9140; + this.state = 9226; this.a_expr_compare(); - this.state = 9164; + this.state = 9250; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 851, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 865, this._ctx) ) { case 1: { - this.state = 9141; - this.match(PostgreSQLParser.IS); - this.state = 9143; + this.state = 9227; + this.match(PostgreSQLParser.KW_IS); + this.state = 9229; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOT) { + if (_la === PostgreSQLParser.KW_NOT) { { - this.state = 9142; - this.match(PostgreSQLParser.NOT); + this.state = 9228; + this.match(PostgreSQLParser.KW_NOT); } } - this.state = 9162; + this.state = 9248; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.NULL_P: + case PostgreSQLParser.KW_NULL: { - this.state = 9145; - this.match(PostgreSQLParser.NULL_P); + this.state = 9231; + this.match(PostgreSQLParser.KW_NULL); } break; - case PostgreSQLParser.TRUE_P: + case PostgreSQLParser.KW_TRUE: { - this.state = 9146; - this.match(PostgreSQLParser.TRUE_P); + this.state = 9232; + this.match(PostgreSQLParser.KW_TRUE); } break; - case PostgreSQLParser.FALSE_P: + case PostgreSQLParser.KW_FALSE: { - this.state = 9147; - this.match(PostgreSQLParser.FALSE_P); + this.state = 9233; + this.match(PostgreSQLParser.KW_FALSE); } break; - case PostgreSQLParser.UNKNOWN: + case PostgreSQLParser.KW_UNKNOWN: { - this.state = 9148; - this.match(PostgreSQLParser.UNKNOWN); + this.state = 9234; + this.match(PostgreSQLParser.KW_UNKNOWN); } break; - case PostgreSQLParser.DISTINCT: + case PostgreSQLParser.KW_DISTINCT: { - this.state = 9149; - this.match(PostgreSQLParser.DISTINCT); - this.state = 9150; - this.match(PostgreSQLParser.FROM); - this.state = 9151; + this.state = 9235; + this.match(PostgreSQLParser.KW_DISTINCT); + this.state = 9236; + this.match(PostgreSQLParser.KW_FROM); + this.state = 9237; this.a_expr(); } break; - case PostgreSQLParser.OF: + case PostgreSQLParser.KW_OF: { - this.state = 9152; - this.match(PostgreSQLParser.OF); - this.state = 9153; + this.state = 9238; + this.match(PostgreSQLParser.KW_OF); + this.state = 9239; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9154; + this.state = 9240; this.type_list(); - this.state = 9155; + this.state = 9241; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.KW_DOCUMENT: { - this.state = 9157; - this.match(PostgreSQLParser.DOCUMENT_P); + this.state = 9243; + this.match(PostgreSQLParser.KW_DOCUMENT); } break; - case PostgreSQLParser.NORMALIZED: - case PostgreSQLParser.NFC: - case PostgreSQLParser.NFD: - case PostgreSQLParser.NFKC: - case PostgreSQLParser.NFKD: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: { - this.state = 9159; + this.state = 9245; 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)) { + if (((((_la - 483)) & ~0x1F) === 0 && ((1 << (_la - 483)) & ((1 << (PostgreSQLParser.KW_NFC - 483)) | (1 << (PostgreSQLParser.KW_NFD - 483)) | (1 << (PostgreSQLParser.KW_NFKC - 483)) | (1 << (PostgreSQLParser.KW_NFKD - 483)))) !== 0)) { { - this.state = 9158; + this.state = 9244; this.unicode_normal_form(); } } - this.state = 9161; - this.match(PostgreSQLParser.NORMALIZED); + this.state = 9247; + this.match(PostgreSQLParser.KW_NORMALIZED); } break; default: @@ -48923,19 +48957,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_compare(): A_expr_compareContext { let _localctx: A_expr_compareContext = new A_expr_compareContext(this._ctx, this.state); - this.enterRule(_localctx, 1168, PostgreSQLParser.RULE_a_expr_compare); + this.enterRule(_localctx, 1182, PostgreSQLParser.RULE_a_expr_compare); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9166; + this.state = 9252; this.a_expr_like(); - this.state = 9178; + this.state = 9264; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 853, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 867, this._ctx) ) { case 1: { - this.state = 9167; + this.state = 9253; _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); @@ -48947,34 +48981,34 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9168; + this.state = 9254; this.a_expr_like(); } break; case 2: { - this.state = 9169; + this.state = 9255; this.subquery_Op(); - this.state = 9170; + this.state = 9256; this.sub_type(); - this.state = 9176; + this.state = 9262; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 852, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 866, this._ctx) ) { case 1: { - this.state = 9171; + this.state = 9257; this.select_with_parens(); } break; case 2: { - this.state = 9172; + this.state = 9258; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9173; + this.state = 9259; this.a_expr(); - this.state = 9174; + this.state = 9260; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -49001,62 +49035,62 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_like(): A_expr_likeContext { let _localctx: A_expr_likeContext = new A_expr_likeContext(this._ctx, this.state); - this.enterRule(_localctx, 1170, PostgreSQLParser.RULE_a_expr_like); + this.enterRule(_localctx, 1184, PostgreSQLParser.RULE_a_expr_like); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9180; + this.state = 9266; this.a_expr_qual_op(); - this.state = 9198; + this.state = 9284; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 858, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 872, this._ctx) ) { case 1: { - this.state = 9182; + this.state = 9268; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOT) { + if (_la === PostgreSQLParser.KW_NOT) { { - this.state = 9181; - this.match(PostgreSQLParser.NOT); + this.state = 9267; + this.match(PostgreSQLParser.KW_NOT); } } - this.state = 9192; + this.state = 9278; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.LIKE: + case PostgreSQLParser.KW_LIKE: { - this.state = 9184; - this.match(PostgreSQLParser.LIKE); + this.state = 9270; + this.match(PostgreSQLParser.KW_LIKE); } break; - case PostgreSQLParser.ILIKE: + case PostgreSQLParser.KW_ILIKE: { - this.state = 9185; - this.match(PostgreSQLParser.ILIKE); + this.state = 9271; + this.match(PostgreSQLParser.KW_ILIKE); } break; - case PostgreSQLParser.SIMILAR: + case PostgreSQLParser.KW_SIMILAR: { - this.state = 9186; - this.match(PostgreSQLParser.SIMILAR); - this.state = 9187; - this.match(PostgreSQLParser.TO); + this.state = 9272; + this.match(PostgreSQLParser.KW_SIMILAR); + this.state = 9273; + this.match(PostgreSQLParser.KW_TO); } break; - case PostgreSQLParser.BETWEEN: + case PostgreSQLParser.KW_BETWEEN: { - this.state = 9188; - this.match(PostgreSQLParser.BETWEEN); - this.state = 9190; + this.state = 9274; + this.match(PostgreSQLParser.KW_BETWEEN); + this.state = 9276; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.SYMMETRIC) { + if (_la === PostgreSQLParser.KW_SYMMETRIC) { { - this.state = 9189; - this.match(PostgreSQLParser.SYMMETRIC); + this.state = 9275; + this.match(PostgreSQLParser.KW_SYMMETRIC); } } @@ -49065,14 +49099,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 9194; + this.state = 9280; this.a_expr_qual_op(); - this.state = 9196; + this.state = 9282; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 857, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 871, this._ctx) ) { case 1: { - this.state = 9195; + this.state = 9281; this.opt_escape(); } break; @@ -49099,30 +49133,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_qual_op(): A_expr_qual_opContext { let _localctx: A_expr_qual_opContext = new A_expr_qual_opContext(this._ctx, this.state); - this.enterRule(_localctx, 1172, PostgreSQLParser.RULE_a_expr_qual_op); + this.enterRule(_localctx, 1186, PostgreSQLParser.RULE_a_expr_qual_op); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9200; + this.state = 9286; this.a_expr_unary_qualop(); - this.state = 9206; + this.state = 9292; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 859, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 873, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9201; + this.state = 9287; this.qual_op(); - this.state = 9202; + this.state = 9288; this.a_expr_unary_qualop(); } } } - this.state = 9208; + this.state = 9294; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 859, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 873, this._ctx); } } } @@ -49143,21 +49177,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_unary_qualop(): A_expr_unary_qualopContext { let _localctx: A_expr_unary_qualopContext = new A_expr_unary_qualopContext(this._ctx, this.state); - this.enterRule(_localctx, 1174, PostgreSQLParser.RULE_a_expr_unary_qualop); + this.enterRule(_localctx, 1188, PostgreSQLParser.RULE_a_expr_unary_qualop); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9210; + this.state = 9296; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 860, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 874, this._ctx) ) { case 1: { - this.state = 9209; + this.state = 9295; this.qual_op(); } break; } - this.state = 9212; + this.state = 9298; this.a_expr_add(); } } @@ -49178,22 +49212,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_add(): A_expr_addContext { let _localctx: A_expr_addContext = new A_expr_addContext(this._ctx, this.state); - this.enterRule(_localctx, 1176, PostgreSQLParser.RULE_a_expr_add); + this.enterRule(_localctx, 1190, PostgreSQLParser.RULE_a_expr_add); let _la: number; try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9214; + this.state = 9300; this.a_expr_mul(); - this.state = 9219; + this.state = 9305; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 861, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 875, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9215; + this.state = 9301; _la = this._input.LA(1); if (!(_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS)) { this._errHandler.recoverInline(this); @@ -49205,14 +49239,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9216; + this.state = 9302; this.a_expr_mul(); } } } - this.state = 9221; + this.state = 9307; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 861, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 875, this._ctx); } } } @@ -49233,22 +49267,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_mul(): A_expr_mulContext { let _localctx: A_expr_mulContext = new A_expr_mulContext(this._ctx, this.state); - this.enterRule(_localctx, 1178, PostgreSQLParser.RULE_a_expr_mul); + this.enterRule(_localctx, 1192, PostgreSQLParser.RULE_a_expr_mul); let _la: number; try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9222; + this.state = 9308; this.a_expr_caret(); - this.state = 9227; + this.state = 9313; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 862, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 876, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9223; + this.state = 9309; _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); @@ -49260,14 +49294,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9224; + this.state = 9310; this.a_expr_caret(); } } } - this.state = 9229; + this.state = 9315; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 862, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 876, this._ctx); } } } @@ -49288,20 +49322,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_caret(): A_expr_caretContext { let _localctx: A_expr_caretContext = new A_expr_caretContext(this._ctx, this.state); - this.enterRule(_localctx, 1180, PostgreSQLParser.RULE_a_expr_caret); + this.enterRule(_localctx, 1194, PostgreSQLParser.RULE_a_expr_caret); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9230; + this.state = 9316; this.a_expr_unary_sign(); - this.state = 9233; + this.state = 9319; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 863, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 877, this._ctx) ) { case 1: { - this.state = 9231; + this.state = 9317; this.match(PostgreSQLParser.CARET); - this.state = 9232; + this.state = 9318; this.a_expr(); } break; @@ -49325,17 +49359,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_unary_sign(): A_expr_unary_signContext { let _localctx: A_expr_unary_signContext = new A_expr_unary_signContext(this._ctx, this.state); - this.enterRule(_localctx, 1182, PostgreSQLParser.RULE_a_expr_unary_sign); + this.enterRule(_localctx, 1196, PostgreSQLParser.RULE_a_expr_unary_sign); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9236; + this.state = 9322; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS) { { - this.state = 9235; + this.state = 9321; _la = this._input.LA(1); if (!(_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS)) { this._errHandler.recoverInline(this); @@ -49350,7 +49384,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } - this.state = 9238; + this.state = 9324; this.a_expr_at_time_zone(); } } @@ -49371,24 +49405,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_at_time_zone(): A_expr_at_time_zoneContext { let _localctx: A_expr_at_time_zoneContext = new A_expr_at_time_zoneContext(this._ctx, this.state); - this.enterRule(_localctx, 1184, PostgreSQLParser.RULE_a_expr_at_time_zone); + this.enterRule(_localctx, 1198, PostgreSQLParser.RULE_a_expr_at_time_zone); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9240; + this.state = 9326; this.a_expr_collate(); - this.state = 9245; + this.state = 9331; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 865, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 879, this._ctx) ) { case 1: { - this.state = 9241; - this.match(PostgreSQLParser.AT); - this.state = 9242; - this.match(PostgreSQLParser.TIME); - this.state = 9243; - this.match(PostgreSQLParser.ZONE); - this.state = 9244; + this.state = 9327; + this.match(PostgreSQLParser.KW_AT); + this.state = 9328; + this.match(PostgreSQLParser.KW_TIME); + this.state = 9329; + this.match(PostgreSQLParser.KW_ZONE); + this.state = 9330; this.a_expr(); } break; @@ -49412,20 +49446,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_collate(): A_expr_collateContext { let _localctx: A_expr_collateContext = new A_expr_collateContext(this._ctx, this.state); - this.enterRule(_localctx, 1186, PostgreSQLParser.RULE_a_expr_collate); + this.enterRule(_localctx, 1200, PostgreSQLParser.RULE_a_expr_collate); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9247; + this.state = 9333; this.a_expr_typecast(); - this.state = 9250; + this.state = 9336; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 866, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 880, this._ctx) ) { case 1: { - this.state = 9248; - this.match(PostgreSQLParser.COLLATE); - this.state = 9249; + this.state = 9334; + this.match(PostgreSQLParser.KW_COLLATE); + this.state = 9335; this.any_name(); } break; @@ -49449,26 +49483,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public a_expr_typecast(): A_expr_typecastContext { let _localctx: A_expr_typecastContext = new A_expr_typecastContext(this._ctx, this.state); - this.enterRule(_localctx, 1188, PostgreSQLParser.RULE_a_expr_typecast); + this.enterRule(_localctx, 1202, PostgreSQLParser.RULE_a_expr_typecast); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9252; + this.state = 9338; this.c_expr(); - this.state = 9257; + this.state = 9343; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.TYPECAST) { { { - this.state = 9253; + this.state = 9339; this.match(PostgreSQLParser.TYPECAST); - this.state = 9254; + this.state = 9340; this.typename(); } } - this.state = 9259; + this.state = 9345; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -49501,26 +49535,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { let _parentState: number = this.state; let _localctx: B_exprContext = new B_exprContext(this._ctx, _parentState); let _prevctx: B_exprContext = _localctx; - let _startState: number = 1190; - this.enterRecursionRule(_localctx, 1190, PostgreSQLParser.RULE_b_expr, _p); + let _startState: number = 1204; + this.enterRecursionRule(_localctx, 1204, PostgreSQLParser.RULE_b_expr, _p); let _la: number; try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9267; + this.state = 9353; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 868, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 882, this._ctx) ) { case 1: { - this.state = 9261; + this.state = 9347; this.c_expr(); } break; case 2: { - this.state = 9262; + this.state = 9348; _la = this._input.LA(1); if (!(_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS)) { this._errHandler.recoverInline(this); @@ -49532,24 +49566,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9263; + this.state = 9349; this.b_expr(9); } break; case 3: { - this.state = 9264; + this.state = 9350; this.qual_op(); - this.state = 9265; + this.state = 9351; this.b_expr(3); } break; } this._ctx._stop = this._input.tryLT(-1); - this.state = 9308; + this.state = 9394; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 872, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 886, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { if (this._parseListeners != null) { @@ -49557,20 +49591,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } _prevctx = _localctx; { - this.state = 9306; + this.state = 9392; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 871, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 885, this._ctx) ) { case 1: { _localctx = new B_exprContext(_parentctx, _parentState); this.pushNewRecursionContext(_localctx, _startState, PostgreSQLParser.RULE_b_expr); - this.state = 9269; + this.state = 9355; if (!(this.precpred(this._ctx, 8))) { throw this.createFailedPredicateException("this.precpred(this._ctx, 8)"); } - this.state = 9270; + this.state = 9356; this.match(PostgreSQLParser.CARET); - this.state = 9271; + this.state = 9357; this.b_expr(9); } break; @@ -49579,11 +49613,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { _localctx = new B_exprContext(_parentctx, _parentState); this.pushNewRecursionContext(_localctx, _startState, PostgreSQLParser.RULE_b_expr); - this.state = 9272; + this.state = 9358; if (!(this.precpred(this._ctx, 7))) { throw this.createFailedPredicateException("this.precpred(this._ctx, 7)"); } - this.state = 9273; + this.state = 9359; _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); @@ -49595,7 +49629,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9274; + this.state = 9360; this.b_expr(8); } break; @@ -49604,11 +49638,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { _localctx = new B_exprContext(_parentctx, _parentState); this.pushNewRecursionContext(_localctx, _startState, PostgreSQLParser.RULE_b_expr); - this.state = 9275; + this.state = 9361; if (!(this.precpred(this._ctx, 6))) { throw this.createFailedPredicateException("this.precpred(this._ctx, 6)"); } - this.state = 9276; + this.state = 9362; _la = this._input.LA(1); if (!(_la === PostgreSQLParser.PLUS || _la === PostgreSQLParser.MINUS)) { this._errHandler.recoverInline(this); @@ -49620,7 +49654,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9277; + this.state = 9363; this.b_expr(7); } break; @@ -49629,13 +49663,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { _localctx = new B_exprContext(_parentctx, _parentState); this.pushNewRecursionContext(_localctx, _startState, PostgreSQLParser.RULE_b_expr); - this.state = 9278; + this.state = 9364; if (!(this.precpred(this._ctx, 5))) { throw this.createFailedPredicateException("this.precpred(this._ctx, 5)"); } - this.state = 9279; + this.state = 9365; this.qual_op(); - this.state = 9280; + this.state = 9366; this.b_expr(6); } break; @@ -49644,11 +49678,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { _localctx = new B_exprContext(_parentctx, _parentState); this.pushNewRecursionContext(_localctx, _startState, PostgreSQLParser.RULE_b_expr); - this.state = 9282; + this.state = 9368; if (!(this.precpred(this._ctx, 4))) { throw this.createFailedPredicateException("this.precpred(this._ctx, 4)"); } - this.state = 9283; + this.state = 9369; _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); @@ -49660,7 +49694,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9284; + this.state = 9370; this.b_expr(5); } break; @@ -49669,13 +49703,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { _localctx = new B_exprContext(_parentctx, _parentState); this.pushNewRecursionContext(_localctx, _startState, PostgreSQLParser.RULE_b_expr); - this.state = 9285; + this.state = 9371; if (!(this.precpred(this._ctx, 10))) { throw this.createFailedPredicateException("this.precpred(this._ctx, 10)"); } - this.state = 9286; + this.state = 9372; this.match(PostgreSQLParser.TYPECAST); - this.state = 9287; + this.state = 9373; this.typename(); } break; @@ -49684,11 +49718,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { _localctx = new B_exprContext(_parentctx, _parentState); this.pushNewRecursionContext(_localctx, _startState, PostgreSQLParser.RULE_b_expr); - this.state = 9288; + this.state = 9374; if (!(this.precpred(this._ctx, 2))) { throw this.createFailedPredicateException("this.precpred(this._ctx, 2)"); } - this.state = 9289; + this.state = 9375; this.qual_op(); } break; @@ -49697,51 +49731,51 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { _localctx = new B_exprContext(_parentctx, _parentState); this.pushNewRecursionContext(_localctx, _startState, PostgreSQLParser.RULE_b_expr); - this.state = 9290; + this.state = 9376; if (!(this.precpred(this._ctx, 1))) { throw this.createFailedPredicateException("this.precpred(this._ctx, 1)"); } - this.state = 9291; - this.match(PostgreSQLParser.IS); - this.state = 9293; + this.state = 9377; + this.match(PostgreSQLParser.KW_IS); + this.state = 9379; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NOT) { + if (_la === PostgreSQLParser.KW_NOT) { { - this.state = 9292; - this.match(PostgreSQLParser.NOT); + this.state = 9378; + this.match(PostgreSQLParser.KW_NOT); } } - this.state = 9304; + this.state = 9390; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.DISTINCT: + case PostgreSQLParser.KW_DISTINCT: { - this.state = 9295; - this.match(PostgreSQLParser.DISTINCT); - this.state = 9296; - this.match(PostgreSQLParser.FROM); - this.state = 9297; + this.state = 9381; + this.match(PostgreSQLParser.KW_DISTINCT); + this.state = 9382; + this.match(PostgreSQLParser.KW_FROM); + this.state = 9383; this.b_expr(0); } break; - case PostgreSQLParser.OF: + case PostgreSQLParser.KW_OF: { - this.state = 9298; - this.match(PostgreSQLParser.OF); - this.state = 9299; + this.state = 9384; + this.match(PostgreSQLParser.KW_OF); + this.state = 9385; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9300; + this.state = 9386; this.type_list(); - this.state = 9301; + this.state = 9387; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.DOCUMENT_P: + case PostgreSQLParser.KW_DOCUMENT: { - this.state = 9303; - this.match(PostgreSQLParser.DOCUMENT_P); + this.state = 9389; + this.match(PostgreSQLParser.KW_DOCUMENT); } break; default: @@ -49752,9 +49786,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } } - this.state = 9310; + this.state = 9396; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 872, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 886, this._ctx); } } } @@ -49775,18 +49809,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public c_expr(): C_exprContext { let _localctx: C_exprContext = new C_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 1192, PostgreSQLParser.RULE_c_expr); + this.enterRule(_localctx, 1206, PostgreSQLParser.RULE_c_expr); try { - this.state = 9347; + this.state = 9433; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 875, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 889, this._ctx) ) { case 1: _localctx = new C_expr_existsContext(_localctx); this.enterOuterAlt(_localctx, 1); { - this.state = 9311; - this.match(PostgreSQLParser.EXISTS); - this.state = 9312; + this.state = 9397; + this.match(PostgreSQLParser.KW_EXISTS); + this.state = 9398; this.select_with_parens(); } break; @@ -49795,20 +49829,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 2); { - this.state = 9313; - this.match(PostgreSQLParser.ARRAY); - this.state = 9316; + this.state = 9399; + this.match(PostgreSQLParser.KW_ARRAY); + this.state = 9402; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: { - this.state = 9314; + this.state = 9400; this.select_with_parens(); } break; case PostgreSQLParser.OPEN_BRACKET: { - this.state = 9315; + this.state = 9401; this.array_expr(); } break; @@ -49822,9 +49856,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 3); { - this.state = 9318; + this.state = 9404; this.match(PostgreSQLParser.PARAM); - this.state = 9319; + this.state = 9405; this.opt_indirection(); } break; @@ -49833,13 +49867,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 4); { - this.state = 9320; - this.match(PostgreSQLParser.GROUPING); - this.state = 9321; + this.state = 9406; + this.match(PostgreSQLParser.KW_GROUPING); + this.state = 9407; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9322; + this.state = 9408; this.expr_list(); - this.state = 9323; + this.state = 9409; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -49848,9 +49882,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 5); { - this.state = 9325; - this.match(PostgreSQLParser.UNIQUE); - this.state = 9326; + this.state = 9411; + this.match(PostgreSQLParser.KW_UNIQUE); + this.state = 9412; this.select_with_parens(); } break; @@ -49859,7 +49893,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 6); { - this.state = 9327; + this.state = 9413; this.columnref(); } break; @@ -49868,7 +49902,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 7); { - this.state = 9328; + this.state = 9414; this.aexprconst(); } break; @@ -49877,7 +49911,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 8); { - this.state = 9329; + this.state = 9415; this.plsqlvariablename(); } break; @@ -49886,13 +49920,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 9); { - this.state = 9330; + this.state = 9416; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9331; + this.state = 9417; (_localctx as C_expr_exprContext)._a_expr_in_parens = this.a_expr(); - this.state = 9332; + this.state = 9418; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 9333; + this.state = 9419; this.opt_indirection(); } break; @@ -49901,7 +49935,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_caseContext(_localctx); this.enterOuterAlt(_localctx, 10); { - this.state = 9335; + this.state = 9421; this.case_expr(); } break; @@ -49910,7 +49944,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 11); { - this.state = 9336; + this.state = 9422; this.func_expr(); } break; @@ -49919,14 +49953,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 12); { - this.state = 9337; + this.state = 9423; this.select_with_parens(); - this.state = 9339; + this.state = 9425; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 874, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 888, this._ctx) ) { case 1: { - this.state = 9338; + this.state = 9424; this.indirection(); } break; @@ -49938,7 +49972,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 13); { - this.state = 9341; + this.state = 9427; this.explicit_row(); } break; @@ -49947,7 +49981,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 14); { - this.state = 9342; + this.state = 9428; this.implicit_row(); } break; @@ -49956,11 +49990,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new C_expr_exprContext(_localctx); this.enterOuterAlt(_localctx, 15); { - this.state = 9343; + this.state = 9429; this.row(); - this.state = 9344; - this.match(PostgreSQLParser.OVERLAPS); - this.state = 9345; + this.state = 9430; + this.match(PostgreSQLParser.KW_OVERLAPS); + this.state = 9431; this.row(); } break; @@ -49983,11 +50017,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public plsqlvariablename(): PlsqlvariablenameContext { let _localctx: PlsqlvariablenameContext = new PlsqlvariablenameContext(this._ctx, this.state); - this.enterRule(_localctx, 1194, PostgreSQLParser.RULE_plsqlvariablename); + this.enterRule(_localctx, 1208, PostgreSQLParser.RULE_plsqlvariablename); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9349; + this.state = 9435; this.match(PostgreSQLParser.PLSQLVARIABLENAME); } } @@ -50008,16 +50042,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_application(): Func_applicationContext { let _localctx: Func_applicationContext = new Func_applicationContext(this._ctx, this.state); - this.enterRule(_localctx, 1196, PostgreSQLParser.RULE_func_application); + this.enterRule(_localctx, 1210, PostgreSQLParser.RULE_func_application); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9351; + this.state = 9437; this.func_name(); - this.state = 9352; + this.state = 9438; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9374; + this.state = 9460; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: @@ -50025,434 +50059,434 @@ export class PostgreSQLParser extends PostgreSQLParserBase { 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_CASE: + case PostgreSQLParser.KW_CAST: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_LOCALTIME: + case PostgreSQLParser.KW_LOCALTIMESTAMP: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_NULL: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -50467,58 +50501,58 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: case PostgreSQLParser.EscapeStringConstant: { - this.state = 9353; + this.state = 9439; this.func_arg_list(); - this.state = 9357; + this.state = 9443; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.COMMA) { { - this.state = 9354; + this.state = 9440; this.match(PostgreSQLParser.COMMA); - this.state = 9355; - this.match(PostgreSQLParser.VARIADIC); - this.state = 9356; + this.state = 9441; + this.match(PostgreSQLParser.KW_VARIADIC); + this.state = 9442; this.func_arg_expr(); } } - this.state = 9360; + this.state = 9446; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ORDER) { + if (_la === PostgreSQLParser.KW_ORDER) { { - this.state = 9359; + this.state = 9445; this.opt_sort_clause(); } } } break; - case PostgreSQLParser.VARIADIC: + case PostgreSQLParser.KW_VARIADIC: { - this.state = 9362; - this.match(PostgreSQLParser.VARIADIC); - this.state = 9363; + this.state = 9448; + this.match(PostgreSQLParser.KW_VARIADIC); + this.state = 9449; this.func_arg_expr(); - this.state = 9365; + this.state = 9451; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ORDER) { + if (_la === PostgreSQLParser.KW_ORDER) { { - this.state = 9364; + this.state = 9450; this.opt_sort_clause(); } } } break; - case PostgreSQLParser.ALL: - case PostgreSQLParser.DISTINCT: + case PostgreSQLParser.KW_ALL: + case PostgreSQLParser.KW_DISTINCT: { - this.state = 9367; + this.state = 9453; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ALL || _la === PostgreSQLParser.DISTINCT)) { + if (!(_la === PostgreSQLParser.KW_ALL || _la === PostgreSQLParser.KW_DISTINCT)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -50528,14 +50562,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9368; + this.state = 9454; this.func_arg_list(); - this.state = 9370; + this.state = 9456; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ORDER) { + if (_la === PostgreSQLParser.KW_ORDER) { { - this.state = 9369; + this.state = 9455; this.opt_sort_clause(); } } @@ -50544,7 +50578,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { break; case PostgreSQLParser.STAR: { - this.state = 9372; + this.state = 9458; this.match(PostgreSQLParser.STAR); } break; @@ -50556,7 +50590,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 9376; + this.state = 9462; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -50577,42 +50611,42 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_expr(): Func_exprContext { let _localctx: Func_exprContext = new Func_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 1198, PostgreSQLParser.RULE_func_expr); + this.enterRule(_localctx, 1212, PostgreSQLParser.RULE_func_expr); try { - this.state = 9389; + this.state = 9475; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 884, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 898, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9378; + this.state = 9464; this.func_application(); - this.state = 9380; + this.state = 9466; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 881, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 895, this._ctx) ) { case 1: { - this.state = 9379; + this.state = 9465; this.within_group_clause(); } break; } - this.state = 9383; + this.state = 9469; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 882, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 896, this._ctx) ) { case 1: { - this.state = 9382; + this.state = 9468; this.filter_clause(); } break; } - this.state = 9386; + this.state = 9472; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 883, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 897, this._ctx) ) { case 1: { - this.state = 9385; + this.state = 9471; this.over_clause(); } break; @@ -50623,7 +50657,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9388; + this.state = 9474; this.func_expr_common_subexpr(); } break; @@ -50646,15 +50680,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_expr_windowless(): Func_expr_windowlessContext { let _localctx: Func_expr_windowlessContext = new Func_expr_windowlessContext(this._ctx, this.state); - this.enterRule(_localctx, 1200, PostgreSQLParser.RULE_func_expr_windowless); + this.enterRule(_localctx, 1214, PostgreSQLParser.RULE_func_expr_windowless); try { - this.state = 9393; + this.state = 9479; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 885, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 899, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9391; + this.state = 9477; this.func_application(); } break; @@ -50662,7 +50696,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9392; + this.state = 9478; this.func_expr_common_subexpr(); } break; @@ -50685,310 +50719,310 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_expr_common_subexpr(): Func_expr_common_subexprContext { let _localctx: Func_expr_common_subexprContext = new Func_expr_common_subexprContext(this._ctx, this.state); - this.enterRule(_localctx, 1202, PostgreSQLParser.RULE_func_expr_common_subexpr); + this.enterRule(_localctx, 1216, PostgreSQLParser.RULE_func_expr_common_subexpr); let _la: number; try { - this.state = 9579; + this.state = 9665; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.COLLATION: + case PostgreSQLParser.KW_COLLATION: this.enterOuterAlt(_localctx, 1); { - this.state = 9395; - this.match(PostgreSQLParser.COLLATION); - this.state = 9396; - this.match(PostgreSQLParser.FOR); - this.state = 9397; + this.state = 9481; + this.match(PostgreSQLParser.KW_COLLATION); + this.state = 9482; + this.match(PostgreSQLParser.KW_FOR); + this.state = 9483; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9398; + this.state = 9484; this.a_expr(); - this.state = 9399; + this.state = 9485; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_DATE: this.enterOuterAlt(_localctx, 2); { - this.state = 9401; - this.match(PostgreSQLParser.CURRENT_DATE); + this.state = 9487; + this.match(PostgreSQLParser.KW_CURRENT_DATE); } break; - case PostgreSQLParser.CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIME: this.enterOuterAlt(_localctx, 3); { - this.state = 9402; - this.match(PostgreSQLParser.CURRENT_TIME); - this.state = 9407; + this.state = 9488; + this.match(PostgreSQLParser.KW_CURRENT_TIME); + this.state = 9493; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 886, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 900, this._ctx) ) { case 1: { - this.state = 9403; + this.state = 9489; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9404; + this.state = 9490; this.iconst(); - this.state = 9405; + this.state = 9491; this.match(PostgreSQLParser.CLOSE_PAREN); } break; } } break; - case PostgreSQLParser.CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: this.enterOuterAlt(_localctx, 4); { - this.state = 9409; - this.match(PostgreSQLParser.CURRENT_TIMESTAMP); - this.state = 9414; + this.state = 9495; + this.match(PostgreSQLParser.KW_CURRENT_TIMESTAMP); + this.state = 9500; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 887, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 901, this._ctx) ) { case 1: { - this.state = 9410; + this.state = 9496; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9411; + this.state = 9497; this.iconst(); - this.state = 9412; + this.state = 9498; this.match(PostgreSQLParser.CLOSE_PAREN); } break; } } break; - case PostgreSQLParser.LOCALTIME: + case PostgreSQLParser.KW_LOCALTIME: this.enterOuterAlt(_localctx, 5); { - this.state = 9416; - this.match(PostgreSQLParser.LOCALTIME); - this.state = 9421; + this.state = 9502; + this.match(PostgreSQLParser.KW_LOCALTIME); + this.state = 9507; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 888, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 902, this._ctx) ) { case 1: { - this.state = 9417; + this.state = 9503; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9418; + this.state = 9504; this.iconst(); - this.state = 9419; + this.state = 9505; this.match(PostgreSQLParser.CLOSE_PAREN); } break; } } break; - case PostgreSQLParser.LOCALTIMESTAMP: + case PostgreSQLParser.KW_LOCALTIMESTAMP: this.enterOuterAlt(_localctx, 6); { - this.state = 9423; - this.match(PostgreSQLParser.LOCALTIMESTAMP); - this.state = 9428; + this.state = 9509; + this.match(PostgreSQLParser.KW_LOCALTIMESTAMP); + this.state = 9514; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 889, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 903, this._ctx) ) { case 1: { - this.state = 9424; + this.state = 9510; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9425; + this.state = 9511; this.iconst(); - this.state = 9426; + this.state = 9512; this.match(PostgreSQLParser.CLOSE_PAREN); } break; } } break; - case PostgreSQLParser.CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_ROLE: this.enterOuterAlt(_localctx, 7); { - this.state = 9430; - this.match(PostgreSQLParser.CURRENT_ROLE); + this.state = 9516; + this.match(PostgreSQLParser.KW_CURRENT_ROLE); } break; - case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.KW_CURRENT_USER: this.enterOuterAlt(_localctx, 8); { - this.state = 9431; - this.match(PostgreSQLParser.CURRENT_USER); + this.state = 9517; + this.match(PostgreSQLParser.KW_CURRENT_USER); } break; - case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.KW_SESSION_USER: this.enterOuterAlt(_localctx, 9); { - this.state = 9432; - this.match(PostgreSQLParser.SESSION_USER); + this.state = 9518; + this.match(PostgreSQLParser.KW_SESSION_USER); } break; - case PostgreSQLParser.USER: + case PostgreSQLParser.KW_USER: this.enterOuterAlt(_localctx, 10); { - this.state = 9433; - this.match(PostgreSQLParser.USER); + this.state = 9519; + this.match(PostgreSQLParser.KW_USER); } break; - case PostgreSQLParser.CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_CATALOG: this.enterOuterAlt(_localctx, 11); { - this.state = 9434; - this.match(PostgreSQLParser.CURRENT_CATALOG); + this.state = 9520; + this.match(PostgreSQLParser.KW_CURRENT_CATALOG); } break; - case PostgreSQLParser.CURRENT_SCHEMA: + case PostgreSQLParser.KW_CURRENT_SCHEMA: this.enterOuterAlt(_localctx, 12); { - this.state = 9435; - this.match(PostgreSQLParser.CURRENT_SCHEMA); + this.state = 9521; + this.match(PostgreSQLParser.KW_CURRENT_SCHEMA); } break; - case PostgreSQLParser.CAST: + case PostgreSQLParser.KW_CAST: this.enterOuterAlt(_localctx, 13); { - this.state = 9436; - this.match(PostgreSQLParser.CAST); - this.state = 9437; + this.state = 9522; + this.match(PostgreSQLParser.KW_CAST); + this.state = 9523; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9438; + this.state = 9524; this.a_expr(); - this.state = 9439; - this.match(PostgreSQLParser.AS); - this.state = 9440; + this.state = 9525; + this.match(PostgreSQLParser.KW_AS); + this.state = 9526; this.typename(); - this.state = 9441; + this.state = 9527; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.EXTRACT: + case PostgreSQLParser.KW_EXTRACT: this.enterOuterAlt(_localctx, 14); { - this.state = 9443; - this.match(PostgreSQLParser.EXTRACT); - this.state = 9444; + this.state = 9529; + this.match(PostgreSQLParser.KW_EXTRACT); + this.state = 9530; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9446; + this.state = 9532; 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 - 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 - 167)) & ~0x1F) === 0 && ((1 << (_la - 167)) & ((1 << (PostgreSQLParser.CONTINUE_P - 167)) | (1 << (PostgreSQLParser.CURSOR - 167)) | (1 << (PostgreSQLParser.DAY_P - 167)))) !== 0) || ((((_la - 207)) & ~0x1F) === 0 && ((1 << (_la - 207)) & ((1 << (PostgreSQLParser.FIRST_P - 207)) | (1 << (PostgreSQLParser.FORWARD - 207)) | (1 << (PostgreSQLParser.HOUR_P - 207)) | (1 << (PostgreSQLParser.INSERT - 207)))) !== 0) || ((((_la - 240)) & ~0x1F) === 0 && ((1 << (_la - 240)) & ((1 << (PostgreSQLParser.LAST_P - 240)) | (1 << (PostgreSQLParser.MINUTE_P - 240)) | (1 << (PostgreSQLParser.MONTH_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.SECOND_P || _la === PostgreSQLParser.SET || _la === PostgreSQLParser.TYPE_P || _la === PostgreSQLParser.YEAR_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)) | (1 << (PostgreSQLParser.StringConstant - 500)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 500)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 500)))) !== 0) || ((((_la - 537)) & ~0x1F) === 0 && ((1 << (_la - 537)) & ((1 << (PostgreSQLParser.PLSQLVARIABLENAME - 537)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 537)) | (1 << (PostgreSQLParser.EscapeStringConstant - 537)))) !== 0)) { + if (((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & ((1 << (PostgreSQLParser.KW_ABSOLUTE - 130)) | (1 << (PostgreSQLParser.KW_BACKWARD - 130)) | (1 << (PostgreSQLParser.KW_CHAIN - 130)) | (1 << (PostgreSQLParser.KW_CLOSE - 130)) | (1 << (PostgreSQLParser.KW_COMMIT - 130)))) !== 0) || ((((_la - 167)) & ~0x1F) === 0 && ((1 << (_la - 167)) & ((1 << (PostgreSQLParser.KW_CONTINUE - 167)) | (1 << (PostgreSQLParser.KW_CURSOR - 167)) | (1 << (PostgreSQLParser.KW_DAY - 167)))) !== 0) || ((((_la - 207)) & ~0x1F) === 0 && ((1 << (_la - 207)) & ((1 << (PostgreSQLParser.KW_FIRST - 207)) | (1 << (PostgreSQLParser.KW_FORWARD - 207)) | (1 << (PostgreSQLParser.KW_HOUR - 207)))) !== 0) || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & ((1 << (PostgreSQLParser.KW_INSERT - 241)) | (1 << (PostgreSQLParser.KW_LAST - 241)) | (1 << (PostgreSQLParser.KW_MINUTE - 241)) | (1 << (PostgreSQLParser.KW_MONTH - 241)) | (1 << (PostgreSQLParser.KW_MOVE - 241)) | (1 << (PostgreSQLParser.KW_NEXT - 241)) | (1 << (PostgreSQLParser.KW_NO - 241)))) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & ((1 << (PostgreSQLParser.KW_OPTION - 279)) | (1 << (PostgreSQLParser.KW_PRIOR - 279)) | (1 << (PostgreSQLParser.KW_RELATIVE - 279)))) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & ((1 << (PostgreSQLParser.KW_RESET - 313)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 313)) | (1 << (PostgreSQLParser.KW_SCHEMA - 313)) | (1 << (PostgreSQLParser.KW_SCROLL - 313)) | (1 << (PostgreSQLParser.KW_SECOND - 313)) | (1 << (PostgreSQLParser.KW_SET - 313)))) !== 0) || _la === PostgreSQLParser.KW_TYPE || _la === PostgreSQLParser.KW_YEAR || _la === PostgreSQLParser.KW_CALL || _la === PostgreSQLParser.KW_CURRENT || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & ((1 << (PostgreSQLParser.KW_ROWTYPE - 477)) | (1 << (PostgreSQLParser.KW_DUMP - 477)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 477)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 477)) | (1 << (PostgreSQLParser.KW_ERROR - 477)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 477)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 477)) | (1 << (PostgreSQLParser.KW_ALIAS - 477)) | (1 << (PostgreSQLParser.KW_CONSTANT - 477)) | (1 << (PostgreSQLParser.KW_PERFORM - 477)) | (1 << (PostgreSQLParser.KW_GET - 477)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 477)) | (1 << (PostgreSQLParser.KW_STACKED - 477)) | (1 << (PostgreSQLParser.KW_ELSIF - 477)) | (1 << (PostgreSQLParser.KW_REVERSE - 477)) | (1 << (PostgreSQLParser.KW_SLICE - 477)) | (1 << (PostgreSQLParser.KW_EXIT - 477)) | (1 << (PostgreSQLParser.KW_RETURN - 477)))) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & ((1 << (PostgreSQLParser.KW_QUERY - 509)) | (1 << (PostgreSQLParser.KW_RAISE - 509)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 509)) | (1 << (PostgreSQLParser.KW_DEBUG - 509)) | (1 << (PostgreSQLParser.KW_LOG - 509)) | (1 << (PostgreSQLParser.KW_INFO - 509)) | (1 << (PostgreSQLParser.KW_NOTICE - 509)) | (1 << (PostgreSQLParser.KW_WARNING - 509)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 509)) | (1 << (PostgreSQLParser.KW_ASSERT - 509)) | (1 << (PostgreSQLParser.KW_OPEN - 509)) | (1 << (PostgreSQLParser.Identifier - 509)) | (1 << (PostgreSQLParser.QuotedIdentifier - 509)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 509)) | (1 << (PostgreSQLParser.StringConstant - 509)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 509)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 509)))) !== 0) || ((((_la - 550)) & ~0x1F) === 0 && ((1 << (_la - 550)) & ((1 << (PostgreSQLParser.PLSQLVARIABLENAME - 550)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 550)) | (1 << (PostgreSQLParser.EscapeStringConstant - 550)))) !== 0)) { { - this.state = 9445; + this.state = 9531; this.extract_list(); } } - this.state = 9448; + this.state = 9534; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.NORMALIZE: + case PostgreSQLParser.KW_NORMALIZE: this.enterOuterAlt(_localctx, 15); { - this.state = 9449; - this.match(PostgreSQLParser.NORMALIZE); - this.state = 9450; + this.state = 9535; + this.match(PostgreSQLParser.KW_NORMALIZE); + this.state = 9536; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9451; + this.state = 9537; this.a_expr(); - this.state = 9454; + this.state = 9540; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.COMMA) { { - this.state = 9452; + this.state = 9538; this.match(PostgreSQLParser.COMMA); - this.state = 9453; + this.state = 9539; this.unicode_normal_form(); } } - this.state = 9456; + this.state = 9542; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.OVERLAY: + case PostgreSQLParser.KW_OVERLAY: this.enterOuterAlt(_localctx, 16); { - this.state = 9458; - this.match(PostgreSQLParser.OVERLAY); - this.state = 9459; + this.state = 9544; + this.match(PostgreSQLParser.KW_OVERLAY); + this.state = 9545; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9460; + this.state = 9546; this.overlay_list(); - this.state = 9461; + this.state = 9547; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.POSITION: + case PostgreSQLParser.KW_POSITION: this.enterOuterAlt(_localctx, 17); { - this.state = 9463; - this.match(PostgreSQLParser.POSITION); - this.state = 9464; + this.state = 9549; + this.match(PostgreSQLParser.KW_POSITION); + this.state = 9550; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9466; + this.state = 9552; 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.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)) { + 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.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CASE - 33)) | (1 << (PostgreSQLParser.KW_CAST - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_USER - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.KW_LOCALTIME - 75)) | (1 << (PostgreSQLParser.KW_LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.KW_NULL - 75)) | (1 << (PostgreSQLParser.KW_SESSION_USER - 75)) | (1 << (PostgreSQLParser.KW_TABLE - 75)) | (1 << (PostgreSQLParser.KW_TRUE - 75)) | (1 << (PostgreSQLParser.KW_UNIQUE - 75)) | (1 << (PostgreSQLParser.KW_USER - 75)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.KW_BINARY - 107)) | (1 << (PostgreSQLParser.KW_COLLATION - 107)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.KW_CROSS - 107)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.KW_FREEZE - 107)) | (1 << (PostgreSQLParser.KW_FULL - 107)) | (1 << (PostgreSQLParser.KW_ILIKE - 107)) | (1 << (PostgreSQLParser.KW_INNER - 107)) | (1 << (PostgreSQLParser.KW_IS - 107)) | (1 << (PostgreSQLParser.KW_ISNULL - 107)) | (1 << (PostgreSQLParser.KW_JOIN - 107)) | (1 << (PostgreSQLParser.KW_LEFT - 107)) | (1 << (PostgreSQLParser.KW_LIKE - 107)) | (1 << (PostgreSQLParser.KW_NATURAL - 107)) | (1 << (PostgreSQLParser.KW_NOTNULL - 107)) | (1 << (PostgreSQLParser.KW_OUTER - 107)) | (1 << (PostgreSQLParser.KW_OVER - 107)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 107)) | (1 << (PostgreSQLParser.KW_RIGHT - 107)) | (1 << (PostgreSQLParser.KW_SIMILAR - 107)) | (1 << (PostgreSQLParser.KW_VERBOSE - 107)) | (1 << (PostgreSQLParser.KW_ABORT - 107)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 107)) | (1 << (PostgreSQLParser.KW_ACCESS - 107)) | (1 << (PostgreSQLParser.KW_ACTION - 107)) | (1 << (PostgreSQLParser.KW_ADD - 107)) | (1 << (PostgreSQLParser.KW_ADMIN - 107)) | (1 << (PostgreSQLParser.KW_AFTER - 107)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 107)) | (1 << (PostgreSQLParser.KW_ALSO - 107)) | (1 << (PostgreSQLParser.KW_ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.KW_ALWAYS - 139)) | (1 << (PostgreSQLParser.KW_ASSERTION - 139)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.KW_AT - 139)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.KW_BACKWARD - 139)) | (1 << (PostgreSQLParser.KW_BEFORE - 139)) | (1 << (PostgreSQLParser.KW_BEGIN - 139)) | (1 << (PostgreSQLParser.KW_BY - 139)) | (1 << (PostgreSQLParser.KW_CACHE - 139)) | (1 << (PostgreSQLParser.KW_CALLED - 139)) | (1 << (PostgreSQLParser.KW_CASCADE - 139)) | (1 << (PostgreSQLParser.KW_CASCADED - 139)) | (1 << (PostgreSQLParser.KW_CATALOG - 139)) | (1 << (PostgreSQLParser.KW_CHAIN - 139)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 139)) | (1 << (PostgreSQLParser.KW_CLASS - 139)) | (1 << (PostgreSQLParser.KW_CLOSE - 139)) | (1 << (PostgreSQLParser.KW_CLUSTER - 139)) | (1 << (PostgreSQLParser.KW_COMMENT - 139)) | (1 << (PostgreSQLParser.KW_COMMENTS - 139)) | (1 << (PostgreSQLParser.KW_COMMIT - 139)) | (1 << (PostgreSQLParser.KW_COMMITTED - 139)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 139)) | (1 << (PostgreSQLParser.KW_CONNECTION - 139)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.KW_CONTENT - 139)) | (1 << (PostgreSQLParser.KW_CONTINUE - 139)) | (1 << (PostgreSQLParser.KW_CONVERSION - 139)) | (1 << (PostgreSQLParser.KW_COPY - 139)) | (1 << (PostgreSQLParser.KW_COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.KW_CSV - 171)) | (1 << (PostgreSQLParser.KW_CURSOR - 171)) | (1 << (PostgreSQLParser.KW_CYCLE - 171)) | (1 << (PostgreSQLParser.KW_DATA - 171)) | (1 << (PostgreSQLParser.KW_DATABASE - 171)) | (1 << (PostgreSQLParser.KW_DAY - 171)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 171)) | (1 << (PostgreSQLParser.KW_DECLARE - 171)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 171)) | (1 << (PostgreSQLParser.KW_DEFERRED - 171)) | (1 << (PostgreSQLParser.KW_DEFINER - 171)) | (1 << (PostgreSQLParser.KW_DELETE - 171)) | (1 << (PostgreSQLParser.KW_DELIMITER - 171)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 171)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 171)) | (1 << (PostgreSQLParser.KW_DISABLE - 171)) | (1 << (PostgreSQLParser.KW_DISCARD - 171)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 171)) | (1 << (PostgreSQLParser.KW_DOMAIN - 171)) | (1 << (PostgreSQLParser.KW_DOUBLE - 171)) | (1 << (PostgreSQLParser.KW_DROP - 171)) | (1 << (PostgreSQLParser.KW_EACH - 171)) | (1 << (PostgreSQLParser.KW_ENABLE - 171)) | (1 << (PostgreSQLParser.KW_ENCODING - 171)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 171)) | (1 << (PostgreSQLParser.KW_ENUM - 171)) | (1 << (PostgreSQLParser.KW_ESCAPE - 171)) | (1 << (PostgreSQLParser.KW_EVENT - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 171)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.KW_EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.KW_EXPLAIN - 203)) | (1 << (PostgreSQLParser.KW_EXTENSION - 203)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 203)) | (1 << (PostgreSQLParser.KW_FAMILY - 203)) | (1 << (PostgreSQLParser.KW_FIRST - 203)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 203)) | (1 << (PostgreSQLParser.KW_FORCE - 203)) | (1 << (PostgreSQLParser.KW_FORWARD - 203)) | (1 << (PostgreSQLParser.KW_FUNCTION - 203)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 203)) | (1 << (PostgreSQLParser.KW_GLOBAL - 203)) | (1 << (PostgreSQLParser.KW_GRANTED - 203)) | (1 << (PostgreSQLParser.KW_HANDLER - 203)) | (1 << (PostgreSQLParser.KW_HEADER - 203)) | (1 << (PostgreSQLParser.KW_HOLD - 203)) | (1 << (PostgreSQLParser.KW_HOUR - 203)) | (1 << (PostgreSQLParser.KW_IDENTITY - 203)) | (1 << (PostgreSQLParser.KW_IF - 203)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 203)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 203)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 203)) | (1 << (PostgreSQLParser.KW_INCLUDING - 203)) | (1 << (PostgreSQLParser.KW_INCREMENT - 203)) | (1 << (PostgreSQLParser.KW_INDEX - 203)) | (1 << (PostgreSQLParser.KW_INDEXES - 203)) | (1 << (PostgreSQLParser.KW_INHERIT - 203)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.StringConstant - 526)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 526)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 526)) | (1 << (PostgreSQLParser.BinaryStringConstant - 526)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 526)) | (1 << (PostgreSQLParser.Integral - 526)) | (1 << (PostgreSQLParser.Numeric - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0) || _la === PostgreSQLParser.EscapeStringConstant) { { - this.state = 9465; + this.state = 9551; this.position_list(); } } - this.state = 9468; + this.state = 9554; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.SUBSTRING: + case PostgreSQLParser.KW_SUBSTRING: this.enterOuterAlt(_localctx, 18); { - this.state = 9469; - this.match(PostgreSQLParser.SUBSTRING); - this.state = 9470; + this.state = 9555; + this.match(PostgreSQLParser.KW_SUBSTRING); + this.state = 9556; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9472; + this.state = 9558; 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)) { + 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.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CASE - 33)) | (1 << (PostgreSQLParser.KW_CAST - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_USER - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.KW_LOCALTIME - 75)) | (1 << (PostgreSQLParser.KW_LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.KW_NOT - 75)) | (1 << (PostgreSQLParser.KW_NULL - 75)) | (1 << (PostgreSQLParser.KW_SESSION_USER - 75)) | (1 << (PostgreSQLParser.KW_TABLE - 75)) | (1 << (PostgreSQLParser.KW_TRUE - 75)) | (1 << (PostgreSQLParser.KW_UNIQUE - 75)) | (1 << (PostgreSQLParser.KW_USER - 75)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.KW_BINARY - 107)) | (1 << (PostgreSQLParser.KW_COLLATION - 107)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.KW_CROSS - 107)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.KW_FREEZE - 107)) | (1 << (PostgreSQLParser.KW_FULL - 107)) | (1 << (PostgreSQLParser.KW_ILIKE - 107)) | (1 << (PostgreSQLParser.KW_INNER - 107)) | (1 << (PostgreSQLParser.KW_IS - 107)) | (1 << (PostgreSQLParser.KW_ISNULL - 107)) | (1 << (PostgreSQLParser.KW_JOIN - 107)) | (1 << (PostgreSQLParser.KW_LEFT - 107)) | (1 << (PostgreSQLParser.KW_LIKE - 107)) | (1 << (PostgreSQLParser.KW_NATURAL - 107)) | (1 << (PostgreSQLParser.KW_NOTNULL - 107)) | (1 << (PostgreSQLParser.KW_OUTER - 107)) | (1 << (PostgreSQLParser.KW_OVER - 107)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 107)) | (1 << (PostgreSQLParser.KW_RIGHT - 107)) | (1 << (PostgreSQLParser.KW_SIMILAR - 107)) | (1 << (PostgreSQLParser.KW_VERBOSE - 107)) | (1 << (PostgreSQLParser.KW_ABORT - 107)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 107)) | (1 << (PostgreSQLParser.KW_ACCESS - 107)) | (1 << (PostgreSQLParser.KW_ACTION - 107)) | (1 << (PostgreSQLParser.KW_ADD - 107)) | (1 << (PostgreSQLParser.KW_ADMIN - 107)) | (1 << (PostgreSQLParser.KW_AFTER - 107)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 107)) | (1 << (PostgreSQLParser.KW_ALSO - 107)) | (1 << (PostgreSQLParser.KW_ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.KW_ALWAYS - 139)) | (1 << (PostgreSQLParser.KW_ASSERTION - 139)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.KW_AT - 139)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.KW_BACKWARD - 139)) | (1 << (PostgreSQLParser.KW_BEFORE - 139)) | (1 << (PostgreSQLParser.KW_BEGIN - 139)) | (1 << (PostgreSQLParser.KW_BY - 139)) | (1 << (PostgreSQLParser.KW_CACHE - 139)) | (1 << (PostgreSQLParser.KW_CALLED - 139)) | (1 << (PostgreSQLParser.KW_CASCADE - 139)) | (1 << (PostgreSQLParser.KW_CASCADED - 139)) | (1 << (PostgreSQLParser.KW_CATALOG - 139)) | (1 << (PostgreSQLParser.KW_CHAIN - 139)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 139)) | (1 << (PostgreSQLParser.KW_CLASS - 139)) | (1 << (PostgreSQLParser.KW_CLOSE - 139)) | (1 << (PostgreSQLParser.KW_CLUSTER - 139)) | (1 << (PostgreSQLParser.KW_COMMENT - 139)) | (1 << (PostgreSQLParser.KW_COMMENTS - 139)) | (1 << (PostgreSQLParser.KW_COMMIT - 139)) | (1 << (PostgreSQLParser.KW_COMMITTED - 139)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 139)) | (1 << (PostgreSQLParser.KW_CONNECTION - 139)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.KW_CONTENT - 139)) | (1 << (PostgreSQLParser.KW_CONTINUE - 139)) | (1 << (PostgreSQLParser.KW_CONVERSION - 139)) | (1 << (PostgreSQLParser.KW_COPY - 139)) | (1 << (PostgreSQLParser.KW_COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.KW_CSV - 171)) | (1 << (PostgreSQLParser.KW_CURSOR - 171)) | (1 << (PostgreSQLParser.KW_CYCLE - 171)) | (1 << (PostgreSQLParser.KW_DATA - 171)) | (1 << (PostgreSQLParser.KW_DATABASE - 171)) | (1 << (PostgreSQLParser.KW_DAY - 171)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 171)) | (1 << (PostgreSQLParser.KW_DECLARE - 171)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 171)) | (1 << (PostgreSQLParser.KW_DEFERRED - 171)) | (1 << (PostgreSQLParser.KW_DEFINER - 171)) | (1 << (PostgreSQLParser.KW_DELETE - 171)) | (1 << (PostgreSQLParser.KW_DELIMITER - 171)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 171)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 171)) | (1 << (PostgreSQLParser.KW_DISABLE - 171)) | (1 << (PostgreSQLParser.KW_DISCARD - 171)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 171)) | (1 << (PostgreSQLParser.KW_DOMAIN - 171)) | (1 << (PostgreSQLParser.KW_DOUBLE - 171)) | (1 << (PostgreSQLParser.KW_DROP - 171)) | (1 << (PostgreSQLParser.KW_EACH - 171)) | (1 << (PostgreSQLParser.KW_ENABLE - 171)) | (1 << (PostgreSQLParser.KW_ENCODING - 171)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 171)) | (1 << (PostgreSQLParser.KW_ENUM - 171)) | (1 << (PostgreSQLParser.KW_ESCAPE - 171)) | (1 << (PostgreSQLParser.KW_EVENT - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 171)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.KW_EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.KW_EXPLAIN - 203)) | (1 << (PostgreSQLParser.KW_EXTENSION - 203)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 203)) | (1 << (PostgreSQLParser.KW_FAMILY - 203)) | (1 << (PostgreSQLParser.KW_FIRST - 203)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 203)) | (1 << (PostgreSQLParser.KW_FORCE - 203)) | (1 << (PostgreSQLParser.KW_FORWARD - 203)) | (1 << (PostgreSQLParser.KW_FUNCTION - 203)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 203)) | (1 << (PostgreSQLParser.KW_GLOBAL - 203)) | (1 << (PostgreSQLParser.KW_GRANTED - 203)) | (1 << (PostgreSQLParser.KW_HANDLER - 203)) | (1 << (PostgreSQLParser.KW_HEADER - 203)) | (1 << (PostgreSQLParser.KW_HOLD - 203)) | (1 << (PostgreSQLParser.KW_HOUR - 203)) | (1 << (PostgreSQLParser.KW_IDENTITY - 203)) | (1 << (PostgreSQLParser.KW_IF - 203)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 203)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 203)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 203)) | (1 << (PostgreSQLParser.KW_INCLUDING - 203)) | (1 << (PostgreSQLParser.KW_INCREMENT - 203)) | (1 << (PostgreSQLParser.KW_INDEX - 203)) | (1 << (PostgreSQLParser.KW_INDEXES - 203)) | (1 << (PostgreSQLParser.KW_INHERIT - 203)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.StringConstant - 526)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 526)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 526)) | (1 << (PostgreSQLParser.BinaryStringConstant - 526)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 526)) | (1 << (PostgreSQLParser.Integral - 526)) | (1 << (PostgreSQLParser.Numeric - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0) || _la === PostgreSQLParser.EscapeStringConstant) { { - this.state = 9471; + this.state = 9557; this.substr_list(); } } - this.state = 9474; + this.state = 9560; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.TREAT: + case PostgreSQLParser.KW_TREAT: this.enterOuterAlt(_localctx, 19); { - this.state = 9475; - this.match(PostgreSQLParser.TREAT); - this.state = 9476; + this.state = 9561; + this.match(PostgreSQLParser.KW_TREAT); + this.state = 9562; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9477; + this.state = 9563; this.a_expr(); - this.state = 9478; - this.match(PostgreSQLParser.AS); - this.state = 9479; + this.state = 9564; + this.match(PostgreSQLParser.KW_AS); + this.state = 9565; this.typename(); - this.state = 9480; + this.state = 9566; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.TRIM: + case PostgreSQLParser.KW_TRIM: this.enterOuterAlt(_localctx, 20); { - this.state = 9482; - this.match(PostgreSQLParser.TRIM); - this.state = 9483; + this.state = 9568; + this.match(PostgreSQLParser.KW_TRIM); + this.state = 9569; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9485; + this.state = 9571; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.BOTH || _la === PostgreSQLParser.LEADING || _la === PostgreSQLParser.TRAILING) { + if (_la === PostgreSQLParser.KW_BOTH || _la === PostgreSQLParser.KW_LEADING || _la === PostgreSQLParser.KW_TRAILING) { { - this.state = 9484; + this.state = 9570; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.BOTH || _la === PostgreSQLParser.LEADING || _la === PostgreSQLParser.TRAILING)) { + if (!(_la === PostgreSQLParser.KW_BOTH || _la === PostgreSQLParser.KW_LEADING || _la === PostgreSQLParser.KW_TRAILING)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -51001,112 +51035,112 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } - this.state = 9487; + this.state = 9573; this.trim_list(); - this.state = 9488; + this.state = 9574; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.NULLIF: + case PostgreSQLParser.KW_NULLIF: this.enterOuterAlt(_localctx, 21); { - this.state = 9490; - this.match(PostgreSQLParser.NULLIF); - this.state = 9491; + this.state = 9576; + this.match(PostgreSQLParser.KW_NULLIF); + this.state = 9577; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9492; + this.state = 9578; this.a_expr(); - this.state = 9493; + this.state = 9579; this.match(PostgreSQLParser.COMMA); - this.state = 9494; + this.state = 9580; this.a_expr(); - this.state = 9495; + this.state = 9581; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.COALESCE: + case PostgreSQLParser.KW_COALESCE: this.enterOuterAlt(_localctx, 22); { - this.state = 9497; - this.match(PostgreSQLParser.COALESCE); - this.state = 9498; + this.state = 9583; + this.match(PostgreSQLParser.KW_COALESCE); + this.state = 9584; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9499; + this.state = 9585; this.expr_list(); - this.state = 9500; + this.state = 9586; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.GREATEST: + case PostgreSQLParser.KW_GREATEST: this.enterOuterAlt(_localctx, 23); { - this.state = 9502; - this.match(PostgreSQLParser.GREATEST); - this.state = 9503; + this.state = 9588; + this.match(PostgreSQLParser.KW_GREATEST); + this.state = 9589; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9504; + this.state = 9590; this.expr_list(); - this.state = 9505; + this.state = 9591; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.LEAST: + case PostgreSQLParser.KW_LEAST: this.enterOuterAlt(_localctx, 24); { - this.state = 9507; - this.match(PostgreSQLParser.LEAST); - this.state = 9508; + this.state = 9593; + this.match(PostgreSQLParser.KW_LEAST); + this.state = 9594; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9509; + this.state = 9595; this.expr_list(); - this.state = 9510; + this.state = 9596; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.XMLCONCAT: + case PostgreSQLParser.KW_XMLCONCAT: this.enterOuterAlt(_localctx, 25); { - this.state = 9512; - this.match(PostgreSQLParser.XMLCONCAT); - this.state = 9513; + this.state = 9598; + this.match(PostgreSQLParser.KW_XMLCONCAT); + this.state = 9599; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9514; + this.state = 9600; this.expr_list(); - this.state = 9515; + this.state = 9601; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.XMLELEMENT: + case PostgreSQLParser.KW_XMLELEMENT: this.enterOuterAlt(_localctx, 26); { - this.state = 9517; - this.match(PostgreSQLParser.XMLELEMENT); - this.state = 9518; + this.state = 9603; + this.match(PostgreSQLParser.KW_XMLELEMENT); + this.state = 9604; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9519; - this.match(PostgreSQLParser.NAME_P); - this.state = 9520; + this.state = 9605; + this.match(PostgreSQLParser.KW_NAME); + this.state = 9606; this.collabel(); - this.state = 9526; + this.state = 9612; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.COMMA) { { - this.state = 9521; + this.state = 9607; this.match(PostgreSQLParser.COMMA); - this.state = 9524; + this.state = 9610; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 895, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 909, this._ctx) ) { case 1: { - this.state = 9522; + this.state = 9608; this.xml_attributes(); } break; case 2: { - this.state = 9523; + this.state = 9609; this.expr_list(); } break; @@ -51114,135 +51148,135 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } } - this.state = 9528; + this.state = 9614; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.XMLEXISTS: + case PostgreSQLParser.KW_XMLEXISTS: this.enterOuterAlt(_localctx, 27); { - this.state = 9530; - this.match(PostgreSQLParser.XMLEXISTS); - this.state = 9531; + this.state = 9616; + this.match(PostgreSQLParser.KW_XMLEXISTS); + this.state = 9617; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9532; + this.state = 9618; this.c_expr(); - this.state = 9533; + this.state = 9619; this.xmlexists_argument(); - this.state = 9534; + this.state = 9620; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.XMLFOREST: + case PostgreSQLParser.KW_XMLFOREST: this.enterOuterAlt(_localctx, 28); { - this.state = 9536; - this.match(PostgreSQLParser.XMLFOREST); - this.state = 9537; + this.state = 9622; + this.match(PostgreSQLParser.KW_XMLFOREST); + this.state = 9623; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9538; + this.state = 9624; this.xml_attribute_list(); - this.state = 9539; + this.state = 9625; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.XMLPARSE: + case PostgreSQLParser.KW_XMLPARSE: this.enterOuterAlt(_localctx, 29); { - this.state = 9541; - this.match(PostgreSQLParser.XMLPARSE); - this.state = 9542; + this.state = 9627; + this.match(PostgreSQLParser.KW_XMLPARSE); + this.state = 9628; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9543; + this.state = 9629; this.document_or_content(); - this.state = 9544; + this.state = 9630; this.a_expr(); - this.state = 9546; + this.state = 9632; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PRESERVE || _la === PostgreSQLParser.STRIP_P) { + if (_la === PostgreSQLParser.KW_PRESERVE || _la === PostgreSQLParser.KW_STRIP) { { - this.state = 9545; + this.state = 9631; this.xml_whitespace_option(); } } - this.state = 9548; + this.state = 9634; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.XMLPI: + case PostgreSQLParser.KW_XMLPI: this.enterOuterAlt(_localctx, 30); { - this.state = 9550; - this.match(PostgreSQLParser.XMLPI); - this.state = 9551; + this.state = 9636; + this.match(PostgreSQLParser.KW_XMLPI); + this.state = 9637; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9552; - this.match(PostgreSQLParser.NAME_P); - this.state = 9553; + this.state = 9638; + this.match(PostgreSQLParser.KW_NAME); + this.state = 9639; this.collabel(); - this.state = 9556; + this.state = 9642; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.COMMA) { { - this.state = 9554; + this.state = 9640; this.match(PostgreSQLParser.COMMA); - this.state = 9555; + this.state = 9641; this.a_expr(); } } - this.state = 9558; + this.state = 9644; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.XMLROOT: + case PostgreSQLParser.KW_XMLROOT: this.enterOuterAlt(_localctx, 31); { - this.state = 9560; - this.match(PostgreSQLParser.XMLROOT); - this.state = 9561; + this.state = 9646; + this.match(PostgreSQLParser.KW_XMLROOT); + this.state = 9647; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9562; - this.match(PostgreSQLParser.XML_P); - this.state = 9563; + this.state = 9648; + this.match(PostgreSQLParser.KW_XML); + this.state = 9649; this.a_expr(); - this.state = 9564; + this.state = 9650; this.match(PostgreSQLParser.COMMA); - this.state = 9565; + this.state = 9651; this.xml_root_version(); - this.state = 9567; + this.state = 9653; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.COMMA) { { - this.state = 9566; + this.state = 9652; this.opt_xml_root_standalone(); } } - this.state = 9569; + this.state = 9655; this.match(PostgreSQLParser.CLOSE_PAREN); } break; - case PostgreSQLParser.XMLSERIALIZE: + case PostgreSQLParser.KW_XMLSERIALIZE: this.enterOuterAlt(_localctx, 32); { - this.state = 9571; - this.match(PostgreSQLParser.XMLSERIALIZE); - this.state = 9572; + this.state = 9657; + this.match(PostgreSQLParser.KW_XMLSERIALIZE); + this.state = 9658; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9573; + this.state = 9659; this.document_or_content(); - this.state = 9574; + this.state = 9660; this.a_expr(); - this.state = 9575; - this.match(PostgreSQLParser.AS); - this.state = 9576; + this.state = 9661; + this.match(PostgreSQLParser.KW_AS); + this.state = 9662; this.simpletypename(); - this.state = 9577; + this.state = 9663; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -51267,17 +51301,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xml_root_version(): Xml_root_versionContext { let _localctx: Xml_root_versionContext = new Xml_root_versionContext(this._ctx, this.state); - this.enterRule(_localctx, 1204, PostgreSQLParser.RULE_xml_root_version); + this.enterRule(_localctx, 1218, PostgreSQLParser.RULE_xml_root_version); try { - this.state = 9586; + this.state = 9672; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 901, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 915, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9581; - this.match(PostgreSQLParser.VERSION_P); - this.state = 9582; + this.state = 9667; + this.match(PostgreSQLParser.KW_VERSION); + this.state = 9668; this.a_expr(); } break; @@ -51285,12 +51319,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9583; - this.match(PostgreSQLParser.VERSION_P); - this.state = 9584; - this.match(PostgreSQLParser.NO); - this.state = 9585; - this.match(PostgreSQLParser.VALUE_P); + this.state = 9669; + this.match(PostgreSQLParser.KW_VERSION); + this.state = 9670; + this.match(PostgreSQLParser.KW_NO); + this.state = 9671; + this.match(PostgreSQLParser.KW_VALUE); } break; } @@ -51312,46 +51346,46 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_xml_root_standalone(): Opt_xml_root_standaloneContext { let _localctx: Opt_xml_root_standaloneContext = new Opt_xml_root_standaloneContext(this._ctx, this.state); - this.enterRule(_localctx, 1206, PostgreSQLParser.RULE_opt_xml_root_standalone); + this.enterRule(_localctx, 1220, PostgreSQLParser.RULE_opt_xml_root_standalone); try { - this.state = 9598; + this.state = 9684; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 902, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 916, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9588; + this.state = 9674; this.match(PostgreSQLParser.COMMA); - this.state = 9589; - this.match(PostgreSQLParser.STANDALONE_P); - this.state = 9590; - this.match(PostgreSQLParser.YES_P); + this.state = 9675; + this.match(PostgreSQLParser.KW_STANDALONE); + this.state = 9676; + this.match(PostgreSQLParser.KW_YES); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9591; + this.state = 9677; this.match(PostgreSQLParser.COMMA); - this.state = 9592; - this.match(PostgreSQLParser.STANDALONE_P); - this.state = 9593; - this.match(PostgreSQLParser.NO); + this.state = 9678; + this.match(PostgreSQLParser.KW_STANDALONE); + this.state = 9679; + this.match(PostgreSQLParser.KW_NO); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 9594; + this.state = 9680; this.match(PostgreSQLParser.COMMA); - this.state = 9595; - this.match(PostgreSQLParser.STANDALONE_P); - this.state = 9596; - this.match(PostgreSQLParser.NO); - this.state = 9597; - this.match(PostgreSQLParser.VALUE_P); + this.state = 9681; + this.match(PostgreSQLParser.KW_STANDALONE); + this.state = 9682; + this.match(PostgreSQLParser.KW_NO); + this.state = 9683; + this.match(PostgreSQLParser.KW_VALUE); } break; } @@ -51373,17 +51407,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xml_attributes(): Xml_attributesContext { let _localctx: Xml_attributesContext = new Xml_attributesContext(this._ctx, this.state); - this.enterRule(_localctx, 1208, PostgreSQLParser.RULE_xml_attributes); + this.enterRule(_localctx, 1222, PostgreSQLParser.RULE_xml_attributes); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9600; - this.match(PostgreSQLParser.XMLATTRIBUTES); - this.state = 9601; + this.state = 9686; + this.match(PostgreSQLParser.KW_XMLATTRIBUTES); + this.state = 9687; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9602; + this.state = 9688; this.xml_attribute_list(); - this.state = 9603; + this.state = 9689; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -51404,26 +51438,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xml_attribute_list(): Xml_attribute_listContext { let _localctx: Xml_attribute_listContext = new Xml_attribute_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1210, PostgreSQLParser.RULE_xml_attribute_list); + this.enterRule(_localctx, 1224, PostgreSQLParser.RULE_xml_attribute_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9605; + this.state = 9691; this.xml_attribute_el(); - this.state = 9610; + this.state = 9696; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 9606; + this.state = 9692; this.match(PostgreSQLParser.COMMA); - this.state = 9607; + this.state = 9693; this.xml_attribute_el(); } } - this.state = 9612; + this.state = 9698; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -51446,21 +51480,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xml_attribute_el(): Xml_attribute_elContext { let _localctx: Xml_attribute_elContext = new Xml_attribute_elContext(this._ctx, this.state); - this.enterRule(_localctx, 1212, PostgreSQLParser.RULE_xml_attribute_el); + this.enterRule(_localctx, 1226, PostgreSQLParser.RULE_xml_attribute_el); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9613; + this.state = 9699; this.a_expr(); - this.state = 9616; + this.state = 9702; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AS) { + if (_la === PostgreSQLParser.KW_AS) { { - this.state = 9614; - this.match(PostgreSQLParser.AS); - this.state = 9615; + this.state = 9700; + this.match(PostgreSQLParser.KW_AS); + this.state = 9701; this.collabel(); } } @@ -51484,14 +51518,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public document_or_content(): Document_or_contentContext { let _localctx: Document_or_contentContext = new Document_or_contentContext(this._ctx, this.state); - this.enterRule(_localctx, 1214, PostgreSQLParser.RULE_document_or_content); + this.enterRule(_localctx, 1228, PostgreSQLParser.RULE_document_or_content); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9618; + this.state = 9704; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.CONTENT_P || _la === PostgreSQLParser.DOCUMENT_P)) { + if (!(_la === PostgreSQLParser.KW_CONTENT || _la === PostgreSQLParser.KW_DOCUMENT)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -51520,27 +51554,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xml_whitespace_option(): Xml_whitespace_optionContext { let _localctx: Xml_whitespace_optionContext = new Xml_whitespace_optionContext(this._ctx, this.state); - this.enterRule(_localctx, 1216, PostgreSQLParser.RULE_xml_whitespace_option); + this.enterRule(_localctx, 1230, PostgreSQLParser.RULE_xml_whitespace_option); try { - this.state = 9624; + this.state = 9710; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.PRESERVE: + case PostgreSQLParser.KW_PRESERVE: this.enterOuterAlt(_localctx, 1); { - this.state = 9620; - this.match(PostgreSQLParser.PRESERVE); - this.state = 9621; - this.match(PostgreSQLParser.WHITESPACE_P); + this.state = 9706; + this.match(PostgreSQLParser.KW_PRESERVE); + this.state = 9707; + this.match(PostgreSQLParser.KW_WHITESPACE); } break; - case PostgreSQLParser.STRIP_P: + case PostgreSQLParser.KW_STRIP: this.enterOuterAlt(_localctx, 2); { - this.state = 9622; - this.match(PostgreSQLParser.STRIP_P); - this.state = 9623; - this.match(PostgreSQLParser.WHITESPACE_P); + this.state = 9708; + this.match(PostgreSQLParser.KW_STRIP); + this.state = 9709; + this.match(PostgreSQLParser.KW_WHITESPACE); } break; default: @@ -51564,17 +51598,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xmlexists_argument(): Xmlexists_argumentContext { let _localctx: Xmlexists_argumentContext = new Xmlexists_argumentContext(this._ctx, this.state); - this.enterRule(_localctx, 1218, PostgreSQLParser.RULE_xmlexists_argument); + this.enterRule(_localctx, 1232, PostgreSQLParser.RULE_xmlexists_argument); try { - this.state = 9641; + this.state = 9727; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 906, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 920, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9626; - this.match(PostgreSQLParser.PASSING); - this.state = 9627; + this.state = 9712; + this.match(PostgreSQLParser.KW_PASSING); + this.state = 9713; this.c_expr(); } break; @@ -51582,11 +51616,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9628; - this.match(PostgreSQLParser.PASSING); - this.state = 9629; + this.state = 9714; + this.match(PostgreSQLParser.KW_PASSING); + this.state = 9715; this.c_expr(); - this.state = 9630; + this.state = 9716; this.xml_passing_mech(); } break; @@ -51594,11 +51628,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 9632; - this.match(PostgreSQLParser.PASSING); - this.state = 9633; + this.state = 9718; + this.match(PostgreSQLParser.KW_PASSING); + this.state = 9719; this.xml_passing_mech(); - this.state = 9634; + this.state = 9720; this.c_expr(); } break; @@ -51606,13 +51640,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 9636; - this.match(PostgreSQLParser.PASSING); - this.state = 9637; + this.state = 9722; + this.match(PostgreSQLParser.KW_PASSING); + this.state = 9723; this.xml_passing_mech(); - this.state = 9638; + this.state = 9724; this.c_expr(); - this.state = 9639; + this.state = 9725; this.xml_passing_mech(); } break; @@ -51635,16 +51669,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xml_passing_mech(): Xml_passing_mechContext { let _localctx: Xml_passing_mechContext = new Xml_passing_mechContext(this._ctx, this.state); - this.enterRule(_localctx, 1220, PostgreSQLParser.RULE_xml_passing_mech); + this.enterRule(_localctx, 1234, PostgreSQLParser.RULE_xml_passing_mech); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9643; - this.match(PostgreSQLParser.BY); - this.state = 9644; + this.state = 9729; + this.match(PostgreSQLParser.KW_BY); + this.state = 9730; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.REF || _la === PostgreSQLParser.VALUE_P)) { + if (!(_la === PostgreSQLParser.KW_REF || _la === PostgreSQLParser.KW_VALUE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -51673,19 +51707,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public within_group_clause(): Within_group_clauseContext { let _localctx: Within_group_clauseContext = new Within_group_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1222, PostgreSQLParser.RULE_within_group_clause); + this.enterRule(_localctx, 1236, PostgreSQLParser.RULE_within_group_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9646; - this.match(PostgreSQLParser.WITHIN); - this.state = 9647; - this.match(PostgreSQLParser.GROUP_P); - this.state = 9648; + this.state = 9732; + this.match(PostgreSQLParser.KW_WITHIN); + this.state = 9733; + this.match(PostgreSQLParser.KW_GROUP); + this.state = 9734; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9649; + this.state = 9735; this.sort_clause(); - this.state = 9650; + this.state = 9736; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -51706,19 +51740,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public filter_clause(): Filter_clauseContext { let _localctx: Filter_clauseContext = new Filter_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1224, PostgreSQLParser.RULE_filter_clause); + this.enterRule(_localctx, 1238, PostgreSQLParser.RULE_filter_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9652; - this.match(PostgreSQLParser.FILTER); - this.state = 9653; + this.state = 9738; + this.match(PostgreSQLParser.KW_FILTER); + this.state = 9739; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9654; - this.match(PostgreSQLParser.WHERE); - this.state = 9655; + this.state = 9740; + this.match(PostgreSQLParser.KW_WHERE); + this.state = 9741; this.a_expr(); - this.state = 9656; + this.state = 9742; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -51739,13 +51773,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public window_clause(): Window_clauseContext { let _localctx: Window_clauseContext = new Window_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1226, PostgreSQLParser.RULE_window_clause); + this.enterRule(_localctx, 1240, PostgreSQLParser.RULE_window_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9658; - this.match(PostgreSQLParser.WINDOW); - this.state = 9659; + this.state = 9744; + this.match(PostgreSQLParser.KW_WINDOW); + this.state = 9745; this.window_definition_list(); } } @@ -51766,30 +51800,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public window_definition_list(): Window_definition_listContext { let _localctx: Window_definition_listContext = new Window_definition_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1228, PostgreSQLParser.RULE_window_definition_list); + this.enterRule(_localctx, 1242, PostgreSQLParser.RULE_window_definition_list); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9661; + this.state = 9747; this.window_definition(); - this.state = 9666; + this.state = 9752; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 907, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 921, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9662; + this.state = 9748; this.match(PostgreSQLParser.COMMA); - this.state = 9663; + this.state = 9749; this.window_definition(); } } } - this.state = 9668; + this.state = 9754; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 907, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 921, this._ctx); } } } @@ -51810,15 +51844,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public window_definition(): Window_definitionContext { let _localctx: Window_definitionContext = new Window_definitionContext(this._ctx, this.state); - this.enterRule(_localctx, 1230, PostgreSQLParser.RULE_window_definition); + this.enterRule(_localctx, 1244, PostgreSQLParser.RULE_window_definition); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9669; + this.state = 9755; this.colid(); - this.state = 9670; - this.match(PostgreSQLParser.AS); - this.state = 9671; + this.state = 9756; + this.match(PostgreSQLParser.KW_AS); + this.state = 9757; this.window_specification(); } } @@ -51839,418 +51873,418 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public over_clause(): Over_clauseContext { let _localctx: Over_clauseContext = new Over_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1232, PostgreSQLParser.RULE_over_clause); + this.enterRule(_localctx, 1246, PostgreSQLParser.RULE_over_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9673; - this.match(PostgreSQLParser.OVER); - this.state = 9676; + this.state = 9759; + this.match(PostgreSQLParser.KW_OVER); + this.state = 9762; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: { - this.state = 9674; + this.state = 9760; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: case PostgreSQLParser.PLSQLVARIABLENAME: case PostgreSQLParser.PLSQLIDENTIFIER: { - this.state = 9675; + this.state = 9761; this.colid(); } break; @@ -52276,54 +52310,54 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public window_specification(): Window_specificationContext { let _localctx: Window_specificationContext = new Window_specificationContext(this._ctx, this.state); - this.enterRule(_localctx, 1234, PostgreSQLParser.RULE_window_specification); + this.enterRule(_localctx, 1248, PostgreSQLParser.RULE_window_specification); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9678; + this.state = 9764; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9680; + this.state = 9766; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 909, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 923, this._ctx) ) { case 1: { - this.state = 9679; + this.state = 9765; this.opt_existing_window_name(); } break; } - this.state = 9683; + this.state = 9769; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.PARTITION) { + if (_la === PostgreSQLParser.KW_PARTITION) { { - this.state = 9682; + this.state = 9768; this.opt_partition_clause(); } } - this.state = 9686; + this.state = 9772; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ORDER) { + if (_la === PostgreSQLParser.KW_ORDER) { { - this.state = 9685; + this.state = 9771; this.opt_sort_clause(); } } - this.state = 9689; + this.state = 9775; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.RANGE || _la === PostgreSQLParser.ROWS || _la === PostgreSQLParser.GROUPS) { + if (_la === PostgreSQLParser.KW_RANGE || _la === PostgreSQLParser.KW_ROWS || _la === PostgreSQLParser.KW_GROUPS) { { - this.state = 9688; + this.state = 9774; this.opt_frame_clause(); } } - this.state = 9691; + this.state = 9777; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -52344,11 +52378,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_existing_window_name(): Opt_existing_window_nameContext { let _localctx: Opt_existing_window_nameContext = new Opt_existing_window_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 1236, PostgreSQLParser.RULE_opt_existing_window_name); + this.enterRule(_localctx, 1250, PostgreSQLParser.RULE_opt_existing_window_name); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9693; + this.state = 9779; this.colid(); } } @@ -52369,15 +52403,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_partition_clause(): Opt_partition_clauseContext { let _localctx: Opt_partition_clauseContext = new Opt_partition_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1238, PostgreSQLParser.RULE_opt_partition_clause); + this.enterRule(_localctx, 1252, PostgreSQLParser.RULE_opt_partition_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9695; - this.match(PostgreSQLParser.PARTITION); - this.state = 9696; - this.match(PostgreSQLParser.BY); - this.state = 9697; + this.state = 9781; + this.match(PostgreSQLParser.KW_PARTITION); + this.state = 9782; + this.match(PostgreSQLParser.KW_BY); + this.state = 9783; this.expr_list(); } } @@ -52398,63 +52432,63 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_frame_clause(): Opt_frame_clauseContext { let _localctx: Opt_frame_clauseContext = new Opt_frame_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1240, PostgreSQLParser.RULE_opt_frame_clause); + this.enterRule(_localctx, 1254, PostgreSQLParser.RULE_opt_frame_clause); let _la: number; try { - this.state = 9714; + this.state = 9800; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.RANGE: + case PostgreSQLParser.KW_RANGE: this.enterOuterAlt(_localctx, 1); { - this.state = 9699; - this.match(PostgreSQLParser.RANGE); - this.state = 9700; + this.state = 9785; + this.match(PostgreSQLParser.KW_RANGE); + this.state = 9786; this.frame_extent(); - this.state = 9702; + this.state = 9788; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.EXCLUDE) { + if (_la === PostgreSQLParser.KW_EXCLUDE) { { - this.state = 9701; + this.state = 9787; this.opt_window_exclusion_clause(); } } } break; - case PostgreSQLParser.ROWS: + case PostgreSQLParser.KW_ROWS: this.enterOuterAlt(_localctx, 2); { - this.state = 9704; - this.match(PostgreSQLParser.ROWS); - this.state = 9705; + this.state = 9790; + this.match(PostgreSQLParser.KW_ROWS); + this.state = 9791; this.frame_extent(); - this.state = 9707; + this.state = 9793; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.EXCLUDE) { + if (_la === PostgreSQLParser.KW_EXCLUDE) { { - this.state = 9706; + this.state = 9792; this.opt_window_exclusion_clause(); } } } break; - case PostgreSQLParser.GROUPS: + case PostgreSQLParser.KW_GROUPS: this.enterOuterAlt(_localctx, 3); { - this.state = 9709; - this.match(PostgreSQLParser.GROUPS); - this.state = 9710; + this.state = 9795; + this.match(PostgreSQLParser.KW_GROUPS); + this.state = 9796; this.frame_extent(); - this.state = 9712; + this.state = 9798; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.EXCLUDE) { + if (_la === PostgreSQLParser.KW_EXCLUDE) { { - this.state = 9711; + this.state = 9797; this.opt_window_exclusion_clause(); } } @@ -52482,15 +52516,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public frame_extent(): Frame_extentContext { let _localctx: Frame_extentContext = new Frame_extentContext(this._ctx, this.state); - this.enterRule(_localctx, 1242, PostgreSQLParser.RULE_frame_extent); + this.enterRule(_localctx, 1256, PostgreSQLParser.RULE_frame_extent); try { - this.state = 9722; + this.state = 9808; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 917, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 931, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9716; + this.state = 9802; this.frame_bound(); } break; @@ -52498,13 +52532,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9717; - this.match(PostgreSQLParser.BETWEEN); - this.state = 9718; + this.state = 9803; + this.match(PostgreSQLParser.KW_BETWEEN); + this.state = 9804; this.frame_bound(); - this.state = 9719; - this.match(PostgreSQLParser.AND); - this.state = 9720; + this.state = 9805; + this.match(PostgreSQLParser.KW_AND); + this.state = 9806; this.frame_bound(); } break; @@ -52527,20 +52561,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public frame_bound(): Frame_boundContext { let _localctx: Frame_boundContext = new Frame_boundContext(this._ctx, this.state); - this.enterRule(_localctx, 1244, PostgreSQLParser.RULE_frame_bound); + this.enterRule(_localctx, 1258, PostgreSQLParser.RULE_frame_bound); let _la: number; try { - this.state = 9731; + this.state = 9817; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 918, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 932, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9724; - this.match(PostgreSQLParser.UNBOUNDED); - this.state = 9725; + this.state = 9810; + this.match(PostgreSQLParser.KW_UNBOUNDED); + this.state = 9811; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FOLLOWING || _la === PostgreSQLParser.PRECEDING)) { + if (!(_la === PostgreSQLParser.KW_FOLLOWING || _la === PostgreSQLParser.KW_PRECEDING)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -52556,21 +52590,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9726; - this.match(PostgreSQLParser.CURRENT_P); - this.state = 9727; - this.match(PostgreSQLParser.ROW); + this.state = 9812; + this.match(PostgreSQLParser.KW_CURRENT); + this.state = 9813; + this.match(PostgreSQLParser.KW_ROW); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 9728; + this.state = 9814; this.a_expr(); - this.state = 9729; + this.state = 9815; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FOLLOWING || _la === PostgreSQLParser.PRECEDING)) { + if (!(_la === PostgreSQLParser.KW_FOLLOWING || _la === PostgreSQLParser.KW_PRECEDING)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -52601,41 +52635,41 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_window_exclusion_clause(): Opt_window_exclusion_clauseContext { let _localctx: Opt_window_exclusion_clauseContext = new Opt_window_exclusion_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1246, PostgreSQLParser.RULE_opt_window_exclusion_clause); + this.enterRule(_localctx, 1260, PostgreSQLParser.RULE_opt_window_exclusion_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9733; - this.match(PostgreSQLParser.EXCLUDE); - this.state = 9740; + this.state = 9819; + this.match(PostgreSQLParser.KW_EXCLUDE); + this.state = 9826; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.KW_CURRENT: { - this.state = 9734; - this.match(PostgreSQLParser.CURRENT_P); - this.state = 9735; - this.match(PostgreSQLParser.ROW); + this.state = 9820; + this.match(PostgreSQLParser.KW_CURRENT); + this.state = 9821; + this.match(PostgreSQLParser.KW_ROW); } break; - case PostgreSQLParser.GROUP_P: + case PostgreSQLParser.KW_GROUP: { - this.state = 9736; - this.match(PostgreSQLParser.GROUP_P); + this.state = 9822; + this.match(PostgreSQLParser.KW_GROUP); } break; - case PostgreSQLParser.TIES: + case PostgreSQLParser.KW_TIES: { - this.state = 9737; - this.match(PostgreSQLParser.TIES); + this.state = 9823; + this.match(PostgreSQLParser.KW_TIES); } break; - case PostgreSQLParser.NO: + case PostgreSQLParser.KW_NO: { - this.state = 9738; - this.match(PostgreSQLParser.NO); - this.state = 9739; - this.match(PostgreSQLParser.OTHERS); + this.state = 9824; + this.match(PostgreSQLParser.KW_NO); + this.state = 9825; + this.match(PostgreSQLParser.KW_OTHERS); } break; default: @@ -52660,45 +52694,45 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public row(): RowContext { let _localctx: RowContext = new RowContext(this._ctx, this.state); - this.enterRule(_localctx, 1248, PostgreSQLParser.RULE_row); + this.enterRule(_localctx, 1262, PostgreSQLParser.RULE_row); let _la: number; try { - this.state = 9754; + this.state = 9840; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.ROW: + case PostgreSQLParser.KW_ROW: this.enterOuterAlt(_localctx, 1); { - this.state = 9742; - this.match(PostgreSQLParser.ROW); - this.state = 9743; + this.state = 9828; + this.match(PostgreSQLParser.KW_ROW); + this.state = 9829; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9745; + this.state = 9831; 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)) { + 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.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CASE - 33)) | (1 << (PostgreSQLParser.KW_CAST - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_USER - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.KW_LOCALTIME - 75)) | (1 << (PostgreSQLParser.KW_LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.KW_NOT - 75)) | (1 << (PostgreSQLParser.KW_NULL - 75)) | (1 << (PostgreSQLParser.KW_SESSION_USER - 75)) | (1 << (PostgreSQLParser.KW_TABLE - 75)) | (1 << (PostgreSQLParser.KW_TRUE - 75)) | (1 << (PostgreSQLParser.KW_UNIQUE - 75)) | (1 << (PostgreSQLParser.KW_USER - 75)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.KW_BINARY - 107)) | (1 << (PostgreSQLParser.KW_COLLATION - 107)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.KW_CROSS - 107)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.KW_FREEZE - 107)) | (1 << (PostgreSQLParser.KW_FULL - 107)) | (1 << (PostgreSQLParser.KW_ILIKE - 107)) | (1 << (PostgreSQLParser.KW_INNER - 107)) | (1 << (PostgreSQLParser.KW_IS - 107)) | (1 << (PostgreSQLParser.KW_ISNULL - 107)) | (1 << (PostgreSQLParser.KW_JOIN - 107)) | (1 << (PostgreSQLParser.KW_LEFT - 107)) | (1 << (PostgreSQLParser.KW_LIKE - 107)) | (1 << (PostgreSQLParser.KW_NATURAL - 107)) | (1 << (PostgreSQLParser.KW_NOTNULL - 107)) | (1 << (PostgreSQLParser.KW_OUTER - 107)) | (1 << (PostgreSQLParser.KW_OVER - 107)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 107)) | (1 << (PostgreSQLParser.KW_RIGHT - 107)) | (1 << (PostgreSQLParser.KW_SIMILAR - 107)) | (1 << (PostgreSQLParser.KW_VERBOSE - 107)) | (1 << (PostgreSQLParser.KW_ABORT - 107)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 107)) | (1 << (PostgreSQLParser.KW_ACCESS - 107)) | (1 << (PostgreSQLParser.KW_ACTION - 107)) | (1 << (PostgreSQLParser.KW_ADD - 107)) | (1 << (PostgreSQLParser.KW_ADMIN - 107)) | (1 << (PostgreSQLParser.KW_AFTER - 107)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 107)) | (1 << (PostgreSQLParser.KW_ALSO - 107)) | (1 << (PostgreSQLParser.KW_ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.KW_ALWAYS - 139)) | (1 << (PostgreSQLParser.KW_ASSERTION - 139)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.KW_AT - 139)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.KW_BACKWARD - 139)) | (1 << (PostgreSQLParser.KW_BEFORE - 139)) | (1 << (PostgreSQLParser.KW_BEGIN - 139)) | (1 << (PostgreSQLParser.KW_BY - 139)) | (1 << (PostgreSQLParser.KW_CACHE - 139)) | (1 << (PostgreSQLParser.KW_CALLED - 139)) | (1 << (PostgreSQLParser.KW_CASCADE - 139)) | (1 << (PostgreSQLParser.KW_CASCADED - 139)) | (1 << (PostgreSQLParser.KW_CATALOG - 139)) | (1 << (PostgreSQLParser.KW_CHAIN - 139)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 139)) | (1 << (PostgreSQLParser.KW_CLASS - 139)) | (1 << (PostgreSQLParser.KW_CLOSE - 139)) | (1 << (PostgreSQLParser.KW_CLUSTER - 139)) | (1 << (PostgreSQLParser.KW_COMMENT - 139)) | (1 << (PostgreSQLParser.KW_COMMENTS - 139)) | (1 << (PostgreSQLParser.KW_COMMIT - 139)) | (1 << (PostgreSQLParser.KW_COMMITTED - 139)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 139)) | (1 << (PostgreSQLParser.KW_CONNECTION - 139)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.KW_CONTENT - 139)) | (1 << (PostgreSQLParser.KW_CONTINUE - 139)) | (1 << (PostgreSQLParser.KW_CONVERSION - 139)) | (1 << (PostgreSQLParser.KW_COPY - 139)) | (1 << (PostgreSQLParser.KW_COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.KW_CSV - 171)) | (1 << (PostgreSQLParser.KW_CURSOR - 171)) | (1 << (PostgreSQLParser.KW_CYCLE - 171)) | (1 << (PostgreSQLParser.KW_DATA - 171)) | (1 << (PostgreSQLParser.KW_DATABASE - 171)) | (1 << (PostgreSQLParser.KW_DAY - 171)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 171)) | (1 << (PostgreSQLParser.KW_DECLARE - 171)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 171)) | (1 << (PostgreSQLParser.KW_DEFERRED - 171)) | (1 << (PostgreSQLParser.KW_DEFINER - 171)) | (1 << (PostgreSQLParser.KW_DELETE - 171)) | (1 << (PostgreSQLParser.KW_DELIMITER - 171)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 171)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 171)) | (1 << (PostgreSQLParser.KW_DISABLE - 171)) | (1 << (PostgreSQLParser.KW_DISCARD - 171)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 171)) | (1 << (PostgreSQLParser.KW_DOMAIN - 171)) | (1 << (PostgreSQLParser.KW_DOUBLE - 171)) | (1 << (PostgreSQLParser.KW_DROP - 171)) | (1 << (PostgreSQLParser.KW_EACH - 171)) | (1 << (PostgreSQLParser.KW_ENABLE - 171)) | (1 << (PostgreSQLParser.KW_ENCODING - 171)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 171)) | (1 << (PostgreSQLParser.KW_ENUM - 171)) | (1 << (PostgreSQLParser.KW_ESCAPE - 171)) | (1 << (PostgreSQLParser.KW_EVENT - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 171)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.KW_EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.KW_EXPLAIN - 203)) | (1 << (PostgreSQLParser.KW_EXTENSION - 203)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 203)) | (1 << (PostgreSQLParser.KW_FAMILY - 203)) | (1 << (PostgreSQLParser.KW_FIRST - 203)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 203)) | (1 << (PostgreSQLParser.KW_FORCE - 203)) | (1 << (PostgreSQLParser.KW_FORWARD - 203)) | (1 << (PostgreSQLParser.KW_FUNCTION - 203)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 203)) | (1 << (PostgreSQLParser.KW_GLOBAL - 203)) | (1 << (PostgreSQLParser.KW_GRANTED - 203)) | (1 << (PostgreSQLParser.KW_HANDLER - 203)) | (1 << (PostgreSQLParser.KW_HEADER - 203)) | (1 << (PostgreSQLParser.KW_HOLD - 203)) | (1 << (PostgreSQLParser.KW_HOUR - 203)) | (1 << (PostgreSQLParser.KW_IDENTITY - 203)) | (1 << (PostgreSQLParser.KW_IF - 203)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 203)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 203)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 203)) | (1 << (PostgreSQLParser.KW_INCLUDING - 203)) | (1 << (PostgreSQLParser.KW_INCREMENT - 203)) | (1 << (PostgreSQLParser.KW_INDEX - 203)) | (1 << (PostgreSQLParser.KW_INDEXES - 203)) | (1 << (PostgreSQLParser.KW_INHERIT - 203)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.StringConstant - 526)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 526)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 526)) | (1 << (PostgreSQLParser.BinaryStringConstant - 526)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 526)) | (1 << (PostgreSQLParser.Integral - 526)) | (1 << (PostgreSQLParser.Numeric - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0) || _la === PostgreSQLParser.EscapeStringConstant) { { - this.state = 9744; + this.state = 9830; this.expr_list(); } } - this.state = 9747; + this.state = 9833; this.match(PostgreSQLParser.CLOSE_PAREN); } break; case PostgreSQLParser.OPEN_PAREN: this.enterOuterAlt(_localctx, 2); { - this.state = 9748; + this.state = 9834; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9749; + this.state = 9835; this.expr_list(); - this.state = 9750; + this.state = 9836; this.match(PostgreSQLParser.COMMA); - this.state = 9751; + this.state = 9837; this.a_expr(); - this.state = 9752; + this.state = 9838; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -52723,26 +52757,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public explicit_row(): Explicit_rowContext { let _localctx: Explicit_rowContext = new Explicit_rowContext(this._ctx, this.state); - this.enterRule(_localctx, 1250, PostgreSQLParser.RULE_explicit_row); + this.enterRule(_localctx, 1264, PostgreSQLParser.RULE_explicit_row); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9756; - this.match(PostgreSQLParser.ROW); - this.state = 9757; + this.state = 9842; + this.match(PostgreSQLParser.KW_ROW); + this.state = 9843; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9759; + this.state = 9845; 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)) { + 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.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CASE - 33)) | (1 << (PostgreSQLParser.KW_CAST - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_USER - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.KW_LOCALTIME - 75)) | (1 << (PostgreSQLParser.KW_LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.KW_NOT - 75)) | (1 << (PostgreSQLParser.KW_NULL - 75)) | (1 << (PostgreSQLParser.KW_SESSION_USER - 75)) | (1 << (PostgreSQLParser.KW_TABLE - 75)) | (1 << (PostgreSQLParser.KW_TRUE - 75)) | (1 << (PostgreSQLParser.KW_UNIQUE - 75)) | (1 << (PostgreSQLParser.KW_USER - 75)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.KW_BINARY - 107)) | (1 << (PostgreSQLParser.KW_COLLATION - 107)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.KW_CROSS - 107)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.KW_FREEZE - 107)) | (1 << (PostgreSQLParser.KW_FULL - 107)) | (1 << (PostgreSQLParser.KW_ILIKE - 107)) | (1 << (PostgreSQLParser.KW_INNER - 107)) | (1 << (PostgreSQLParser.KW_IS - 107)) | (1 << (PostgreSQLParser.KW_ISNULL - 107)) | (1 << (PostgreSQLParser.KW_JOIN - 107)) | (1 << (PostgreSQLParser.KW_LEFT - 107)) | (1 << (PostgreSQLParser.KW_LIKE - 107)) | (1 << (PostgreSQLParser.KW_NATURAL - 107)) | (1 << (PostgreSQLParser.KW_NOTNULL - 107)) | (1 << (PostgreSQLParser.KW_OUTER - 107)) | (1 << (PostgreSQLParser.KW_OVER - 107)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 107)) | (1 << (PostgreSQLParser.KW_RIGHT - 107)) | (1 << (PostgreSQLParser.KW_SIMILAR - 107)) | (1 << (PostgreSQLParser.KW_VERBOSE - 107)) | (1 << (PostgreSQLParser.KW_ABORT - 107)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 107)) | (1 << (PostgreSQLParser.KW_ACCESS - 107)) | (1 << (PostgreSQLParser.KW_ACTION - 107)) | (1 << (PostgreSQLParser.KW_ADD - 107)) | (1 << (PostgreSQLParser.KW_ADMIN - 107)) | (1 << (PostgreSQLParser.KW_AFTER - 107)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 107)) | (1 << (PostgreSQLParser.KW_ALSO - 107)) | (1 << (PostgreSQLParser.KW_ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.KW_ALWAYS - 139)) | (1 << (PostgreSQLParser.KW_ASSERTION - 139)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.KW_AT - 139)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.KW_BACKWARD - 139)) | (1 << (PostgreSQLParser.KW_BEFORE - 139)) | (1 << (PostgreSQLParser.KW_BEGIN - 139)) | (1 << (PostgreSQLParser.KW_BY - 139)) | (1 << (PostgreSQLParser.KW_CACHE - 139)) | (1 << (PostgreSQLParser.KW_CALLED - 139)) | (1 << (PostgreSQLParser.KW_CASCADE - 139)) | (1 << (PostgreSQLParser.KW_CASCADED - 139)) | (1 << (PostgreSQLParser.KW_CATALOG - 139)) | (1 << (PostgreSQLParser.KW_CHAIN - 139)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 139)) | (1 << (PostgreSQLParser.KW_CLASS - 139)) | (1 << (PostgreSQLParser.KW_CLOSE - 139)) | (1 << (PostgreSQLParser.KW_CLUSTER - 139)) | (1 << (PostgreSQLParser.KW_COMMENT - 139)) | (1 << (PostgreSQLParser.KW_COMMENTS - 139)) | (1 << (PostgreSQLParser.KW_COMMIT - 139)) | (1 << (PostgreSQLParser.KW_COMMITTED - 139)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 139)) | (1 << (PostgreSQLParser.KW_CONNECTION - 139)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.KW_CONTENT - 139)) | (1 << (PostgreSQLParser.KW_CONTINUE - 139)) | (1 << (PostgreSQLParser.KW_CONVERSION - 139)) | (1 << (PostgreSQLParser.KW_COPY - 139)) | (1 << (PostgreSQLParser.KW_COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.KW_CSV - 171)) | (1 << (PostgreSQLParser.KW_CURSOR - 171)) | (1 << (PostgreSQLParser.KW_CYCLE - 171)) | (1 << (PostgreSQLParser.KW_DATA - 171)) | (1 << (PostgreSQLParser.KW_DATABASE - 171)) | (1 << (PostgreSQLParser.KW_DAY - 171)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 171)) | (1 << (PostgreSQLParser.KW_DECLARE - 171)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 171)) | (1 << (PostgreSQLParser.KW_DEFERRED - 171)) | (1 << (PostgreSQLParser.KW_DEFINER - 171)) | (1 << (PostgreSQLParser.KW_DELETE - 171)) | (1 << (PostgreSQLParser.KW_DELIMITER - 171)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 171)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 171)) | (1 << (PostgreSQLParser.KW_DISABLE - 171)) | (1 << (PostgreSQLParser.KW_DISCARD - 171)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 171)) | (1 << (PostgreSQLParser.KW_DOMAIN - 171)) | (1 << (PostgreSQLParser.KW_DOUBLE - 171)) | (1 << (PostgreSQLParser.KW_DROP - 171)) | (1 << (PostgreSQLParser.KW_EACH - 171)) | (1 << (PostgreSQLParser.KW_ENABLE - 171)) | (1 << (PostgreSQLParser.KW_ENCODING - 171)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 171)) | (1 << (PostgreSQLParser.KW_ENUM - 171)) | (1 << (PostgreSQLParser.KW_ESCAPE - 171)) | (1 << (PostgreSQLParser.KW_EVENT - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 171)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.KW_EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.KW_EXPLAIN - 203)) | (1 << (PostgreSQLParser.KW_EXTENSION - 203)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 203)) | (1 << (PostgreSQLParser.KW_FAMILY - 203)) | (1 << (PostgreSQLParser.KW_FIRST - 203)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 203)) | (1 << (PostgreSQLParser.KW_FORCE - 203)) | (1 << (PostgreSQLParser.KW_FORWARD - 203)) | (1 << (PostgreSQLParser.KW_FUNCTION - 203)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 203)) | (1 << (PostgreSQLParser.KW_GLOBAL - 203)) | (1 << (PostgreSQLParser.KW_GRANTED - 203)) | (1 << (PostgreSQLParser.KW_HANDLER - 203)) | (1 << (PostgreSQLParser.KW_HEADER - 203)) | (1 << (PostgreSQLParser.KW_HOLD - 203)) | (1 << (PostgreSQLParser.KW_HOUR - 203)) | (1 << (PostgreSQLParser.KW_IDENTITY - 203)) | (1 << (PostgreSQLParser.KW_IF - 203)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 203)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 203)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 203)) | (1 << (PostgreSQLParser.KW_INCLUDING - 203)) | (1 << (PostgreSQLParser.KW_INCREMENT - 203)) | (1 << (PostgreSQLParser.KW_INDEX - 203)) | (1 << (PostgreSQLParser.KW_INDEXES - 203)) | (1 << (PostgreSQLParser.KW_INHERIT - 203)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.StringConstant - 526)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 526)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 526)) | (1 << (PostgreSQLParser.BinaryStringConstant - 526)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 526)) | (1 << (PostgreSQLParser.Integral - 526)) | (1 << (PostgreSQLParser.Numeric - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0) || _la === PostgreSQLParser.EscapeStringConstant) { { - this.state = 9758; + this.state = 9844; this.expr_list(); } } - this.state = 9761; + this.state = 9847; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -52763,19 +52797,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public implicit_row(): Implicit_rowContext { let _localctx: Implicit_rowContext = new Implicit_rowContext(this._ctx, this.state); - this.enterRule(_localctx, 1252, PostgreSQLParser.RULE_implicit_row); + this.enterRule(_localctx, 1266, PostgreSQLParser.RULE_implicit_row); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9763; + this.state = 9849; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9764; + this.state = 9850; this.expr_list(); - this.state = 9765; + this.state = 9851; this.match(PostgreSQLParser.COMMA); - this.state = 9766; + this.state = 9852; this.a_expr(); - this.state = 9767; + this.state = 9853; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -52796,14 +52830,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public sub_type(): Sub_typeContext { let _localctx: Sub_typeContext = new Sub_typeContext(this._ctx, this.state); - this.enterRule(_localctx, 1254, PostgreSQLParser.RULE_sub_type); + this.enterRule(_localctx, 1268, PostgreSQLParser.RULE_sub_type); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9769; + this.state = 9855; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.ALL || _la === PostgreSQLParser.ANY || _la === PostgreSQLParser.SOME)) { + if (!(_la === PostgreSQLParser.KW_ALL || _la === PostgreSQLParser.KW_ANY || _la === PostgreSQLParser.KW_SOME)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -52832,15 +52866,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public all_op(): All_opContext { let _localctx: All_opContext = new All_opContext(this._ctx, this.state); - this.enterRule(_localctx, 1256, PostgreSQLParser.RULE_all_op); + this.enterRule(_localctx, 1270, PostgreSQLParser.RULE_all_op); try { - this.state = 9773; + this.state = 9859; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.Operator: this.enterOuterAlt(_localctx, 1); { - this.state = 9771; + this.state = 9857; this.match(PostgreSQLParser.Operator); } break; @@ -52858,7 +52892,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PERCENT: this.enterOuterAlt(_localctx, 2); { - this.state = 9772; + this.state = 9858; this.mathop(); } break; @@ -52883,12 +52917,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public mathop(): MathopContext { let _localctx: MathopContext = new MathopContext(this._ctx, this.state); - this.enterRule(_localctx, 1258, PostgreSQLParser.RULE_mathop); + this.enterRule(_localctx, 1272, PostgreSQLParser.RULE_mathop); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9775; + this.state = 9861; _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); @@ -52919,28 +52953,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public qual_op(): Qual_opContext { let _localctx: Qual_opContext = new Qual_opContext(this._ctx, this.state); - this.enterRule(_localctx, 1260, PostgreSQLParser.RULE_qual_op); + this.enterRule(_localctx, 1274, PostgreSQLParser.RULE_qual_op); try { - this.state = 9783; + this.state = 9869; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.Operator: this.enterOuterAlt(_localctx, 1); { - this.state = 9777; + this.state = 9863; this.match(PostgreSQLParser.Operator); } break; - case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.KW_OPERATOR: this.enterOuterAlt(_localctx, 2); { - this.state = 9778; - this.match(PostgreSQLParser.OPERATOR); - this.state = 9779; + this.state = 9864; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 9865; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9780; + this.state = 9866; this.any_operator(); - this.state = 9781; + this.state = 9867; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -52965,9 +52999,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public qual_all_op(): Qual_all_opContext { let _localctx: Qual_all_opContext = new Qual_all_opContext(this._ctx, this.state); - this.enterRule(_localctx, 1262, PostgreSQLParser.RULE_qual_all_op); + this.enterRule(_localctx, 1276, PostgreSQLParser.RULE_qual_all_op); try { - this.state = 9791; + this.state = 9877; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.STAR: @@ -52985,20 +53019,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.Operator: this.enterOuterAlt(_localctx, 1); { - this.state = 9785; + this.state = 9871; this.all_op(); } break; - case PostgreSQLParser.OPERATOR: + case PostgreSQLParser.KW_OPERATOR: this.enterOuterAlt(_localctx, 2); { - this.state = 9786; - this.match(PostgreSQLParser.OPERATOR); - this.state = 9787; + this.state = 9872; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 9873; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9788; + this.state = 9874; this.any_operator(); - this.state = 9789; + this.state = 9875; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -53023,15 +53057,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public subquery_Op(): Subquery_OpContext { let _localctx: Subquery_OpContext = new Subquery_OpContext(this._ctx, this.state); - this.enterRule(_localctx, 1264, PostgreSQLParser.RULE_subquery_Op); + this.enterRule(_localctx, 1278, PostgreSQLParser.RULE_subquery_Op); try { - this.state = 9805; + this.state = 9891; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 926, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 940, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9793; + this.state = 9879; this.all_op(); } break; @@ -53039,13 +53073,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9794; - this.match(PostgreSQLParser.OPERATOR); - this.state = 9795; + this.state = 9880; + this.match(PostgreSQLParser.KW_OPERATOR); + this.state = 9881; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9796; + this.state = 9882; this.any_operator(); - this.state = 9797; + this.state = 9883; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -53053,36 +53087,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 9799; - this.match(PostgreSQLParser.LIKE); + this.state = 9885; + this.match(PostgreSQLParser.KW_LIKE); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 9800; - this.match(PostgreSQLParser.NOT); - this.state = 9801; - this.match(PostgreSQLParser.LIKE); + this.state = 9886; + this.match(PostgreSQLParser.KW_NOT); + this.state = 9887; + this.match(PostgreSQLParser.KW_LIKE); } break; case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 9802; - this.match(PostgreSQLParser.ILIKE); + this.state = 9888; + this.match(PostgreSQLParser.KW_ILIKE); } break; case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 9803; - this.match(PostgreSQLParser.NOT); - this.state = 9804; - this.match(PostgreSQLParser.ILIKE); + this.state = 9889; + this.match(PostgreSQLParser.KW_NOT); + this.state = 9890; + this.match(PostgreSQLParser.KW_ILIKE); } break; } @@ -53104,30 +53138,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public expr_list(): Expr_listContext { let _localctx: Expr_listContext = new Expr_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1266, PostgreSQLParser.RULE_expr_list); + this.enterRule(_localctx, 1280, PostgreSQLParser.RULE_expr_list); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9807; + this.state = 9893; this.a_expr(); - this.state = 9812; + this.state = 9898; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 927, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 941, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9808; + this.state = 9894; this.match(PostgreSQLParser.COMMA); - this.state = 9809; + this.state = 9895; this.a_expr(); } } } - this.state = 9814; + this.state = 9900; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 927, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 941, this._ctx); } } } @@ -53148,30 +53182,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_arg_list(): Func_arg_listContext { let _localctx: Func_arg_listContext = new Func_arg_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1268, PostgreSQLParser.RULE_func_arg_list); + this.enterRule(_localctx, 1282, PostgreSQLParser.RULE_func_arg_list); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9815; + this.state = 9901; this.func_arg_expr(); - this.state = 9820; + this.state = 9906; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 928, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 942, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9816; + this.state = 9902; this.match(PostgreSQLParser.COMMA); - this.state = 9817; + this.state = 9903; this.func_arg_expr(); } } } - this.state = 9822; + this.state = 9908; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 928, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 942, this._ctx); } } } @@ -53192,16 +53226,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_arg_expr(): Func_arg_exprContext { let _localctx: Func_arg_exprContext = new Func_arg_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 1270, PostgreSQLParser.RULE_func_arg_expr); + this.enterRule(_localctx, 1284, PostgreSQLParser.RULE_func_arg_expr); let _la: number; try { - this.state = 9828; + this.state = 9914; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 929, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 943, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9823; + this.state = 9909; this.a_expr(); } break; @@ -53209,9 +53243,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9824; + this.state = 9910; this.param_name(); - this.state = 9825; + this.state = 9911; _la = this._input.LA(1); if (!(_la === PostgreSQLParser.COLON_EQUALS || _la === PostgreSQLParser.EQUALS_GREATER)) { this._errHandler.recoverInline(this); @@ -53223,7 +53257,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 9826; + this.state = 9912; this.a_expr(); } break; @@ -53246,26 +53280,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public type_list(): Type_listContext { let _localctx: Type_listContext = new Type_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1272, PostgreSQLParser.RULE_type_list); + this.enterRule(_localctx, 1286, PostgreSQLParser.RULE_type_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9830; + this.state = 9916; this.typename(); - this.state = 9835; + this.state = 9921; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 9831; + this.state = 9917; this.match(PostgreSQLParser.COMMA); - this.state = 9832; + this.state = 9918; this.typename(); } } - this.state = 9837; + this.state = 9923; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -53288,13 +53322,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public array_expr(): Array_exprContext { let _localctx: Array_exprContext = new Array_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 1274, PostgreSQLParser.RULE_array_expr); + this.enterRule(_localctx, 1288, PostgreSQLParser.RULE_array_expr); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9838; + this.state = 9924; this.match(PostgreSQLParser.OPEN_BRACKET); - this.state = 9841; + this.state = 9927; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: @@ -53302,434 +53336,434 @@ export class PostgreSQLParser extends PostgreSQLParserBase { 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_CASE: + case PostgreSQLParser.KW_CAST: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_LOCALTIME: + case PostgreSQLParser.KW_LOCALTIMESTAMP: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_NULL: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -53744,13 +53778,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: case PostgreSQLParser.EscapeStringConstant: { - this.state = 9839; + this.state = 9925; this.expr_list(); } break; case PostgreSQLParser.OPEN_BRACKET: { - this.state = 9840; + this.state = 9926; this.array_expr_list(); } break; @@ -53759,7 +53793,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: break; } - this.state = 9843; + this.state = 9929; this.match(PostgreSQLParser.CLOSE_BRACKET); } } @@ -53780,26 +53814,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public array_expr_list(): Array_expr_listContext { let _localctx: Array_expr_listContext = new Array_expr_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1276, PostgreSQLParser.RULE_array_expr_list); + this.enterRule(_localctx, 1290, PostgreSQLParser.RULE_array_expr_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9845; + this.state = 9931; this.array_expr(); - this.state = 9850; + this.state = 9936; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 9846; + this.state = 9932; this.match(PostgreSQLParser.COMMA); - this.state = 9847; + this.state = 9933; this.array_expr(); } } - this.state = 9852; + this.state = 9938; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -53822,15 +53856,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public extract_list(): Extract_listContext { let _localctx: Extract_listContext = new Extract_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1278, PostgreSQLParser.RULE_extract_list); + this.enterRule(_localctx, 1292, PostgreSQLParser.RULE_extract_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9853; + this.state = 9939; this.extract_arg(); - this.state = 9854; - this.match(PostgreSQLParser.FROM); - this.state = 9855; + this.state = 9940; + this.match(PostgreSQLParser.KW_FROM); + this.state = 9941; this.a_expr(); } } @@ -53851,76 +53885,76 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public extract_arg(): Extract_argContext { let _localctx: Extract_argContext = new Extract_argContext(this._ctx, this.state); - this.enterRule(_localctx, 1280, PostgreSQLParser.RULE_extract_arg); + this.enterRule(_localctx, 1294, PostgreSQLParser.RULE_extract_arg); try { - this.state = 9865; + this.state = 9951; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -53928,50 +53962,50 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 9857; + this.state = 9943; this.identifier(); } break; - case PostgreSQLParser.YEAR_P: + case PostgreSQLParser.KW_YEAR: this.enterOuterAlt(_localctx, 2); { - this.state = 9858; - this.match(PostgreSQLParser.YEAR_P); + this.state = 9944; + this.match(PostgreSQLParser.KW_YEAR); } break; - case PostgreSQLParser.MONTH_P: + case PostgreSQLParser.KW_MONTH: this.enterOuterAlt(_localctx, 3); { - this.state = 9859; - this.match(PostgreSQLParser.MONTH_P); + this.state = 9945; + this.match(PostgreSQLParser.KW_MONTH); } break; - case PostgreSQLParser.DAY_P: + case PostgreSQLParser.KW_DAY: this.enterOuterAlt(_localctx, 4); { - this.state = 9860; - this.match(PostgreSQLParser.DAY_P); + this.state = 9946; + this.match(PostgreSQLParser.KW_DAY); } break; - case PostgreSQLParser.HOUR_P: + case PostgreSQLParser.KW_HOUR: this.enterOuterAlt(_localctx, 5); { - this.state = 9861; - this.match(PostgreSQLParser.HOUR_P); + this.state = 9947; + this.match(PostgreSQLParser.KW_HOUR); } break; - case PostgreSQLParser.MINUTE_P: + case PostgreSQLParser.KW_MINUTE: this.enterOuterAlt(_localctx, 6); { - this.state = 9862; - this.match(PostgreSQLParser.MINUTE_P); + this.state = 9948; + this.match(PostgreSQLParser.KW_MINUTE); } break; - case PostgreSQLParser.SECOND_P: + case PostgreSQLParser.KW_SECOND: this.enterOuterAlt(_localctx, 7); { - this.state = 9863; - this.match(PostgreSQLParser.SECOND_P); + this.state = 9949; + this.match(PostgreSQLParser.KW_SECOND); } break; case PostgreSQLParser.StringConstant: @@ -53980,7 +54014,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 8); { - this.state = 9864; + this.state = 9950; this.sconst(); } break; @@ -54005,14 +54039,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public unicode_normal_form(): Unicode_normal_formContext { let _localctx: Unicode_normal_formContext = new Unicode_normal_formContext(this._ctx, this.state); - this.enterRule(_localctx, 1282, PostgreSQLParser.RULE_unicode_normal_form); + this.enterRule(_localctx, 1296, PostgreSQLParser.RULE_unicode_normal_form); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9867; + this.state = 9953; _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))) { + if (!(((((_la - 483)) & ~0x1F) === 0 && ((1 << (_la - 483)) & ((1 << (PostgreSQLParser.KW_NFC - 483)) | (1 << (PostgreSQLParser.KW_NFD - 483)) | (1 << (PostgreSQLParser.KW_NFKC - 483)) | (1 << (PostgreSQLParser.KW_NFKD - 483)))) !== 0))) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -54041,29 +54075,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public overlay_list(): Overlay_listContext { let _localctx: Overlay_listContext = new Overlay_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1284, PostgreSQLParser.RULE_overlay_list); + this.enterRule(_localctx, 1298, PostgreSQLParser.RULE_overlay_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9869; + this.state = 9955; this.a_expr(); - this.state = 9870; - this.match(PostgreSQLParser.PLACING); - this.state = 9871; + this.state = 9956; + this.match(PostgreSQLParser.KW_PLACING); + this.state = 9957; this.a_expr(); - this.state = 9872; - this.match(PostgreSQLParser.FROM); - this.state = 9873; + this.state = 9958; + this.match(PostgreSQLParser.KW_FROM); + this.state = 9959; this.a_expr(); - this.state = 9876; + this.state = 9962; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FOR) { + if (_la === PostgreSQLParser.KW_FOR) { { - this.state = 9874; - this.match(PostgreSQLParser.FOR); - this.state = 9875; + this.state = 9960; + this.match(PostgreSQLParser.KW_FOR); + this.state = 9961; this.a_expr(); } } @@ -54087,15 +54121,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public position_list(): Position_listContext { let _localctx: Position_listContext = new Position_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1286, PostgreSQLParser.RULE_position_list); + this.enterRule(_localctx, 1300, PostgreSQLParser.RULE_position_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9878; + this.state = 9964; this.b_expr(0); - this.state = 9879; - this.match(PostgreSQLParser.IN_P); - this.state = 9880; + this.state = 9965; + this.match(PostgreSQLParser.KW_IN); + this.state = 9966; this.b_expr(0); } } @@ -54116,23 +54150,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public substr_list(): Substr_listContext { let _localctx: Substr_listContext = new Substr_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1288, PostgreSQLParser.RULE_substr_list); + this.enterRule(_localctx, 1302, PostgreSQLParser.RULE_substr_list); try { - this.state = 9909; + this.state = 9995; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 935, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 949, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9882; + this.state = 9968; this.a_expr(); - this.state = 9883; - this.match(PostgreSQLParser.FROM); - this.state = 9884; + this.state = 9969; + this.match(PostgreSQLParser.KW_FROM); + this.state = 9970; this.a_expr(); - this.state = 9885; - this.match(PostgreSQLParser.FOR); - this.state = 9886; + this.state = 9971; + this.match(PostgreSQLParser.KW_FOR); + this.state = 9972; this.a_expr(); } break; @@ -54140,15 +54174,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9888; + this.state = 9974; this.a_expr(); - this.state = 9889; - this.match(PostgreSQLParser.FOR); - this.state = 9890; + this.state = 9975; + this.match(PostgreSQLParser.KW_FOR); + this.state = 9976; this.a_expr(); - this.state = 9891; - this.match(PostgreSQLParser.FROM); - this.state = 9892; + this.state = 9977; + this.match(PostgreSQLParser.KW_FROM); + this.state = 9978; this.a_expr(); } break; @@ -54156,11 +54190,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 9894; + this.state = 9980; this.a_expr(); - this.state = 9895; - this.match(PostgreSQLParser.FROM); - this.state = 9896; + this.state = 9981; + this.match(PostgreSQLParser.KW_FROM); + this.state = 9982; this.a_expr(); } break; @@ -54168,11 +54202,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 9898; + this.state = 9984; this.a_expr(); - this.state = 9899; - this.match(PostgreSQLParser.FOR); - this.state = 9900; + this.state = 9985; + this.match(PostgreSQLParser.KW_FOR); + this.state = 9986; this.a_expr(); } break; @@ -54180,15 +54214,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 9902; + this.state = 9988; this.a_expr(); - this.state = 9903; - this.match(PostgreSQLParser.SIMILAR); - this.state = 9904; + this.state = 9989; + this.match(PostgreSQLParser.KW_SIMILAR); + this.state = 9990; this.a_expr(); - this.state = 9905; - this.match(PostgreSQLParser.ESCAPE); - this.state = 9906; + this.state = 9991; + this.match(PostgreSQLParser.KW_ESCAPE); + this.state = 9992; this.a_expr(); } break; @@ -54196,7 +54230,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 9908; + this.state = 9994; this.expr_list(); } break; @@ -54219,19 +54253,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public trim_list(): Trim_listContext { let _localctx: Trim_listContext = new Trim_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1290, PostgreSQLParser.RULE_trim_list); + this.enterRule(_localctx, 1304, PostgreSQLParser.RULE_trim_list); try { - this.state = 9918; + this.state = 10004; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 936, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 950, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 9911; + this.state = 9997; this.a_expr(); - this.state = 9912; - this.match(PostgreSQLParser.FROM); - this.state = 9913; + this.state = 9998; + this.match(PostgreSQLParser.KW_FROM); + this.state = 9999; this.expr_list(); } break; @@ -54239,9 +54273,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 9915; - this.match(PostgreSQLParser.FROM); - this.state = 9916; + this.state = 10001; + this.match(PostgreSQLParser.KW_FROM); + this.state = 10002; this.expr_list(); } break; @@ -54249,7 +54283,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 9917; + this.state = 10003; this.expr_list(); } break; @@ -54272,16 +54306,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public in_expr(): In_exprContext { let _localctx: In_exprContext = new In_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 1292, PostgreSQLParser.RULE_in_expr); + this.enterRule(_localctx, 1306, PostgreSQLParser.RULE_in_expr); try { - this.state = 9925; + this.state = 10011; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 937, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 951, this._ctx) ) { case 1: _localctx = new In_expr_selectContext(_localctx); this.enterOuterAlt(_localctx, 1); { - this.state = 9920; + this.state = 10006; this.select_with_parens(); } break; @@ -54290,11 +54324,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new In_expr_listContext(_localctx); this.enterOuterAlt(_localctx, 2); { - this.state = 9921; + this.state = 10007; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 9922; + this.state = 10008; this.expr_list(); - this.state = 9923; + this.state = 10009; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -54317,37 +54351,37 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public case_expr(): Case_exprContext { let _localctx: Case_exprContext = new Case_exprContext(this._ctx, this.state); - this.enterRule(_localctx, 1294, PostgreSQLParser.RULE_case_expr); + this.enterRule(_localctx, 1308, PostgreSQLParser.RULE_case_expr); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9927; - this.match(PostgreSQLParser.CASE); - this.state = 9929; + this.state = 10013; + this.match(PostgreSQLParser.KW_CASE); + this.state = 10015; 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)) { + 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.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CASE - 33)) | (1 << (PostgreSQLParser.KW_CAST - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_USER - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.KW_LOCALTIME - 75)) | (1 << (PostgreSQLParser.KW_LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.KW_NOT - 75)) | (1 << (PostgreSQLParser.KW_NULL - 75)) | (1 << (PostgreSQLParser.KW_SESSION_USER - 75)) | (1 << (PostgreSQLParser.KW_TABLE - 75)) | (1 << (PostgreSQLParser.KW_TRUE - 75)) | (1 << (PostgreSQLParser.KW_UNIQUE - 75)) | (1 << (PostgreSQLParser.KW_USER - 75)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.KW_BINARY - 107)) | (1 << (PostgreSQLParser.KW_COLLATION - 107)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.KW_CROSS - 107)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.KW_FREEZE - 107)) | (1 << (PostgreSQLParser.KW_FULL - 107)) | (1 << (PostgreSQLParser.KW_ILIKE - 107)) | (1 << (PostgreSQLParser.KW_INNER - 107)) | (1 << (PostgreSQLParser.KW_IS - 107)) | (1 << (PostgreSQLParser.KW_ISNULL - 107)) | (1 << (PostgreSQLParser.KW_JOIN - 107)) | (1 << (PostgreSQLParser.KW_LEFT - 107)) | (1 << (PostgreSQLParser.KW_LIKE - 107)) | (1 << (PostgreSQLParser.KW_NATURAL - 107)) | (1 << (PostgreSQLParser.KW_NOTNULL - 107)) | (1 << (PostgreSQLParser.KW_OUTER - 107)) | (1 << (PostgreSQLParser.KW_OVER - 107)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 107)) | (1 << (PostgreSQLParser.KW_RIGHT - 107)) | (1 << (PostgreSQLParser.KW_SIMILAR - 107)) | (1 << (PostgreSQLParser.KW_VERBOSE - 107)) | (1 << (PostgreSQLParser.KW_ABORT - 107)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 107)) | (1 << (PostgreSQLParser.KW_ACCESS - 107)) | (1 << (PostgreSQLParser.KW_ACTION - 107)) | (1 << (PostgreSQLParser.KW_ADD - 107)) | (1 << (PostgreSQLParser.KW_ADMIN - 107)) | (1 << (PostgreSQLParser.KW_AFTER - 107)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 107)) | (1 << (PostgreSQLParser.KW_ALSO - 107)) | (1 << (PostgreSQLParser.KW_ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.KW_ALWAYS - 139)) | (1 << (PostgreSQLParser.KW_ASSERTION - 139)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.KW_AT - 139)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.KW_BACKWARD - 139)) | (1 << (PostgreSQLParser.KW_BEFORE - 139)) | (1 << (PostgreSQLParser.KW_BEGIN - 139)) | (1 << (PostgreSQLParser.KW_BY - 139)) | (1 << (PostgreSQLParser.KW_CACHE - 139)) | (1 << (PostgreSQLParser.KW_CALLED - 139)) | (1 << (PostgreSQLParser.KW_CASCADE - 139)) | (1 << (PostgreSQLParser.KW_CASCADED - 139)) | (1 << (PostgreSQLParser.KW_CATALOG - 139)) | (1 << (PostgreSQLParser.KW_CHAIN - 139)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 139)) | (1 << (PostgreSQLParser.KW_CLASS - 139)) | (1 << (PostgreSQLParser.KW_CLOSE - 139)) | (1 << (PostgreSQLParser.KW_CLUSTER - 139)) | (1 << (PostgreSQLParser.KW_COMMENT - 139)) | (1 << (PostgreSQLParser.KW_COMMENTS - 139)) | (1 << (PostgreSQLParser.KW_COMMIT - 139)) | (1 << (PostgreSQLParser.KW_COMMITTED - 139)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 139)) | (1 << (PostgreSQLParser.KW_CONNECTION - 139)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.KW_CONTENT - 139)) | (1 << (PostgreSQLParser.KW_CONTINUE - 139)) | (1 << (PostgreSQLParser.KW_CONVERSION - 139)) | (1 << (PostgreSQLParser.KW_COPY - 139)) | (1 << (PostgreSQLParser.KW_COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.KW_CSV - 171)) | (1 << (PostgreSQLParser.KW_CURSOR - 171)) | (1 << (PostgreSQLParser.KW_CYCLE - 171)) | (1 << (PostgreSQLParser.KW_DATA - 171)) | (1 << (PostgreSQLParser.KW_DATABASE - 171)) | (1 << (PostgreSQLParser.KW_DAY - 171)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 171)) | (1 << (PostgreSQLParser.KW_DECLARE - 171)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 171)) | (1 << (PostgreSQLParser.KW_DEFERRED - 171)) | (1 << (PostgreSQLParser.KW_DEFINER - 171)) | (1 << (PostgreSQLParser.KW_DELETE - 171)) | (1 << (PostgreSQLParser.KW_DELIMITER - 171)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 171)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 171)) | (1 << (PostgreSQLParser.KW_DISABLE - 171)) | (1 << (PostgreSQLParser.KW_DISCARD - 171)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 171)) | (1 << (PostgreSQLParser.KW_DOMAIN - 171)) | (1 << (PostgreSQLParser.KW_DOUBLE - 171)) | (1 << (PostgreSQLParser.KW_DROP - 171)) | (1 << (PostgreSQLParser.KW_EACH - 171)) | (1 << (PostgreSQLParser.KW_ENABLE - 171)) | (1 << (PostgreSQLParser.KW_ENCODING - 171)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 171)) | (1 << (PostgreSQLParser.KW_ENUM - 171)) | (1 << (PostgreSQLParser.KW_ESCAPE - 171)) | (1 << (PostgreSQLParser.KW_EVENT - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 171)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.KW_EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.KW_EXPLAIN - 203)) | (1 << (PostgreSQLParser.KW_EXTENSION - 203)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 203)) | (1 << (PostgreSQLParser.KW_FAMILY - 203)) | (1 << (PostgreSQLParser.KW_FIRST - 203)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 203)) | (1 << (PostgreSQLParser.KW_FORCE - 203)) | (1 << (PostgreSQLParser.KW_FORWARD - 203)) | (1 << (PostgreSQLParser.KW_FUNCTION - 203)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 203)) | (1 << (PostgreSQLParser.KW_GLOBAL - 203)) | (1 << (PostgreSQLParser.KW_GRANTED - 203)) | (1 << (PostgreSQLParser.KW_HANDLER - 203)) | (1 << (PostgreSQLParser.KW_HEADER - 203)) | (1 << (PostgreSQLParser.KW_HOLD - 203)) | (1 << (PostgreSQLParser.KW_HOUR - 203)) | (1 << (PostgreSQLParser.KW_IDENTITY - 203)) | (1 << (PostgreSQLParser.KW_IF - 203)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 203)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 203)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 203)) | (1 << (PostgreSQLParser.KW_INCLUDING - 203)) | (1 << (PostgreSQLParser.KW_INCREMENT - 203)) | (1 << (PostgreSQLParser.KW_INDEX - 203)) | (1 << (PostgreSQLParser.KW_INDEXES - 203)) | (1 << (PostgreSQLParser.KW_INHERIT - 203)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.StringConstant - 526)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 526)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 526)) | (1 << (PostgreSQLParser.BinaryStringConstant - 526)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 526)) | (1 << (PostgreSQLParser.Integral - 526)) | (1 << (PostgreSQLParser.Numeric - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0) || _la === PostgreSQLParser.EscapeStringConstant) { { - this.state = 9928; + this.state = 10014; this.case_arg(); } } - this.state = 9931; + this.state = 10017; this.when_clause_list(); - this.state = 9933; + this.state = 10019; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ELSE) { + if (_la === PostgreSQLParser.KW_ELSE) { { - this.state = 9932; + this.state = 10018; this.case_default(); } } - this.state = 9935; - this.match(PostgreSQLParser.END_P); + this.state = 10021; + this.match(PostgreSQLParser.KW_END); } } catch (re) { @@ -54367,25 +54401,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public when_clause_list(): When_clause_listContext { let _localctx: When_clause_listContext = new When_clause_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1296, PostgreSQLParser.RULE_when_clause_list); + this.enterRule(_localctx, 1310, PostgreSQLParser.RULE_when_clause_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 9938; + this.state = 10024; this._errHandler.sync(this); _la = this._input.LA(1); do { { { - this.state = 9937; + this.state = 10023; this.when_clause(); } } - this.state = 9940; + this.state = 10026; this._errHandler.sync(this); _la = this._input.LA(1); - } while (_la === PostgreSQLParser.WHEN); + } while (_la === PostgreSQLParser.KW_WHEN); } } catch (re) { @@ -54405,17 +54439,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public when_clause(): When_clauseContext { let _localctx: When_clauseContext = new When_clauseContext(this._ctx, this.state); - this.enterRule(_localctx, 1298, PostgreSQLParser.RULE_when_clause); + this.enterRule(_localctx, 1312, PostgreSQLParser.RULE_when_clause); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9942; - this.match(PostgreSQLParser.WHEN); - this.state = 9943; + this.state = 10028; + this.match(PostgreSQLParser.KW_WHEN); + this.state = 10029; this.a_expr(); - this.state = 9944; - this.match(PostgreSQLParser.THEN); - this.state = 9945; + this.state = 10030; + this.match(PostgreSQLParser.KW_THEN); + this.state = 10031; this.a_expr(); } } @@ -54436,13 +54470,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public case_default(): Case_defaultContext { let _localctx: Case_defaultContext = new Case_defaultContext(this._ctx, this.state); - this.enterRule(_localctx, 1300, PostgreSQLParser.RULE_case_default); + this.enterRule(_localctx, 1314, PostgreSQLParser.RULE_case_default); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9947; - this.match(PostgreSQLParser.ELSE); - this.state = 9948; + this.state = 10033; + this.match(PostgreSQLParser.KW_ELSE); + this.state = 10034; this.a_expr(); } } @@ -54463,11 +54497,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public case_arg(): Case_argContext { let _localctx: Case_argContext = new Case_argContext(this._ctx, this.state); - this.enterRule(_localctx, 1302, PostgreSQLParser.RULE_case_arg); + this.enterRule(_localctx, 1316, PostgreSQLParser.RULE_case_arg); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9950; + this.state = 10036; this.a_expr(); } } @@ -54488,18 +54522,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public columnref(): ColumnrefContext { let _localctx: ColumnrefContext = new ColumnrefContext(this._ctx, this.state); - this.enterRule(_localctx, 1304, PostgreSQLParser.RULE_columnref); + this.enterRule(_localctx, 1318, PostgreSQLParser.RULE_columnref); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9952; + this.state = 10038; this.colid(); - this.state = 9954; + this.state = 10040; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 941, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 955, this._ctx) ) { case 1: { - this.state = 9953; + this.state = 10039; this.indirection(); } break; @@ -54523,511 +54557,511 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public indirection_el(): Indirection_elContext { let _localctx: Indirection_elContext = new Indirection_elContext(this._ctx, this.state); - this.enterRule(_localctx, 1306, PostgreSQLParser.RULE_indirection_el); + this.enterRule(_localctx, 1320, PostgreSQLParser.RULE_indirection_el); let _la: number; try { - this.state = 9973; + this.state = 10059; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.DOT: this.enterOuterAlt(_localctx, 1); { - this.state = 9956; + this.state = 10042; this.match(PostgreSQLParser.DOT); - this.state = 9959; + this.state = 10045; 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.KW_ALL: + case PostgreSQLParser.KW_ANALYSE: + case PostgreSQLParser.KW_ANALYZE: + case PostgreSQLParser.KW_AND: + case PostgreSQLParser.KW_ANY: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_AS: + case PostgreSQLParser.KW_ASC: + case PostgreSQLParser.KW_ASYMMETRIC: + case PostgreSQLParser.KW_BOTH: + case PostgreSQLParser.KW_CASE: + case PostgreSQLParser.KW_CAST: + case PostgreSQLParser.KW_CHECK: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CREATE: + case PostgreSQLParser.KW_CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DEFERRABLE: + case PostgreSQLParser.KW_DESC: + case PostgreSQLParser.KW_DISTINCT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_ELSE: + case PostgreSQLParser.KW_EXCEPT: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_FOR: + case PostgreSQLParser.KW_FOREIGN: + case PostgreSQLParser.KW_FROM: + case PostgreSQLParser.KW_GRANT: + case PostgreSQLParser.KW_GROUP: + case PostgreSQLParser.KW_HAVING: + case PostgreSQLParser.KW_IN: + case PostgreSQLParser.KW_INITIALLY: + case PostgreSQLParser.KW_INTERSECT: + case PostgreSQLParser.KW_LATERAL: + case PostgreSQLParser.KW_LEADING: + case PostgreSQLParser.KW_LIMIT: + case PostgreSQLParser.KW_LOCALTIME: + case PostgreSQLParser.KW_LOCALTIMESTAMP: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_NULL: + case PostgreSQLParser.KW_OFFSET: + case PostgreSQLParser.KW_ON: + case PostgreSQLParser.KW_ONLY: + case PostgreSQLParser.KW_OR: + case PostgreSQLParser.KW_ORDER: + case PostgreSQLParser.KW_PLACING: + case PostgreSQLParser.KW_PRIMARY: + case PostgreSQLParser.KW_REFERENCES: + case PostgreSQLParser.KW_RETURNING: + case PostgreSQLParser.KW_SELECT: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_SOME: + case PostgreSQLParser.KW_SYMMETRIC: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_THEN: + case PostgreSQLParser.KW_TO: + case PostgreSQLParser.KW_TRAILING: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_UNION: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_USING: + case PostgreSQLParser.KW_VARIADIC: + case PostgreSQLParser.KW_WHEN: + case PostgreSQLParser.KW_WHERE: + case PostgreSQLParser.KW_WINDOW: + case PostgreSQLParser.KW_WITH: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_END: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: case PostgreSQLParser.PLSQLVARIABLENAME: case PostgreSQLParser.PLSQLIDENTIFIER: { - this.state = 9957; + this.state = 10043; this.attr_name(); } break; case PostgreSQLParser.STAR: { - this.state = 9958; + this.state = 10044; this.match(PostgreSQLParser.STAR); } break; @@ -55039,38 +55073,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.OPEN_BRACKET: this.enterOuterAlt(_localctx, 2); { - this.state = 9961; + this.state = 10047; this.match(PostgreSQLParser.OPEN_BRACKET); - this.state = 9970; + this.state = 10056; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 945, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 959, this._ctx) ) { case 1: { - this.state = 9962; + this.state = 10048; this.a_expr(); } break; case 2: { - this.state = 9964; + this.state = 10050; 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)) { + 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.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CASE - 33)) | (1 << (PostgreSQLParser.KW_CAST - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_USER - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.KW_LOCALTIME - 75)) | (1 << (PostgreSQLParser.KW_LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.KW_NOT - 75)) | (1 << (PostgreSQLParser.KW_NULL - 75)) | (1 << (PostgreSQLParser.KW_SESSION_USER - 75)) | (1 << (PostgreSQLParser.KW_TABLE - 75)) | (1 << (PostgreSQLParser.KW_TRUE - 75)) | (1 << (PostgreSQLParser.KW_UNIQUE - 75)) | (1 << (PostgreSQLParser.KW_USER - 75)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.KW_BINARY - 107)) | (1 << (PostgreSQLParser.KW_COLLATION - 107)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.KW_CROSS - 107)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.KW_FREEZE - 107)) | (1 << (PostgreSQLParser.KW_FULL - 107)) | (1 << (PostgreSQLParser.KW_ILIKE - 107)) | (1 << (PostgreSQLParser.KW_INNER - 107)) | (1 << (PostgreSQLParser.KW_IS - 107)) | (1 << (PostgreSQLParser.KW_ISNULL - 107)) | (1 << (PostgreSQLParser.KW_JOIN - 107)) | (1 << (PostgreSQLParser.KW_LEFT - 107)) | (1 << (PostgreSQLParser.KW_LIKE - 107)) | (1 << (PostgreSQLParser.KW_NATURAL - 107)) | (1 << (PostgreSQLParser.KW_NOTNULL - 107)) | (1 << (PostgreSQLParser.KW_OUTER - 107)) | (1 << (PostgreSQLParser.KW_OVER - 107)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 107)) | (1 << (PostgreSQLParser.KW_RIGHT - 107)) | (1 << (PostgreSQLParser.KW_SIMILAR - 107)) | (1 << (PostgreSQLParser.KW_VERBOSE - 107)) | (1 << (PostgreSQLParser.KW_ABORT - 107)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 107)) | (1 << (PostgreSQLParser.KW_ACCESS - 107)) | (1 << (PostgreSQLParser.KW_ACTION - 107)) | (1 << (PostgreSQLParser.KW_ADD - 107)) | (1 << (PostgreSQLParser.KW_ADMIN - 107)) | (1 << (PostgreSQLParser.KW_AFTER - 107)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 107)) | (1 << (PostgreSQLParser.KW_ALSO - 107)) | (1 << (PostgreSQLParser.KW_ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.KW_ALWAYS - 139)) | (1 << (PostgreSQLParser.KW_ASSERTION - 139)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.KW_AT - 139)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.KW_BACKWARD - 139)) | (1 << (PostgreSQLParser.KW_BEFORE - 139)) | (1 << (PostgreSQLParser.KW_BEGIN - 139)) | (1 << (PostgreSQLParser.KW_BY - 139)) | (1 << (PostgreSQLParser.KW_CACHE - 139)) | (1 << (PostgreSQLParser.KW_CALLED - 139)) | (1 << (PostgreSQLParser.KW_CASCADE - 139)) | (1 << (PostgreSQLParser.KW_CASCADED - 139)) | (1 << (PostgreSQLParser.KW_CATALOG - 139)) | (1 << (PostgreSQLParser.KW_CHAIN - 139)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 139)) | (1 << (PostgreSQLParser.KW_CLASS - 139)) | (1 << (PostgreSQLParser.KW_CLOSE - 139)) | (1 << (PostgreSQLParser.KW_CLUSTER - 139)) | (1 << (PostgreSQLParser.KW_COMMENT - 139)) | (1 << (PostgreSQLParser.KW_COMMENTS - 139)) | (1 << (PostgreSQLParser.KW_COMMIT - 139)) | (1 << (PostgreSQLParser.KW_COMMITTED - 139)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 139)) | (1 << (PostgreSQLParser.KW_CONNECTION - 139)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.KW_CONTENT - 139)) | (1 << (PostgreSQLParser.KW_CONTINUE - 139)) | (1 << (PostgreSQLParser.KW_CONVERSION - 139)) | (1 << (PostgreSQLParser.KW_COPY - 139)) | (1 << (PostgreSQLParser.KW_COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.KW_CSV - 171)) | (1 << (PostgreSQLParser.KW_CURSOR - 171)) | (1 << (PostgreSQLParser.KW_CYCLE - 171)) | (1 << (PostgreSQLParser.KW_DATA - 171)) | (1 << (PostgreSQLParser.KW_DATABASE - 171)) | (1 << (PostgreSQLParser.KW_DAY - 171)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 171)) | (1 << (PostgreSQLParser.KW_DECLARE - 171)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 171)) | (1 << (PostgreSQLParser.KW_DEFERRED - 171)) | (1 << (PostgreSQLParser.KW_DEFINER - 171)) | (1 << (PostgreSQLParser.KW_DELETE - 171)) | (1 << (PostgreSQLParser.KW_DELIMITER - 171)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 171)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 171)) | (1 << (PostgreSQLParser.KW_DISABLE - 171)) | (1 << (PostgreSQLParser.KW_DISCARD - 171)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 171)) | (1 << (PostgreSQLParser.KW_DOMAIN - 171)) | (1 << (PostgreSQLParser.KW_DOUBLE - 171)) | (1 << (PostgreSQLParser.KW_DROP - 171)) | (1 << (PostgreSQLParser.KW_EACH - 171)) | (1 << (PostgreSQLParser.KW_ENABLE - 171)) | (1 << (PostgreSQLParser.KW_ENCODING - 171)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 171)) | (1 << (PostgreSQLParser.KW_ENUM - 171)) | (1 << (PostgreSQLParser.KW_ESCAPE - 171)) | (1 << (PostgreSQLParser.KW_EVENT - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 171)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.KW_EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.KW_EXPLAIN - 203)) | (1 << (PostgreSQLParser.KW_EXTENSION - 203)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 203)) | (1 << (PostgreSQLParser.KW_FAMILY - 203)) | (1 << (PostgreSQLParser.KW_FIRST - 203)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 203)) | (1 << (PostgreSQLParser.KW_FORCE - 203)) | (1 << (PostgreSQLParser.KW_FORWARD - 203)) | (1 << (PostgreSQLParser.KW_FUNCTION - 203)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 203)) | (1 << (PostgreSQLParser.KW_GLOBAL - 203)) | (1 << (PostgreSQLParser.KW_GRANTED - 203)) | (1 << (PostgreSQLParser.KW_HANDLER - 203)) | (1 << (PostgreSQLParser.KW_HEADER - 203)) | (1 << (PostgreSQLParser.KW_HOLD - 203)) | (1 << (PostgreSQLParser.KW_HOUR - 203)) | (1 << (PostgreSQLParser.KW_IDENTITY - 203)) | (1 << (PostgreSQLParser.KW_IF - 203)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 203)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 203)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 203)) | (1 << (PostgreSQLParser.KW_INCLUDING - 203)) | (1 << (PostgreSQLParser.KW_INCREMENT - 203)) | (1 << (PostgreSQLParser.KW_INDEX - 203)) | (1 << (PostgreSQLParser.KW_INDEXES - 203)) | (1 << (PostgreSQLParser.KW_INHERIT - 203)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.StringConstant - 526)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 526)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 526)) | (1 << (PostgreSQLParser.BinaryStringConstant - 526)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 526)) | (1 << (PostgreSQLParser.Integral - 526)) | (1 << (PostgreSQLParser.Numeric - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0) || _la === PostgreSQLParser.EscapeStringConstant) { { - this.state = 9963; + this.state = 10049; this.opt_slice_bound(); } } - this.state = 9966; + this.state = 10052; this.match(PostgreSQLParser.COLON); - this.state = 9968; + this.state = 10054; 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)) { + 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.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CASE - 33)) | (1 << (PostgreSQLParser.KW_CAST - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_USER - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.KW_LOCALTIME - 75)) | (1 << (PostgreSQLParser.KW_LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.KW_NOT - 75)) | (1 << (PostgreSQLParser.KW_NULL - 75)) | (1 << (PostgreSQLParser.KW_SESSION_USER - 75)) | (1 << (PostgreSQLParser.KW_TABLE - 75)) | (1 << (PostgreSQLParser.KW_TRUE - 75)) | (1 << (PostgreSQLParser.KW_UNIQUE - 75)) | (1 << (PostgreSQLParser.KW_USER - 75)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.KW_BINARY - 107)) | (1 << (PostgreSQLParser.KW_COLLATION - 107)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.KW_CROSS - 107)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.KW_FREEZE - 107)) | (1 << (PostgreSQLParser.KW_FULL - 107)) | (1 << (PostgreSQLParser.KW_ILIKE - 107)) | (1 << (PostgreSQLParser.KW_INNER - 107)) | (1 << (PostgreSQLParser.KW_IS - 107)) | (1 << (PostgreSQLParser.KW_ISNULL - 107)) | (1 << (PostgreSQLParser.KW_JOIN - 107)) | (1 << (PostgreSQLParser.KW_LEFT - 107)) | (1 << (PostgreSQLParser.KW_LIKE - 107)) | (1 << (PostgreSQLParser.KW_NATURAL - 107)) | (1 << (PostgreSQLParser.KW_NOTNULL - 107)) | (1 << (PostgreSQLParser.KW_OUTER - 107)) | (1 << (PostgreSQLParser.KW_OVER - 107)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 107)) | (1 << (PostgreSQLParser.KW_RIGHT - 107)) | (1 << (PostgreSQLParser.KW_SIMILAR - 107)) | (1 << (PostgreSQLParser.KW_VERBOSE - 107)) | (1 << (PostgreSQLParser.KW_ABORT - 107)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 107)) | (1 << (PostgreSQLParser.KW_ACCESS - 107)) | (1 << (PostgreSQLParser.KW_ACTION - 107)) | (1 << (PostgreSQLParser.KW_ADD - 107)) | (1 << (PostgreSQLParser.KW_ADMIN - 107)) | (1 << (PostgreSQLParser.KW_AFTER - 107)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 107)) | (1 << (PostgreSQLParser.KW_ALSO - 107)) | (1 << (PostgreSQLParser.KW_ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.KW_ALWAYS - 139)) | (1 << (PostgreSQLParser.KW_ASSERTION - 139)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.KW_AT - 139)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.KW_BACKWARD - 139)) | (1 << (PostgreSQLParser.KW_BEFORE - 139)) | (1 << (PostgreSQLParser.KW_BEGIN - 139)) | (1 << (PostgreSQLParser.KW_BY - 139)) | (1 << (PostgreSQLParser.KW_CACHE - 139)) | (1 << (PostgreSQLParser.KW_CALLED - 139)) | (1 << (PostgreSQLParser.KW_CASCADE - 139)) | (1 << (PostgreSQLParser.KW_CASCADED - 139)) | (1 << (PostgreSQLParser.KW_CATALOG - 139)) | (1 << (PostgreSQLParser.KW_CHAIN - 139)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 139)) | (1 << (PostgreSQLParser.KW_CLASS - 139)) | (1 << (PostgreSQLParser.KW_CLOSE - 139)) | (1 << (PostgreSQLParser.KW_CLUSTER - 139)) | (1 << (PostgreSQLParser.KW_COMMENT - 139)) | (1 << (PostgreSQLParser.KW_COMMENTS - 139)) | (1 << (PostgreSQLParser.KW_COMMIT - 139)) | (1 << (PostgreSQLParser.KW_COMMITTED - 139)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 139)) | (1 << (PostgreSQLParser.KW_CONNECTION - 139)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.KW_CONTENT - 139)) | (1 << (PostgreSQLParser.KW_CONTINUE - 139)) | (1 << (PostgreSQLParser.KW_CONVERSION - 139)) | (1 << (PostgreSQLParser.KW_COPY - 139)) | (1 << (PostgreSQLParser.KW_COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.KW_CSV - 171)) | (1 << (PostgreSQLParser.KW_CURSOR - 171)) | (1 << (PostgreSQLParser.KW_CYCLE - 171)) | (1 << (PostgreSQLParser.KW_DATA - 171)) | (1 << (PostgreSQLParser.KW_DATABASE - 171)) | (1 << (PostgreSQLParser.KW_DAY - 171)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 171)) | (1 << (PostgreSQLParser.KW_DECLARE - 171)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 171)) | (1 << (PostgreSQLParser.KW_DEFERRED - 171)) | (1 << (PostgreSQLParser.KW_DEFINER - 171)) | (1 << (PostgreSQLParser.KW_DELETE - 171)) | (1 << (PostgreSQLParser.KW_DELIMITER - 171)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 171)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 171)) | (1 << (PostgreSQLParser.KW_DISABLE - 171)) | (1 << (PostgreSQLParser.KW_DISCARD - 171)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 171)) | (1 << (PostgreSQLParser.KW_DOMAIN - 171)) | (1 << (PostgreSQLParser.KW_DOUBLE - 171)) | (1 << (PostgreSQLParser.KW_DROP - 171)) | (1 << (PostgreSQLParser.KW_EACH - 171)) | (1 << (PostgreSQLParser.KW_ENABLE - 171)) | (1 << (PostgreSQLParser.KW_ENCODING - 171)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 171)) | (1 << (PostgreSQLParser.KW_ENUM - 171)) | (1 << (PostgreSQLParser.KW_ESCAPE - 171)) | (1 << (PostgreSQLParser.KW_EVENT - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 171)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.KW_EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.KW_EXPLAIN - 203)) | (1 << (PostgreSQLParser.KW_EXTENSION - 203)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 203)) | (1 << (PostgreSQLParser.KW_FAMILY - 203)) | (1 << (PostgreSQLParser.KW_FIRST - 203)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 203)) | (1 << (PostgreSQLParser.KW_FORCE - 203)) | (1 << (PostgreSQLParser.KW_FORWARD - 203)) | (1 << (PostgreSQLParser.KW_FUNCTION - 203)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 203)) | (1 << (PostgreSQLParser.KW_GLOBAL - 203)) | (1 << (PostgreSQLParser.KW_GRANTED - 203)) | (1 << (PostgreSQLParser.KW_HANDLER - 203)) | (1 << (PostgreSQLParser.KW_HEADER - 203)) | (1 << (PostgreSQLParser.KW_HOLD - 203)) | (1 << (PostgreSQLParser.KW_HOUR - 203)) | (1 << (PostgreSQLParser.KW_IDENTITY - 203)) | (1 << (PostgreSQLParser.KW_IF - 203)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 203)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 203)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 203)) | (1 << (PostgreSQLParser.KW_INCLUDING - 203)) | (1 << (PostgreSQLParser.KW_INCREMENT - 203)) | (1 << (PostgreSQLParser.KW_INDEX - 203)) | (1 << (PostgreSQLParser.KW_INDEXES - 203)) | (1 << (PostgreSQLParser.KW_INHERIT - 203)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.StringConstant - 526)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 526)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 526)) | (1 << (PostgreSQLParser.BinaryStringConstant - 526)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 526)) | (1 << (PostgreSQLParser.Integral - 526)) | (1 << (PostgreSQLParser.Numeric - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0) || _la === PostgreSQLParser.EscapeStringConstant) { { - this.state = 9967; + this.state = 10053; this.opt_slice_bound(); } } @@ -55078,7 +55112,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } break; } - this.state = 9972; + this.state = 10058; this.match(PostgreSQLParser.CLOSE_BRACKET); } break; @@ -55103,11 +55137,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_slice_bound(): Opt_slice_boundContext { let _localctx: Opt_slice_boundContext = new Opt_slice_boundContext(this._ctx, this.state); - this.enterRule(_localctx, 1308, PostgreSQLParser.RULE_opt_slice_bound); + this.enterRule(_localctx, 1322, PostgreSQLParser.RULE_opt_slice_bound); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9975; + this.state = 10061; this.a_expr(); } } @@ -55128,12 +55162,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public indirection(): IndirectionContext { let _localctx: IndirectionContext = new IndirectionContext(this._ctx, this.state); - this.enterRule(_localctx, 1310, PostgreSQLParser.RULE_indirection); + this.enterRule(_localctx, 1324, PostgreSQLParser.RULE_indirection); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9978; + this.state = 10064; this._errHandler.sync(this); _alt = 1; do { @@ -55141,7 +55175,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 1: { { - this.state = 9977; + this.state = 10063; this.indirection_el(); } } @@ -55149,9 +55183,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 9980; + this.state = 10066; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 947, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 961, this._ctx); } while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER); } } @@ -55172,26 +55206,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_indirection(): Opt_indirectionContext { let _localctx: Opt_indirectionContext = new Opt_indirectionContext(this._ctx, this.state); - this.enterRule(_localctx, 1312, PostgreSQLParser.RULE_opt_indirection); + this.enterRule(_localctx, 1326, PostgreSQLParser.RULE_opt_indirection); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9985; + this.state = 10071; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 948, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 962, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9982; + this.state = 10068; this.indirection_el(); } } } - this.state = 9987; + this.state = 10073; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 948, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 962, this._ctx); } } } @@ -55212,11 +55246,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_target_list(): Opt_target_listContext { let _localctx: Opt_target_listContext = new Opt_target_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1314, PostgreSQLParser.RULE_opt_target_list); + this.enterRule(_localctx, 1328, PostgreSQLParser.RULE_opt_target_list); try { this.enterOuterAlt(_localctx, 1); { - this.state = 9988; + this.state = 10074; this.target_list(); } } @@ -55237,30 +55271,30 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public target_list(): Target_listContext { let _localctx: Target_listContext = new Target_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1316, PostgreSQLParser.RULE_target_list); + this.enterRule(_localctx, 1330, PostgreSQLParser.RULE_target_list); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 9990; + this.state = 10076; this.target_el(); - this.state = 9995; + this.state = 10081; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 949, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 963, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 9991; + this.state = 10077; this.match(PostgreSQLParser.COMMA); - this.state = 9992; + this.state = 10078; this.target_el(); } } } - this.state = 9997; + this.state = 10083; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 949, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 963, this._ctx); } } } @@ -55281,9 +55315,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public target_el(): Target_elContext { let _localctx: Target_elContext = new Target_elContext(this._ctx, this.state); - this.enterRule(_localctx, 1318, PostgreSQLParser.RULE_target_el); + this.enterRule(_localctx, 1332, PostgreSQLParser.RULE_target_el); try { - this.state = 10006; + this.state = 10092; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.OPEN_PAREN: @@ -55291,434 +55325,434 @@ export class PostgreSQLParser extends PostgreSQLParserBase { 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_CASE: + case PostgreSQLParser.KW_CAST: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_LOCALTIME: + case PostgreSQLParser.KW_LOCALTIMESTAMP: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_NULL: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -55735,23 +55769,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new Target_labelContext(_localctx); this.enterOuterAlt(_localctx, 1); { - this.state = 9998; + this.state = 10084; this.a_expr(); - this.state = 10003; + this.state = 10089; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 950, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 964, this._ctx) ) { case 1: { - this.state = 9999; - this.match(PostgreSQLParser.AS); - this.state = 10000; + this.state = 10085; + this.match(PostgreSQLParser.KW_AS); + this.state = 10086; this.collabel(); } break; case 2: { - this.state = 10001; + this.state = 10087; this.identifier(); } break; @@ -55768,7 +55802,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { _localctx = new Target_starContext(_localctx); this.enterOuterAlt(_localctx, 2); { - this.state = 10005; + this.state = 10091; this.match(PostgreSQLParser.STAR); } break; @@ -55793,26 +55827,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public qualified_name_list(): Qualified_name_listContext { let _localctx: Qualified_name_listContext = new Qualified_name_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1320, PostgreSQLParser.RULE_qualified_name_list); + this.enterRule(_localctx, 1334, PostgreSQLParser.RULE_qualified_name_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10008; + this.state = 10094; this.qualified_name(); - this.state = 10013; + this.state = 10099; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 10009; + this.state = 10095; this.match(PostgreSQLParser.COMMA); - this.state = 10010; + this.state = 10096; this.qualified_name(); } } - this.state = 10015; + this.state = 10101; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -55833,21 +55867,57 @@ export class PostgreSQLParser extends PostgreSQLParserBase { return _localctx; } // @RuleVersion(0) - public qualified_name(): Qualified_nameContext { - let _localctx: Qualified_nameContext = new Qualified_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 1322, PostgreSQLParser.RULE_qualified_name); + public table_qualified_name(): Table_qualified_nameContext { + let _localctx: Table_qualified_nameContext = new Table_qualified_nameContext(this._ctx, this.state); + this.enterRule(_localctx, 1336, PostgreSQLParser.RULE_table_qualified_name); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10016; + this.state = 10102; this.colid(); - this.state = 10018; + this.state = 10104; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_BRACKET || _la === PostgreSQLParser.DOT) { { - this.state = 10017; + this.state = 10103; + this.indirection(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public qualified_name(): Qualified_nameContext { + let _localctx: Qualified_nameContext = new Qualified_nameContext(this._ctx, this.state); + this.enterRule(_localctx, 1338, PostgreSQLParser.RULE_qualified_name); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 10106; + this.colid(); + this.state = 10108; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.OPEN_BRACKET || _la === PostgreSQLParser.DOT) { + { + this.state = 10107; this.indirection(); } } @@ -55871,26 +55941,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public name_list(): Name_listContext { let _localctx: Name_listContext = new Name_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1324, PostgreSQLParser.RULE_name_list); + this.enterRule(_localctx, 1340, PostgreSQLParser.RULE_name_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10020; + this.state = 10110; this.name(); - this.state = 10025; + this.state = 10115; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 10021; + this.state = 10111; this.match(PostgreSQLParser.COMMA); - this.state = 10022; + this.state = 10112; this.name(); } } - this.state = 10027; + this.state = 10117; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -55913,11 +55983,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public name(): NameContext { let _localctx: NameContext = new NameContext(this._ctx, this.state); - this.enterRule(_localctx, 1326, PostgreSQLParser.RULE_name); + this.enterRule(_localctx, 1342, PostgreSQLParser.RULE_name); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10028; + this.state = 10118; this.colid(); } } @@ -55938,11 +56008,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public attr_name(): Attr_nameContext { let _localctx: Attr_nameContext = new Attr_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 1328, PostgreSQLParser.RULE_attr_name); + this.enterRule(_localctx, 1344, PostgreSQLParser.RULE_attr_name); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10030; + this.state = 10120; this.collabel(); } } @@ -55963,11 +56033,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public file_name(): File_nameContext { let _localctx: File_nameContext = new File_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 1330, PostgreSQLParser.RULE_file_name); + this.enterRule(_localctx, 1346, PostgreSQLParser.RULE_file_name); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10032; + this.state = 10122; this.sconst(); } } @@ -55988,15 +56058,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public func_name(): Func_nameContext { let _localctx: Func_nameContext = new Func_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 1332, PostgreSQLParser.RULE_func_name); + this.enterRule(_localctx, 1348, PostgreSQLParser.RULE_func_name); try { - this.state = 10038; + this.state = 10128; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 955, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 970, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10034; + this.state = 10124; this.type_function_name(); } break; @@ -56004,9 +56074,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10035; + this.state = 10125; this.colid(); - this.state = 10036; + this.state = 10126; this.indirection(); } break; @@ -56029,16 +56099,16 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public aexprconst(): AexprconstContext { let _localctx: AexprconstContext = new AexprconstContext(this._ctx, this.state); - this.enterRule(_localctx, 1334, PostgreSQLParser.RULE_aexprconst); + this.enterRule(_localctx, 1350, PostgreSQLParser.RULE_aexprconst); let _la: number; try { - this.state = 10075; + this.state = 10165; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 960, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 975, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10040; + this.state = 10130; this.iconst(); } break; @@ -56046,7 +56116,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10041; + this.state = 10131; this.fconst(); } break; @@ -56054,7 +56124,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10042; + this.state = 10132; this.sconst(); } break; @@ -56062,7 +56132,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10043; + this.state = 10133; this.bconst(); } break; @@ -56070,7 +56140,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 10044; + this.state = 10134; this.xconst(); } break; @@ -56078,9 +56148,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 10045; + this.state = 10135; this.func_name(); - this.state = 10055; + this.state = 10145; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: @@ -56088,29 +56158,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.BeginDollarStringConstant: case PostgreSQLParser.EscapeStringConstant: { - this.state = 10046; + this.state = 10136; this.sconst(); } break; case PostgreSQLParser.OPEN_PAREN: { - this.state = 10047; + this.state = 10137; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 10048; + this.state = 10138; this.func_arg_list(); - this.state = 10050; + this.state = 10140; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.ORDER) { + if (_la === PostgreSQLParser.KW_ORDER) { { - this.state = 10049; + this.state = 10139; this.opt_sort_clause(); } } - this.state = 10052; + this.state = 10142; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 10053; + this.state = 10143; this.sconst(); } break; @@ -56123,9 +56193,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 10057; + this.state = 10147; this.consttypename(); - this.state = 10058; + this.state = 10148; this.sconst(); } break; @@ -56133,9 +56203,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 10060; + this.state = 10150; this.constinterval(); - this.state = 10070; + this.state = 10160; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: @@ -56143,14 +56213,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.BeginDollarStringConstant: case PostgreSQLParser.EscapeStringConstant: { - this.state = 10061; + this.state = 10151; this.sconst(); - this.state = 10063; + this.state = 10153; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 958, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 973, this._ctx) ) { case 1: { - this.state = 10062; + this.state = 10152; this.opt_interval(); } break; @@ -56159,13 +56229,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { break; case PostgreSQLParser.OPEN_PAREN: { - this.state = 10065; + this.state = 10155; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 10066; + this.state = 10156; this.iconst(); - this.state = 10067; + this.state = 10157; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 10068; + this.state = 10158; this.sconst(); } break; @@ -56178,24 +56248,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 10072; - this.match(PostgreSQLParser.TRUE_P); + this.state = 10162; + this.match(PostgreSQLParser.KW_TRUE); } break; case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 10073; - this.match(PostgreSQLParser.FALSE_P); + this.state = 10163; + this.match(PostgreSQLParser.KW_FALSE); } break; case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 10074; - this.match(PostgreSQLParser.NULL_P); + this.state = 10164; + this.match(PostgreSQLParser.KW_NULL); } break; } @@ -56217,11 +56287,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public xconst(): XconstContext { let _localctx: XconstContext = new XconstContext(this._ctx, this.state); - this.enterRule(_localctx, 1336, PostgreSQLParser.RULE_xconst); + this.enterRule(_localctx, 1352, PostgreSQLParser.RULE_xconst); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10077; + this.state = 10167; this.match(PostgreSQLParser.HexadecimalStringConstant); } } @@ -56242,11 +56312,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public bconst(): BconstContext { let _localctx: BconstContext = new BconstContext(this._ctx, this.state); - this.enterRule(_localctx, 1338, PostgreSQLParser.RULE_bconst); + this.enterRule(_localctx, 1354, PostgreSQLParser.RULE_bconst); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10079; + this.state = 10169; this.match(PostgreSQLParser.BinaryStringConstant); } } @@ -56267,11 +56337,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public fconst(): FconstContext { let _localctx: FconstContext = new FconstContext(this._ctx, this.state); - this.enterRule(_localctx, 1340, PostgreSQLParser.RULE_fconst); + this.enterRule(_localctx, 1356, PostgreSQLParser.RULE_fconst); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10081; + this.state = 10171; this.match(PostgreSQLParser.Numeric); } } @@ -56292,11 +56362,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public iconst(): IconstContext { let _localctx: IconstContext = new IconstContext(this._ctx, this.state); - this.enterRule(_localctx, 1342, PostgreSQLParser.RULE_iconst); + this.enterRule(_localctx, 1358, PostgreSQLParser.RULE_iconst); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10083; + this.state = 10173; this.match(PostgreSQLParser.Integral); } } @@ -56317,18 +56387,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public sconst(): SconstContext { let _localctx: SconstContext = new SconstContext(this._ctx, this.state); - this.enterRule(_localctx, 1344, PostgreSQLParser.RULE_sconst); + this.enterRule(_localctx, 1360, PostgreSQLParser.RULE_sconst); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10085; + this.state = 10175; this.anysconst(); - this.state = 10087; + this.state = 10177; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 961, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 976, this._ctx) ) { case 1: { - this.state = 10086; + this.state = 10176; this.opt_uescape(); } break; @@ -56352,53 +56422,53 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public anysconst(): AnysconstContext { let _localctx: AnysconstContext = new AnysconstContext(this._ctx, this.state); - this.enterRule(_localctx, 1346, PostgreSQLParser.RULE_anysconst); + this.enterRule(_localctx, 1362, PostgreSQLParser.RULE_anysconst); let _la: number; try { - this.state = 10100; + this.state = 10190; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.StringConstant: this.enterOuterAlt(_localctx, 1); { - this.state = 10089; + this.state = 10179; this.match(PostgreSQLParser.StringConstant); } break; case PostgreSQLParser.UnicodeEscapeStringConstant: this.enterOuterAlt(_localctx, 2); { - this.state = 10090; + this.state = 10180; this.match(PostgreSQLParser.UnicodeEscapeStringConstant); } break; case PostgreSQLParser.BeginDollarStringConstant: this.enterOuterAlt(_localctx, 3); { - this.state = 10091; + this.state = 10181; this.match(PostgreSQLParser.BeginDollarStringConstant); - this.state = 10095; + this.state = 10185; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.DollarText) { { { - this.state = 10092; + this.state = 10182; this.match(PostgreSQLParser.DollarText); } } - this.state = 10097; + this.state = 10187; this._errHandler.sync(this); _la = this._input.LA(1); } - this.state = 10098; + this.state = 10188; this.match(PostgreSQLParser.EndDollarStringConstant); } break; case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 4); { - this.state = 10099; + this.state = 10189; this.match(PostgreSQLParser.EscapeStringConstant); } break; @@ -56423,13 +56493,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_uescape(): Opt_uescapeContext { let _localctx: Opt_uescapeContext = new Opt_uescapeContext(this._ctx, this.state); - this.enterRule(_localctx, 1348, PostgreSQLParser.RULE_opt_uescape); + this.enterRule(_localctx, 1364, PostgreSQLParser.RULE_opt_uescape); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10102; - this.match(PostgreSQLParser.UESCAPE); - this.state = 10103; + this.state = 10192; + this.match(PostgreSQLParser.KW_UESCAPE); + this.state = 10193; this.anysconst(); } } @@ -56450,33 +56520,33 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public signediconst(): SignediconstContext { let _localctx: SignediconstContext = new SignediconstContext(this._ctx, this.state); - this.enterRule(_localctx, 1350, PostgreSQLParser.RULE_signediconst); + this.enterRule(_localctx, 1366, PostgreSQLParser.RULE_signediconst); try { - this.state = 10110; + this.state = 10200; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.Integral: this.enterOuterAlt(_localctx, 1); { - this.state = 10105; + this.state = 10195; this.iconst(); } break; case PostgreSQLParser.PLUS: this.enterOuterAlt(_localctx, 2); { - this.state = 10106; + this.state = 10196; this.match(PostgreSQLParser.PLUS); - this.state = 10107; + this.state = 10197; this.iconst(); } break; case PostgreSQLParser.MINUS: this.enterOuterAlt(_localctx, 3); { - this.state = 10108; + this.state = 10198; this.match(PostgreSQLParser.MINUS); - this.state = 10109; + this.state = 10199; this.iconst(); } break; @@ -56499,13 +56569,38 @@ export class PostgreSQLParser extends PostgreSQLParserBase { return _localctx; } // @RuleVersion(0) - public roleid(): RoleidContext { - let _localctx: RoleidContext = new RoleidContext(this._ctx, this.state); - this.enterRule(_localctx, 1352, PostgreSQLParser.RULE_roleid); + public groupname(): GroupnameContext { + let _localctx: GroupnameContext = new GroupnameContext(this._ctx, this.state); + this.enterRule(_localctx, 1368, PostgreSQLParser.RULE_groupname); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10112; + this.state = 10202; + this.rolespec(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public roleid(): RoleidContext { + let _localctx: RoleidContext = new RoleidContext(this._ctx, this.state); + this.enterRule(_localctx, 1370, PostgreSQLParser.RULE_roleid); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 10204; this.rolespec(); } } @@ -56526,422 +56621,422 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public rolespec(): RolespecContext { let _localctx: RolespecContext = new RolespecContext(this._ctx, this.state); - this.enterRule(_localctx, 1354, PostgreSQLParser.RULE_rolespec); + this.enterRule(_localctx, 1372, PostgreSQLParser.RULE_rolespec); try { - this.state = 10117; + this.state = 10210; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -56949,22 +57044,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 10114; + this.state = 10206; this.nonreservedword(); } break; - case PostgreSQLParser.CURRENT_USER: + case PostgreSQLParser.KW_CURRENT_USER: this.enterOuterAlt(_localctx, 2); { - this.state = 10115; - this.match(PostgreSQLParser.CURRENT_USER); + this.state = 10207; + this.match(PostgreSQLParser.KW_CURRENT_USER); } break; - case PostgreSQLParser.SESSION_USER: + case PostgreSQLParser.KW_SESSION_USER: this.enterOuterAlt(_localctx, 3); { - this.state = 10116; - this.match(PostgreSQLParser.SESSION_USER); + this.state = 10208; + this.match(PostgreSQLParser.KW_SESSION_USER); + } + break; + case PostgreSQLParser.KW_PUBLIC: + this.enterOuterAlt(_localctx, 4); + { + this.state = 10209; + this.match(PostgreSQLParser.KW_PUBLIC); } break; default: @@ -56988,26 +57090,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public role_list(): Role_listContext { let _localctx: Role_listContext = new Role_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1356, PostgreSQLParser.RULE_role_list); + this.enterRule(_localctx, 1374, PostgreSQLParser.RULE_role_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10119; + this.state = 10212; this.rolespec(); - this.state = 10124; + this.state = 10217; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 10120; + this.state = 10213; this.match(PostgreSQLParser.COMMA); - this.state = 10121; + this.state = 10214; this.rolespec(); } } - this.state = 10126; + this.state = 10219; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -57030,15 +57132,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public colid(): ColidContext { let _localctx: ColidContext = new ColidContext(this._ctx, this.state); - this.enterRule(_localctx, 1358, PostgreSQLParser.RULE_colid); + this.enterRule(_localctx, 1376, PostgreSQLParser.RULE_colid); try { - this.state = 10131; + this.state = 10224; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 967, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 982, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10127; + this.state = 10220; this.identifier(); } break; @@ -57046,7 +57148,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10128; + this.state = 10221; this.unreserved_keyword(); } break; @@ -57054,7 +57156,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10129; + this.state = 10222; this.col_name_keyword(); } break; @@ -57062,7 +57164,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10130; + this.state = 10223; this.plsql_unreserved_keyword(); } break; @@ -57083,17 +57185,184 @@ export class PostgreSQLParser extends PostgreSQLParserBase { return _localctx; } // @RuleVersion(0) + public index_method_choices(): Index_method_choicesContext { + let _localctx: Index_method_choicesContext = new Index_method_choicesContext(this._ctx, this.state); + this.enterRule(_localctx, 1378, PostgreSQLParser.RULE_index_method_choices); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 10226; + this.identifier(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public exclude_element(): Exclude_elementContext { + let _localctx: Exclude_elementContext = new Exclude_elementContext(this._ctx, this.state); + this.enterRule(_localctx, 1380, PostgreSQLParser.RULE_exclude_element); + let _la: number; + try { + this.state = 10240; + this._errHandler.sync(this); + switch (this._input.LA(1)) { + case PostgreSQLParser.KW_WITH: + this.enterOuterAlt(_localctx, 1); + { + this.state = 10228; + this.opt_definition(); + } + break; + case PostgreSQLParser.OPEN_PAREN: + this.enterOuterAlt(_localctx, 2); + { + { + this.state = 10229; + this.match(PostgreSQLParser.OPEN_PAREN); + this.state = 10230; + this.a_expr(); + this.state = 10231; + this.match(PostgreSQLParser.CLOSE_PAREN); + } + this.state = 10233; + this.identifier(); + this.state = 10235; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_ASC || _la === PostgreSQLParser.KW_DESC) { + { + this.state = 10234; + this.opt_asc_desc(); + } + } + + this.state = 10238; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_NULLS) { + { + this.state = 10237; + this.opt_nulls_order(); + } + } + + } + break; + default: + throw new NoViableAltException(this); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public index_paramenters(): Index_paramentersContext { + let _localctx: Index_paramentersContext = new Index_paramentersContext(this._ctx, this.state); + this.enterRule(_localctx, 1382, PostgreSQLParser.RULE_index_paramenters); + let _la: number; + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 10244; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_WITH) { + { + this.state = 10242; + this.match(PostgreSQLParser.KW_WITH); + this.state = 10243; + this.reloptions(); + } + } + + this.state = 10247; + this._errHandler.sync(this); + _la = this._input.LA(1); + if (_la === PostgreSQLParser.KW_USING) { + { + this.state = 10246; + this.optconstablespace(); + } + } + + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) + public wherePredicate(): WherePredicateContext { + let _localctx: WherePredicateContext = new WherePredicateContext(this._ctx, this.state); + this.enterRule(_localctx, 1384, PostgreSQLParser.RULE_wherePredicate); + try { + this.enterOuterAlt(_localctx, 1); + { + this.state = 10249; + this.match(PostgreSQLParser.KW_WHERE); + this.state = 10250; + this.identifier(); + } + } + catch (re) { + if (re instanceof RecognitionException) { + _localctx.exception = re; + this._errHandler.reportError(this, re); + this._errHandler.recover(this, re); + } else { + throw re; + } + } + finally { + this.exitRule(); + } + return _localctx; + } + // @RuleVersion(0) public type_function_name(): Type_function_nameContext { let _localctx: Type_function_nameContext = new Type_function_nameContext(this._ctx, this.state); - this.enterRule(_localctx, 1360, PostgreSQLParser.RULE_type_function_name); + this.enterRule(_localctx, 1386, PostgreSQLParser.RULE_type_function_name); try { - this.state = 10137; + this.state = 10256; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 968, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 988, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10133; + this.state = 10252; this.identifier(); } break; @@ -57101,7 +57370,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10134; + this.state = 10253; this.unreserved_keyword(); } break; @@ -57109,7 +57378,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10135; + this.state = 10254; this.plsql_unreserved_keyword(); } break; @@ -57117,7 +57386,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10136; + this.state = 10255; this.type_func_name_keyword(); } break; @@ -57140,15 +57409,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public nonreservedword(): NonreservedwordContext { let _localctx: NonreservedwordContext = new NonreservedwordContext(this._ctx, this.state); - this.enterRule(_localctx, 1362, PostgreSQLParser.RULE_nonreservedword); + this.enterRule(_localctx, 1388, PostgreSQLParser.RULE_nonreservedword); try { - this.state = 10143; + this.state = 10262; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 969, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 989, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10139; + this.state = 10258; this.identifier(); } break; @@ -57156,7 +57425,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10140; + this.state = 10259; this.unreserved_keyword(); } break; @@ -57164,7 +57433,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10141; + this.state = 10260; this.col_name_keyword(); } break; @@ -57172,7 +57441,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10142; + this.state = 10261; this.type_func_name_keyword(); } break; @@ -57195,15 +57464,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public collabel(): CollabelContext { let _localctx: CollabelContext = new CollabelContext(this._ctx, this.state); - this.enterRule(_localctx, 1364, PostgreSQLParser.RULE_collabel); + this.enterRule(_localctx, 1390, PostgreSQLParser.RULE_collabel); try { - this.state = 10151; + this.state = 10270; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 970, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 990, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10145; + this.state = 10264; this.identifier(); } break; @@ -57211,7 +57480,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10146; + this.state = 10265; this.plsql_unreserved_keyword(); } break; @@ -57219,7 +57488,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10147; + this.state = 10266; this.unreserved_keyword(); } break; @@ -57227,7 +57496,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10148; + this.state = 10267; this.col_name_keyword(); } break; @@ -57235,7 +57504,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 10149; + this.state = 10268; this.type_func_name_keyword(); } break; @@ -57243,7 +57512,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 10150; + this.state = 10269; this.reserved_keyword(); } break; @@ -57266,22 +57535,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public identifier(): IdentifierContext { let _localctx: IdentifierContext = new IdentifierContext(this._ctx, this.state); - this.enterRule(_localctx, 1366, PostgreSQLParser.RULE_identifier); + this.enterRule(_localctx, 1392, PostgreSQLParser.RULE_identifier); try { - this.state = 10162; + this.state = 10281; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.Identifier: this.enterOuterAlt(_localctx, 1); { - this.state = 10153; + this.state = 10272; this.match(PostgreSQLParser.Identifier); - this.state = 10155; + this.state = 10274; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 971, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 991, this._ctx) ) { case 1: { - this.state = 10154; + this.state = 10273; this.opt_uescape(); } break; @@ -57291,99 +57560,99 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.QuotedIdentifier: this.enterOuterAlt(_localctx, 2); { - this.state = 10157; + this.state = 10276; this.match(PostgreSQLParser.QuotedIdentifier); } break; case PostgreSQLParser.UnicodeQuotedIdentifier: this.enterOuterAlt(_localctx, 3); { - this.state = 10158; + this.state = 10277; this.match(PostgreSQLParser.UnicodeQuotedIdentifier); } break; case PostgreSQLParser.PLSQLVARIABLENAME: this.enterOuterAlt(_localctx, 4); { - this.state = 10159; + this.state = 10278; this.plsqlvariablename(); } break; case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 5); { - this.state = 10160; + this.state = 10279; 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: + case PostgreSQLParser.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: this.enterOuterAlt(_localctx, 6); { - this.state = 10161; + this.state = 10280; this.plsql_unreserved_keyword(); } break; @@ -57408,11 +57677,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public plsqlidentifier(): PlsqlidentifierContext { let _localctx: PlsqlidentifierContext = new PlsqlidentifierContext(this._ctx, this.state); - this.enterRule(_localctx, 1368, PostgreSQLParser.RULE_plsqlidentifier); + this.enterRule(_localctx, 1394, PostgreSQLParser.RULE_plsqlidentifier); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10164; + this.state = 10283; this.match(PostgreSQLParser.PLSQLIDENTIFIER); } } @@ -57433,14 +57702,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public unreserved_keyword(): Unreserved_keywordContext { let _localctx: Unreserved_keywordContext = new Unreserved_keywordContext(this._ctx, this.state); - this.enterRule(_localctx, 1370, PostgreSQLParser.RULE_unreserved_keyword); + this.enterRule(_localctx, 1396, PostgreSQLParser.RULE_unreserved_keyword); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10166; + this.state = 10285; _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))) { + if (!(((((_la - 124)) & ~0x1F) === 0 && ((1 << (_la - 124)) & ((1 << (PostgreSQLParser.KW_OVER - 124)) | (1 << (PostgreSQLParser.KW_ABORT - 124)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 124)) | (1 << (PostgreSQLParser.KW_ACCESS - 124)) | (1 << (PostgreSQLParser.KW_ACTION - 124)) | (1 << (PostgreSQLParser.KW_ADD - 124)) | (1 << (PostgreSQLParser.KW_ADMIN - 124)) | (1 << (PostgreSQLParser.KW_AFTER - 124)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 124)) | (1 << (PostgreSQLParser.KW_ALSO - 124)) | (1 << (PostgreSQLParser.KW_ALTER - 124)) | (1 << (PostgreSQLParser.KW_ALWAYS - 124)) | (1 << (PostgreSQLParser.KW_ASSERTION - 124)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 124)) | (1 << (PostgreSQLParser.KW_AT - 124)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 124)) | (1 << (PostgreSQLParser.KW_BACKWARD - 124)) | (1 << (PostgreSQLParser.KW_BEFORE - 124)) | (1 << (PostgreSQLParser.KW_BEGIN - 124)) | (1 << (PostgreSQLParser.KW_BY - 124)) | (1 << (PostgreSQLParser.KW_CACHE - 124)) | (1 << (PostgreSQLParser.KW_CALLED - 124)) | (1 << (PostgreSQLParser.KW_CASCADE - 124)) | (1 << (PostgreSQLParser.KW_CASCADED - 124)) | (1 << (PostgreSQLParser.KW_CATALOG - 124)) | (1 << (PostgreSQLParser.KW_CHAIN - 124)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 124)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 124)))) !== 0) || ((((_la - 156)) & ~0x1F) === 0 && ((1 << (_la - 156)) & ((1 << (PostgreSQLParser.KW_CLASS - 156)) | (1 << (PostgreSQLParser.KW_CLOSE - 156)) | (1 << (PostgreSQLParser.KW_CLUSTER - 156)) | (1 << (PostgreSQLParser.KW_COMMENT - 156)) | (1 << (PostgreSQLParser.KW_COMMENTS - 156)) | (1 << (PostgreSQLParser.KW_COMMIT - 156)) | (1 << (PostgreSQLParser.KW_COMMITTED - 156)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 156)) | (1 << (PostgreSQLParser.KW_CONNECTION - 156)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 156)) | (1 << (PostgreSQLParser.KW_CONTENT - 156)) | (1 << (PostgreSQLParser.KW_CONTINUE - 156)) | (1 << (PostgreSQLParser.KW_CONVERSION - 156)) | (1 << (PostgreSQLParser.KW_COPY - 156)) | (1 << (PostgreSQLParser.KW_COST - 156)) | (1 << (PostgreSQLParser.KW_CSV - 156)) | (1 << (PostgreSQLParser.KW_CURSOR - 156)) | (1 << (PostgreSQLParser.KW_CYCLE - 156)) | (1 << (PostgreSQLParser.KW_DATA - 156)) | (1 << (PostgreSQLParser.KW_DATABASE - 156)) | (1 << (PostgreSQLParser.KW_DAY - 156)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 156)) | (1 << (PostgreSQLParser.KW_DECLARE - 156)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 156)) | (1 << (PostgreSQLParser.KW_DEFERRED - 156)) | (1 << (PostgreSQLParser.KW_DEFINER - 156)) | (1 << (PostgreSQLParser.KW_DELETE - 156)) | (1 << (PostgreSQLParser.KW_DELIMITER - 156)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 156)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 156)) | (1 << (PostgreSQLParser.KW_DISABLE - 156)) | (1 << (PostgreSQLParser.KW_DISCARD - 156)))) !== 0) || ((((_la - 188)) & ~0x1F) === 0 && ((1 << (_la - 188)) & ((1 << (PostgreSQLParser.KW_DOCUMENT - 188)) | (1 << (PostgreSQLParser.KW_DOMAIN - 188)) | (1 << (PostgreSQLParser.KW_DOUBLE - 188)) | (1 << (PostgreSQLParser.KW_DROP - 188)) | (1 << (PostgreSQLParser.KW_EACH - 188)) | (1 << (PostgreSQLParser.KW_ENABLE - 188)) | (1 << (PostgreSQLParser.KW_ENCODING - 188)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 188)) | (1 << (PostgreSQLParser.KW_ENUM - 188)) | (1 << (PostgreSQLParser.KW_ESCAPE - 188)) | (1 << (PostgreSQLParser.KW_EVENT - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 188)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 188)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 188)) | (1 << (PostgreSQLParser.KW_EXECUTE - 188)) | (1 << (PostgreSQLParser.KW_EXPLAIN - 188)) | (1 << (PostgreSQLParser.KW_EXTENSION - 188)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 188)) | (1 << (PostgreSQLParser.KW_FAMILY - 188)) | (1 << (PostgreSQLParser.KW_FIRST - 188)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 188)) | (1 << (PostgreSQLParser.KW_FORCE - 188)) | (1 << (PostgreSQLParser.KW_FORWARD - 188)) | (1 << (PostgreSQLParser.KW_FUNCTION - 188)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 188)) | (1 << (PostgreSQLParser.KW_GLOBAL - 188)) | (1 << (PostgreSQLParser.KW_GRANTED - 188)) | (1 << (PostgreSQLParser.KW_HANDLER - 188)) | (1 << (PostgreSQLParser.KW_HEADER - 188)) | (1 << (PostgreSQLParser.KW_HOLD - 188)) | (1 << (PostgreSQLParser.KW_HOUR - 188)) | (1 << (PostgreSQLParser.KW_IDENTITY - 188)))) !== 0) || ((((_la - 220)) & ~0x1F) === 0 && ((1 << (_la - 220)) & ((1 << (PostgreSQLParser.KW_IF - 220)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 220)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 220)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 220)) | (1 << (PostgreSQLParser.KW_INCLUDING - 220)) | (1 << (PostgreSQLParser.KW_INCREMENT - 220)) | (1 << (PostgreSQLParser.KW_INDEX - 220)) | (1 << (PostgreSQLParser.KW_INDEXES - 220)) | (1 << (PostgreSQLParser.KW_INHERIT - 220)) | (1 << (PostgreSQLParser.KW_INHERITS - 220)) | (1 << (PostgreSQLParser.KW_INLINE - 220)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 220)) | (1 << (PostgreSQLParser.KW_INSERT - 220)) | (1 << (PostgreSQLParser.KW_INSTEAD - 220)) | (1 << (PostgreSQLParser.KW_INVOKER - 220)) | (1 << (PostgreSQLParser.KW_ISOLATION - 220)) | (1 << (PostgreSQLParser.KW_KEY - 220)) | (1 << (PostgreSQLParser.KW_LABEL - 220)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 220)) | (1 << (PostgreSQLParser.KW_LARGE - 220)) | (1 << (PostgreSQLParser.KW_LAST - 220)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 220)) | (1 << (PostgreSQLParser.KW_LEVEL - 220)))) !== 0) || ((((_la - 252)) & ~0x1F) === 0 && ((1 << (_la - 252)) & ((1 << (PostgreSQLParser.KW_LISTEN - 252)) | (1 << (PostgreSQLParser.KW_LOAD - 252)) | (1 << (PostgreSQLParser.KW_LOCAL - 252)) | (1 << (PostgreSQLParser.KW_LOCATION - 252)) | (1 << (PostgreSQLParser.KW_LOCK - 252)) | (1 << (PostgreSQLParser.KW_MAPPING - 252)) | (1 << (PostgreSQLParser.KW_MATCH - 252)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 252)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 252)) | (1 << (PostgreSQLParser.KW_MINUTE - 252)) | (1 << (PostgreSQLParser.KW_MINVALUE - 252)) | (1 << (PostgreSQLParser.KW_MODE - 252)) | (1 << (PostgreSQLParser.KW_MONTH - 252)) | (1 << (PostgreSQLParser.KW_MOVE - 252)) | (1 << (PostgreSQLParser.KW_NAME - 252)) | (1 << (PostgreSQLParser.KW_NAMES - 252)) | (1 << (PostgreSQLParser.KW_NEXT - 252)) | (1 << (PostgreSQLParser.KW_NO - 252)) | (1 << (PostgreSQLParser.KW_NOTHING - 252)) | (1 << (PostgreSQLParser.KW_NOTIFY - 252)) | (1 << (PostgreSQLParser.KW_NOWAIT - 252)) | (1 << (PostgreSQLParser.KW_NULLS - 252)) | (1 << (PostgreSQLParser.KW_OBJECT - 252)) | (1 << (PostgreSQLParser.KW_OF - 252)) | (1 << (PostgreSQLParser.KW_OFF - 252)) | (1 << (PostgreSQLParser.KW_OIDS - 252)) | (1 << (PostgreSQLParser.KW_OPERATOR - 252)) | (1 << (PostgreSQLParser.KW_OPTION - 252)) | (1 << (PostgreSQLParser.KW_OPTIONS - 252)) | (1 << (PostgreSQLParser.KW_OWNED - 252)) | (1 << (PostgreSQLParser.KW_OWNER - 252)) | (1 << (PostgreSQLParser.KW_PARSER - 252)))) !== 0) || ((((_la - 284)) & ~0x1F) === 0 && ((1 << (_la - 284)) & ((1 << (PostgreSQLParser.KW_PARTIAL - 284)) | (1 << (PostgreSQLParser.KW_PARTITION - 284)) | (1 << (PostgreSQLParser.KW_PASSING - 284)) | (1 << (PostgreSQLParser.KW_PASSWORD - 284)) | (1 << (PostgreSQLParser.KW_PLANS - 284)) | (1 << (PostgreSQLParser.KW_PRECEDING - 284)) | (1 << (PostgreSQLParser.KW_PREPARE - 284)) | (1 << (PostgreSQLParser.KW_PREPARED - 284)) | (1 << (PostgreSQLParser.KW_PRESERVE - 284)) | (1 << (PostgreSQLParser.KW_PRIOR - 284)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 284)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 284)) | (1 << (PostgreSQLParser.KW_PROGRAM - 284)) | (1 << (PostgreSQLParser.KW_QUOTE - 284)) | (1 << (PostgreSQLParser.KW_RANGE - 284)) | (1 << (PostgreSQLParser.KW_READ - 284)) | (1 << (PostgreSQLParser.KW_REASSIGN - 284)) | (1 << (PostgreSQLParser.KW_RECHECK - 284)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 284)) | (1 << (PostgreSQLParser.KW_REF - 284)) | (1 << (PostgreSQLParser.KW_REFRESH - 284)) | (1 << (PostgreSQLParser.KW_REINDEX - 284)) | (1 << (PostgreSQLParser.KW_RELATIVE - 284)) | (1 << (PostgreSQLParser.KW_RELEASE - 284)) | (1 << (PostgreSQLParser.KW_RENAME - 284)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 284)) | (1 << (PostgreSQLParser.KW_REPLACE - 284)) | (1 << (PostgreSQLParser.KW_REPLICA - 284)) | (1 << (PostgreSQLParser.KW_RESET - 284)) | (1 << (PostgreSQLParser.KW_RESTART - 284)) | (1 << (PostgreSQLParser.KW_RESTRICT - 284)))) !== 0) || ((((_la - 316)) & ~0x1F) === 0 && ((1 << (_la - 316)) & ((1 << (PostgreSQLParser.KW_RETURNS - 316)) | (1 << (PostgreSQLParser.KW_REVOKE - 316)) | (1 << (PostgreSQLParser.KW_ROLE - 316)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 316)) | (1 << (PostgreSQLParser.KW_ROWS - 316)) | (1 << (PostgreSQLParser.KW_RULE - 316)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 316)) | (1 << (PostgreSQLParser.KW_SCHEMA - 316)) | (1 << (PostgreSQLParser.KW_SCROLL - 316)) | (1 << (PostgreSQLParser.KW_SEARCH - 316)) | (1 << (PostgreSQLParser.KW_SECOND - 316)) | (1 << (PostgreSQLParser.KW_SECURITY - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 316)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 316)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 316)) | (1 << (PostgreSQLParser.KW_SERVER - 316)) | (1 << (PostgreSQLParser.KW_SESSION - 316)) | (1 << (PostgreSQLParser.KW_SET - 316)) | (1 << (PostgreSQLParser.KW_SHARE - 316)) | (1 << (PostgreSQLParser.KW_SHOW - 316)) | (1 << (PostgreSQLParser.KW_SIMPLE - 316)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 316)) | (1 << (PostgreSQLParser.KW_STABLE - 316)) | (1 << (PostgreSQLParser.KW_STANDALONE - 316)) | (1 << (PostgreSQLParser.KW_START - 316)) | (1 << (PostgreSQLParser.KW_STATEMENT - 316)) | (1 << (PostgreSQLParser.KW_STATISTICS - 316)) | (1 << (PostgreSQLParser.KW_STDIN - 316)) | (1 << (PostgreSQLParser.KW_STDOUT - 316)) | (1 << (PostgreSQLParser.KW_STORAGE - 316)) | (1 << (PostgreSQLParser.KW_STRICT - 316)) | (1 << (PostgreSQLParser.KW_STRIP - 316)))) !== 0) || ((((_la - 348)) & ~0x1F) === 0 && ((1 << (_la - 348)) & ((1 << (PostgreSQLParser.KW_SYSID - 348)) | (1 << (PostgreSQLParser.KW_SYSTEM - 348)) | (1 << (PostgreSQLParser.KW_TABLES - 348)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 348)) | (1 << (PostgreSQLParser.KW_TEMP - 348)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 348)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 348)) | (1 << (PostgreSQLParser.KW_TEXT - 348)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 348)) | (1 << (PostgreSQLParser.KW_TRIGGER - 348)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 348)) | (1 << (PostgreSQLParser.KW_TRUSTED - 348)) | (1 << (PostgreSQLParser.KW_TYPE - 348)) | (1 << (PostgreSQLParser.KW_TYPES - 348)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 348)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 348)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 348)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 348)) | (1 << (PostgreSQLParser.KW_UNLISTEN - 348)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 348)) | (1 << (PostgreSQLParser.KW_UNTIL - 348)) | (1 << (PostgreSQLParser.KW_UPDATE - 348)) | (1 << (PostgreSQLParser.KW_VACUUM - 348)) | (1 << (PostgreSQLParser.KW_VALID - 348)) | (1 << (PostgreSQLParser.KW_VALIDATE - 348)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 348)) | (1 << (PostgreSQLParser.KW_VARYING - 348)) | (1 << (PostgreSQLParser.KW_VERSION - 348)) | (1 << (PostgreSQLParser.KW_VIEW - 348)) | (1 << (PostgreSQLParser.KW_VOLATILE - 348)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 348)) | (1 << (PostgreSQLParser.KW_WITHOUT - 348)))) !== 0) || ((((_la - 380)) & ~0x1F) === 0 && ((1 << (_la - 380)) & ((1 << (PostgreSQLParser.KW_WORK - 380)) | (1 << (PostgreSQLParser.KW_WRAPPER - 380)) | (1 << (PostgreSQLParser.KW_WRITE - 380)) | (1 << (PostgreSQLParser.KW_XML - 380)) | (1 << (PostgreSQLParser.KW_YEAR - 380)) | (1 << (PostgreSQLParser.KW_YES - 380)) | (1 << (PostgreSQLParser.KW_ZONE - 380)))) !== 0) || ((((_la - 433)) & ~0x1F) === 0 && ((1 << (_la - 433)) & ((1 << (PostgreSQLParser.KW_CALL - 433)) | (1 << (PostgreSQLParser.KW_CURRENT - 433)) | (1 << (PostgreSQLParser.KW_ATTACH - 433)) | (1 << (PostgreSQLParser.KW_DETACH - 433)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 433)) | (1 << (PostgreSQLParser.KW_GENERATED - 433)) | (1 << (PostgreSQLParser.KW_LOGGED - 433)) | (1 << (PostgreSQLParser.KW_STORED - 433)) | (1 << (PostgreSQLParser.KW_INCLUDE - 433)) | (1 << (PostgreSQLParser.KW_ROUTINE - 433)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 433)) | (1 << (PostgreSQLParser.KW_IMPORT - 433)) | (1 << (PostgreSQLParser.KW_POLICY - 433)) | (1 << (PostgreSQLParser.KW_METHOD - 433)) | (1 << (PostgreSQLParser.KW_REFERENCING - 433)) | (1 << (PostgreSQLParser.KW_NEW - 433)) | (1 << (PostgreSQLParser.KW_OLD - 433)) | (1 << (PostgreSQLParser.KW_VALUE - 433)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 433)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 433)) | (1 << (PostgreSQLParser.KW_ROUTINES - 433)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 433)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 433)) | (1 << (PostgreSQLParser.KW_INPUT - 433)) | (1 << (PostgreSQLParser.KW_SUPPORT - 433)) | (1 << (PostgreSQLParser.KW_PARALLEL - 433)) | (1 << (PostgreSQLParser.KW_SQL - 433)) | (1 << (PostgreSQLParser.KW_DEPENDS - 433)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 433)) | (1 << (PostgreSQLParser.KW_CONFLICT - 433)))) !== 0) || ((((_la - 465)) & ~0x1F) === 0 && ((1 << (_la - 465)) & ((1 << (PostgreSQLParser.KW_SKIP - 465)) | (1 << (PostgreSQLParser.KW_LOCKED - 465)) | (1 << (PostgreSQLParser.KW_TIES - 465)) | (1 << (PostgreSQLParser.KW_ROLLUP - 465)) | (1 << (PostgreSQLParser.KW_CUBE - 465)) | (1 << (PostgreSQLParser.KW_SETS - 465)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 465)) | (1 << (PostgreSQLParser.KW_COLUMNS - 465)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 465)) | (1 << (PostgreSQLParser.KW_WITHIN - 465)) | (1 << (PostgreSQLParser.KW_FILTER - 465)) | (1 << (PostgreSQLParser.KW_GROUPS - 465)) | (1 << (PostgreSQLParser.KW_OTHERS - 465)) | (1 << (PostgreSQLParser.KW_NFC - 465)) | (1 << (PostgreSQLParser.KW_NFD - 465)) | (1 << (PostgreSQLParser.KW_NFKC - 465)) | (1 << (PostgreSQLParser.KW_NFKD - 465)) | (1 << (PostgreSQLParser.KW_UESCAPE - 465)) | (1 << (PostgreSQLParser.KW_VIEWS - 465)))) !== 0))) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -57469,31 +57738,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public col_name_keyword(): Col_name_keywordContext { let _localctx: Col_name_keywordContext = new Col_name_keywordContext(this._ctx, this.state); - this.enterRule(_localctx, 1372, PostgreSQLParser.RULE_col_name_keyword); + this.enterRule(_localctx, 1398, PostgreSQLParser.RULE_col_name_keyword); try { - this.state = 10219; + this.state = 10338; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 973, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 993, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10168; - this.match(PostgreSQLParser.BETWEEN); + this.state = 10287; + this.match(PostgreSQLParser.KW_BETWEEN); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10169; - this.match(PostgreSQLParser.BIGINT); + this.state = 10288; + this.match(PostgreSQLParser.KW_BIGINT); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10170; + this.state = 10289; this.bit(); } break; @@ -57501,23 +57770,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10171; - this.match(PostgreSQLParser.BOOLEAN_P); + this.state = 10290; + this.match(PostgreSQLParser.KW_BOOLEAN); } break; case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 10172; - this.match(PostgreSQLParser.CHAR_P); + this.state = 10291; + this.match(PostgreSQLParser.KW_CHAR); } break; case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 10173; + this.state = 10292; this.character(); } break; @@ -57525,151 +57794,151 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 10174; - this.match(PostgreSQLParser.COALESCE); + this.state = 10293; + this.match(PostgreSQLParser.KW_COALESCE); } break; case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 10175; - this.match(PostgreSQLParser.DEC); + this.state = 10294; + this.match(PostgreSQLParser.KW_DEC); } break; case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 10176; - this.match(PostgreSQLParser.DECIMAL_P); + this.state = 10295; + this.match(PostgreSQLParser.KW_DECIMAL); } break; case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 10177; - this.match(PostgreSQLParser.EXISTS); + this.state = 10296; + this.match(PostgreSQLParser.KW_EXISTS); } break; case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 10178; - this.match(PostgreSQLParser.EXTRACT); + this.state = 10297; + this.match(PostgreSQLParser.KW_EXTRACT); } break; case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 10179; - this.match(PostgreSQLParser.FLOAT_P); + this.state = 10298; + this.match(PostgreSQLParser.KW_FLOAT); } break; case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 10180; - this.match(PostgreSQLParser.GREATEST); + this.state = 10299; + this.match(PostgreSQLParser.KW_GREATEST); } break; case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 10181; - this.match(PostgreSQLParser.GROUPING); + this.state = 10300; + this.match(PostgreSQLParser.KW_GROUPING); } break; case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 10182; - this.match(PostgreSQLParser.INOUT); + this.state = 10301; + this.match(PostgreSQLParser.KW_INOUT); } break; case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 10183; - this.match(PostgreSQLParser.INT_P); + this.state = 10302; + this.match(PostgreSQLParser.KW_INT); } break; case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 10184; - this.match(PostgreSQLParser.INTEGER); + this.state = 10303; + this.match(PostgreSQLParser.KW_INTEGER); } break; case 18: this.enterOuterAlt(_localctx, 18); { - this.state = 10185; - this.match(PostgreSQLParser.INTERVAL); + this.state = 10304; + this.match(PostgreSQLParser.KW_INTERVAL); } break; case 19: this.enterOuterAlt(_localctx, 19); { - this.state = 10186; - this.match(PostgreSQLParser.LEAST); + this.state = 10305; + this.match(PostgreSQLParser.KW_LEAST); } break; case 20: this.enterOuterAlt(_localctx, 20); { - this.state = 10187; - this.match(PostgreSQLParser.NATIONAL); + this.state = 10306; + this.match(PostgreSQLParser.KW_NATIONAL); } break; case 21: this.enterOuterAlt(_localctx, 21); { - this.state = 10188; - this.match(PostgreSQLParser.NCHAR); + this.state = 10307; + this.match(PostgreSQLParser.KW_NCHAR); } break; case 22: this.enterOuterAlt(_localctx, 22); { - this.state = 10189; - this.match(PostgreSQLParser.NONE); + this.state = 10308; + this.match(PostgreSQLParser.KW_NONE); } break; case 23: this.enterOuterAlt(_localctx, 23); { - this.state = 10190; - this.match(PostgreSQLParser.NORMALIZE); + this.state = 10309; + this.match(PostgreSQLParser.KW_NORMALIZE); } break; case 24: this.enterOuterAlt(_localctx, 24); { - this.state = 10191; - this.match(PostgreSQLParser.NULLIF); + this.state = 10310; + this.match(PostgreSQLParser.KW_NULLIF); } break; case 25: this.enterOuterAlt(_localctx, 25); { - this.state = 10192; + this.state = 10311; this.numeric(); } break; @@ -57677,208 +57946,208 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 26: this.enterOuterAlt(_localctx, 26); { - this.state = 10193; - this.match(PostgreSQLParser.OUT_P); + this.state = 10312; + this.match(PostgreSQLParser.KW_OUT); } break; case 27: this.enterOuterAlt(_localctx, 27); { - this.state = 10194; - this.match(PostgreSQLParser.OVERLAY); + this.state = 10313; + this.match(PostgreSQLParser.KW_OVERLAY); } break; case 28: this.enterOuterAlt(_localctx, 28); { - this.state = 10195; - this.match(PostgreSQLParser.POSITION); + this.state = 10314; + this.match(PostgreSQLParser.KW_POSITION); } break; case 29: this.enterOuterAlt(_localctx, 29); { - this.state = 10196; - this.match(PostgreSQLParser.PRECISION); + this.state = 10315; + this.match(PostgreSQLParser.KW_PRECISION); } break; case 30: this.enterOuterAlt(_localctx, 30); { - this.state = 10197; - this.match(PostgreSQLParser.REAL); + this.state = 10316; + this.match(PostgreSQLParser.KW_REAL); } break; case 31: this.enterOuterAlt(_localctx, 31); { - this.state = 10198; - this.match(PostgreSQLParser.ROW); + this.state = 10317; + this.match(PostgreSQLParser.KW_ROW); } break; case 32: this.enterOuterAlt(_localctx, 32); { - this.state = 10199; - this.match(PostgreSQLParser.SETOF); + this.state = 10318; + this.match(PostgreSQLParser.KW_SETOF); } break; case 33: this.enterOuterAlt(_localctx, 33); { - this.state = 10200; - this.match(PostgreSQLParser.SMALLINT); + this.state = 10319; + this.match(PostgreSQLParser.KW_SMALLINT); } break; case 34: this.enterOuterAlt(_localctx, 34); { - this.state = 10201; - this.match(PostgreSQLParser.SUBSTRING); + this.state = 10320; + this.match(PostgreSQLParser.KW_SUBSTRING); } break; case 35: this.enterOuterAlt(_localctx, 35); { - this.state = 10202; - this.match(PostgreSQLParser.TIME); + this.state = 10321; + this.match(PostgreSQLParser.KW_TIME); } break; case 36: this.enterOuterAlt(_localctx, 36); { - this.state = 10203; - this.match(PostgreSQLParser.TIMESTAMP); + this.state = 10322; + this.match(PostgreSQLParser.KW_TIMESTAMP); } break; case 37: this.enterOuterAlt(_localctx, 37); { - this.state = 10204; - this.match(PostgreSQLParser.TREAT); + this.state = 10323; + this.match(PostgreSQLParser.KW_TREAT); } break; case 38: this.enterOuterAlt(_localctx, 38); { - this.state = 10205; - this.match(PostgreSQLParser.TRIM); + this.state = 10324; + this.match(PostgreSQLParser.KW_TRIM); } break; case 39: this.enterOuterAlt(_localctx, 39); { - this.state = 10206; - this.match(PostgreSQLParser.VALUES); + this.state = 10325; + this.match(PostgreSQLParser.KW_VALUES); } break; case 40: this.enterOuterAlt(_localctx, 40); { - this.state = 10207; - this.match(PostgreSQLParser.VARCHAR); + this.state = 10326; + this.match(PostgreSQLParser.KW_VARCHAR); } break; case 41: this.enterOuterAlt(_localctx, 41); { - this.state = 10208; - this.match(PostgreSQLParser.XMLATTRIBUTES); + this.state = 10327; + this.match(PostgreSQLParser.KW_XMLATTRIBUTES); } break; case 42: this.enterOuterAlt(_localctx, 42); { - this.state = 10209; - this.match(PostgreSQLParser.XMLCONCAT); + this.state = 10328; + this.match(PostgreSQLParser.KW_XMLCONCAT); } break; case 43: this.enterOuterAlt(_localctx, 43); { - this.state = 10210; - this.match(PostgreSQLParser.XMLELEMENT); + this.state = 10329; + this.match(PostgreSQLParser.KW_XMLELEMENT); } break; case 44: this.enterOuterAlt(_localctx, 44); { - this.state = 10211; - this.match(PostgreSQLParser.XMLEXISTS); + this.state = 10330; + this.match(PostgreSQLParser.KW_XMLEXISTS); } break; case 45: this.enterOuterAlt(_localctx, 45); { - this.state = 10212; - this.match(PostgreSQLParser.XMLFOREST); + this.state = 10331; + this.match(PostgreSQLParser.KW_XMLFOREST); } break; case 46: this.enterOuterAlt(_localctx, 46); { - this.state = 10213; - this.match(PostgreSQLParser.XMLNAMESPACES); + this.state = 10332; + this.match(PostgreSQLParser.KW_XMLNAMESPACES); } break; case 47: this.enterOuterAlt(_localctx, 47); { - this.state = 10214; - this.match(PostgreSQLParser.XMLPARSE); + this.state = 10333; + this.match(PostgreSQLParser.KW_XMLPARSE); } break; case 48: this.enterOuterAlt(_localctx, 48); { - this.state = 10215; - this.match(PostgreSQLParser.XMLPI); + this.state = 10334; + this.match(PostgreSQLParser.KW_XMLPI); } break; case 49: this.enterOuterAlt(_localctx, 49); { - this.state = 10216; - this.match(PostgreSQLParser.XMLROOT); + this.state = 10335; + this.match(PostgreSQLParser.KW_XMLROOT); } break; case 50: this.enterOuterAlt(_localctx, 50); { - this.state = 10217; - this.match(PostgreSQLParser.XMLSERIALIZE); + this.state = 10336; + this.match(PostgreSQLParser.KW_XMLSERIALIZE); } break; case 51: this.enterOuterAlt(_localctx, 51); { - this.state = 10218; - this.match(PostgreSQLParser.XMLTABLE); + this.state = 10337; + this.match(PostgreSQLParser.KW_XMLTABLE); } break; } @@ -57900,14 +58169,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public type_func_name_keyword(): Type_func_name_keywordContext { let _localctx: Type_func_name_keywordContext = new Type_func_name_keywordContext(this._ctx, this.state); - this.enterRule(_localctx, 1374, PostgreSQLParser.RULE_type_func_name_keyword); + this.enterRule(_localctx, 1400, PostgreSQLParser.RULE_type_func_name_keyword); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10221; + this.state = 10340; _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)) { + if (!(((((_la - 106)) & ~0x1F) === 0 && ((1 << (_la - 106)) & ((1 << (PostgreSQLParser.KW_AUTHORIZATION - 106)) | (1 << (PostgreSQLParser.KW_BINARY - 106)) | (1 << (PostgreSQLParser.KW_COLLATION - 106)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 106)) | (1 << (PostgreSQLParser.KW_CROSS - 106)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 106)) | (1 << (PostgreSQLParser.KW_FREEZE - 106)) | (1 << (PostgreSQLParser.KW_FULL - 106)) | (1 << (PostgreSQLParser.KW_ILIKE - 106)) | (1 << (PostgreSQLParser.KW_INNER - 106)) | (1 << (PostgreSQLParser.KW_IS - 106)) | (1 << (PostgreSQLParser.KW_ISNULL - 106)) | (1 << (PostgreSQLParser.KW_JOIN - 106)) | (1 << (PostgreSQLParser.KW_LEFT - 106)) | (1 << (PostgreSQLParser.KW_LIKE - 106)) | (1 << (PostgreSQLParser.KW_NATURAL - 106)) | (1 << (PostgreSQLParser.KW_NOTNULL - 106)) | (1 << (PostgreSQLParser.KW_OUTER - 106)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 106)) | (1 << (PostgreSQLParser.KW_RIGHT - 106)) | (1 << (PostgreSQLParser.KW_SIMILAR - 106)) | (1 << (PostgreSQLParser.KW_VERBOSE - 106)))) !== 0) || _la === PostgreSQLParser.KW_TABLESAMPLE)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -57936,14 +58205,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public reserved_keyword(): Reserved_keywordContext { let _localctx: Reserved_keywordContext = new Reserved_keywordContext(this._ctx, this.state); - this.enterRule(_localctx, 1376, PostgreSQLParser.RULE_reserved_keyword); + this.enterRule(_localctx, 1402, PostgreSQLParser.RULE_reserved_keyword); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10223; + this.state = 10342; _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)) { + if (!(((((_la - 30)) & ~0x1F) === 0 && ((1 << (_la - 30)) & ((1 << (PostgreSQLParser.KW_ALL - 30)) | (1 << (PostgreSQLParser.KW_ANALYSE - 30)) | (1 << (PostgreSQLParser.KW_ANALYZE - 30)) | (1 << (PostgreSQLParser.KW_AND - 30)) | (1 << (PostgreSQLParser.KW_ANY - 30)) | (1 << (PostgreSQLParser.KW_ARRAY - 30)) | (1 << (PostgreSQLParser.KW_AS - 30)) | (1 << (PostgreSQLParser.KW_ASC - 30)) | (1 << (PostgreSQLParser.KW_ASYMMETRIC - 30)) | (1 << (PostgreSQLParser.KW_BOTH - 30)) | (1 << (PostgreSQLParser.KW_CASE - 30)) | (1 << (PostgreSQLParser.KW_CAST - 30)) | (1 << (PostgreSQLParser.KW_CHECK - 30)) | (1 << (PostgreSQLParser.KW_COLLATE - 30)) | (1 << (PostgreSQLParser.KW_COLUMN - 30)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 30)) | (1 << (PostgreSQLParser.KW_CREATE - 30)) | (1 << (PostgreSQLParser.KW_CURRENT_CATALOG - 30)) | (1 << (PostgreSQLParser.KW_CURRENT_DATE - 30)) | (1 << (PostgreSQLParser.KW_CURRENT_ROLE - 30)) | (1 << (PostgreSQLParser.KW_CURRENT_TIME - 30)) | (1 << (PostgreSQLParser.KW_CURRENT_TIMESTAMP - 30)) | (1 << (PostgreSQLParser.KW_CURRENT_USER - 30)) | (1 << (PostgreSQLParser.KW_DEFERRABLE - 30)) | (1 << (PostgreSQLParser.KW_DESC - 30)) | (1 << (PostgreSQLParser.KW_DISTINCT - 30)) | (1 << (PostgreSQLParser.KW_DO - 30)) | (1 << (PostgreSQLParser.KW_ELSE - 30)) | (1 << (PostgreSQLParser.KW_EXCEPT - 30)) | (1 << (PostgreSQLParser.KW_FALSE - 30)) | (1 << (PostgreSQLParser.KW_FETCH - 30)))) !== 0) || ((((_la - 62)) & ~0x1F) === 0 && ((1 << (_la - 62)) & ((1 << (PostgreSQLParser.KW_FOR - 62)) | (1 << (PostgreSQLParser.KW_FOREIGN - 62)) | (1 << (PostgreSQLParser.KW_FROM - 62)) | (1 << (PostgreSQLParser.KW_GRANT - 62)) | (1 << (PostgreSQLParser.KW_GROUP - 62)) | (1 << (PostgreSQLParser.KW_HAVING - 62)) | (1 << (PostgreSQLParser.KW_IN - 62)) | (1 << (PostgreSQLParser.KW_INITIALLY - 62)) | (1 << (PostgreSQLParser.KW_INTERSECT - 62)) | (1 << (PostgreSQLParser.KW_LATERAL - 62)) | (1 << (PostgreSQLParser.KW_LEADING - 62)) | (1 << (PostgreSQLParser.KW_LIMIT - 62)) | (1 << (PostgreSQLParser.KW_LOCALTIME - 62)) | (1 << (PostgreSQLParser.KW_LOCALTIMESTAMP - 62)) | (1 << (PostgreSQLParser.KW_NOT - 62)) | (1 << (PostgreSQLParser.KW_NULL - 62)) | (1 << (PostgreSQLParser.KW_OFFSET - 62)) | (1 << (PostgreSQLParser.KW_ON - 62)) | (1 << (PostgreSQLParser.KW_ONLY - 62)) | (1 << (PostgreSQLParser.KW_OR - 62)) | (1 << (PostgreSQLParser.KW_ORDER - 62)) | (1 << (PostgreSQLParser.KW_PLACING - 62)) | (1 << (PostgreSQLParser.KW_PRIMARY - 62)) | (1 << (PostgreSQLParser.KW_REFERENCES - 62)) | (1 << (PostgreSQLParser.KW_RETURNING - 62)) | (1 << (PostgreSQLParser.KW_SELECT - 62)) | (1 << (PostgreSQLParser.KW_SESSION_USER - 62)) | (1 << (PostgreSQLParser.KW_SOME - 62)) | (1 << (PostgreSQLParser.KW_SYMMETRIC - 62)) | (1 << (PostgreSQLParser.KW_TABLE - 62)) | (1 << (PostgreSQLParser.KW_THEN - 62)))) !== 0) || ((((_la - 94)) & ~0x1F) === 0 && ((1 << (_la - 94)) & ((1 << (PostgreSQLParser.KW_TO - 94)) | (1 << (PostgreSQLParser.KW_TRAILING - 94)) | (1 << (PostgreSQLParser.KW_TRUE - 94)) | (1 << (PostgreSQLParser.KW_UNION - 94)) | (1 << (PostgreSQLParser.KW_UNIQUE - 94)) | (1 << (PostgreSQLParser.KW_USER - 94)) | (1 << (PostgreSQLParser.KW_USING - 94)) | (1 << (PostgreSQLParser.KW_VARIADIC - 94)) | (1 << (PostgreSQLParser.KW_WHEN - 94)) | (1 << (PostgreSQLParser.KW_WHERE - 94)) | (1 << (PostgreSQLParser.KW_WINDOW - 94)) | (1 << (PostgreSQLParser.KW_WITH - 94)))) !== 0) || _la === PostgreSQLParser.KW_END)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -57972,15 +58241,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public pl_function(): Pl_functionContext { let _localctx: Pl_functionContext = new Pl_functionContext(this._ctx, this.state); - this.enterRule(_localctx, 1378, PostgreSQLParser.RULE_pl_function); + this.enterRule(_localctx, 1404, PostgreSQLParser.RULE_pl_function); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10225; + this.state = 10344; this.comp_options(); - this.state = 10226; + this.state = 10345; this.pl_block(); - this.state = 10227; + this.state = 10346; this.opt_semi(); } } @@ -58001,22 +58270,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public comp_options(): Comp_optionsContext { let _localctx: Comp_optionsContext = new Comp_optionsContext(this._ctx, this.state); - this.enterRule(_localctx, 1380, PostgreSQLParser.RULE_comp_options); + this.enterRule(_localctx, 1406, PostgreSQLParser.RULE_comp_options); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10232; + this.state = 10351; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.Operator) { { { - this.state = 10229; + this.state = 10348; this.comp_option(); } } - this.state = 10234; + this.state = 10353; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -58039,31 +58308,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public comp_option(): Comp_optionContext { let _localctx: Comp_optionContext = new Comp_optionContext(this._ctx, this.state); - this.enterRule(_localctx, 1382, PostgreSQLParser.RULE_comp_option); + this.enterRule(_localctx, 1408, PostgreSQLParser.RULE_comp_option); try { - this.state = 10255; + this.state = 10374; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 975, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 995, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10235; + this.state = 10354; this.sharp(); - this.state = 10236; - this.match(PostgreSQLParser.OPTION); - this.state = 10237; - this.match(PostgreSQLParser.DUMP); + this.state = 10355; + this.match(PostgreSQLParser.KW_OPTION); + this.state = 10356; + this.match(PostgreSQLParser.KW_DUMP); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10239; + this.state = 10358; this.sharp(); - this.state = 10240; - this.match(PostgreSQLParser.PRINT_STRICT_PARAMS); - this.state = 10241; + this.state = 10359; + this.match(PostgreSQLParser.KW_PRINT_STRICT_PARAMS); + this.state = 10360; this.option_value(); } break; @@ -58071,36 +58340,36 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10243; + this.state = 10362; this.sharp(); - this.state = 10244; - this.match(PostgreSQLParser.VARIABLE_CONFLICT); - this.state = 10245; - this.match(PostgreSQLParser.ERROR); + this.state = 10363; + this.match(PostgreSQLParser.KW_VARIABLE_CONFLICT); + this.state = 10364; + this.match(PostgreSQLParser.KW_ERROR); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10247; + this.state = 10366; this.sharp(); - this.state = 10248; - this.match(PostgreSQLParser.VARIABLE_CONFLICT); - this.state = 10249; - this.match(PostgreSQLParser.USE_VARIABLE); + this.state = 10367; + this.match(PostgreSQLParser.KW_VARIABLE_CONFLICT); + this.state = 10368; + this.match(PostgreSQLParser.KW_USE_VARIABLE); } break; case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 10251; + this.state = 10370; this.sharp(); - this.state = 10252; - this.match(PostgreSQLParser.VARIABLE_CONFLICT); - this.state = 10253; - this.match(PostgreSQLParser.USE_COLUMN); + this.state = 10371; + this.match(PostgreSQLParser.KW_VARIABLE_CONFLICT); + this.state = 10372; + this.match(PostgreSQLParser.KW_USE_COLUMN); } break; } @@ -58122,11 +58391,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public sharp(): SharpContext { let _localctx: SharpContext = new SharpContext(this._ctx, this.state); - this.enterRule(_localctx, 1384, PostgreSQLParser.RULE_sharp); + this.enterRule(_localctx, 1410, PostgreSQLParser.RULE_sharp); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10257; + this.state = 10376; this.match(PostgreSQLParser.Operator); } } @@ -58147,15 +58416,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public option_value(): Option_valueContext { let _localctx: Option_valueContext = new Option_valueContext(this._ctx, this.state); - this.enterRule(_localctx, 1386, PostgreSQLParser.RULE_option_value); + this.enterRule(_localctx, 1412, PostgreSQLParser.RULE_option_value); try { - this.state = 10263; + this.state = 10382; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 976, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 996, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10259; + this.state = 10378; this.sconst(); } break; @@ -58163,7 +58432,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10260; + this.state = 10379; this.reserved_keyword(); } break; @@ -58171,7 +58440,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10261; + this.state = 10380; this.plsql_unreserved_keyword(); } break; @@ -58179,7 +58448,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10262; + this.state = 10381; this.unreserved_keyword(); } break; @@ -58202,9 +58471,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_semi(): Opt_semiContext { let _localctx: Opt_semiContext = new Opt_semiContext(this._ctx, this.state); - this.enterRule(_localctx, 1388, PostgreSQLParser.RULE_opt_semi); + this.enterRule(_localctx, 1414, PostgreSQLParser.RULE_opt_semi); try { - this.state = 10267; + this.state = 10386; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.EOF: @@ -58216,7 +58485,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.SEMI: this.enterOuterAlt(_localctx, 2); { - this.state = 10266; + this.state = 10385; this.match(PostgreSQLParser.SEMI); } break; @@ -58241,21 +58510,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public pl_block(): Pl_blockContext { let _localctx: Pl_blockContext = new Pl_blockContext(this._ctx, this.state); - this.enterRule(_localctx, 1390, PostgreSQLParser.RULE_pl_block); + this.enterRule(_localctx, 1416, PostgreSQLParser.RULE_pl_block); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10269; + this.state = 10388; this.decl_sect(); - this.state = 10270; - this.match(PostgreSQLParser.BEGIN_P); - this.state = 10271; + this.state = 10389; + this.match(PostgreSQLParser.KW_BEGIN); + this.state = 10390; this.proc_sect(); - this.state = 10272; + this.state = 10391; this.exception_sect(); - this.state = 10273; - this.match(PostgreSQLParser.END_P); - this.state = 10274; + this.state = 10392; + this.match(PostgreSQLParser.KW_END); + this.state = 10393; this.opt_label(); } } @@ -58276,26 +58545,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_sect(): Decl_sectContext { let _localctx: Decl_sectContext = new Decl_sectContext(this._ctx, this.state); - this.enterRule(_localctx, 1392, PostgreSQLParser.RULE_decl_sect); + this.enterRule(_localctx, 1418, PostgreSQLParser.RULE_decl_sect); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10276; + this.state = 10395; this.opt_block_label(); - this.state = 10281; + this.state = 10400; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.DECLARE) { + if (_la === PostgreSQLParser.KW_DECLARE) { { - this.state = 10277; + this.state = 10396; this.decl_start(); - this.state = 10279; + this.state = 10398; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 978, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 998, this._ctx) ) { case 1: { - this.state = 10278; + this.state = 10397; this.decl_stmts(); } break; @@ -58322,12 +58591,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_start(): Decl_startContext { let _localctx: Decl_startContext = new Decl_startContext(this._ctx, this.state); - this.enterRule(_localctx, 1394, PostgreSQLParser.RULE_decl_start); + this.enterRule(_localctx, 1420, PostgreSQLParser.RULE_decl_start); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10283; - this.match(PostgreSQLParser.DECLARE); + this.state = 10402; + this.match(PostgreSQLParser.KW_DECLARE); } } catch (re) { @@ -58347,12 +58616,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_stmts(): Decl_stmtsContext { let _localctx: Decl_stmtsContext = new Decl_stmtsContext(this._ctx, this.state); - this.enterRule(_localctx, 1396, PostgreSQLParser.RULE_decl_stmts); + this.enterRule(_localctx, 1422, PostgreSQLParser.RULE_decl_stmts); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 10286; + this.state = 10405; this._errHandler.sync(this); _alt = 1; do { @@ -58360,7 +58629,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 1: { { - this.state = 10285; + this.state = 10404; this.decl_stmt(); } } @@ -58368,9 +58637,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { default: throw new NoViableAltException(this); } - this.state = 10288; + this.state = 10407; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 980, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 1000, this._ctx); } while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER); } } @@ -58391,15 +58660,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public label_decl(): Label_declContext { let _localctx: Label_declContext = new Label_declContext(this._ctx, this.state); - this.enterRule(_localctx, 1398, PostgreSQLParser.RULE_label_decl); + this.enterRule(_localctx, 1424, PostgreSQLParser.RULE_label_decl); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10290; + this.state = 10409; this.match(PostgreSQLParser.LESS_LESS); - this.state = 10291; + this.state = 10410; this.any_identifier(); - this.state = 10292; + this.state = 10411; this.match(PostgreSQLParser.GREATER_GREATER); } } @@ -58420,15 +58689,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_stmt(): Decl_stmtContext { let _localctx: Decl_stmtContext = new Decl_stmtContext(this._ctx, this.state); - this.enterRule(_localctx, 1400, PostgreSQLParser.RULE_decl_stmt); + this.enterRule(_localctx, 1426, PostgreSQLParser.RULE_decl_stmt); try { - this.state = 10297; + this.state = 10416; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 981, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1001, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10294; + this.state = 10413; this.decl_statement(); } break; @@ -58436,15 +58705,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10295; - this.match(PostgreSQLParser.DECLARE); + this.state = 10414; + this.match(PostgreSQLParser.KW_DECLARE); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10296; + this.state = 10415; this.label_decl(); } break; @@ -58467,57 +58736,57 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_statement(): Decl_statementContext { let _localctx: Decl_statementContext = new Decl_statementContext(this._ctx, this.state); - this.enterRule(_localctx, 1402, PostgreSQLParser.RULE_decl_statement); + this.enterRule(_localctx, 1428, PostgreSQLParser.RULE_decl_statement); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10299; + this.state = 10418; this.decl_varname(); - this.state = 10315; + this.state = 10434; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 982, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1002, this._ctx) ) { case 1: { - this.state = 10300; - this.match(PostgreSQLParser.ALIAS); - this.state = 10301; - this.match(PostgreSQLParser.FOR); - this.state = 10302; + this.state = 10419; + this.match(PostgreSQLParser.KW_ALIAS); + this.state = 10420; + this.match(PostgreSQLParser.KW_FOR); + this.state = 10421; this.decl_aliasitem(); } break; case 2: { - this.state = 10303; + this.state = 10422; this.decl_const(); - this.state = 10304; + this.state = 10423; this.decl_datatype(); - this.state = 10305; + this.state = 10424; this.decl_collate(); - this.state = 10306; + this.state = 10425; this.decl_notnull(); - this.state = 10307; + this.state = 10426; this.decl_defval(); } break; case 3: { - this.state = 10309; + this.state = 10428; this.opt_scrollable(); - this.state = 10310; - this.match(PostgreSQLParser.CURSOR); - this.state = 10311; + this.state = 10429; + this.match(PostgreSQLParser.KW_CURSOR); + this.state = 10430; this.decl_cursor_args(); - this.state = 10312; + this.state = 10431; this.decl_is_for(); - this.state = 10313; + this.state = 10432; this.decl_cursor_query(); } break; } - this.state = 10317; + this.state = 10436; this.match(PostgreSQLParser.SEMI); } } @@ -58538,31 +58807,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_scrollable(): Opt_scrollableContext { let _localctx: Opt_scrollableContext = new Opt_scrollableContext(this._ctx, this.state); - this.enterRule(_localctx, 1404, PostgreSQLParser.RULE_opt_scrollable); + this.enterRule(_localctx, 1430, PostgreSQLParser.RULE_opt_scrollable); try { - this.state = 10323; + this.state = 10442; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.CURSOR: + case PostgreSQLParser.KW_CURSOR: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.NO: + case PostgreSQLParser.KW_NO: this.enterOuterAlt(_localctx, 2); { - this.state = 10320; - this.match(PostgreSQLParser.NO); - this.state = 10321; - this.match(PostgreSQLParser.SCROLL); + this.state = 10439; + this.match(PostgreSQLParser.KW_NO); + this.state = 10440; + this.match(PostgreSQLParser.KW_SCROLL); } break; - case PostgreSQLParser.SCROLL: + case PostgreSQLParser.KW_SCROLL: this.enterOuterAlt(_localctx, 3); { - this.state = 10322; - this.match(PostgreSQLParser.SCROLL); + this.state = 10441; + this.match(PostgreSQLParser.KW_SCROLL); } break; default: @@ -58586,11 +58855,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_cursor_query(): Decl_cursor_queryContext { let _localctx: Decl_cursor_queryContext = new Decl_cursor_queryContext(this._ctx, this.state); - this.enterRule(_localctx, 1406, PostgreSQLParser.RULE_decl_cursor_query); + this.enterRule(_localctx, 1432, PostgreSQLParser.RULE_decl_cursor_query); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10325; + this.state = 10444; this.selectstmt(); } } @@ -58611,13 +58880,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_cursor_args(): Decl_cursor_argsContext { let _localctx: Decl_cursor_argsContext = new Decl_cursor_argsContext(this._ctx, this.state); - this.enterRule(_localctx, 1408, PostgreSQLParser.RULE_decl_cursor_args); + this.enterRule(_localctx, 1434, PostgreSQLParser.RULE_decl_cursor_args); try { - this.state = 10332; + this.state = 10451; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.FOR: - case PostgreSQLParser.IS: + case PostgreSQLParser.KW_FOR: + case PostgreSQLParser.KW_IS: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { @@ -58626,11 +58895,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.OPEN_PAREN: this.enterOuterAlt(_localctx, 2); { - this.state = 10328; + this.state = 10447; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 10329; + this.state = 10448; this.decl_cursor_arglist(); - this.state = 10330; + this.state = 10449; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -58655,26 +58924,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_cursor_arglist(): Decl_cursor_arglistContext { let _localctx: Decl_cursor_arglistContext = new Decl_cursor_arglistContext(this._ctx, this.state); - this.enterRule(_localctx, 1410, PostgreSQLParser.RULE_decl_cursor_arglist); + this.enterRule(_localctx, 1436, PostgreSQLParser.RULE_decl_cursor_arglist); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10334; + this.state = 10453; this.decl_cursor_arg(); - this.state = 10339; + this.state = 10458; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 10335; + this.state = 10454; this.match(PostgreSQLParser.COMMA); - this.state = 10336; + this.state = 10455; this.decl_cursor_arg(); } } - this.state = 10341; + this.state = 10460; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -58697,13 +58966,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_cursor_arg(): Decl_cursor_argContext { let _localctx: Decl_cursor_argContext = new Decl_cursor_argContext(this._ctx, this.state); - this.enterRule(_localctx, 1412, PostgreSQLParser.RULE_decl_cursor_arg); + this.enterRule(_localctx, 1438, PostgreSQLParser.RULE_decl_cursor_arg); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10342; + this.state = 10461; this.decl_varname(); - this.state = 10343; + this.state = 10462; this.decl_datatype(); } } @@ -58724,14 +58993,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_is_for(): Decl_is_forContext { let _localctx: Decl_is_forContext = new Decl_is_forContext(this._ctx, this.state); - this.enterRule(_localctx, 1414, PostgreSQLParser.RULE_decl_is_for); + this.enterRule(_localctx, 1440, PostgreSQLParser.RULE_decl_is_for); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10345; + this.state = 10464; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.FOR || _la === PostgreSQLParser.IS)) { + if (!(_la === PostgreSQLParser.KW_FOR || _la === PostgreSQLParser.KW_IS)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -58760,408 +59029,408 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_aliasitem(): Decl_aliasitemContext { let _localctx: Decl_aliasitemContext = new Decl_aliasitemContext(this._ctx, this.state); - this.enterRule(_localctx, 1416, PostgreSQLParser.RULE_decl_aliasitem); + this.enterRule(_localctx, 1442, PostgreSQLParser.RULE_decl_aliasitem); try { - this.state = 10349; + this.state = 10468; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.PARAM: this.enterOuterAlt(_localctx, 1); { - this.state = 10347; + this.state = 10466; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -59169,7 +59438,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 2); { - this.state = 10348; + this.state = 10467; this.colid(); } break; @@ -59194,11 +59463,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_varname(): Decl_varnameContext { let _localctx: Decl_varnameContext = new Decl_varnameContext(this._ctx, this.state); - this.enterRule(_localctx, 1418, PostgreSQLParser.RULE_decl_varname); + this.enterRule(_localctx, 1444, PostgreSQLParser.RULE_decl_varname); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10351; + this.state = 10470; this.any_identifier(); } } @@ -59219,11 +59488,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_const(): Decl_constContext { let _localctx: Decl_constContext = new Decl_constContext(this._ctx, this.state); - this.enterRule(_localctx, 1420, PostgreSQLParser.RULE_decl_const); + this.enterRule(_localctx, 1446, PostgreSQLParser.RULE_decl_const); try { - this.state = 10355; + this.state = 10474; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 987, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1007, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty @@ -59234,8 +59503,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10354; - this.match(PostgreSQLParser.CONSTANT); + this.state = 10473; + this.match(PostgreSQLParser.KW_CONSTANT); } break; } @@ -59257,11 +59526,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_datatype(): Decl_datatypeContext { let _localctx: Decl_datatypeContext = new Decl_datatypeContext(this._ctx, this.state); - this.enterRule(_localctx, 1422, PostgreSQLParser.RULE_decl_datatype); + this.enterRule(_localctx, 1448, PostgreSQLParser.RULE_decl_datatype); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10357; + this.state = 10476; this.typename(); } } @@ -59282,27 +59551,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_collate(): Decl_collateContext { let _localctx: Decl_collateContext = new Decl_collateContext(this._ctx, this.state); - this.enterRule(_localctx, 1424, PostgreSQLParser.RULE_decl_collate); + this.enterRule(_localctx, 1450, PostgreSQLParser.RULE_decl_collate); try { - this.state = 10362; + this.state = 10481; 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: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_NOT: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.COLLATE: + case PostgreSQLParser.KW_COLLATE: this.enterOuterAlt(_localctx, 2); { - this.state = 10360; - this.match(PostgreSQLParser.COLLATE); - this.state = 10361; + this.state = 10479; + this.match(PostgreSQLParser.KW_COLLATE); + this.state = 10480; this.any_name(); } break; @@ -59327,27 +59596,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_notnull(): Decl_notnullContext { let _localctx: Decl_notnullContext = new Decl_notnullContext(this._ctx, this.state); - this.enterRule(_localctx, 1426, PostgreSQLParser.RULE_decl_notnull); + this.enterRule(_localctx, 1452, PostgreSQLParser.RULE_decl_notnull); try { - this.state = 10367; + this.state = 10486; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.SEMI: case PostgreSQLParser.EQUAL: case PostgreSQLParser.COLON_EQUALS: - case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.KW_DEFAULT: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.NOT: + case PostgreSQLParser.KW_NOT: this.enterOuterAlt(_localctx, 2); { - this.state = 10365; - this.match(PostgreSQLParser.NOT); - this.state = 10366; - this.match(PostgreSQLParser.NULL_P); + this.state = 10484; + this.match(PostgreSQLParser.KW_NOT); + this.state = 10485; + this.match(PostgreSQLParser.KW_NULL); } break; default: @@ -59371,9 +59640,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_defval(): Decl_defvalContext { let _localctx: Decl_defvalContext = new Decl_defvalContext(this._ctx, this.state); - this.enterRule(_localctx, 1428, PostgreSQLParser.RULE_decl_defval); + this.enterRule(_localctx, 1454, PostgreSQLParser.RULE_decl_defval); try { - this.state = 10373; + this.state = 10492; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.SEMI: @@ -59384,12 +59653,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { break; case PostgreSQLParser.EQUAL: case PostgreSQLParser.COLON_EQUALS: - case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.KW_DEFAULT: this.enterOuterAlt(_localctx, 2); { - this.state = 10370; + this.state = 10489; this.decl_defkey(); - this.state = 10371; + this.state = 10490; this.sql_expression(); } break; @@ -59414,24 +59683,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public decl_defkey(): Decl_defkeyContext { let _localctx: Decl_defkeyContext = new Decl_defkeyContext(this._ctx, this.state); - this.enterRule(_localctx, 1430, PostgreSQLParser.RULE_decl_defkey); + this.enterRule(_localctx, 1456, PostgreSQLParser.RULE_decl_defkey); try { - this.state = 10377; + this.state = 10496; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.EQUAL: case PostgreSQLParser.COLON_EQUALS: this.enterOuterAlt(_localctx, 1); { - this.state = 10375; + this.state = 10494; this.assign_operator(); } break; - case PostgreSQLParser.DEFAULT: + case PostgreSQLParser.KW_DEFAULT: this.enterOuterAlt(_localctx, 2); { - this.state = 10376; - this.match(PostgreSQLParser.DEFAULT); + this.state = 10495; + this.match(PostgreSQLParser.KW_DEFAULT); } break; default: @@ -59455,12 +59724,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public assign_operator(): Assign_operatorContext { let _localctx: Assign_operatorContext = new Assign_operatorContext(this._ctx, this.state); - this.enterRule(_localctx, 1432, PostgreSQLParser.RULE_assign_operator); + this.enterRule(_localctx, 1458, PostgreSQLParser.RULE_assign_operator); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10379; + this.state = 10498; _la = this._input.LA(1); if (!(_la === PostgreSQLParser.EQUAL || _la === PostgreSQLParser.COLON_EQUALS)) { this._errHandler.recoverInline(this); @@ -59491,26 +59760,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public proc_sect(): Proc_sectContext { let _localctx: Proc_sectContext = new Proc_sectContext(this._ctx, this.state); - this.enterRule(_localctx, 1434, PostgreSQLParser.RULE_proc_sect); + this.enterRule(_localctx, 1460, PostgreSQLParser.RULE_proc_sect); try { let _alt: number; this.enterOuterAlt(_localctx, 1); { - this.state = 10384; + this.state = 10503; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 992, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 1012, this._ctx); while (_alt !== 2 && _alt !== ATN.INVALID_ALT_NUMBER) { if (_alt === 1) { { { - this.state = 10381; + this.state = 10500; this.proc_stmt(); } } } - this.state = 10386; + this.state = 10505; this._errHandler.sync(this); - _alt = this.interpreter.adaptivePredict(this._input, 992, this._ctx); + _alt = this.interpreter.adaptivePredict(this._input, 1012, this._ctx); } } } @@ -59531,17 +59800,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public proc_stmt(): Proc_stmtContext { let _localctx: Proc_stmtContext = new Proc_stmtContext(this._ctx, this.state); - this.enterRule(_localctx, 1436, PostgreSQLParser.RULE_proc_stmt); + this.enterRule(_localctx, 1462, PostgreSQLParser.RULE_proc_stmt); try { - this.state = 10414; + this.state = 10533; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 993, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1013, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10387; + this.state = 10506; this.pl_block(); - this.state = 10388; + this.state = 10507; this.match(PostgreSQLParser.SEMI); } break; @@ -59549,7 +59818,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10390; + this.state = 10509; this.stmt_return(); } break; @@ -59557,7 +59826,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10391; + this.state = 10510; this.stmt_raise(); } break; @@ -59565,7 +59834,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10392; + this.state = 10511; this.stmt_assign(); } break; @@ -59573,7 +59842,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 10393; + this.state = 10512; this.stmt_if(); } break; @@ -59581,7 +59850,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 10394; + this.state = 10513; this.stmt_case(); } break; @@ -59589,7 +59858,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 10395; + this.state = 10514; this.stmt_loop(); } break; @@ -59597,7 +59866,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 10396; + this.state = 10515; this.stmt_while(); } break; @@ -59605,7 +59874,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 10397; + this.state = 10516; this.stmt_for(); } break; @@ -59613,7 +59882,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 10: this.enterOuterAlt(_localctx, 10); { - this.state = 10398; + this.state = 10517; this.stmt_foreach_a(); } break; @@ -59621,7 +59890,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 11: this.enterOuterAlt(_localctx, 11); { - this.state = 10399; + this.state = 10518; this.stmt_exit(); } break; @@ -59629,7 +59898,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 12: this.enterOuterAlt(_localctx, 12); { - this.state = 10400; + this.state = 10519; this.stmt_assert(); } break; @@ -59637,7 +59906,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 13: this.enterOuterAlt(_localctx, 13); { - this.state = 10401; + this.state = 10520; this.stmt_execsql(); } break; @@ -59645,7 +59914,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 14: this.enterOuterAlt(_localctx, 14); { - this.state = 10402; + this.state = 10521; this.stmt_dynexecute(); } break; @@ -59653,7 +59922,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 15: this.enterOuterAlt(_localctx, 15); { - this.state = 10403; + this.state = 10522; this.stmt_perform(); } break; @@ -59661,7 +59930,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 16: this.enterOuterAlt(_localctx, 16); { - this.state = 10404; + this.state = 10523; this.stmt_call(); } break; @@ -59669,7 +59938,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 17: this.enterOuterAlt(_localctx, 17); { - this.state = 10405; + this.state = 10524; this.stmt_getdiag(); } break; @@ -59677,7 +59946,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 18: this.enterOuterAlt(_localctx, 18); { - this.state = 10406; + this.state = 10525; this.stmt_open(); } break; @@ -59685,7 +59954,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 19: this.enterOuterAlt(_localctx, 19); { - this.state = 10407; + this.state = 10526; this.stmt_fetch(); } break; @@ -59693,7 +59962,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 20: this.enterOuterAlt(_localctx, 20); { - this.state = 10408; + this.state = 10527; this.stmt_move(); } break; @@ -59701,7 +59970,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 21: this.enterOuterAlt(_localctx, 21); { - this.state = 10409; + this.state = 10528; this.stmt_close(); } break; @@ -59709,7 +59978,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 22: this.enterOuterAlt(_localctx, 22); { - this.state = 10410; + this.state = 10529; this.stmt_null(); } break; @@ -59717,7 +59986,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 23: this.enterOuterAlt(_localctx, 23); { - this.state = 10411; + this.state = 10530; this.stmt_commit(); } break; @@ -59725,7 +59994,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 24: this.enterOuterAlt(_localctx, 24); { - this.state = 10412; + this.state = 10531; this.stmt_rollback(); } break; @@ -59733,7 +60002,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 25: this.enterOuterAlt(_localctx, 25); { - this.state = 10413; + this.state = 10532; this.stmt_set(); } break; @@ -59756,15 +60025,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_perform(): Stmt_performContext { let _localctx: Stmt_performContext = new Stmt_performContext(this._ctx, this.state); - this.enterRule(_localctx, 1438, PostgreSQLParser.RULE_stmt_perform); + this.enterRule(_localctx, 1464, PostgreSQLParser.RULE_stmt_perform); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10416; - this.match(PostgreSQLParser.PERFORM); - this.state = 10417; + this.state = 10535; + this.match(PostgreSQLParser.KW_PERFORM); + this.state = 10536; this.expr_until_semi(); - this.state = 10418; + this.state = 10537; this.match(PostgreSQLParser.SEMI); } } @@ -59785,42 +60054,42 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_call(): Stmt_callContext { let _localctx: Stmt_callContext = new Stmt_callContext(this._ctx, this.state); - this.enterRule(_localctx, 1440, PostgreSQLParser.RULE_stmt_call); + this.enterRule(_localctx, 1466, PostgreSQLParser.RULE_stmt_call); try { - this.state = 10434; + this.state = 10553; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.CALL: + case PostgreSQLParser.KW_CALL: this.enterOuterAlt(_localctx, 1); { - this.state = 10420; - this.match(PostgreSQLParser.CALL); - this.state = 10421; + this.state = 10539; + this.match(PostgreSQLParser.KW_CALL); + this.state = 10540; this.any_identifier(); - this.state = 10422; + this.state = 10541; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 10423; + this.state = 10542; this.opt_expr_list(); - this.state = 10424; + this.state = 10543; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 10425; + this.state = 10544; this.match(PostgreSQLParser.SEMI); } break; - case PostgreSQLParser.DO: + case PostgreSQLParser.KW_DO: this.enterOuterAlt(_localctx, 2); { - this.state = 10427; - this.match(PostgreSQLParser.DO); - this.state = 10428; + this.state = 10546; + this.match(PostgreSQLParser.KW_DO); + this.state = 10547; this.any_identifier(); - this.state = 10429; + this.state = 10548; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 10430; + this.state = 10549; this.opt_expr_list(); - this.state = 10431; + this.state = 10550; this.match(PostgreSQLParser.CLOSE_PAREN); - this.state = 10432; + this.state = 10551; this.match(PostgreSQLParser.SEMI); } break; @@ -59845,9 +60114,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_expr_list(): Opt_expr_listContext { let _localctx: Opt_expr_listContext = new Opt_expr_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1442, PostgreSQLParser.RULE_opt_expr_list); + this.enterRule(_localctx, 1468, PostgreSQLParser.RULE_opt_expr_list); try { - this.state = 10438; + this.state = 10557; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.CLOSE_PAREN: @@ -59861,434 +60130,434 @@ export class PostgreSQLParser extends PostgreSQLParserBase { 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_CASE: + case PostgreSQLParser.KW_CAST: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_CURRENT_CATALOG: + case PostgreSQLParser.KW_CURRENT_DATE: + case PostgreSQLParser.KW_CURRENT_ROLE: + case PostgreSQLParser.KW_CURRENT_TIME: + case PostgreSQLParser.KW_CURRENT_TIMESTAMP: + case PostgreSQLParser.KW_CURRENT_USER: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FALSE: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_LOCALTIME: + case PostgreSQLParser.KW_LOCALTIMESTAMP: + case PostgreSQLParser.KW_NOT: + case PostgreSQLParser.KW_NULL: + case PostgreSQLParser.KW_SESSION_USER: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_TRUE: + case PostgreSQLParser.KW_UNIQUE: + case PostgreSQLParser.KW_USER: + case PostgreSQLParser.KW_AUTHORIZATION: + case PostgreSQLParser.KW_BINARY: + case PostgreSQLParser.KW_COLLATION: + case PostgreSQLParser.KW_CONCURRENTLY: + case PostgreSQLParser.KW_CROSS: + case PostgreSQLParser.KW_CURRENT_SCHEMA: + case PostgreSQLParser.KW_FREEZE: + case PostgreSQLParser.KW_FULL: + case PostgreSQLParser.KW_ILIKE: + case PostgreSQLParser.KW_INNER: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_ISNULL: + case PostgreSQLParser.KW_JOIN: + case PostgreSQLParser.KW_LEFT: + case PostgreSQLParser.KW_LIKE: + case PostgreSQLParser.KW_NATURAL: + case PostgreSQLParser.KW_NOTNULL: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_OVERLAPS: + case PostgreSQLParser.KW_RIGHT: + case PostgreSQLParser.KW_SIMILAR: + case PostgreSQLParser.KW_VERBOSE: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_TABLESAMPLE: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -60304,7 +60573,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.EscapeStringConstant: this.enterOuterAlt(_localctx, 2); { - this.state = 10437; + this.state = 10556; this.expr_list(); } break; @@ -60329,17 +60598,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_assign(): Stmt_assignContext { let _localctx: Stmt_assignContext = new Stmt_assignContext(this._ctx, this.state); - this.enterRule(_localctx, 1444, PostgreSQLParser.RULE_stmt_assign); + this.enterRule(_localctx, 1470, PostgreSQLParser.RULE_stmt_assign); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10440; + this.state = 10559; this.assign_var(); - this.state = 10441; + this.state = 10560; this.assign_operator(); - this.state = 10442; + this.state = 10561; this.sql_expression(); - this.state = 10443; + this.state = 10562; this.match(PostgreSQLParser.SEMI); } } @@ -60360,19 +60629,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_getdiag(): Stmt_getdiagContext { let _localctx: Stmt_getdiagContext = new Stmt_getdiagContext(this._ctx, this.state); - this.enterRule(_localctx, 1446, PostgreSQLParser.RULE_stmt_getdiag); + this.enterRule(_localctx, 1472, PostgreSQLParser.RULE_stmt_getdiag); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10445; - this.match(PostgreSQLParser.GET); - this.state = 10446; + this.state = 10564; + this.match(PostgreSQLParser.KW_GET); + this.state = 10565; this.getdiag_area_opt(); - this.state = 10447; - this.match(PostgreSQLParser.DIAGNOSTICS); - this.state = 10448; + this.state = 10566; + this.match(PostgreSQLParser.KW_DIAGNOSTICS); + this.state = 10567; this.getdiag_list(); - this.state = 10449; + this.state = 10568; this.match(PostgreSQLParser.SEMI); } } @@ -60393,29 +60662,29 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public getdiag_area_opt(): Getdiag_area_optContext { let _localctx: Getdiag_area_optContext = new Getdiag_area_optContext(this._ctx, this.state); - this.enterRule(_localctx, 1448, PostgreSQLParser.RULE_getdiag_area_opt); + this.enterRule(_localctx, 1474, PostgreSQLParser.RULE_getdiag_area_opt); try { - this.state = 10454; + this.state = 10573; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.DIAGNOSTICS: + case PostgreSQLParser.KW_DIAGNOSTICS: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.CURRENT_P: + case PostgreSQLParser.KW_CURRENT: this.enterOuterAlt(_localctx, 2); { - this.state = 10452; - this.match(PostgreSQLParser.CURRENT_P); + this.state = 10571; + this.match(PostgreSQLParser.KW_CURRENT); } break; - case PostgreSQLParser.STACKED: + case PostgreSQLParser.KW_STACKED: this.enterOuterAlt(_localctx, 3); { - this.state = 10453; - this.match(PostgreSQLParser.STACKED); + this.state = 10572; + this.match(PostgreSQLParser.KW_STACKED); } break; default: @@ -60439,26 +60708,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public getdiag_list(): Getdiag_listContext { let _localctx: Getdiag_listContext = new Getdiag_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1450, PostgreSQLParser.RULE_getdiag_list); + this.enterRule(_localctx, 1476, PostgreSQLParser.RULE_getdiag_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10456; + this.state = 10575; this.getdiag_list_item(); - this.state = 10461; + this.state = 10580; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 10457; + this.state = 10576; this.match(PostgreSQLParser.COMMA); - this.state = 10458; + this.state = 10577; this.getdiag_list_item(); } } - this.state = 10463; + this.state = 10582; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -60481,15 +60750,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public getdiag_list_item(): Getdiag_list_itemContext { let _localctx: Getdiag_list_itemContext = new Getdiag_list_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 1452, PostgreSQLParser.RULE_getdiag_list_item); + this.enterRule(_localctx, 1478, PostgreSQLParser.RULE_getdiag_list_item); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10464; + this.state = 10583; this.getdiag_target(); - this.state = 10465; + this.state = 10584; this.assign_operator(); - this.state = 10466; + this.state = 10585; this.getdiag_item(); } } @@ -60510,11 +60779,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public getdiag_item(): Getdiag_itemContext { let _localctx: Getdiag_itemContext = new Getdiag_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 1454, PostgreSQLParser.RULE_getdiag_item); + this.enterRule(_localctx, 1480, PostgreSQLParser.RULE_getdiag_item); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10468; + this.state = 10587; this.colid(); } } @@ -60535,11 +60804,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public getdiag_target(): Getdiag_targetContext { let _localctx: Getdiag_targetContext = new Getdiag_targetContext(this._ctx, this.state); - this.enterRule(_localctx, 1456, PostgreSQLParser.RULE_getdiag_target); + this.enterRule(_localctx, 1482, PostgreSQLParser.RULE_getdiag_target); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10470; + this.state = 10589; this.assign_var(); } } @@ -60560,438 +60829,438 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public assign_var(): Assign_varContext { let _localctx: Assign_varContext = new Assign_varContext(this._ctx, this.state); - this.enterRule(_localctx, 1458, PostgreSQLParser.RULE_assign_var); + this.enterRule(_localctx, 1484, PostgreSQLParser.RULE_assign_var); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10474; + this.state = 10593; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: case PostgreSQLParser.PLSQLVARIABLENAME: case PostgreSQLParser.PLSQLIDENTIFIER: { - this.state = 10472; + this.state = 10591; this.any_name(); } break; case PostgreSQLParser.PARAM: { - this.state = 10473; + this.state = 10592; this.match(PostgreSQLParser.PARAM); } break; default: throw new NoViableAltException(this); } - this.state = 10482; + this.state = 10601; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.OPEN_BRACKET) { { { - this.state = 10476; + this.state = 10595; this.match(PostgreSQLParser.OPEN_BRACKET); - this.state = 10477; + this.state = 10596; this.expr_until_rightbracket(); - this.state = 10478; + this.state = 10597; this.match(PostgreSQLParser.CLOSE_BRACKET); } } - this.state = 10484; + this.state = 10603; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -61014,27 +61283,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_if(): Stmt_ifContext { let _localctx: Stmt_ifContext = new Stmt_ifContext(this._ctx, this.state); - this.enterRule(_localctx, 1460, PostgreSQLParser.RULE_stmt_if); + this.enterRule(_localctx, 1486, PostgreSQLParser.RULE_stmt_if); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10485; - this.match(PostgreSQLParser.IF_P); - this.state = 10486; + this.state = 10604; + this.match(PostgreSQLParser.KW_IF); + this.state = 10605; this.expr_until_then(); - this.state = 10487; - this.match(PostgreSQLParser.THEN); - this.state = 10488; + this.state = 10606; + this.match(PostgreSQLParser.KW_THEN); + this.state = 10607; this.proc_sect(); - this.state = 10489; + this.state = 10608; this.stmt_elsifs(); - this.state = 10490; + this.state = 10609; this.stmt_else(); - this.state = 10491; - this.match(PostgreSQLParser.END_P); - this.state = 10492; - this.match(PostgreSQLParser.IF_P); - this.state = 10493; + this.state = 10610; + this.match(PostgreSQLParser.KW_END); + this.state = 10611; + this.match(PostgreSQLParser.KW_IF); + this.state = 10612; this.match(PostgreSQLParser.SEMI); } } @@ -61055,28 +61324,28 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_elsifs(): Stmt_elsifsContext { let _localctx: Stmt_elsifsContext = new Stmt_elsifsContext(this._ctx, this.state); - this.enterRule(_localctx, 1462, PostgreSQLParser.RULE_stmt_elsifs); + this.enterRule(_localctx, 1488, PostgreSQLParser.RULE_stmt_elsifs); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10502; + this.state = 10621; this._errHandler.sync(this); _la = this._input.LA(1); - while (_la === PostgreSQLParser.ELSIF) { + while (_la === PostgreSQLParser.KW_ELSIF) { { { - this.state = 10495; - this.match(PostgreSQLParser.ELSIF); - this.state = 10496; + this.state = 10614; + this.match(PostgreSQLParser.KW_ELSIF); + this.state = 10615; this.a_expr(); - this.state = 10497; - this.match(PostgreSQLParser.THEN); - this.state = 10498; + this.state = 10616; + this.match(PostgreSQLParser.KW_THEN); + this.state = 10617; this.proc_sect(); } } - this.state = 10504; + this.state = 10623; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -61099,23 +61368,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_else(): Stmt_elseContext { let _localctx: Stmt_elseContext = new Stmt_elseContext(this._ctx, this.state); - this.enterRule(_localctx, 1464, PostgreSQLParser.RULE_stmt_else); + this.enterRule(_localctx, 1490, PostgreSQLParser.RULE_stmt_else); try { - this.state = 10508; + this.state = 10627; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.END_P: + case PostgreSQLParser.KW_END: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.ELSE: + case PostgreSQLParser.KW_ELSE: this.enterOuterAlt(_localctx, 2); { - this.state = 10506; - this.match(PostgreSQLParser.ELSE); - this.state = 10507; + this.state = 10625; + this.match(PostgreSQLParser.KW_ELSE); + this.state = 10626; this.proc_sect(); } break; @@ -61140,23 +61409,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_case(): Stmt_caseContext { let _localctx: Stmt_caseContext = new Stmt_caseContext(this._ctx, this.state); - this.enterRule(_localctx, 1466, PostgreSQLParser.RULE_stmt_case); + this.enterRule(_localctx, 1492, PostgreSQLParser.RULE_stmt_case); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10510; - this.match(PostgreSQLParser.CASE); - this.state = 10511; + this.state = 10629; + this.match(PostgreSQLParser.KW_CASE); + this.state = 10630; this.opt_expr_until_when(); - this.state = 10512; + this.state = 10631; this.case_when_list(); - this.state = 10513; + this.state = 10632; this.opt_case_else(); - this.state = 10514; - this.match(PostgreSQLParser.END_P); - this.state = 10515; - this.match(PostgreSQLParser.CASE); - this.state = 10516; + this.state = 10633; + this.match(PostgreSQLParser.KW_END); + this.state = 10634; + this.match(PostgreSQLParser.KW_CASE); + this.state = 10635; this.match(PostgreSQLParser.SEMI); } } @@ -61177,11 +61446,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_expr_until_when(): Opt_expr_until_whenContext { let _localctx: Opt_expr_until_whenContext = new Opt_expr_until_whenContext(this._ctx, this.state); - this.enterRule(_localctx, 1468, PostgreSQLParser.RULE_opt_expr_until_when); + this.enterRule(_localctx, 1494, PostgreSQLParser.RULE_opt_expr_until_when); try { - this.state = 10520; + this.state = 10639; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1002, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1022, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty @@ -61192,7 +61461,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10519; + this.state = 10638; this.sql_expression(); } break; @@ -61215,25 +61484,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public case_when_list(): Case_when_listContext { let _localctx: Case_when_listContext = new Case_when_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1470, PostgreSQLParser.RULE_case_when_list); + this.enterRule(_localctx, 1496, PostgreSQLParser.RULE_case_when_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10523; + this.state = 10642; this._errHandler.sync(this); _la = this._input.LA(1); do { { { - this.state = 10522; + this.state = 10641; this.case_when(); } } - this.state = 10525; + this.state = 10644; this._errHandler.sync(this); _la = this._input.LA(1); - } while (_la === PostgreSQLParser.WHEN); + } while (_la === PostgreSQLParser.KW_WHEN); } } catch (re) { @@ -61253,17 +61522,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public case_when(): Case_whenContext { let _localctx: Case_whenContext = new Case_whenContext(this._ctx, this.state); - this.enterRule(_localctx, 1472, PostgreSQLParser.RULE_case_when); + this.enterRule(_localctx, 1498, PostgreSQLParser.RULE_case_when); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10527; - this.match(PostgreSQLParser.WHEN); - this.state = 10528; + this.state = 10646; + this.match(PostgreSQLParser.KW_WHEN); + this.state = 10647; this.expr_list(); - this.state = 10529; - this.match(PostgreSQLParser.THEN); - this.state = 10530; + this.state = 10648; + this.match(PostgreSQLParser.KW_THEN); + this.state = 10649; this.proc_sect(); } } @@ -61284,23 +61553,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_case_else(): Opt_case_elseContext { let _localctx: Opt_case_elseContext = new Opt_case_elseContext(this._ctx, this.state); - this.enterRule(_localctx, 1474, PostgreSQLParser.RULE_opt_case_else); + this.enterRule(_localctx, 1500, PostgreSQLParser.RULE_opt_case_else); try { - this.state = 10535; + this.state = 10654; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.END_P: + case PostgreSQLParser.KW_END: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.ELSE: + case PostgreSQLParser.KW_ELSE: this.enterOuterAlt(_localctx, 2); { - this.state = 10533; - this.match(PostgreSQLParser.ELSE); - this.state = 10534; + this.state = 10652; + this.match(PostgreSQLParser.KW_ELSE); + this.state = 10653; this.proc_sect(); } break; @@ -61325,13 +61594,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_loop(): Stmt_loopContext { let _localctx: Stmt_loopContext = new Stmt_loopContext(this._ctx, this.state); - this.enterRule(_localctx, 1476, PostgreSQLParser.RULE_stmt_loop); + this.enterRule(_localctx, 1502, PostgreSQLParser.RULE_stmt_loop); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10537; + this.state = 10656; this.opt_loop_label(); - this.state = 10538; + this.state = 10657; this.loop_body(); } } @@ -61352,17 +61621,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_while(): Stmt_whileContext { let _localctx: Stmt_whileContext = new Stmt_whileContext(this._ctx, this.state); - this.enterRule(_localctx, 1478, PostgreSQLParser.RULE_stmt_while); + this.enterRule(_localctx, 1504, PostgreSQLParser.RULE_stmt_while); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10540; + this.state = 10659; this.opt_loop_label(); - this.state = 10541; - this.match(PostgreSQLParser.WHILE); - this.state = 10542; + this.state = 10660; + this.match(PostgreSQLParser.KW_WHILE); + this.state = 10661; this.expr_until_loop(); - this.state = 10543; + this.state = 10662; this.loop_body(); } } @@ -61383,17 +61652,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_for(): Stmt_forContext { let _localctx: Stmt_forContext = new Stmt_forContext(this._ctx, this.state); - this.enterRule(_localctx, 1480, PostgreSQLParser.RULE_stmt_for); + this.enterRule(_localctx, 1506, PostgreSQLParser.RULE_stmt_for); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10545; + this.state = 10664; this.opt_loop_label(); - this.state = 10546; - this.match(PostgreSQLParser.FOR); - this.state = 10547; + this.state = 10665; + this.match(PostgreSQLParser.KW_FOR); + this.state = 10666; this.for_control(); - this.state = 10548; + this.state = 10667; this.loop_body(); } } @@ -61414,62 +61683,62 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public for_control(): For_controlContext { let _localctx: For_controlContext = new For_controlContext(this._ctx, this.state); - this.enterRule(_localctx, 1482, PostgreSQLParser.RULE_for_control); + this.enterRule(_localctx, 1508, PostgreSQLParser.RULE_for_control); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10550; + this.state = 10669; this.for_variable(); - this.state = 10551; - this.match(PostgreSQLParser.IN_P); - this.state = 10567; + this.state = 10670; + this.match(PostgreSQLParser.KW_IN); + this.state = 10686; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1005, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1025, this._ctx) ) { case 1: { - this.state = 10552; + this.state = 10671; this.cursor_name(); - this.state = 10553; + this.state = 10672; this.opt_cursor_parameters(); } break; case 2: { - this.state = 10555; + this.state = 10674; this.selectstmt(); } break; case 3: { - this.state = 10556; + this.state = 10675; this.explainstmt(); } break; case 4: { - this.state = 10557; - this.match(PostgreSQLParser.EXECUTE); - this.state = 10558; + this.state = 10676; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 10677; this.a_expr(); - this.state = 10559; + this.state = 10678; this.opt_for_using_expression(); } break; case 5: { - this.state = 10561; + this.state = 10680; this.opt_reverse(); - this.state = 10562; + this.state = 10681; this.a_expr(); - this.state = 10563; + this.state = 10682; this.match(PostgreSQLParser.DOT_DOT); - this.state = 10564; + this.state = 10683; this.a_expr(); - this.state = 10565; + this.state = 10684; this.opt_by_expression(); } break; @@ -61493,24 +61762,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_for_using_expression(): Opt_for_using_expressionContext { let _localctx: Opt_for_using_expressionContext = new Opt_for_using_expressionContext(this._ctx, this.state); - this.enterRule(_localctx, 1484, PostgreSQLParser.RULE_opt_for_using_expression); + this.enterRule(_localctx, 1510, PostgreSQLParser.RULE_opt_for_using_expression); try { - this.state = 10572; + this.state = 10691; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.SEMI: - case PostgreSQLParser.LOOP: + case PostgreSQLParser.KW_LOOP: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.USING: + case PostgreSQLParser.KW_USING: this.enterOuterAlt(_localctx, 2); { - this.state = 10570; - this.match(PostgreSQLParser.USING); - this.state = 10571; + this.state = 10689; + this.match(PostgreSQLParser.KW_USING); + this.state = 10690; this.expr_list(); } break; @@ -61535,13 +61804,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_cursor_parameters(): Opt_cursor_parametersContext { let _localctx: Opt_cursor_parametersContext = new Opt_cursor_parametersContext(this._ctx, this.state); - this.enterRule(_localctx, 1486, PostgreSQLParser.RULE_opt_cursor_parameters); + this.enterRule(_localctx, 1512, PostgreSQLParser.RULE_opt_cursor_parameters); let _la: number; try { - this.state = 10586; + this.state = 10705; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.LOOP: + case PostgreSQLParser.KW_LOOP: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { @@ -61550,27 +61819,27 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.OPEN_PAREN: this.enterOuterAlt(_localctx, 2); { - this.state = 10575; + this.state = 10694; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 10576; + this.state = 10695; this.a_expr(); - this.state = 10581; + this.state = 10700; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 10577; + this.state = 10696; this.match(PostgreSQLParser.COMMA); - this.state = 10578; + this.state = 10697; this.a_expr(); } } - this.state = 10583; + this.state = 10702; this._errHandler.sync(this); _la = this._input.LA(1); } - this.state = 10584; + this.state = 10703; this.match(PostgreSQLParser.CLOSE_PAREN); } break; @@ -61595,11 +61864,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_reverse(): Opt_reverseContext { let _localctx: Opt_reverseContext = new Opt_reverseContext(this._ctx, this.state); - this.enterRule(_localctx, 1488, PostgreSQLParser.RULE_opt_reverse); + this.enterRule(_localctx, 1514, PostgreSQLParser.RULE_opt_reverse); try { - this.state = 10590; + this.state = 10709; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1009, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1029, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty @@ -61610,8 +61879,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10589; - this.match(PostgreSQLParser.REVERSE); + this.state = 10708; + this.match(PostgreSQLParser.KW_REVERSE); } break; } @@ -61633,23 +61902,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_by_expression(): Opt_by_expressionContext { let _localctx: Opt_by_expressionContext = new Opt_by_expressionContext(this._ctx, this.state); - this.enterRule(_localctx, 1490, PostgreSQLParser.RULE_opt_by_expression); + this.enterRule(_localctx, 1516, PostgreSQLParser.RULE_opt_by_expression); try { - this.state = 10595; + this.state = 10714; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.LOOP: + case PostgreSQLParser.KW_LOOP: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.BY: + case PostgreSQLParser.KW_BY: this.enterOuterAlt(_localctx, 2); { - this.state = 10593; - this.match(PostgreSQLParser.BY); - this.state = 10594; + this.state = 10712; + this.match(PostgreSQLParser.KW_BY); + this.state = 10713; this.a_expr(); } break; @@ -61674,11 +61943,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public for_variable(): For_variableContext { let _localctx: For_variableContext = new For_variableContext(this._ctx, this.state); - this.enterRule(_localctx, 1492, PostgreSQLParser.RULE_for_variable); + this.enterRule(_localctx, 1518, PostgreSQLParser.RULE_for_variable); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10597; + this.state = 10716; this.any_name_list(); } } @@ -61699,25 +61968,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_foreach_a(): Stmt_foreach_aContext { let _localctx: Stmt_foreach_aContext = new Stmt_foreach_aContext(this._ctx, this.state); - this.enterRule(_localctx, 1494, PostgreSQLParser.RULE_stmt_foreach_a); + this.enterRule(_localctx, 1520, PostgreSQLParser.RULE_stmt_foreach_a); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10599; + this.state = 10718; this.opt_loop_label(); - this.state = 10600; - this.match(PostgreSQLParser.FOREACH); - this.state = 10601; + this.state = 10719; + this.match(PostgreSQLParser.KW_FOREACH); + this.state = 10720; this.for_variable(); - this.state = 10602; + this.state = 10721; this.foreach_slice(); - this.state = 10603; - this.match(PostgreSQLParser.IN_P); - this.state = 10604; - this.match(PostgreSQLParser.ARRAY); - this.state = 10605; + this.state = 10722; + this.match(PostgreSQLParser.KW_IN); + this.state = 10723; + this.match(PostgreSQLParser.KW_ARRAY); + this.state = 10724; this.a_expr(); - this.state = 10606; + this.state = 10725; this.loop_body(); } } @@ -61738,23 +62007,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public foreach_slice(): Foreach_sliceContext { let _localctx: Foreach_sliceContext = new Foreach_sliceContext(this._ctx, this.state); - this.enterRule(_localctx, 1496, PostgreSQLParser.RULE_foreach_slice); + this.enterRule(_localctx, 1522, PostgreSQLParser.RULE_foreach_slice); try { - this.state = 10611; + this.state = 10730; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.IN_P: + case PostgreSQLParser.KW_IN: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.SLICE: + case PostgreSQLParser.KW_SLICE: this.enterOuterAlt(_localctx, 2); { - this.state = 10609; - this.match(PostgreSQLParser.SLICE); - this.state = 10610; + this.state = 10728; + this.match(PostgreSQLParser.KW_SLICE); + this.state = 10729; this.iconst(); } break; @@ -61779,26 +62048,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_exit(): Stmt_exitContext { let _localctx: Stmt_exitContext = new Stmt_exitContext(this._ctx, this.state); - this.enterRule(_localctx, 1498, PostgreSQLParser.RULE_stmt_exit); + this.enterRule(_localctx, 1524, PostgreSQLParser.RULE_stmt_exit); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10613; + this.state = 10732; this.exit_type(); - this.state = 10614; + this.state = 10733; this.opt_label(); - this.state = 10616; + this.state = 10735; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHEN) { + if (_la === PostgreSQLParser.KW_WHEN) { { - this.state = 10615; + this.state = 10734; this.opt_exitcond(); } } - this.state = 10618; + this.state = 10737; this.match(PostgreSQLParser.SEMI); } } @@ -61819,14 +62088,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public exit_type(): Exit_typeContext { let _localctx: Exit_typeContext = new Exit_typeContext(this._ctx, this.state); - this.enterRule(_localctx, 1500, PostgreSQLParser.RULE_exit_type); + this.enterRule(_localctx, 1526, PostgreSQLParser.RULE_exit_type); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10620; + this.state = 10739; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.CONTINUE_P || _la === PostgreSQLParser.EXIT)) { + if (!(_la === PostgreSQLParser.KW_CONTINUE || _la === PostgreSQLParser.KW_EXIT)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -61855,48 +62124,48 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_return(): Stmt_returnContext { let _localctx: Stmt_returnContext = new Stmt_returnContext(this._ctx, this.state); - this.enterRule(_localctx, 1502, PostgreSQLParser.RULE_stmt_return); + this.enterRule(_localctx, 1528, PostgreSQLParser.RULE_stmt_return); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10622; - this.match(PostgreSQLParser.RETURN); - this.state = 10634; + this.state = 10741; + this.match(PostgreSQLParser.KW_RETURN); + this.state = 10753; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1014, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1034, this._ctx) ) { case 1: { - this.state = 10623; - this.match(PostgreSQLParser.NEXT); - this.state = 10624; + this.state = 10742; + this.match(PostgreSQLParser.KW_NEXT); + this.state = 10743; this.sql_expression(); } break; case 2: { - this.state = 10625; - this.match(PostgreSQLParser.QUERY); - this.state = 10631; + this.state = 10744; + this.match(PostgreSQLParser.KW_QUERY); + this.state = 10750; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.KW_EXECUTE: { - this.state = 10626; - this.match(PostgreSQLParser.EXECUTE); - this.state = 10627; + this.state = 10745; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 10746; this.a_expr(); - this.state = 10628; + this.state = 10747; this.opt_for_using_expression(); } break; case PostgreSQLParser.OPEN_PAREN: - case PostgreSQLParser.SELECT: - case PostgreSQLParser.TABLE: - case PostgreSQLParser.WITH: - case PostgreSQLParser.VALUES: + case PostgreSQLParser.KW_SELECT: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_WITH: + case PostgreSQLParser.KW_VALUES: { - this.state = 10630; + this.state = 10749; this.selectstmt(); } break; @@ -61908,12 +62177,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: { - this.state = 10633; + this.state = 10752; this.opt_return_result(); } break; } - this.state = 10636; + this.state = 10755; this.match(PostgreSQLParser.SEMI); } } @@ -61934,11 +62203,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_return_result(): Opt_return_resultContext { let _localctx: Opt_return_resultContext = new Opt_return_resultContext(this._ctx, this.state); - this.enterRule(_localctx, 1504, PostgreSQLParser.RULE_opt_return_result); + this.enterRule(_localctx, 1530, PostgreSQLParser.RULE_opt_return_result); try { - this.state = 10640; + this.state = 10759; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1015, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1035, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty @@ -61949,7 +62218,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10639; + this.state = 10758; this.sql_expression(); } break; @@ -61972,34 +62241,34 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_raise(): Stmt_raiseContext { let _localctx: Stmt_raiseContext = new Stmt_raiseContext(this._ctx, this.state); - this.enterRule(_localctx, 1506, PostgreSQLParser.RULE_stmt_raise); + this.enterRule(_localctx, 1532, PostgreSQLParser.RULE_stmt_raise); let _la: number; try { - this.state = 10676; + this.state = 10795; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1020, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1040, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10642; - this.match(PostgreSQLParser.RAISE); - this.state = 10644; + this.state = 10761; + this.match(PostgreSQLParser.KW_RAISE); + this.state = 10763; this._errHandler.sync(this); _la = this._input.LA(1); - if (((((_la - 503)) & ~0x1F) === 0 && ((1 << (_la - 503)) & ((1 << (PostgreSQLParser.DEBUG - 503)) | (1 << (PostgreSQLParser.LOG - 503)) | (1 << (PostgreSQLParser.INFO - 503)) | (1 << (PostgreSQLParser.NOTICE - 503)) | (1 << (PostgreSQLParser.WARNING - 503)) | (1 << (PostgreSQLParser.EXCEPTION - 503)))) !== 0)) { + if (((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & ((1 << (PostgreSQLParser.KW_DEBUG - 512)) | (1 << (PostgreSQLParser.KW_LOG - 512)) | (1 << (PostgreSQLParser.KW_INFO - 512)) | (1 << (PostgreSQLParser.KW_NOTICE - 512)) | (1 << (PostgreSQLParser.KW_WARNING - 512)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 512)))) !== 0)) { { - this.state = 10643; + this.state = 10762; this.opt_stmt_raise_level(); } } - this.state = 10646; + this.state = 10765; this.sconst(); - this.state = 10647; + this.state = 10766; this.opt_raise_list(); - this.state = 10648; + this.state = 10767; this.opt_raise_using(); - this.state = 10649; + this.state = 10768; this.match(PostgreSQLParser.SEMI); } break; @@ -62007,23 +62276,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10651; - this.match(PostgreSQLParser.RAISE); - this.state = 10653; + this.state = 10770; + this.match(PostgreSQLParser.KW_RAISE); + this.state = 10772; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1017, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1037, this._ctx) ) { case 1: { - this.state = 10652; + this.state = 10771; this.opt_stmt_raise_level(); } break; } - this.state = 10655; + this.state = 10774; this.identifier(); - this.state = 10656; + this.state = 10775; this.opt_raise_using(); - this.state = 10657; + this.state = 10776; this.match(PostgreSQLParser.SEMI); } break; @@ -62031,25 +62300,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10659; - this.match(PostgreSQLParser.RAISE); - this.state = 10661; + this.state = 10778; + this.match(PostgreSQLParser.KW_RAISE); + this.state = 10780; this._errHandler.sync(this); _la = this._input.LA(1); - if (((((_la - 503)) & ~0x1F) === 0 && ((1 << (_la - 503)) & ((1 << (PostgreSQLParser.DEBUG - 503)) | (1 << (PostgreSQLParser.LOG - 503)) | (1 << (PostgreSQLParser.INFO - 503)) | (1 << (PostgreSQLParser.NOTICE - 503)) | (1 << (PostgreSQLParser.WARNING - 503)) | (1 << (PostgreSQLParser.EXCEPTION - 503)))) !== 0)) { + if (((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & ((1 << (PostgreSQLParser.KW_DEBUG - 512)) | (1 << (PostgreSQLParser.KW_LOG - 512)) | (1 << (PostgreSQLParser.KW_INFO - 512)) | (1 << (PostgreSQLParser.KW_NOTICE - 512)) | (1 << (PostgreSQLParser.KW_WARNING - 512)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 512)))) !== 0)) { { - this.state = 10660; + this.state = 10779; this.opt_stmt_raise_level(); } } - this.state = 10663; - this.match(PostgreSQLParser.SQLSTATE); - this.state = 10664; + this.state = 10782; + this.match(PostgreSQLParser.KW_SQLSTATE); + this.state = 10783; this.sconst(); - this.state = 10665; + this.state = 10784; this.opt_raise_using(); - this.state = 10666; + this.state = 10785; this.match(PostgreSQLParser.SEMI); } break; @@ -62057,21 +62326,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10668; - this.match(PostgreSQLParser.RAISE); - this.state = 10670; + this.state = 10787; + this.match(PostgreSQLParser.KW_RAISE); + this.state = 10789; this._errHandler.sync(this); _la = this._input.LA(1); - if (((((_la - 503)) & ~0x1F) === 0 && ((1 << (_la - 503)) & ((1 << (PostgreSQLParser.DEBUG - 503)) | (1 << (PostgreSQLParser.LOG - 503)) | (1 << (PostgreSQLParser.INFO - 503)) | (1 << (PostgreSQLParser.NOTICE - 503)) | (1 << (PostgreSQLParser.WARNING - 503)) | (1 << (PostgreSQLParser.EXCEPTION - 503)))) !== 0)) { + if (((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & ((1 << (PostgreSQLParser.KW_DEBUG - 512)) | (1 << (PostgreSQLParser.KW_LOG - 512)) | (1 << (PostgreSQLParser.KW_INFO - 512)) | (1 << (PostgreSQLParser.KW_NOTICE - 512)) | (1 << (PostgreSQLParser.KW_WARNING - 512)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 512)))) !== 0)) { { - this.state = 10669; + this.state = 10788; this.opt_stmt_raise_level(); } } - this.state = 10672; + this.state = 10791; this.opt_raise_using(); - this.state = 10673; + this.state = 10792; this.match(PostgreSQLParser.SEMI); } break; @@ -62079,8 +62348,8 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 10675; - this.match(PostgreSQLParser.RAISE); + this.state = 10794; + this.match(PostgreSQLParser.KW_RAISE); } break; } @@ -62102,14 +62371,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_stmt_raise_level(): Opt_stmt_raise_levelContext { let _localctx: Opt_stmt_raise_levelContext = new Opt_stmt_raise_levelContext(this._ctx, this.state); - this.enterRule(_localctx, 1508, PostgreSQLParser.RULE_opt_stmt_raise_level); + this.enterRule(_localctx, 1534, PostgreSQLParser.RULE_opt_stmt_raise_level); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10678; + this.state = 10797; _la = this._input.LA(1); - if (!(((((_la - 503)) & ~0x1F) === 0 && ((1 << (_la - 503)) & ((1 << (PostgreSQLParser.DEBUG - 503)) | (1 << (PostgreSQLParser.LOG - 503)) | (1 << (PostgreSQLParser.INFO - 503)) | (1 << (PostgreSQLParser.NOTICE - 503)) | (1 << (PostgreSQLParser.WARNING - 503)) | (1 << (PostgreSQLParser.EXCEPTION - 503)))) !== 0))) { + if (!(((((_la - 512)) & ~0x1F) === 0 && ((1 << (_la - 512)) & ((1 << (PostgreSQLParser.KW_DEBUG - 512)) | (1 << (PostgreSQLParser.KW_LOG - 512)) | (1 << (PostgreSQLParser.KW_INFO - 512)) | (1 << (PostgreSQLParser.KW_NOTICE - 512)) | (1 << (PostgreSQLParser.KW_WARNING - 512)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 512)))) !== 0))) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -62138,14 +62407,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_raise_list(): Opt_raise_listContext { let _localctx: Opt_raise_listContext = new Opt_raise_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1510, PostgreSQLParser.RULE_opt_raise_list); + this.enterRule(_localctx, 1536, PostgreSQLParser.RULE_opt_raise_list); let _la: number; try { - this.state = 10687; + this.state = 10806; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.SEMI: - case PostgreSQLParser.USING: + case PostgreSQLParser.KW_USING: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { @@ -62154,19 +62423,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.COMMA: this.enterOuterAlt(_localctx, 2); { - this.state = 10683; + this.state = 10802; this._errHandler.sync(this); _la = this._input.LA(1); do { { { - this.state = 10681; + this.state = 10800; this.match(PostgreSQLParser.COMMA); - this.state = 10682; + this.state = 10801; this.a_expr(); } } - this.state = 10685; + this.state = 10804; this._errHandler.sync(this); _la = this._input.LA(1); } while (_la === PostgreSQLParser.COMMA); @@ -62193,9 +62462,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_raise_using(): Opt_raise_usingContext { let _localctx: Opt_raise_usingContext = new Opt_raise_usingContext(this._ctx, this.state); - this.enterRule(_localctx, 1512, PostgreSQLParser.RULE_opt_raise_using); + this.enterRule(_localctx, 1538, PostgreSQLParser.RULE_opt_raise_using); try { - this.state = 10692; + this.state = 10811; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.SEMI: @@ -62204,12 +62473,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { } break; - case PostgreSQLParser.USING: + case PostgreSQLParser.KW_USING: this.enterOuterAlt(_localctx, 2); { - this.state = 10690; - this.match(PostgreSQLParser.USING); - this.state = 10691; + this.state = 10809; + this.match(PostgreSQLParser.KW_USING); + this.state = 10810; this.opt_raise_using_elem_list(); } break; @@ -62234,15 +62503,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_raise_using_elem(): Opt_raise_using_elemContext { let _localctx: Opt_raise_using_elemContext = new Opt_raise_using_elemContext(this._ctx, this.state); - this.enterRule(_localctx, 1514, PostgreSQLParser.RULE_opt_raise_using_elem); + this.enterRule(_localctx, 1540, PostgreSQLParser.RULE_opt_raise_using_elem); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10694; + this.state = 10813; this.identifier(); - this.state = 10695; + this.state = 10814; this.match(PostgreSQLParser.EQUAL); - this.state = 10696; + this.state = 10815; this.a_expr(); } } @@ -62263,26 +62532,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_raise_using_elem_list(): Opt_raise_using_elem_listContext { let _localctx: Opt_raise_using_elem_listContext = new Opt_raise_using_elem_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1516, PostgreSQLParser.RULE_opt_raise_using_elem_list); + this.enterRule(_localctx, 1542, PostgreSQLParser.RULE_opt_raise_using_elem_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10698; + this.state = 10817; this.opt_raise_using_elem(); - this.state = 10703; + this.state = 10822; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 10699; + this.state = 10818; this.match(PostgreSQLParser.COMMA); - this.state = 10700; + this.state = 10819; this.opt_raise_using_elem(); } } - this.state = 10705; + this.state = 10824; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -62305,17 +62574,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_assert(): Stmt_assertContext { let _localctx: Stmt_assertContext = new Stmt_assertContext(this._ctx, this.state); - this.enterRule(_localctx, 1518, PostgreSQLParser.RULE_stmt_assert); + this.enterRule(_localctx, 1544, PostgreSQLParser.RULE_stmt_assert); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10706; - this.match(PostgreSQLParser.ASSERT); - this.state = 10707; + this.state = 10825; + this.match(PostgreSQLParser.KW_ASSERT); + this.state = 10826; this.sql_expression(); - this.state = 10708; + this.state = 10827; this.opt_stmt_assert_message(); - this.state = 10709; + this.state = 10828; this.match(PostgreSQLParser.SEMI); } } @@ -62336,9 +62605,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_stmt_assert_message(): Opt_stmt_assert_messageContext { let _localctx: Opt_stmt_assert_messageContext = new Opt_stmt_assert_messageContext(this._ctx, this.state); - this.enterRule(_localctx, 1520, PostgreSQLParser.RULE_opt_stmt_assert_message); + this.enterRule(_localctx, 1546, PostgreSQLParser.RULE_opt_stmt_assert_message); try { - this.state = 10714; + this.state = 10833; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.SEMI: @@ -62350,9 +62619,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.COMMA: this.enterOuterAlt(_localctx, 2); { - this.state = 10712; + this.state = 10831; this.match(PostgreSQLParser.COMMA); - this.state = 10713; + this.state = 10832; this.sql_expression(); } break; @@ -62377,21 +62646,21 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public loop_body(): Loop_bodyContext { let _localctx: Loop_bodyContext = new Loop_bodyContext(this._ctx, this.state); - this.enterRule(_localctx, 1522, PostgreSQLParser.RULE_loop_body); + this.enterRule(_localctx, 1548, PostgreSQLParser.RULE_loop_body); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10716; - this.match(PostgreSQLParser.LOOP); - this.state = 10717; + this.state = 10835; + this.match(PostgreSQLParser.KW_LOOP); + this.state = 10836; this.proc_sect(); - this.state = 10718; - this.match(PostgreSQLParser.END_P); - this.state = 10719; - this.match(PostgreSQLParser.LOOP); - this.state = 10720; + this.state = 10837; + this.match(PostgreSQLParser.KW_END); + this.state = 10838; + this.match(PostgreSQLParser.KW_LOOP); + this.state = 10839; this.opt_label(); - this.state = 10721; + this.state = 10840; this.match(PostgreSQLParser.SEMI); } } @@ -62412,13 +62681,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_execsql(): Stmt_execsqlContext { let _localctx: Stmt_execsqlContext = new Stmt_execsqlContext(this._ctx, this.state); - this.enterRule(_localctx, 1524, PostgreSQLParser.RULE_stmt_execsql); + this.enterRule(_localctx, 1550, PostgreSQLParser.RULE_stmt_execsql); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10723; + this.state = 10842; this.make_execsql_stmt(); - this.state = 10724; + this.state = 10843; this.match(PostgreSQLParser.SEMI); } } @@ -62439,31 +62708,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_dynexecute(): Stmt_dynexecuteContext { let _localctx: Stmt_dynexecuteContext = new Stmt_dynexecuteContext(this._ctx, this.state); - this.enterRule(_localctx, 1526, PostgreSQLParser.RULE_stmt_dynexecute); + this.enterRule(_localctx, 1552, PostgreSQLParser.RULE_stmt_dynexecute); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10726; - this.match(PostgreSQLParser.EXECUTE); - this.state = 10727; + this.state = 10845; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 10846; this.a_expr(); - this.state = 10735; + this.state = 10854; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1026, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1046, this._ctx) ) { case 1: { - this.state = 10728; + this.state = 10847; this.opt_execute_into(); - this.state = 10729; + this.state = 10848; this.opt_execute_using(); } break; case 2: { - this.state = 10731; + this.state = 10850; this.opt_execute_using(); - this.state = 10732; + this.state = 10851; this.opt_execute_into(); } break; @@ -62474,7 +62743,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } break; } - this.state = 10737; + this.state = 10856; this.match(PostgreSQLParser.SEMI); } } @@ -62495,11 +62764,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_execute_using(): Opt_execute_usingContext { let _localctx: Opt_execute_usingContext = new Opt_execute_usingContext(this._ctx, this.state); - this.enterRule(_localctx, 1528, PostgreSQLParser.RULE_opt_execute_using); + this.enterRule(_localctx, 1554, PostgreSQLParser.RULE_opt_execute_using); try { - this.state = 10742; + this.state = 10861; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1027, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1047, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty @@ -62510,9 +62779,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10740; - this.match(PostgreSQLParser.USING); - this.state = 10741; + this.state = 10859; + this.match(PostgreSQLParser.KW_USING); + this.state = 10860; this.opt_execute_using_list(); } break; @@ -62535,26 +62804,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_execute_using_list(): Opt_execute_using_listContext { let _localctx: Opt_execute_using_listContext = new Opt_execute_using_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1530, PostgreSQLParser.RULE_opt_execute_using_list); + this.enterRule(_localctx, 1556, PostgreSQLParser.RULE_opt_execute_using_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10744; + this.state = 10863; this.a_expr(); - this.state = 10749; + this.state = 10868; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 10745; + this.state = 10864; this.match(PostgreSQLParser.COMMA); - this.state = 10746; + this.state = 10865; this.a_expr(); } } - this.state = 10751; + this.state = 10870; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -62577,11 +62846,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_execute_into(): Opt_execute_intoContext { let _localctx: Opt_execute_intoContext = new Opt_execute_intoContext(this._ctx, this.state); - this.enterRule(_localctx, 1532, PostgreSQLParser.RULE_opt_execute_into); + this.enterRule(_localctx, 1558, PostgreSQLParser.RULE_opt_execute_into); try { - this.state = 10758; + this.state = 10877; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1030, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1050, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty @@ -62592,19 +62861,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10753; - this.match(PostgreSQLParser.INTO); - this.state = 10755; + this.state = 10872; + this.match(PostgreSQLParser.KW_INTO); + this.state = 10874; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1029, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1049, this._ctx) ) { case 1: { - this.state = 10754; - this.match(PostgreSQLParser.STRICT_P); + this.state = 10873; + this.match(PostgreSQLParser.KW_STRICT); } break; } - this.state = 10757; + this.state = 10876; this.into_target(); } break; @@ -62627,44 +62896,44 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_open(): Stmt_openContext { let _localctx: Stmt_openContext = new Stmt_openContext(this._ctx, this.state); - this.enterRule(_localctx, 1534, PostgreSQLParser.RULE_stmt_open); + this.enterRule(_localctx, 1560, PostgreSQLParser.RULE_stmt_open); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10760; - this.match(PostgreSQLParser.OPEN); - this.state = 10778; + this.state = 10879; + this.match(PostgreSQLParser.KW_OPEN); + this.state = 10897; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1033, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1053, this._ctx) ) { case 1: { - this.state = 10761; + this.state = 10880; this.cursor_variable(); - this.state = 10762; + this.state = 10881; this.opt_scroll_option(); - this.state = 10763; - this.match(PostgreSQLParser.FOR); - this.state = 10769; + this.state = 10882; + this.match(PostgreSQLParser.KW_FOR); + this.state = 10888; 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: + case PostgreSQLParser.KW_SELECT: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_WITH: + case PostgreSQLParser.KW_VALUES: { - this.state = 10764; + this.state = 10883; this.selectstmt(); } break; - case PostgreSQLParser.EXECUTE: + case PostgreSQLParser.KW_EXECUTE: { - this.state = 10765; - this.match(PostgreSQLParser.EXECUTE); - this.state = 10766; + this.state = 10884; + this.match(PostgreSQLParser.KW_EXECUTE); + this.state = 10885; this.sql_expression(); - this.state = 10767; + this.state = 10886; this.opt_open_using(); } break; @@ -62676,18 +62945,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: { - this.state = 10771; + this.state = 10890; this.colid(); - this.state = 10776; + this.state = 10895; this._errHandler.sync(this); _la = this._input.LA(1); if (_la === PostgreSQLParser.OPEN_PAREN) { { - this.state = 10772; + this.state = 10891; this.match(PostgreSQLParser.OPEN_PAREN); - this.state = 10773; + this.state = 10892; this.opt_open_bound_list(); - this.state = 10774; + this.state = 10893; this.match(PostgreSQLParser.CLOSE_PAREN); } } @@ -62695,7 +62964,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { } break; } - this.state = 10780; + this.state = 10899; this.match(PostgreSQLParser.SEMI); } } @@ -62716,19 +62985,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_open_bound_list_item(): Opt_open_bound_list_itemContext { let _localctx: Opt_open_bound_list_itemContext = new Opt_open_bound_list_itemContext(this._ctx, this.state); - this.enterRule(_localctx, 1536, PostgreSQLParser.RULE_opt_open_bound_list_item); + this.enterRule(_localctx, 1562, PostgreSQLParser.RULE_opt_open_bound_list_item); try { - this.state = 10787; + this.state = 10906; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1034, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1054, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10782; + this.state = 10901; this.colid(); - this.state = 10783; + this.state = 10902; this.match(PostgreSQLParser.COLON_EQUALS); - this.state = 10784; + this.state = 10903; this.a_expr(); } break; @@ -62736,7 +63005,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10786; + this.state = 10905; this.a_expr(); } break; @@ -62759,26 +63028,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_open_bound_list(): Opt_open_bound_listContext { let _localctx: Opt_open_bound_listContext = new Opt_open_bound_listContext(this._ctx, this.state); - this.enterRule(_localctx, 1538, PostgreSQLParser.RULE_opt_open_bound_list); + this.enterRule(_localctx, 1564, PostgreSQLParser.RULE_opt_open_bound_list); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10789; + this.state = 10908; this.opt_open_bound_list_item(); - this.state = 10794; + this.state = 10913; this._errHandler.sync(this); _la = this._input.LA(1); while (_la === PostgreSQLParser.COMMA) { { { - this.state = 10790; + this.state = 10909; this.match(PostgreSQLParser.COMMA); - this.state = 10791; + this.state = 10910; this.opt_open_bound_list_item(); } } - this.state = 10796; + this.state = 10915; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -62801,9 +63070,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_open_using(): Opt_open_usingContext { let _localctx: Opt_open_usingContext = new Opt_open_usingContext(this._ctx, this.state); - this.enterRule(_localctx, 1540, PostgreSQLParser.RULE_opt_open_using); + this.enterRule(_localctx, 1566, PostgreSQLParser.RULE_opt_open_using); try { - this.state = 10800; + this.state = 10919; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.SEMI: @@ -62812,12 +63081,12 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { } break; - case PostgreSQLParser.USING: + case PostgreSQLParser.KW_USING: this.enterOuterAlt(_localctx, 2); { - this.state = 10798; - this.match(PostgreSQLParser.USING); - this.state = 10799; + this.state = 10917; + this.match(PostgreSQLParser.KW_USING); + this.state = 10918; this.expr_list(); } break; @@ -62842,25 +63111,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_scroll_option(): Opt_scroll_optionContext { let _localctx: Opt_scroll_optionContext = new Opt_scroll_optionContext(this._ctx, this.state); - this.enterRule(_localctx, 1542, PostgreSQLParser.RULE_opt_scroll_option); + this.enterRule(_localctx, 1568, PostgreSQLParser.RULE_opt_scroll_option); try { - this.state = 10806; + this.state = 10925; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.FOR: + case PostgreSQLParser.KW_FOR: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.NO: - case PostgreSQLParser.SCROLL: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_SCROLL: this.enterOuterAlt(_localctx, 2); { - this.state = 10803; + this.state = 10922; this.opt_scroll_option_no(); - this.state = 10804; - this.match(PostgreSQLParser.SCROLL); + this.state = 10923; + this.match(PostgreSQLParser.KW_SCROLL); } break; default: @@ -62884,22 +63153,22 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_scroll_option_no(): Opt_scroll_option_noContext { let _localctx: Opt_scroll_option_noContext = new Opt_scroll_option_noContext(this._ctx, this.state); - this.enterRule(_localctx, 1544, PostgreSQLParser.RULE_opt_scroll_option_no); + this.enterRule(_localctx, 1570, PostgreSQLParser.RULE_opt_scroll_option_no); try { - this.state = 10810; + this.state = 10929; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.SCROLL: + case PostgreSQLParser.KW_SCROLL: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.NO: + case PostgreSQLParser.KW_NO: this.enterOuterAlt(_localctx, 2); { - this.state = 10809; - this.match(PostgreSQLParser.NO); + this.state = 10928; + this.match(PostgreSQLParser.KW_NO); } break; default: @@ -62923,31 +63192,31 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_fetch(): Stmt_fetchContext { let _localctx: Stmt_fetchContext = new Stmt_fetchContext(this._ctx, this.state); - this.enterRule(_localctx, 1546, PostgreSQLParser.RULE_stmt_fetch); + this.enterRule(_localctx, 1572, PostgreSQLParser.RULE_stmt_fetch); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10812; - this.match(PostgreSQLParser.FETCH); - this.state = 10814; + this.state = 10931; + this.match(PostgreSQLParser.KW_FETCH); + this.state = 10933; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1039, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1059, this._ctx) ) { case 1: { - this.state = 10813; + this.state = 10932; _localctx._direction = this.opt_fetch_direction(); } break; } - this.state = 10816; + this.state = 10935; this.opt_cursor_from(); - this.state = 10817; + this.state = 10936; this.cursor_variable(); - this.state = 10818; - this.match(PostgreSQLParser.INTO); - this.state = 10819; + this.state = 10937; + this.match(PostgreSQLParser.KW_INTO); + this.state = 10938; this.into_target(); - this.state = 10820; + this.state = 10939; this.match(PostgreSQLParser.SEMI); } } @@ -62968,11 +63237,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public into_target(): Into_targetContext { let _localctx: Into_targetContext = new Into_targetContext(this._ctx, this.state); - this.enterRule(_localctx, 1548, PostgreSQLParser.RULE_into_target); + this.enterRule(_localctx, 1574, PostgreSQLParser.RULE_into_target); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10822; + this.state = 10941; this.expr_list(); } } @@ -62993,402 +63262,402 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_cursor_from(): Opt_cursor_fromContext { let _localctx: Opt_cursor_fromContext = new Opt_cursor_fromContext(this._ctx, this.state); - this.enterRule(_localctx, 1550, PostgreSQLParser.RULE_opt_cursor_from); + this.enterRule(_localctx, 1576, PostgreSQLParser.RULE_opt_cursor_from); try { - this.state = 10827; + this.state = 10946; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -63399,18 +63668,18 @@ export class PostgreSQLParser extends PostgreSQLParserBase { { } break; - case PostgreSQLParser.FROM: + case PostgreSQLParser.KW_FROM: this.enterOuterAlt(_localctx, 2); { - this.state = 10825; - this.match(PostgreSQLParser.FROM); + this.state = 10944; + this.match(PostgreSQLParser.KW_FROM); } break; - case PostgreSQLParser.IN_P: + case PostgreSQLParser.KW_IN: this.enterOuterAlt(_localctx, 3); { - this.state = 10826; - this.match(PostgreSQLParser.IN_P); + this.state = 10945; + this.match(PostgreSQLParser.KW_IN); } break; default: @@ -63434,50 +63703,50 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_fetch_direction(): Opt_fetch_directionContext { let _localctx: Opt_fetch_directionContext = new Opt_fetch_directionContext(this._ctx, this.state); - this.enterRule(_localctx, 1552, PostgreSQLParser.RULE_opt_fetch_direction); + this.enterRule(_localctx, 1578, PostgreSQLParser.RULE_opt_fetch_direction); let _la: number; try { - this.state = 10844; + this.state = 10963; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1042, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1062, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10829; - this.match(PostgreSQLParser.NEXT); + this.state = 10948; + this.match(PostgreSQLParser.KW_NEXT); } break; case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10830; - this.match(PostgreSQLParser.PRIOR); + this.state = 10949; + this.match(PostgreSQLParser.KW_PRIOR); } break; case 3: this.enterOuterAlt(_localctx, 3); { - this.state = 10831; - this.match(PostgreSQLParser.FIRST_P); + this.state = 10950; + this.match(PostgreSQLParser.KW_FIRST); } break; case 4: this.enterOuterAlt(_localctx, 4); { - this.state = 10832; - this.match(PostgreSQLParser.LAST_P); + this.state = 10951; + this.match(PostgreSQLParser.KW_LAST); } break; case 5: this.enterOuterAlt(_localctx, 5); { - this.state = 10833; - this.match(PostgreSQLParser.ABSOLUTE_P); - this.state = 10834; + this.state = 10952; + this.match(PostgreSQLParser.KW_ABSOLUTE); + this.state = 10953; this.a_expr(); } break; @@ -63485,9 +63754,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 6: this.enterOuterAlt(_localctx, 6); { - this.state = 10835; - this.match(PostgreSQLParser.RELATIVE_P); - this.state = 10836; + this.state = 10954; + this.match(PostgreSQLParser.KW_RELATIVE); + this.state = 10955; this.a_expr(); } break; @@ -63495,7 +63764,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 7: this.enterOuterAlt(_localctx, 7); { - this.state = 10837; + this.state = 10956; this.a_expr(); } break; @@ -63503,17 +63772,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 8: this.enterOuterAlt(_localctx, 8); { - this.state = 10838; - this.match(PostgreSQLParser.ALL); + this.state = 10957; + this.match(PostgreSQLParser.KW_ALL); } break; case 9: this.enterOuterAlt(_localctx, 9); { - this.state = 10839; + this.state = 10958; _la = this._input.LA(1); - if (!(_la === PostgreSQLParser.BACKWARD || _la === PostgreSQLParser.FORWARD)) { + if (!(_la === PostgreSQLParser.KW_BACKWARD || _la === PostgreSQLParser.KW_FORWARD)) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -63523,20 +63792,20 @@ export class PostgreSQLParser extends PostgreSQLParserBase { this._errHandler.reportMatch(this); this.consume(); } - this.state = 10842; + this.state = 10961; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1041, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1061, this._ctx) ) { case 1: { - this.state = 10840; + this.state = 10959; this.a_expr(); } break; case 2: { - this.state = 10841; - this.match(PostgreSQLParser.ALL); + this.state = 10960; + this.match(PostgreSQLParser.KW_ALL); } break; } @@ -63561,25 +63830,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_move(): Stmt_moveContext { let _localctx: Stmt_moveContext = new Stmt_moveContext(this._ctx, this.state); - this.enterRule(_localctx, 1554, PostgreSQLParser.RULE_stmt_move); + this.enterRule(_localctx, 1580, PostgreSQLParser.RULE_stmt_move); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10846; - this.match(PostgreSQLParser.MOVE); - this.state = 10848; + this.state = 10965; + this.match(PostgreSQLParser.KW_MOVE); + this.state = 10967; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1043, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1063, this._ctx) ) { case 1: { - this.state = 10847; + this.state = 10966; this.opt_fetch_direction(); } break; } - this.state = 10850; + this.state = 10969; this.cursor_variable(); - this.state = 10851; + this.state = 10970; this.match(PostgreSQLParser.SEMI); } } @@ -63600,15 +63869,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_close(): Stmt_closeContext { let _localctx: Stmt_closeContext = new Stmt_closeContext(this._ctx, this.state); - this.enterRule(_localctx, 1556, PostgreSQLParser.RULE_stmt_close); + this.enterRule(_localctx, 1582, PostgreSQLParser.RULE_stmt_close); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10853; - this.match(PostgreSQLParser.CLOSE); - this.state = 10854; + this.state = 10972; + this.match(PostgreSQLParser.KW_CLOSE); + this.state = 10973; this.cursor_variable(); - this.state = 10855; + this.state = 10974; this.match(PostgreSQLParser.SEMI); } } @@ -63629,13 +63898,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_null(): Stmt_nullContext { let _localctx: Stmt_nullContext = new Stmt_nullContext(this._ctx, this.state); - this.enterRule(_localctx, 1558, PostgreSQLParser.RULE_stmt_null); + this.enterRule(_localctx, 1584, PostgreSQLParser.RULE_stmt_null); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10857; - this.match(PostgreSQLParser.NULL_P); - this.state = 10858; + this.state = 10976; + this.match(PostgreSQLParser.KW_NULL); + this.state = 10977; this.match(PostgreSQLParser.SEMI); } } @@ -63656,24 +63925,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_commit(): Stmt_commitContext { let _localctx: Stmt_commitContext = new Stmt_commitContext(this._ctx, this.state); - this.enterRule(_localctx, 1560, PostgreSQLParser.RULE_stmt_commit); + this.enterRule(_localctx, 1586, PostgreSQLParser.RULE_stmt_commit); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10860; - this.match(PostgreSQLParser.COMMIT); - this.state = 10862; + this.state = 10979; + this.match(PostgreSQLParser.KW_COMMIT); + this.state = 10981; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AND) { + if (_la === PostgreSQLParser.KW_AND) { { - this.state = 10861; + this.state = 10980; this.plsql_opt_transaction_chain(); } } - this.state = 10864; + this.state = 10983; this.match(PostgreSQLParser.SEMI); } } @@ -63694,24 +63963,24 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_rollback(): Stmt_rollbackContext { let _localctx: Stmt_rollbackContext = new Stmt_rollbackContext(this._ctx, this.state); - this.enterRule(_localctx, 1562, PostgreSQLParser.RULE_stmt_rollback); + this.enterRule(_localctx, 1588, PostgreSQLParser.RULE_stmt_rollback); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10866; - this.match(PostgreSQLParser.ROLLBACK); - this.state = 10868; + this.state = 10985; + this.match(PostgreSQLParser.KW_ROLLBACK); + this.state = 10987; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.AND) { + if (_la === PostgreSQLParser.KW_AND) { { - this.state = 10867; + this.state = 10986; this.plsql_opt_transaction_chain(); } } - this.state = 10870; + this.state = 10989; this.match(PostgreSQLParser.SEMI); } } @@ -63732,25 +64001,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public plsql_opt_transaction_chain(): Plsql_opt_transaction_chainContext { let _localctx: Plsql_opt_transaction_chainContext = new Plsql_opt_transaction_chainContext(this._ctx, this.state); - this.enterRule(_localctx, 1564, PostgreSQLParser.RULE_plsql_opt_transaction_chain); + this.enterRule(_localctx, 1590, PostgreSQLParser.RULE_plsql_opt_transaction_chain); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10872; - this.match(PostgreSQLParser.AND); - this.state = 10874; + this.state = 10991; + this.match(PostgreSQLParser.KW_AND); + this.state = 10993; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.NO) { + if (_la === PostgreSQLParser.KW_NO) { { - this.state = 10873; - this.match(PostgreSQLParser.NO); + this.state = 10992; + this.match(PostgreSQLParser.KW_NO); } } - this.state = 10876; - this.match(PostgreSQLParser.CHAIN); + this.state = 10995; + this.match(PostgreSQLParser.KW_CHAIN); } } catch (re) { @@ -63770,444 +64039,444 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public stmt_set(): Stmt_setContext { let _localctx: Stmt_setContext = new Stmt_setContext(this._ctx, this.state); - this.enterRule(_localctx, 1566, PostgreSQLParser.RULE_stmt_set); + this.enterRule(_localctx, 1592, PostgreSQLParser.RULE_stmt_set); try { - this.state = 10890; + this.state = 11009; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.SET: + case PostgreSQLParser.KW_SET: this.enterOuterAlt(_localctx, 1); { - this.state = 10878; - this.match(PostgreSQLParser.SET); - this.state = 10879; + this.state = 10997; + this.match(PostgreSQLParser.KW_SET); + this.state = 10998; this.any_name(); - this.state = 10880; - this.match(PostgreSQLParser.TO); - this.state = 10881; - this.match(PostgreSQLParser.DEFAULT); - this.state = 10882; + this.state = 10999; + this.match(PostgreSQLParser.KW_TO); + this.state = 11000; + this.match(PostgreSQLParser.KW_DEFAULT); + this.state = 11001; this.match(PostgreSQLParser.SEMI); } break; - case PostgreSQLParser.RESET: + case PostgreSQLParser.KW_RESET: this.enterOuterAlt(_localctx, 2); { - this.state = 10884; - this.match(PostgreSQLParser.RESET); - this.state = 10887; + this.state = 11003; + this.match(PostgreSQLParser.KW_RESET); + this.state = 11006; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: case PostgreSQLParser.PLSQLVARIABLENAME: case PostgreSQLParser.PLSQLIDENTIFIER: { - this.state = 10885; + this.state = 11004; this.any_name(); } break; - case PostgreSQLParser.ALL: + case PostgreSQLParser.KW_ALL: { - this.state = 10886; - this.match(PostgreSQLParser.ALL); + this.state = 11005; + this.match(PostgreSQLParser.KW_ALL); } break; default: throw new NoViableAltException(this); } - this.state = 10889; + this.state = 11008; this.match(PostgreSQLParser.SEMI); } break; @@ -64232,401 +64501,401 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public cursor_variable(): Cursor_variableContext { let _localctx: Cursor_variableContext = new Cursor_variableContext(this._ctx, this.state); - this.enterRule(_localctx, 1568, PostgreSQLParser.RULE_cursor_variable); + this.enterRule(_localctx, 1594, PostgreSQLParser.RULE_cursor_variable); try { - this.state = 10894; + this.state = 11013; 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -64634,14 +64903,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 1); { - this.state = 10892; + this.state = 11011; this.colid(); } break; case PostgreSQLParser.PARAM: this.enterOuterAlt(_localctx, 2); { - this.state = 10893; + this.state = 11012; this.match(PostgreSQLParser.PARAM); } break; @@ -64666,23 +64935,23 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public exception_sect(): Exception_sectContext { let _localctx: Exception_sectContext = new Exception_sectContext(this._ctx, this.state); - this.enterRule(_localctx, 1570, PostgreSQLParser.RULE_exception_sect); + this.enterRule(_localctx, 1596, PostgreSQLParser.RULE_exception_sect); try { - this.state = 10899; + this.state = 11018; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.END_P: + case PostgreSQLParser.KW_END: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } break; - case PostgreSQLParser.EXCEPTION: + case PostgreSQLParser.KW_EXCEPTION: this.enterOuterAlt(_localctx, 2); { - this.state = 10897; - this.match(PostgreSQLParser.EXCEPTION); - this.state = 10898; + this.state = 11016; + this.match(PostgreSQLParser.KW_EXCEPTION); + this.state = 11017; this.proc_exceptions(); } break; @@ -64707,25 +64976,25 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public proc_exceptions(): Proc_exceptionsContext { let _localctx: Proc_exceptionsContext = new Proc_exceptionsContext(this._ctx, this.state); - this.enterRule(_localctx, 1572, PostgreSQLParser.RULE_proc_exceptions); + this.enterRule(_localctx, 1598, PostgreSQLParser.RULE_proc_exceptions); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10902; + this.state = 11021; this._errHandler.sync(this); _la = this._input.LA(1); do { { { - this.state = 10901; + this.state = 11020; this.proc_exception(); } } - this.state = 10904; + this.state = 11023; this._errHandler.sync(this); _la = this._input.LA(1); - } while (_la === PostgreSQLParser.WHEN); + } while (_la === PostgreSQLParser.KW_WHEN); } } catch (re) { @@ -64745,17 +65014,17 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public proc_exception(): Proc_exceptionContext { let _localctx: Proc_exceptionContext = new Proc_exceptionContext(this._ctx, this.state); - this.enterRule(_localctx, 1574, PostgreSQLParser.RULE_proc_exception); + this.enterRule(_localctx, 1600, PostgreSQLParser.RULE_proc_exception); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10906; - this.match(PostgreSQLParser.WHEN); - this.state = 10907; + this.state = 11025; + this.match(PostgreSQLParser.KW_WHEN); + this.state = 11026; this.proc_conditions(); - this.state = 10908; - this.match(PostgreSQLParser.THEN); - this.state = 10909; + this.state = 11027; + this.match(PostgreSQLParser.KW_THEN); + this.state = 11028; this.proc_sect(); } } @@ -64776,26 +65045,26 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public proc_conditions(): Proc_conditionsContext { let _localctx: Proc_conditionsContext = new Proc_conditionsContext(this._ctx, this.state); - this.enterRule(_localctx, 1576, PostgreSQLParser.RULE_proc_conditions); + this.enterRule(_localctx, 1602, PostgreSQLParser.RULE_proc_conditions); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10911; + this.state = 11030; this.proc_condition(); - this.state = 10916; + this.state = 11035; this._errHandler.sync(this); _la = this._input.LA(1); - while (_la === PostgreSQLParser.OR) { + while (_la === PostgreSQLParser.KW_OR) { { { - this.state = 10912; - this.match(PostgreSQLParser.OR); - this.state = 10913; + this.state = 11031; + this.match(PostgreSQLParser.KW_OR); + this.state = 11032; this.proc_condition(); } } - this.state = 10918; + this.state = 11037; this._errHandler.sync(this); _la = this._input.LA(1); } @@ -64818,15 +65087,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public proc_condition(): Proc_conditionContext { let _localctx: Proc_conditionContext = new Proc_conditionContext(this._ctx, this.state); - this.enterRule(_localctx, 1578, PostgreSQLParser.RULE_proc_condition); + this.enterRule(_localctx, 1604, PostgreSQLParser.RULE_proc_condition); try { - this.state = 10922; + this.state = 11041; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1053, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1073, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10919; + this.state = 11038; this.any_identifier(); } break; @@ -64834,9 +65103,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10920; - this.match(PostgreSQLParser.SQLSTATE); - this.state = 10921; + this.state = 11039; + this.match(PostgreSQLParser.KW_SQLSTATE); + this.state = 11040; this.sconst(); } break; @@ -64859,13 +65128,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_block_label(): Opt_block_labelContext { let _localctx: Opt_block_labelContext = new Opt_block_labelContext(this._ctx, this.state); - this.enterRule(_localctx, 1580, PostgreSQLParser.RULE_opt_block_label); + this.enterRule(_localctx, 1606, PostgreSQLParser.RULE_opt_block_label); try { - this.state = 10926; + this.state = 11045; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.BEGIN_P: - case PostgreSQLParser.DECLARE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_DECLARE: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { @@ -64874,7 +65143,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.LESS_LESS: this.enterOuterAlt(_localctx, 2); { - this.state = 10925; + this.state = 11044; this.label_decl(); } break; @@ -64899,15 +65168,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_loop_label(): Opt_loop_labelContext { let _localctx: Opt_loop_labelContext = new Opt_loop_labelContext(this._ctx, this.state); - this.enterRule(_localctx, 1582, PostgreSQLParser.RULE_opt_loop_label); + this.enterRule(_localctx, 1608, PostgreSQLParser.RULE_opt_loop_label); try { - this.state = 10930; + this.state = 11049; this._errHandler.sync(this); switch (this._input.LA(1)) { - case PostgreSQLParser.FOR: - case PostgreSQLParser.WHILE: - case PostgreSQLParser.FOREACH: - case PostgreSQLParser.LOOP: + case PostgreSQLParser.KW_FOR: + case PostgreSQLParser.KW_WHILE: + case PostgreSQLParser.KW_FOREACH: + case PostgreSQLParser.KW_LOOP: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { @@ -64916,7 +65185,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.LESS_LESS: this.enterOuterAlt(_localctx, 2); { - this.state = 10929; + this.state = 11048; this.label_decl(); } break; @@ -64941,409 +65210,409 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_label(): Opt_labelContext { let _localctx: Opt_labelContext = new Opt_labelContext(this._ctx, this.state); - this.enterRule(_localctx, 1584, PostgreSQLParser.RULE_opt_label); + this.enterRule(_localctx, 1610, PostgreSQLParser.RULE_opt_label); try { - this.state = 10934; + this.state = 11053; this._errHandler.sync(this); switch (this._input.LA(1)) { case PostgreSQLParser.EOF: case PostgreSQLParser.SEMI: - case PostgreSQLParser.WHEN: + case PostgreSQLParser.KW_WHEN: this.enterOuterAlt(_localctx, 1); // tslint:disable-next-line:no-empty { } 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.KW_AND: + case PostgreSQLParser.KW_ARRAY: + case PostgreSQLParser.KW_COLLATE: + case PostgreSQLParser.KW_COLUMN: + case PostgreSQLParser.KW_CONSTRAINT: + case PostgreSQLParser.KW_DEFAULT: + case PostgreSQLParser.KW_DO: + case PostgreSQLParser.KW_FETCH: + case PostgreSQLParser.KW_TABLE: + case PostgreSQLParser.KW_IS: + case PostgreSQLParser.KW_OUTER: + case PostgreSQLParser.KW_OVER: + case PostgreSQLParser.KW_ABORT: + case PostgreSQLParser.KW_ABSOLUTE: + case PostgreSQLParser.KW_ACCESS: + case PostgreSQLParser.KW_ACTION: + case PostgreSQLParser.KW_ADD: + case PostgreSQLParser.KW_ADMIN: + case PostgreSQLParser.KW_AFTER: + case PostgreSQLParser.KW_AGGREGATE: + case PostgreSQLParser.KW_ALSO: + case PostgreSQLParser.KW_ALTER: + case PostgreSQLParser.KW_ALWAYS: + case PostgreSQLParser.KW_ASSERTION: + case PostgreSQLParser.KW_ASSIGNMENT: + case PostgreSQLParser.KW_AT: + case PostgreSQLParser.KW_ATTRIBUTE: + case PostgreSQLParser.KW_BACKWARD: + case PostgreSQLParser.KW_BEFORE: + case PostgreSQLParser.KW_BEGIN: + case PostgreSQLParser.KW_BY: + case PostgreSQLParser.KW_CACHE: + case PostgreSQLParser.KW_CALLED: + case PostgreSQLParser.KW_CASCADE: + case PostgreSQLParser.KW_CASCADED: + case PostgreSQLParser.KW_CATALOG: + case PostgreSQLParser.KW_CHAIN: + case PostgreSQLParser.KW_CHARACTERISTICS: + case PostgreSQLParser.KW_CHECKPOINT: + case PostgreSQLParser.KW_CLASS: + case PostgreSQLParser.KW_CLOSE: + case PostgreSQLParser.KW_CLUSTER: + case PostgreSQLParser.KW_COMMENT: + case PostgreSQLParser.KW_COMMENTS: + case PostgreSQLParser.KW_COMMIT: + case PostgreSQLParser.KW_COMMITTED: + case PostgreSQLParser.KW_CONFIGURATION: + case PostgreSQLParser.KW_CONNECTION: + case PostgreSQLParser.KW_CONSTRAINTS: + case PostgreSQLParser.KW_CONTENT: + case PostgreSQLParser.KW_CONTINUE: + case PostgreSQLParser.KW_CONVERSION: + case PostgreSQLParser.KW_COPY: + case PostgreSQLParser.KW_COST: + case PostgreSQLParser.KW_CSV: + case PostgreSQLParser.KW_CURSOR: + case PostgreSQLParser.KW_CYCLE: + case PostgreSQLParser.KW_DATA: + case PostgreSQLParser.KW_DATABASE: + case PostgreSQLParser.KW_DAY: + case PostgreSQLParser.KW_DEALLOCATE: + case PostgreSQLParser.KW_DECLARE: + case PostgreSQLParser.KW_DEFAULTS: + case PostgreSQLParser.KW_DEFERRED: + case PostgreSQLParser.KW_DEFINER: + case PostgreSQLParser.KW_DELETE: + case PostgreSQLParser.KW_DELIMITER: + case PostgreSQLParser.KW_DELIMITERS: + case PostgreSQLParser.KW_DICTIONARY: + case PostgreSQLParser.KW_DISABLE: + case PostgreSQLParser.KW_DISCARD: + case PostgreSQLParser.KW_DOCUMENT: + case PostgreSQLParser.KW_DOMAIN: + case PostgreSQLParser.KW_DOUBLE: + case PostgreSQLParser.KW_DROP: + case PostgreSQLParser.KW_EACH: + case PostgreSQLParser.KW_ENABLE: + case PostgreSQLParser.KW_ENCODING: + case PostgreSQLParser.KW_ENCRYPTED: + case PostgreSQLParser.KW_ENUM: + case PostgreSQLParser.KW_ESCAPE: + case PostgreSQLParser.KW_EVENT: + case PostgreSQLParser.KW_EXCLUDE: + case PostgreSQLParser.KW_EXCLUDING: + case PostgreSQLParser.KW_EXCLUSIVE: + case PostgreSQLParser.KW_EXECUTE: + case PostgreSQLParser.KW_EXPLAIN: + case PostgreSQLParser.KW_EXTENSION: + case PostgreSQLParser.KW_EXTERNAL: + case PostgreSQLParser.KW_FAMILY: + case PostgreSQLParser.KW_FIRST: + case PostgreSQLParser.KW_FOLLOWING: + case PostgreSQLParser.KW_FORCE: + case PostgreSQLParser.KW_FORWARD: + case PostgreSQLParser.KW_FUNCTION: + case PostgreSQLParser.KW_FUNCTIONS: + case PostgreSQLParser.KW_GLOBAL: + case PostgreSQLParser.KW_GRANTED: + case PostgreSQLParser.KW_HANDLER: + case PostgreSQLParser.KW_HEADER: + case PostgreSQLParser.KW_HOLD: + case PostgreSQLParser.KW_HOUR: + case PostgreSQLParser.KW_IDENTITY: + case PostgreSQLParser.KW_IF: + case PostgreSQLParser.KW_IMMEDIATE: + case PostgreSQLParser.KW_IMMUTABLE: + case PostgreSQLParser.KW_IMPLICIT: + case PostgreSQLParser.KW_INCLUDING: + case PostgreSQLParser.KW_INCREMENT: + case PostgreSQLParser.KW_INDEX: + case PostgreSQLParser.KW_INDEXES: + case PostgreSQLParser.KW_INHERIT: + case PostgreSQLParser.KW_INHERITS: + case PostgreSQLParser.KW_INLINE: + case PostgreSQLParser.KW_INSENSITIVE: + case PostgreSQLParser.KW_INSERT: + case PostgreSQLParser.KW_INSTEAD: + case PostgreSQLParser.KW_INVOKER: + case PostgreSQLParser.KW_ISOLATION: + case PostgreSQLParser.KW_KEY: + case PostgreSQLParser.KW_LABEL: + case PostgreSQLParser.KW_LANGUAGE: + case PostgreSQLParser.KW_LARGE: + case PostgreSQLParser.KW_LAST: + case PostgreSQLParser.KW_LEAKPROOF: + case PostgreSQLParser.KW_LEVEL: + case PostgreSQLParser.KW_LISTEN: + case PostgreSQLParser.KW_LOAD: + case PostgreSQLParser.KW_LOCAL: + case PostgreSQLParser.KW_LOCATION: + case PostgreSQLParser.KW_LOCK: + case PostgreSQLParser.KW_MAPPING: + case PostgreSQLParser.KW_MATCH: + case PostgreSQLParser.KW_MATERIALIZED: + case PostgreSQLParser.KW_MAXVALUE: + case PostgreSQLParser.KW_MINUTE: + case PostgreSQLParser.KW_MINVALUE: + case PostgreSQLParser.KW_MODE: + case PostgreSQLParser.KW_MONTH: + case PostgreSQLParser.KW_MOVE: + case PostgreSQLParser.KW_NAME: + case PostgreSQLParser.KW_NAMES: + case PostgreSQLParser.KW_NEXT: + case PostgreSQLParser.KW_NO: + case PostgreSQLParser.KW_NOTHING: + case PostgreSQLParser.KW_NOTIFY: + case PostgreSQLParser.KW_NOWAIT: + case PostgreSQLParser.KW_NULLS: + case PostgreSQLParser.KW_OBJECT: + case PostgreSQLParser.KW_OF: + case PostgreSQLParser.KW_OFF: + case PostgreSQLParser.KW_OIDS: + case PostgreSQLParser.KW_OPERATOR: + case PostgreSQLParser.KW_OPTION: + case PostgreSQLParser.KW_OPTIONS: + case PostgreSQLParser.KW_OWNED: + case PostgreSQLParser.KW_OWNER: + case PostgreSQLParser.KW_PARSER: + case PostgreSQLParser.KW_PARTIAL: + case PostgreSQLParser.KW_PARTITION: + case PostgreSQLParser.KW_PASSING: + case PostgreSQLParser.KW_PASSWORD: + case PostgreSQLParser.KW_PLANS: + case PostgreSQLParser.KW_PRECEDING: + case PostgreSQLParser.KW_PREPARE: + case PostgreSQLParser.KW_PREPARED: + case PostgreSQLParser.KW_PRESERVE: + case PostgreSQLParser.KW_PRIOR: + case PostgreSQLParser.KW_PRIVILEGES: + case PostgreSQLParser.KW_PROCEDURAL: + case PostgreSQLParser.KW_PROCEDURE: + case PostgreSQLParser.KW_PROGRAM: + case PostgreSQLParser.KW_QUOTE: + case PostgreSQLParser.KW_RANGE: + case PostgreSQLParser.KW_READ: + case PostgreSQLParser.KW_REASSIGN: + case PostgreSQLParser.KW_RECHECK: + case PostgreSQLParser.KW_RECURSIVE: + case PostgreSQLParser.KW_REF: + case PostgreSQLParser.KW_REFRESH: + case PostgreSQLParser.KW_REINDEX: + case PostgreSQLParser.KW_RELATIVE: + case PostgreSQLParser.KW_RELEASE: + case PostgreSQLParser.KW_RENAME: + case PostgreSQLParser.KW_REPEATABLE: + case PostgreSQLParser.KW_REPLACE: + case PostgreSQLParser.KW_REPLICA: + case PostgreSQLParser.KW_RESET: + case PostgreSQLParser.KW_RESTART: + case PostgreSQLParser.KW_RESTRICT: + case PostgreSQLParser.KW_RETURNS: + case PostgreSQLParser.KW_REVOKE: + case PostgreSQLParser.KW_ROLE: + case PostgreSQLParser.KW_ROLLBACK: + case PostgreSQLParser.KW_ROWS: + case PostgreSQLParser.KW_RULE: + case PostgreSQLParser.KW_SAVEPOINT: + case PostgreSQLParser.KW_SCHEMA: + case PostgreSQLParser.KW_SCROLL: + case PostgreSQLParser.KW_SEARCH: + case PostgreSQLParser.KW_SECOND: + case PostgreSQLParser.KW_SECURITY: + case PostgreSQLParser.KW_SEQUENCE: + case PostgreSQLParser.KW_SEQUENCES: + case PostgreSQLParser.KW_SERIALIZABLE: + case PostgreSQLParser.KW_SERVER: + case PostgreSQLParser.KW_SESSION: + case PostgreSQLParser.KW_SET: + case PostgreSQLParser.KW_SHARE: + case PostgreSQLParser.KW_SHOW: + case PostgreSQLParser.KW_SIMPLE: + case PostgreSQLParser.KW_SNAPSHOT: + case PostgreSQLParser.KW_STABLE: + case PostgreSQLParser.KW_STANDALONE: + case PostgreSQLParser.KW_START: + case PostgreSQLParser.KW_STATEMENT: + case PostgreSQLParser.KW_STATISTICS: + case PostgreSQLParser.KW_STDIN: + case PostgreSQLParser.KW_STDOUT: + case PostgreSQLParser.KW_STORAGE: + case PostgreSQLParser.KW_STRICT: + case PostgreSQLParser.KW_STRIP: + case PostgreSQLParser.KW_SYSID: + case PostgreSQLParser.KW_SYSTEM: + case PostgreSQLParser.KW_TABLES: + case PostgreSQLParser.KW_TABLESPACE: + case PostgreSQLParser.KW_TEMP: + case PostgreSQLParser.KW_TEMPLATE: + case PostgreSQLParser.KW_TEMPORARY: + case PostgreSQLParser.KW_TEXT: + case PostgreSQLParser.KW_TRANSACTION: + case PostgreSQLParser.KW_TRIGGER: + case PostgreSQLParser.KW_TRUNCATE: + case PostgreSQLParser.KW_TRUSTED: + case PostgreSQLParser.KW_TYPE: + case PostgreSQLParser.KW_TYPES: + case PostgreSQLParser.KW_UNBOUNDED: + case PostgreSQLParser.KW_UNCOMMITTED: + case PostgreSQLParser.KW_UNENCRYPTED: + case PostgreSQLParser.KW_UNKNOWN: + case PostgreSQLParser.KW_UNLISTEN: + case PostgreSQLParser.KW_UNLOGGED: + case PostgreSQLParser.KW_UNTIL: + case PostgreSQLParser.KW_UPDATE: + case PostgreSQLParser.KW_VACUUM: + case PostgreSQLParser.KW_VALID: + case PostgreSQLParser.KW_VALIDATE: + case PostgreSQLParser.KW_VALIDATOR: + case PostgreSQLParser.KW_VARYING: + case PostgreSQLParser.KW_VERSION: + case PostgreSQLParser.KW_VIEW: + case PostgreSQLParser.KW_VOLATILE: + case PostgreSQLParser.KW_WHITESPACE: + case PostgreSQLParser.KW_WITHOUT: + case PostgreSQLParser.KW_WORK: + case PostgreSQLParser.KW_WRAPPER: + case PostgreSQLParser.KW_WRITE: + case PostgreSQLParser.KW_XML: + case PostgreSQLParser.KW_YEAR: + case PostgreSQLParser.KW_YES: + case PostgreSQLParser.KW_ZONE: + case PostgreSQLParser.KW_BETWEEN: + case PostgreSQLParser.KW_BIGINT: + case PostgreSQLParser.KW_BIT: + case PostgreSQLParser.KW_BOOLEAN: + case PostgreSQLParser.KW_CHAR: + case PostgreSQLParser.KW_CHARACTER: + case PostgreSQLParser.KW_COALESCE: + case PostgreSQLParser.KW_DEC: + case PostgreSQLParser.KW_DECIMAL: + case PostgreSQLParser.KW_EXISTS: + case PostgreSQLParser.KW_EXTRACT: + case PostgreSQLParser.KW_FLOAT: + case PostgreSQLParser.KW_GREATEST: + case PostgreSQLParser.KW_INOUT: + case PostgreSQLParser.KW_INT: + case PostgreSQLParser.KW_INTEGER: + case PostgreSQLParser.KW_INTERVAL: + case PostgreSQLParser.KW_LEAST: + case PostgreSQLParser.KW_NATIONAL: + case PostgreSQLParser.KW_NCHAR: + case PostgreSQLParser.KW_NONE: + case PostgreSQLParser.KW_NULLIF: + case PostgreSQLParser.KW_NUMERIC: + case PostgreSQLParser.KW_OVERLAY: + case PostgreSQLParser.KW_POSITION: + case PostgreSQLParser.KW_PRECISION: + case PostgreSQLParser.KW_REAL: + case PostgreSQLParser.KW_ROW: + case PostgreSQLParser.KW_SETOF: + case PostgreSQLParser.KW_SMALLINT: + case PostgreSQLParser.KW_SUBSTRING: + case PostgreSQLParser.KW_TIME: + case PostgreSQLParser.KW_TIMESTAMP: + case PostgreSQLParser.KW_TREAT: + case PostgreSQLParser.KW_TRIM: + case PostgreSQLParser.KW_VALUES: + case PostgreSQLParser.KW_VARCHAR: + case PostgreSQLParser.KW_XMLATTRIBUTES: + case PostgreSQLParser.KW_XMLCONCAT: + case PostgreSQLParser.KW_XMLELEMENT: + case PostgreSQLParser.KW_XMLEXISTS: + case PostgreSQLParser.KW_XMLFOREST: + case PostgreSQLParser.KW_XMLPARSE: + case PostgreSQLParser.KW_XMLPI: + case PostgreSQLParser.KW_XMLROOT: + case PostgreSQLParser.KW_XMLSERIALIZE: + case PostgreSQLParser.KW_CALL: + case PostgreSQLParser.KW_CURRENT: + case PostgreSQLParser.KW_ATTACH: + case PostgreSQLParser.KW_DETACH: + case PostgreSQLParser.KW_EXPRESSION: + case PostgreSQLParser.KW_GENERATED: + case PostgreSQLParser.KW_LOGGED: + case PostgreSQLParser.KW_STORED: + case PostgreSQLParser.KW_INCLUDE: + case PostgreSQLParser.KW_ROUTINE: + case PostgreSQLParser.KW_TRANSFORM: + case PostgreSQLParser.KW_IMPORT: + case PostgreSQLParser.KW_POLICY: + case PostgreSQLParser.KW_METHOD: + case PostgreSQLParser.KW_REFERENCING: + case PostgreSQLParser.KW_NEW: + case PostgreSQLParser.KW_OLD: + case PostgreSQLParser.KW_VALUE: + case PostgreSQLParser.KW_SUBSCRIPTION: + case PostgreSQLParser.KW_PUBLICATION: + case PostgreSQLParser.KW_OUT: + case PostgreSQLParser.KW_ROUTINES: + case PostgreSQLParser.KW_SCHEMAS: + case PostgreSQLParser.KW_PROCEDURES: + case PostgreSQLParser.KW_INPUT: + case PostgreSQLParser.KW_SUPPORT: + case PostgreSQLParser.KW_PARALLEL: + case PostgreSQLParser.KW_SQL: + case PostgreSQLParser.KW_DEPENDS: + case PostgreSQLParser.KW_OVERRIDING: + case PostgreSQLParser.KW_CONFLICT: + case PostgreSQLParser.KW_SKIP: + case PostgreSQLParser.KW_LOCKED: + case PostgreSQLParser.KW_TIES: + case PostgreSQLParser.KW_ROLLUP: + case PostgreSQLParser.KW_CUBE: + case PostgreSQLParser.KW_GROUPING: + case PostgreSQLParser.KW_SETS: + case PostgreSQLParser.KW_ORDINALITY: + case PostgreSQLParser.KW_XMLTABLE: + case PostgreSQLParser.KW_COLUMNS: + case PostgreSQLParser.KW_XMLNAMESPACES: + case PostgreSQLParser.KW_ROWTYPE: + case PostgreSQLParser.KW_NORMALIZED: + case PostgreSQLParser.KW_WITHIN: + case PostgreSQLParser.KW_FILTER: + case PostgreSQLParser.KW_GROUPS: + case PostgreSQLParser.KW_OTHERS: + case PostgreSQLParser.KW_NFC: + case PostgreSQLParser.KW_NFD: + case PostgreSQLParser.KW_NFKC: + case PostgreSQLParser.KW_NFKD: + case PostgreSQLParser.KW_UESCAPE: + case PostgreSQLParser.KW_VIEWS: + case PostgreSQLParser.KW_NORMALIZE: + case PostgreSQLParser.KW_DUMP: + case PostgreSQLParser.KW_PRINT_STRICT_PARAMS: + case PostgreSQLParser.KW_VARIABLE_CONFLICT: + case PostgreSQLParser.KW_ERROR: + case PostgreSQLParser.KW_USE_VARIABLE: + case PostgreSQLParser.KW_USE_COLUMN: + case PostgreSQLParser.KW_ALIAS: + case PostgreSQLParser.KW_CONSTANT: + case PostgreSQLParser.KW_PERFORM: + case PostgreSQLParser.KW_GET: + case PostgreSQLParser.KW_DIAGNOSTICS: + case PostgreSQLParser.KW_STACKED: + case PostgreSQLParser.KW_ELSIF: + case PostgreSQLParser.KW_REVERSE: + case PostgreSQLParser.KW_SLICE: + case PostgreSQLParser.KW_EXIT: + case PostgreSQLParser.KW_RETURN: + case PostgreSQLParser.KW_QUERY: + case PostgreSQLParser.KW_RAISE: + case PostgreSQLParser.KW_SQLSTATE: + case PostgreSQLParser.KW_DEBUG: + case PostgreSQLParser.KW_LOG: + case PostgreSQLParser.KW_INFO: + case PostgreSQLParser.KW_NOTICE: + case PostgreSQLParser.KW_WARNING: + case PostgreSQLParser.KW_EXCEPTION: + case PostgreSQLParser.KW_ASSERT: + case PostgreSQLParser.KW_OPEN: case PostgreSQLParser.Identifier: case PostgreSQLParser.QuotedIdentifier: case PostgreSQLParser.UnicodeQuotedIdentifier: @@ -65351,7 +65620,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case PostgreSQLParser.PLSQLIDENTIFIER: this.enterOuterAlt(_localctx, 2); { - this.state = 10933; + this.state = 11052; this.any_identifier(); } break; @@ -65376,13 +65645,13 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_exitcond(): Opt_exitcondContext { let _localctx: Opt_exitcondContext = new Opt_exitcondContext(this._ctx, this.state); - this.enterRule(_localctx, 1586, PostgreSQLParser.RULE_opt_exitcond); + this.enterRule(_localctx, 1612, PostgreSQLParser.RULE_opt_exitcond); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10936; - this.match(PostgreSQLParser.WHEN); - this.state = 10937; + this.state = 11055; + this.match(PostgreSQLParser.KW_WHEN); + this.state = 11056; this.expr_until_semi(); } } @@ -65403,15 +65672,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public any_identifier(): Any_identifierContext { let _localctx: Any_identifierContext = new Any_identifierContext(this._ctx, this.state); - this.enterRule(_localctx, 1588, PostgreSQLParser.RULE_any_identifier); + this.enterRule(_localctx, 1614, PostgreSQLParser.RULE_any_identifier); try { - this.state = 10941; + this.state = 11060; this._errHandler.sync(this); - switch ( this.interpreter.adaptivePredict(this._input, 1057, this._ctx) ) { + switch ( this.interpreter.adaptivePredict(this._input, 1077, this._ctx) ) { case 1: this.enterOuterAlt(_localctx, 1); { - this.state = 10939; + this.state = 11058; this.colid(); } break; @@ -65419,7 +65688,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { case 2: this.enterOuterAlt(_localctx, 2); { - this.state = 10940; + this.state = 11059; this.plsql_unreserved_keyword(); } break; @@ -65442,14 +65711,14 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public plsql_unreserved_keyword(): Plsql_unreserved_keywordContext { let _localctx: Plsql_unreserved_keywordContext = new Plsql_unreserved_keywordContext(this._ctx, this.state); - this.enterRule(_localctx, 1590, PostgreSQLParser.RULE_plsql_unreserved_keyword); + this.enterRule(_localctx, 1616, PostgreSQLParser.RULE_plsql_unreserved_keyword); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10943; + this.state = 11062; _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))) { + if (!(((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 92)) & ~0x1F) === 0 && ((1 << (_la - 92)) & ((1 << (PostgreSQLParser.KW_TABLE - 92)) | (1 << (PostgreSQLParser.KW_IS - 92)) | (1 << (PostgreSQLParser.KW_OUTER - 92)))) !== 0) || ((((_la - 130)) & ~0x1F) === 0 && ((1 << (_la - 130)) & ((1 << (PostgreSQLParser.KW_ABSOLUTE - 130)) | (1 << (PostgreSQLParser.KW_BACKWARD - 130)) | (1 << (PostgreSQLParser.KW_CHAIN - 130)) | (1 << (PostgreSQLParser.KW_CLOSE - 130)) | (1 << (PostgreSQLParser.KW_COMMIT - 130)))) !== 0) || _la === PostgreSQLParser.KW_CONTINUE || _la === PostgreSQLParser.KW_CURSOR || _la === PostgreSQLParser.KW_FIRST || _la === PostgreSQLParser.KW_FORWARD || ((((_la - 241)) & ~0x1F) === 0 && ((1 << (_la - 241)) & ((1 << (PostgreSQLParser.KW_INSERT - 241)) | (1 << (PostgreSQLParser.KW_LAST - 241)) | (1 << (PostgreSQLParser.KW_MOVE - 241)) | (1 << (PostgreSQLParser.KW_NEXT - 241)) | (1 << (PostgreSQLParser.KW_NO - 241)))) !== 0) || ((((_la - 279)) & ~0x1F) === 0 && ((1 << (_la - 279)) & ((1 << (PostgreSQLParser.KW_OPTION - 279)) | (1 << (PostgreSQLParser.KW_PRIOR - 279)) | (1 << (PostgreSQLParser.KW_RELATIVE - 279)))) !== 0) || ((((_la - 313)) & ~0x1F) === 0 && ((1 << (_la - 313)) & ((1 << (PostgreSQLParser.KW_RESET - 313)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 313)) | (1 << (PostgreSQLParser.KW_SCHEMA - 313)) | (1 << (PostgreSQLParser.KW_SCROLL - 313)) | (1 << (PostgreSQLParser.KW_SET - 313)))) !== 0) || _la === PostgreSQLParser.KW_TYPE || _la === PostgreSQLParser.KW_CALL || _la === PostgreSQLParser.KW_CURRENT || ((((_la - 477)) & ~0x1F) === 0 && ((1 << (_la - 477)) & ((1 << (PostgreSQLParser.KW_ROWTYPE - 477)) | (1 << (PostgreSQLParser.KW_DUMP - 477)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 477)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 477)) | (1 << (PostgreSQLParser.KW_ERROR - 477)) | (1 << (PostgreSQLParser.KW_USE_VARIABLE - 477)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 477)) | (1 << (PostgreSQLParser.KW_ALIAS - 477)) | (1 << (PostgreSQLParser.KW_CONSTANT - 477)) | (1 << (PostgreSQLParser.KW_PERFORM - 477)) | (1 << (PostgreSQLParser.KW_GET - 477)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 477)) | (1 << (PostgreSQLParser.KW_STACKED - 477)) | (1 << (PostgreSQLParser.KW_ELSIF - 477)) | (1 << (PostgreSQLParser.KW_REVERSE - 477)) | (1 << (PostgreSQLParser.KW_SLICE - 477)) | (1 << (PostgreSQLParser.KW_EXIT - 477)) | (1 << (PostgreSQLParser.KW_RETURN - 477)))) !== 0) || ((((_la - 509)) & ~0x1F) === 0 && ((1 << (_la - 509)) & ((1 << (PostgreSQLParser.KW_QUERY - 509)) | (1 << (PostgreSQLParser.KW_RAISE - 509)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 509)) | (1 << (PostgreSQLParser.KW_DEBUG - 509)) | (1 << (PostgreSQLParser.KW_LOG - 509)) | (1 << (PostgreSQLParser.KW_INFO - 509)) | (1 << (PostgreSQLParser.KW_NOTICE - 509)) | (1 << (PostgreSQLParser.KW_WARNING - 509)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 509)) | (1 << (PostgreSQLParser.KW_ASSERT - 509)) | (1 << (PostgreSQLParser.KW_OPEN - 509)))) !== 0))) { this._errHandler.recoverInline(this); } else { if (this._input.LA(1) === Token.EOF) { @@ -65478,77 +65747,77 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public sql_expression(): Sql_expressionContext { let _localctx: Sql_expressionContext = new Sql_expressionContext(this._ctx, this.state); - this.enterRule(_localctx, 1592, PostgreSQLParser.RULE_sql_expression); + this.enterRule(_localctx, 1618, PostgreSQLParser.RULE_sql_expression); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10946; + this.state = 11065; this._errHandler.sync(this); _la = this._input.LA(1); - if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << PostgreSQLParser.OPEN_PAREN) | (1 << PostgreSQLParser.STAR) | (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)) { + if ((((_la) & ~0x1F) === 0 && ((1 << _la) & ((1 << PostgreSQLParser.OPEN_PAREN) | (1 << PostgreSQLParser.STAR) | (1 << PostgreSQLParser.PLUS) | (1 << PostgreSQLParser.MINUS) | (1 << PostgreSQLParser.PARAM) | (1 << PostgreSQLParser.Operator))) !== 0) || ((((_la - 33)) & ~0x1F) === 0 && ((1 << (_la - 33)) & ((1 << (PostgreSQLParser.KW_AND - 33)) | (1 << (PostgreSQLParser.KW_ARRAY - 33)) | (1 << (PostgreSQLParser.KW_CASE - 33)) | (1 << (PostgreSQLParser.KW_CAST - 33)) | (1 << (PostgreSQLParser.KW_COLLATE - 33)) | (1 << (PostgreSQLParser.KW_COLUMN - 33)) | (1 << (PostgreSQLParser.KW_CONSTRAINT - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_CATALOG - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_DATE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_ROLE - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIME - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_TIMESTAMP - 33)) | (1 << (PostgreSQLParser.KW_CURRENT_USER - 33)) | (1 << (PostgreSQLParser.KW_DEFAULT - 33)) | (1 << (PostgreSQLParser.KW_DO - 33)) | (1 << (PostgreSQLParser.KW_FALSE - 33)) | (1 << (PostgreSQLParser.KW_FETCH - 33)))) !== 0) || ((((_la - 75)) & ~0x1F) === 0 && ((1 << (_la - 75)) & ((1 << (PostgreSQLParser.KW_LOCALTIME - 75)) | (1 << (PostgreSQLParser.KW_LOCALTIMESTAMP - 75)) | (1 << (PostgreSQLParser.KW_NOT - 75)) | (1 << (PostgreSQLParser.KW_NULL - 75)) | (1 << (PostgreSQLParser.KW_SESSION_USER - 75)) | (1 << (PostgreSQLParser.KW_TABLE - 75)) | (1 << (PostgreSQLParser.KW_TRUE - 75)) | (1 << (PostgreSQLParser.KW_UNIQUE - 75)) | (1 << (PostgreSQLParser.KW_USER - 75)) | (1 << (PostgreSQLParser.KW_AUTHORIZATION - 75)))) !== 0) || ((((_la - 107)) & ~0x1F) === 0 && ((1 << (_la - 107)) & ((1 << (PostgreSQLParser.KW_BINARY - 107)) | (1 << (PostgreSQLParser.KW_COLLATION - 107)) | (1 << (PostgreSQLParser.KW_CONCURRENTLY - 107)) | (1 << (PostgreSQLParser.KW_CROSS - 107)) | (1 << (PostgreSQLParser.KW_CURRENT_SCHEMA - 107)) | (1 << (PostgreSQLParser.KW_FREEZE - 107)) | (1 << (PostgreSQLParser.KW_FULL - 107)) | (1 << (PostgreSQLParser.KW_ILIKE - 107)) | (1 << (PostgreSQLParser.KW_INNER - 107)) | (1 << (PostgreSQLParser.KW_IS - 107)) | (1 << (PostgreSQLParser.KW_ISNULL - 107)) | (1 << (PostgreSQLParser.KW_JOIN - 107)) | (1 << (PostgreSQLParser.KW_LEFT - 107)) | (1 << (PostgreSQLParser.KW_LIKE - 107)) | (1 << (PostgreSQLParser.KW_NATURAL - 107)) | (1 << (PostgreSQLParser.KW_NOTNULL - 107)) | (1 << (PostgreSQLParser.KW_OUTER - 107)) | (1 << (PostgreSQLParser.KW_OVER - 107)) | (1 << (PostgreSQLParser.KW_OVERLAPS - 107)) | (1 << (PostgreSQLParser.KW_RIGHT - 107)) | (1 << (PostgreSQLParser.KW_SIMILAR - 107)) | (1 << (PostgreSQLParser.KW_VERBOSE - 107)) | (1 << (PostgreSQLParser.KW_ABORT - 107)) | (1 << (PostgreSQLParser.KW_ABSOLUTE - 107)) | (1 << (PostgreSQLParser.KW_ACCESS - 107)) | (1 << (PostgreSQLParser.KW_ACTION - 107)) | (1 << (PostgreSQLParser.KW_ADD - 107)) | (1 << (PostgreSQLParser.KW_ADMIN - 107)) | (1 << (PostgreSQLParser.KW_AFTER - 107)) | (1 << (PostgreSQLParser.KW_AGGREGATE - 107)) | (1 << (PostgreSQLParser.KW_ALSO - 107)) | (1 << (PostgreSQLParser.KW_ALTER - 107)))) !== 0) || ((((_la - 139)) & ~0x1F) === 0 && ((1 << (_la - 139)) & ((1 << (PostgreSQLParser.KW_ALWAYS - 139)) | (1 << (PostgreSQLParser.KW_ASSERTION - 139)) | (1 << (PostgreSQLParser.KW_ASSIGNMENT - 139)) | (1 << (PostgreSQLParser.KW_AT - 139)) | (1 << (PostgreSQLParser.KW_ATTRIBUTE - 139)) | (1 << (PostgreSQLParser.KW_BACKWARD - 139)) | (1 << (PostgreSQLParser.KW_BEFORE - 139)) | (1 << (PostgreSQLParser.KW_BEGIN - 139)) | (1 << (PostgreSQLParser.KW_BY - 139)) | (1 << (PostgreSQLParser.KW_CACHE - 139)) | (1 << (PostgreSQLParser.KW_CALLED - 139)) | (1 << (PostgreSQLParser.KW_CASCADE - 139)) | (1 << (PostgreSQLParser.KW_CASCADED - 139)) | (1 << (PostgreSQLParser.KW_CATALOG - 139)) | (1 << (PostgreSQLParser.KW_CHAIN - 139)) | (1 << (PostgreSQLParser.KW_CHARACTERISTICS - 139)) | (1 << (PostgreSQLParser.KW_CHECKPOINT - 139)) | (1 << (PostgreSQLParser.KW_CLASS - 139)) | (1 << (PostgreSQLParser.KW_CLOSE - 139)) | (1 << (PostgreSQLParser.KW_CLUSTER - 139)) | (1 << (PostgreSQLParser.KW_COMMENT - 139)) | (1 << (PostgreSQLParser.KW_COMMENTS - 139)) | (1 << (PostgreSQLParser.KW_COMMIT - 139)) | (1 << (PostgreSQLParser.KW_COMMITTED - 139)) | (1 << (PostgreSQLParser.KW_CONFIGURATION - 139)) | (1 << (PostgreSQLParser.KW_CONNECTION - 139)) | (1 << (PostgreSQLParser.KW_CONSTRAINTS - 139)) | (1 << (PostgreSQLParser.KW_CONTENT - 139)) | (1 << (PostgreSQLParser.KW_CONTINUE - 139)) | (1 << (PostgreSQLParser.KW_CONVERSION - 139)) | (1 << (PostgreSQLParser.KW_COPY - 139)) | (1 << (PostgreSQLParser.KW_COST - 139)))) !== 0) || ((((_la - 171)) & ~0x1F) === 0 && ((1 << (_la - 171)) & ((1 << (PostgreSQLParser.KW_CSV - 171)) | (1 << (PostgreSQLParser.KW_CURSOR - 171)) | (1 << (PostgreSQLParser.KW_CYCLE - 171)) | (1 << (PostgreSQLParser.KW_DATA - 171)) | (1 << (PostgreSQLParser.KW_DATABASE - 171)) | (1 << (PostgreSQLParser.KW_DAY - 171)) | (1 << (PostgreSQLParser.KW_DEALLOCATE - 171)) | (1 << (PostgreSQLParser.KW_DECLARE - 171)) | (1 << (PostgreSQLParser.KW_DEFAULTS - 171)) | (1 << (PostgreSQLParser.KW_DEFERRED - 171)) | (1 << (PostgreSQLParser.KW_DEFINER - 171)) | (1 << (PostgreSQLParser.KW_DELETE - 171)) | (1 << (PostgreSQLParser.KW_DELIMITER - 171)) | (1 << (PostgreSQLParser.KW_DELIMITERS - 171)) | (1 << (PostgreSQLParser.KW_DICTIONARY - 171)) | (1 << (PostgreSQLParser.KW_DISABLE - 171)) | (1 << (PostgreSQLParser.KW_DISCARD - 171)) | (1 << (PostgreSQLParser.KW_DOCUMENT - 171)) | (1 << (PostgreSQLParser.KW_DOMAIN - 171)) | (1 << (PostgreSQLParser.KW_DOUBLE - 171)) | (1 << (PostgreSQLParser.KW_DROP - 171)) | (1 << (PostgreSQLParser.KW_EACH - 171)) | (1 << (PostgreSQLParser.KW_ENABLE - 171)) | (1 << (PostgreSQLParser.KW_ENCODING - 171)) | (1 << (PostgreSQLParser.KW_ENCRYPTED - 171)) | (1 << (PostgreSQLParser.KW_ENUM - 171)) | (1 << (PostgreSQLParser.KW_ESCAPE - 171)) | (1 << (PostgreSQLParser.KW_EVENT - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDE - 171)) | (1 << (PostgreSQLParser.KW_EXCLUDING - 171)) | (1 << (PostgreSQLParser.KW_EXCLUSIVE - 171)) | (1 << (PostgreSQLParser.KW_EXECUTE - 171)))) !== 0) || ((((_la - 203)) & ~0x1F) === 0 && ((1 << (_la - 203)) & ((1 << (PostgreSQLParser.KW_EXPLAIN - 203)) | (1 << (PostgreSQLParser.KW_EXTENSION - 203)) | (1 << (PostgreSQLParser.KW_EXTERNAL - 203)) | (1 << (PostgreSQLParser.KW_FAMILY - 203)) | (1 << (PostgreSQLParser.KW_FIRST - 203)) | (1 << (PostgreSQLParser.KW_FOLLOWING - 203)) | (1 << (PostgreSQLParser.KW_FORCE - 203)) | (1 << (PostgreSQLParser.KW_FORWARD - 203)) | (1 << (PostgreSQLParser.KW_FUNCTION - 203)) | (1 << (PostgreSQLParser.KW_FUNCTIONS - 203)) | (1 << (PostgreSQLParser.KW_GLOBAL - 203)) | (1 << (PostgreSQLParser.KW_GRANTED - 203)) | (1 << (PostgreSQLParser.KW_HANDLER - 203)) | (1 << (PostgreSQLParser.KW_HEADER - 203)) | (1 << (PostgreSQLParser.KW_HOLD - 203)) | (1 << (PostgreSQLParser.KW_HOUR - 203)) | (1 << (PostgreSQLParser.KW_IDENTITY - 203)) | (1 << (PostgreSQLParser.KW_IF - 203)) | (1 << (PostgreSQLParser.KW_IMMEDIATE - 203)) | (1 << (PostgreSQLParser.KW_IMMUTABLE - 203)) | (1 << (PostgreSQLParser.KW_IMPLICIT - 203)) | (1 << (PostgreSQLParser.KW_INCLUDING - 203)) | (1 << (PostgreSQLParser.KW_INCREMENT - 203)) | (1 << (PostgreSQLParser.KW_INDEX - 203)) | (1 << (PostgreSQLParser.KW_INDEXES - 203)) | (1 << (PostgreSQLParser.KW_INHERIT - 203)))) !== 0) || ((((_la - 238)) & ~0x1F) === 0 && ((1 << (_la - 238)) & ((1 << (PostgreSQLParser.KW_INHERITS - 238)) | (1 << (PostgreSQLParser.KW_INLINE - 238)) | (1 << (PostgreSQLParser.KW_INSENSITIVE - 238)) | (1 << (PostgreSQLParser.KW_INSERT - 238)) | (1 << (PostgreSQLParser.KW_INSTEAD - 238)) | (1 << (PostgreSQLParser.KW_INVOKER - 238)) | (1 << (PostgreSQLParser.KW_ISOLATION - 238)) | (1 << (PostgreSQLParser.KW_KEY - 238)) | (1 << (PostgreSQLParser.KW_LABEL - 238)) | (1 << (PostgreSQLParser.KW_LANGUAGE - 238)) | (1 << (PostgreSQLParser.KW_LARGE - 238)) | (1 << (PostgreSQLParser.KW_LAST - 238)) | (1 << (PostgreSQLParser.KW_LEAKPROOF - 238)) | (1 << (PostgreSQLParser.KW_LEVEL - 238)) | (1 << (PostgreSQLParser.KW_LISTEN - 238)) | (1 << (PostgreSQLParser.KW_LOAD - 238)) | (1 << (PostgreSQLParser.KW_LOCAL - 238)) | (1 << (PostgreSQLParser.KW_LOCATION - 238)) | (1 << (PostgreSQLParser.KW_LOCK - 238)) | (1 << (PostgreSQLParser.KW_MAPPING - 238)) | (1 << (PostgreSQLParser.KW_MATCH - 238)) | (1 << (PostgreSQLParser.KW_MATERIALIZED - 238)) | (1 << (PostgreSQLParser.KW_MAXVALUE - 238)) | (1 << (PostgreSQLParser.KW_MINUTE - 238)) | (1 << (PostgreSQLParser.KW_MINVALUE - 238)) | (1 << (PostgreSQLParser.KW_MODE - 238)) | (1 << (PostgreSQLParser.KW_MONTH - 238)) | (1 << (PostgreSQLParser.KW_MOVE - 238)) | (1 << (PostgreSQLParser.KW_NAME - 238)) | (1 << (PostgreSQLParser.KW_NAMES - 238)) | (1 << (PostgreSQLParser.KW_NEXT - 238)) | (1 << (PostgreSQLParser.KW_NO - 238)))) !== 0) || ((((_la - 270)) & ~0x1F) === 0 && ((1 << (_la - 270)) & ((1 << (PostgreSQLParser.KW_NOTHING - 270)) | (1 << (PostgreSQLParser.KW_NOTIFY - 270)) | (1 << (PostgreSQLParser.KW_NOWAIT - 270)) | (1 << (PostgreSQLParser.KW_NULLS - 270)) | (1 << (PostgreSQLParser.KW_OBJECT - 270)) | (1 << (PostgreSQLParser.KW_OF - 270)) | (1 << (PostgreSQLParser.KW_OFF - 270)) | (1 << (PostgreSQLParser.KW_OIDS - 270)) | (1 << (PostgreSQLParser.KW_OPERATOR - 270)) | (1 << (PostgreSQLParser.KW_OPTION - 270)) | (1 << (PostgreSQLParser.KW_OPTIONS - 270)) | (1 << (PostgreSQLParser.KW_OWNED - 270)) | (1 << (PostgreSQLParser.KW_OWNER - 270)) | (1 << (PostgreSQLParser.KW_PARSER - 270)) | (1 << (PostgreSQLParser.KW_PARTIAL - 270)) | (1 << (PostgreSQLParser.KW_PARTITION - 270)) | (1 << (PostgreSQLParser.KW_PASSING - 270)) | (1 << (PostgreSQLParser.KW_PASSWORD - 270)) | (1 << (PostgreSQLParser.KW_PLANS - 270)) | (1 << (PostgreSQLParser.KW_PRECEDING - 270)) | (1 << (PostgreSQLParser.KW_PREPARE - 270)) | (1 << (PostgreSQLParser.KW_PREPARED - 270)) | (1 << (PostgreSQLParser.KW_PRESERVE - 270)) | (1 << (PostgreSQLParser.KW_PRIOR - 270)) | (1 << (PostgreSQLParser.KW_PRIVILEGES - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURAL - 270)) | (1 << (PostgreSQLParser.KW_PROCEDURE - 270)) | (1 << (PostgreSQLParser.KW_PROGRAM - 270)) | (1 << (PostgreSQLParser.KW_QUOTE - 270)) | (1 << (PostgreSQLParser.KW_RANGE - 270)) | (1 << (PostgreSQLParser.KW_READ - 270)) | (1 << (PostgreSQLParser.KW_REASSIGN - 270)))) !== 0) || ((((_la - 302)) & ~0x1F) === 0 && ((1 << (_la - 302)) & ((1 << (PostgreSQLParser.KW_RECHECK - 302)) | (1 << (PostgreSQLParser.KW_RECURSIVE - 302)) | (1 << (PostgreSQLParser.KW_REF - 302)) | (1 << (PostgreSQLParser.KW_REFRESH - 302)) | (1 << (PostgreSQLParser.KW_REINDEX - 302)) | (1 << (PostgreSQLParser.KW_RELATIVE - 302)) | (1 << (PostgreSQLParser.KW_RELEASE - 302)) | (1 << (PostgreSQLParser.KW_RENAME - 302)) | (1 << (PostgreSQLParser.KW_REPEATABLE - 302)) | (1 << (PostgreSQLParser.KW_REPLACE - 302)) | (1 << (PostgreSQLParser.KW_REPLICA - 302)) | (1 << (PostgreSQLParser.KW_RESET - 302)) | (1 << (PostgreSQLParser.KW_RESTART - 302)) | (1 << (PostgreSQLParser.KW_RESTRICT - 302)) | (1 << (PostgreSQLParser.KW_RETURNS - 302)) | (1 << (PostgreSQLParser.KW_REVOKE - 302)) | (1 << (PostgreSQLParser.KW_ROLE - 302)) | (1 << (PostgreSQLParser.KW_ROLLBACK - 302)) | (1 << (PostgreSQLParser.KW_ROWS - 302)) | (1 << (PostgreSQLParser.KW_RULE - 302)) | (1 << (PostgreSQLParser.KW_SAVEPOINT - 302)) | (1 << (PostgreSQLParser.KW_SCHEMA - 302)) | (1 << (PostgreSQLParser.KW_SCROLL - 302)) | (1 << (PostgreSQLParser.KW_SEARCH - 302)) | (1 << (PostgreSQLParser.KW_SECOND - 302)) | (1 << (PostgreSQLParser.KW_SECURITY - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCE - 302)) | (1 << (PostgreSQLParser.KW_SEQUENCES - 302)) | (1 << (PostgreSQLParser.KW_SERIALIZABLE - 302)) | (1 << (PostgreSQLParser.KW_SERVER - 302)) | (1 << (PostgreSQLParser.KW_SESSION - 302)) | (1 << (PostgreSQLParser.KW_SET - 302)))) !== 0) || ((((_la - 334)) & ~0x1F) === 0 && ((1 << (_la - 334)) & ((1 << (PostgreSQLParser.KW_SHARE - 334)) | (1 << (PostgreSQLParser.KW_SHOW - 334)) | (1 << (PostgreSQLParser.KW_SIMPLE - 334)) | (1 << (PostgreSQLParser.KW_SNAPSHOT - 334)) | (1 << (PostgreSQLParser.KW_STABLE - 334)) | (1 << (PostgreSQLParser.KW_STANDALONE - 334)) | (1 << (PostgreSQLParser.KW_START - 334)) | (1 << (PostgreSQLParser.KW_STATEMENT - 334)) | (1 << (PostgreSQLParser.KW_STATISTICS - 334)) | (1 << (PostgreSQLParser.KW_STDIN - 334)) | (1 << (PostgreSQLParser.KW_STDOUT - 334)) | (1 << (PostgreSQLParser.KW_STORAGE - 334)) | (1 << (PostgreSQLParser.KW_STRICT - 334)) | (1 << (PostgreSQLParser.KW_STRIP - 334)) | (1 << (PostgreSQLParser.KW_SYSID - 334)) | (1 << (PostgreSQLParser.KW_SYSTEM - 334)) | (1 << (PostgreSQLParser.KW_TABLES - 334)) | (1 << (PostgreSQLParser.KW_TABLESPACE - 334)) | (1 << (PostgreSQLParser.KW_TEMP - 334)) | (1 << (PostgreSQLParser.KW_TEMPLATE - 334)) | (1 << (PostgreSQLParser.KW_TEMPORARY - 334)) | (1 << (PostgreSQLParser.KW_TEXT - 334)) | (1 << (PostgreSQLParser.KW_TRANSACTION - 334)) | (1 << (PostgreSQLParser.KW_TRIGGER - 334)) | (1 << (PostgreSQLParser.KW_TRUNCATE - 334)) | (1 << (PostgreSQLParser.KW_TRUSTED - 334)) | (1 << (PostgreSQLParser.KW_TYPE - 334)) | (1 << (PostgreSQLParser.KW_TYPES - 334)) | (1 << (PostgreSQLParser.KW_UNBOUNDED - 334)) | (1 << (PostgreSQLParser.KW_UNCOMMITTED - 334)) | (1 << (PostgreSQLParser.KW_UNENCRYPTED - 334)) | (1 << (PostgreSQLParser.KW_UNKNOWN - 334)))) !== 0) || ((((_la - 366)) & ~0x1F) === 0 && ((1 << (_la - 366)) & ((1 << (PostgreSQLParser.KW_UNLISTEN - 366)) | (1 << (PostgreSQLParser.KW_UNLOGGED - 366)) | (1 << (PostgreSQLParser.KW_UNTIL - 366)) | (1 << (PostgreSQLParser.KW_UPDATE - 366)) | (1 << (PostgreSQLParser.KW_VACUUM - 366)) | (1 << (PostgreSQLParser.KW_VALID - 366)) | (1 << (PostgreSQLParser.KW_VALIDATE - 366)) | (1 << (PostgreSQLParser.KW_VALIDATOR - 366)) | (1 << (PostgreSQLParser.KW_VARYING - 366)) | (1 << (PostgreSQLParser.KW_VERSION - 366)) | (1 << (PostgreSQLParser.KW_VIEW - 366)) | (1 << (PostgreSQLParser.KW_VOLATILE - 366)) | (1 << (PostgreSQLParser.KW_WHITESPACE - 366)) | (1 << (PostgreSQLParser.KW_WITHOUT - 366)) | (1 << (PostgreSQLParser.KW_WORK - 366)) | (1 << (PostgreSQLParser.KW_WRAPPER - 366)) | (1 << (PostgreSQLParser.KW_WRITE - 366)) | (1 << (PostgreSQLParser.KW_XML - 366)) | (1 << (PostgreSQLParser.KW_YEAR - 366)) | (1 << (PostgreSQLParser.KW_YES - 366)) | (1 << (PostgreSQLParser.KW_ZONE - 366)) | (1 << (PostgreSQLParser.KW_BETWEEN - 366)) | (1 << (PostgreSQLParser.KW_BIGINT - 366)) | (1 << (PostgreSQLParser.KW_BIT - 366)) | (1 << (PostgreSQLParser.KW_BOOLEAN - 366)) | (1 << (PostgreSQLParser.KW_CHAR - 366)) | (1 << (PostgreSQLParser.KW_CHARACTER - 366)) | (1 << (PostgreSQLParser.KW_COALESCE - 366)) | (1 << (PostgreSQLParser.KW_DEC - 366)) | (1 << (PostgreSQLParser.KW_DECIMAL - 366)) | (1 << (PostgreSQLParser.KW_EXISTS - 366)) | (1 << (PostgreSQLParser.KW_EXTRACT - 366)))) !== 0) || ((((_la - 398)) & ~0x1F) === 0 && ((1 << (_la - 398)) & ((1 << (PostgreSQLParser.KW_FLOAT - 398)) | (1 << (PostgreSQLParser.KW_GREATEST - 398)) | (1 << (PostgreSQLParser.KW_INOUT - 398)) | (1 << (PostgreSQLParser.KW_INT - 398)) | (1 << (PostgreSQLParser.KW_INTEGER - 398)) | (1 << (PostgreSQLParser.KW_INTERVAL - 398)) | (1 << (PostgreSQLParser.KW_LEAST - 398)) | (1 << (PostgreSQLParser.KW_NATIONAL - 398)) | (1 << (PostgreSQLParser.KW_NCHAR - 398)) | (1 << (PostgreSQLParser.KW_NONE - 398)) | (1 << (PostgreSQLParser.KW_NULLIF - 398)) | (1 << (PostgreSQLParser.KW_NUMERIC - 398)) | (1 << (PostgreSQLParser.KW_OVERLAY - 398)) | (1 << (PostgreSQLParser.KW_POSITION - 398)) | (1 << (PostgreSQLParser.KW_PRECISION - 398)) | (1 << (PostgreSQLParser.KW_REAL - 398)) | (1 << (PostgreSQLParser.KW_ROW - 398)) | (1 << (PostgreSQLParser.KW_SETOF - 398)) | (1 << (PostgreSQLParser.KW_SMALLINT - 398)) | (1 << (PostgreSQLParser.KW_SUBSTRING - 398)) | (1 << (PostgreSQLParser.KW_TIME - 398)) | (1 << (PostgreSQLParser.KW_TIMESTAMP - 398)) | (1 << (PostgreSQLParser.KW_TREAT - 398)) | (1 << (PostgreSQLParser.KW_TRIM - 398)) | (1 << (PostgreSQLParser.KW_VALUES - 398)) | (1 << (PostgreSQLParser.KW_VARCHAR - 398)) | (1 << (PostgreSQLParser.KW_XMLATTRIBUTES - 398)) | (1 << (PostgreSQLParser.KW_XMLCONCAT - 398)) | (1 << (PostgreSQLParser.KW_XMLELEMENT - 398)) | (1 << (PostgreSQLParser.KW_XMLEXISTS - 398)) | (1 << (PostgreSQLParser.KW_XMLFOREST - 398)) | (1 << (PostgreSQLParser.KW_XMLPARSE - 398)))) !== 0) || ((((_la - 430)) & ~0x1F) === 0 && ((1 << (_la - 430)) & ((1 << (PostgreSQLParser.KW_XMLPI - 430)) | (1 << (PostgreSQLParser.KW_XMLROOT - 430)) | (1 << (PostgreSQLParser.KW_XMLSERIALIZE - 430)) | (1 << (PostgreSQLParser.KW_CALL - 430)) | (1 << (PostgreSQLParser.KW_CURRENT - 430)) | (1 << (PostgreSQLParser.KW_ATTACH - 430)) | (1 << (PostgreSQLParser.KW_DETACH - 430)) | (1 << (PostgreSQLParser.KW_EXPRESSION - 430)) | (1 << (PostgreSQLParser.KW_GENERATED - 430)) | (1 << (PostgreSQLParser.KW_LOGGED - 430)) | (1 << (PostgreSQLParser.KW_STORED - 430)) | (1 << (PostgreSQLParser.KW_INCLUDE - 430)) | (1 << (PostgreSQLParser.KW_ROUTINE - 430)) | (1 << (PostgreSQLParser.KW_TRANSFORM - 430)) | (1 << (PostgreSQLParser.KW_IMPORT - 430)) | (1 << (PostgreSQLParser.KW_POLICY - 430)) | (1 << (PostgreSQLParser.KW_METHOD - 430)) | (1 << (PostgreSQLParser.KW_REFERENCING - 430)) | (1 << (PostgreSQLParser.KW_NEW - 430)) | (1 << (PostgreSQLParser.KW_OLD - 430)) | (1 << (PostgreSQLParser.KW_VALUE - 430)) | (1 << (PostgreSQLParser.KW_SUBSCRIPTION - 430)) | (1 << (PostgreSQLParser.KW_PUBLICATION - 430)) | (1 << (PostgreSQLParser.KW_OUT - 430)) | (1 << (PostgreSQLParser.KW_ROUTINES - 430)) | (1 << (PostgreSQLParser.KW_SCHEMAS - 430)) | (1 << (PostgreSQLParser.KW_PROCEDURES - 430)) | (1 << (PostgreSQLParser.KW_INPUT - 430)) | (1 << (PostgreSQLParser.KW_SUPPORT - 430)) | (1 << (PostgreSQLParser.KW_PARALLEL - 430)) | (1 << (PostgreSQLParser.KW_SQL - 430)))) !== 0) || ((((_la - 462)) & ~0x1F) === 0 && ((1 << (_la - 462)) & ((1 << (PostgreSQLParser.KW_DEPENDS - 462)) | (1 << (PostgreSQLParser.KW_OVERRIDING - 462)) | (1 << (PostgreSQLParser.KW_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_SKIP - 462)) | (1 << (PostgreSQLParser.KW_LOCKED - 462)) | (1 << (PostgreSQLParser.KW_TIES - 462)) | (1 << (PostgreSQLParser.KW_ROLLUP - 462)) | (1 << (PostgreSQLParser.KW_CUBE - 462)) | (1 << (PostgreSQLParser.KW_GROUPING - 462)) | (1 << (PostgreSQLParser.KW_SETS - 462)) | (1 << (PostgreSQLParser.KW_TABLESAMPLE - 462)) | (1 << (PostgreSQLParser.KW_ORDINALITY - 462)) | (1 << (PostgreSQLParser.KW_XMLTABLE - 462)) | (1 << (PostgreSQLParser.KW_COLUMNS - 462)) | (1 << (PostgreSQLParser.KW_XMLNAMESPACES - 462)) | (1 << (PostgreSQLParser.KW_ROWTYPE - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZED - 462)) | (1 << (PostgreSQLParser.KW_WITHIN - 462)) | (1 << (PostgreSQLParser.KW_FILTER - 462)) | (1 << (PostgreSQLParser.KW_GROUPS - 462)) | (1 << (PostgreSQLParser.KW_OTHERS - 462)) | (1 << (PostgreSQLParser.KW_NFC - 462)) | (1 << (PostgreSQLParser.KW_NFD - 462)) | (1 << (PostgreSQLParser.KW_NFKC - 462)) | (1 << (PostgreSQLParser.KW_NFKD - 462)) | (1 << (PostgreSQLParser.KW_UESCAPE - 462)) | (1 << (PostgreSQLParser.KW_VIEWS - 462)) | (1 << (PostgreSQLParser.KW_NORMALIZE - 462)) | (1 << (PostgreSQLParser.KW_DUMP - 462)) | (1 << (PostgreSQLParser.KW_PRINT_STRICT_PARAMS - 462)) | (1 << (PostgreSQLParser.KW_VARIABLE_CONFLICT - 462)) | (1 << (PostgreSQLParser.KW_ERROR - 462)))) !== 0) || ((((_la - 494)) & ~0x1F) === 0 && ((1 << (_la - 494)) & ((1 << (PostgreSQLParser.KW_USE_VARIABLE - 494)) | (1 << (PostgreSQLParser.KW_USE_COLUMN - 494)) | (1 << (PostgreSQLParser.KW_ALIAS - 494)) | (1 << (PostgreSQLParser.KW_CONSTANT - 494)) | (1 << (PostgreSQLParser.KW_PERFORM - 494)) | (1 << (PostgreSQLParser.KW_GET - 494)) | (1 << (PostgreSQLParser.KW_DIAGNOSTICS - 494)) | (1 << (PostgreSQLParser.KW_STACKED - 494)) | (1 << (PostgreSQLParser.KW_ELSIF - 494)) | (1 << (PostgreSQLParser.KW_REVERSE - 494)) | (1 << (PostgreSQLParser.KW_SLICE - 494)) | (1 << (PostgreSQLParser.KW_EXIT - 494)) | (1 << (PostgreSQLParser.KW_RETURN - 494)) | (1 << (PostgreSQLParser.KW_QUERY - 494)) | (1 << (PostgreSQLParser.KW_RAISE - 494)) | (1 << (PostgreSQLParser.KW_SQLSTATE - 494)) | (1 << (PostgreSQLParser.KW_DEBUG - 494)) | (1 << (PostgreSQLParser.KW_LOG - 494)) | (1 << (PostgreSQLParser.KW_INFO - 494)) | (1 << (PostgreSQLParser.KW_NOTICE - 494)) | (1 << (PostgreSQLParser.KW_WARNING - 494)) | (1 << (PostgreSQLParser.KW_EXCEPTION - 494)) | (1 << (PostgreSQLParser.KW_ASSERT - 494)) | (1 << (PostgreSQLParser.KW_OPEN - 494)) | (1 << (PostgreSQLParser.Identifier - 494)))) !== 0) || ((((_la - 526)) & ~0x1F) === 0 && ((1 << (_la - 526)) & ((1 << (PostgreSQLParser.QuotedIdentifier - 526)) | (1 << (PostgreSQLParser.UnicodeQuotedIdentifier - 526)) | (1 << (PostgreSQLParser.StringConstant - 526)) | (1 << (PostgreSQLParser.UnicodeEscapeStringConstant - 526)) | (1 << (PostgreSQLParser.BeginDollarStringConstant - 526)) | (1 << (PostgreSQLParser.BinaryStringConstant - 526)) | (1 << (PostgreSQLParser.HexadecimalStringConstant - 526)) | (1 << (PostgreSQLParser.Integral - 526)) | (1 << (PostgreSQLParser.Numeric - 526)) | (1 << (PostgreSQLParser.PLSQLVARIABLENAME - 526)) | (1 << (PostgreSQLParser.PLSQLIDENTIFIER - 526)))) !== 0) || _la === PostgreSQLParser.EscapeStringConstant) { { - this.state = 10945; + this.state = 11064; this.opt_target_list(); } } - this.state = 10949; + this.state = 11068; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INTO) { + if (_la === PostgreSQLParser.KW_INTO) { { - this.state = 10948; + this.state = 11067; this.into_clause(); } } - this.state = 10952; + this.state = 11071; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.FROM) { + if (_la === PostgreSQLParser.KW_FROM) { { - this.state = 10951; + this.state = 11070; this.from_clause(); } } - this.state = 10955; + this.state = 11074; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WHERE) { + if (_la === PostgreSQLParser.KW_WHERE) { { - this.state = 10954; + this.state = 11073; this.where_clause(); } } - this.state = 10958; + this.state = 11077; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.GROUP_P) { + if (_la === PostgreSQLParser.KW_GROUP) { { - this.state = 10957; + this.state = 11076; this.group_clause(); } } - this.state = 10961; + this.state = 11080; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.HAVING) { + if (_la === PostgreSQLParser.KW_HAVING) { { - this.state = 10960; + this.state = 11079; this.having_clause(); } } - this.state = 10964; + this.state = 11083; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.WINDOW) { + if (_la === PostgreSQLParser.KW_WINDOW) { { - this.state = 10963; + this.state = 11082; this.window_clause(); } } @@ -65572,11 +65841,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public expr_until_then(): Expr_until_thenContext { let _localctx: Expr_until_thenContext = new Expr_until_thenContext(this._ctx, this.state); - this.enterRule(_localctx, 1594, PostgreSQLParser.RULE_expr_until_then); + this.enterRule(_localctx, 1620, PostgreSQLParser.RULE_expr_until_then); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10966; + this.state = 11085; this.sql_expression(); } } @@ -65597,11 +65866,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public expr_until_semi(): Expr_until_semiContext { let _localctx: Expr_until_semiContext = new Expr_until_semiContext(this._ctx, this.state); - this.enterRule(_localctx, 1596, PostgreSQLParser.RULE_expr_until_semi); + this.enterRule(_localctx, 1622, PostgreSQLParser.RULE_expr_until_semi); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10968; + this.state = 11087; this.sql_expression(); } } @@ -65622,11 +65891,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public expr_until_rightbracket(): Expr_until_rightbracketContext { let _localctx: Expr_until_rightbracketContext = new Expr_until_rightbracketContext(this._ctx, this.state); - this.enterRule(_localctx, 1598, PostgreSQLParser.RULE_expr_until_rightbracket); + this.enterRule(_localctx, 1624, PostgreSQLParser.RULE_expr_until_rightbracket); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10970; + this.state = 11089; this.a_expr(); } } @@ -65647,11 +65916,11 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public expr_until_loop(): Expr_until_loopContext { let _localctx: Expr_until_loopContext = new Expr_until_loopContext(this._ctx, this.state); - this.enterRule(_localctx, 1600, PostgreSQLParser.RULE_expr_until_loop); + this.enterRule(_localctx, 1626, PostgreSQLParser.RULE_expr_until_loop); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10972; + this.state = 11091; this.a_expr(); } } @@ -65672,19 +65941,19 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public make_execsql_stmt(): Make_execsql_stmtContext { let _localctx: Make_execsql_stmtContext = new Make_execsql_stmtContext(this._ctx, this.state); - this.enterRule(_localctx, 1602, PostgreSQLParser.RULE_make_execsql_stmt); + this.enterRule(_localctx, 1628, PostgreSQLParser.RULE_make_execsql_stmt); let _la: number; try { this.enterOuterAlt(_localctx, 1); { - this.state = 10974; + this.state = 11093; this.stmt(); - this.state = 10976; + this.state = 11095; this._errHandler.sync(this); _la = this._input.LA(1); - if (_la === PostgreSQLParser.INTO) { + if (_la === PostgreSQLParser.KW_INTO) { { - this.state = 10975; + this.state = 11094; this.opt_returning_clause_into(); } } @@ -65708,15 +65977,15 @@ export class PostgreSQLParser extends PostgreSQLParserBase { // @RuleVersion(0) public opt_returning_clause_into(): Opt_returning_clause_intoContext { let _localctx: Opt_returning_clause_intoContext = new Opt_returning_clause_intoContext(this._ctx, this.state); - this.enterRule(_localctx, 1604, PostgreSQLParser.RULE_opt_returning_clause_into); + this.enterRule(_localctx, 1630, PostgreSQLParser.RULE_opt_returning_clause_into); try { this.enterOuterAlt(_localctx, 1); { - this.state = 10978; - this.match(PostgreSQLParser.INTO); - this.state = 10979; + this.state = 11097; + this.match(PostgreSQLParser.KW_INTO); + this.state = 11098; this.opt_strict(); - this.state = 10980; + this.state = 11099; this.into_target(); } } @@ -65737,7 +66006,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { public sempred(_localctx: RuleContext, ruleIndex: number, predIndex: number): boolean { switch (ruleIndex) { - case 595: + case 602: return this.b_expr_sempred(_localctx as B_exprContext, predIndex); } return true; @@ -65771,9 +66040,9 @@ export class PostgreSQLParser extends PostgreSQLParserBase { return true; } - private static readonly _serializedATNSegments: number = 20; + private static readonly _serializedATNSegments: number = 21; private static readonly _serializedATNSegment0: string = - "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\u022B\u2AE9\x04" + + "\x03\uC91D\uCABA\u058D\uAFBA\u4F53\u0607\uEA8B\uC241\x03\u0238\u2B60\x04" + "\x02\t\x02\x04\x03\t\x03\x04\x04\t\x04\x04\x05\t\x05\x04\x06\t\x06\x04" + "\x07\t\x07\x04\b\t\b\x04\t\t\t\x04\n\t\n\x04\v\t\v\x04\f\t\f\x04\r\t\r" + "\x04\x0E\t\x0E\x04\x0F\t\x0F\x04\x10\t\x10\x04\x11\t\x11\x04\x12\t\x12" + @@ -65953,1247 +66222,1267 @@ export class PostgreSQLParser extends PostgreSQLParserBase { "\u0317\t\u0317\x04\u0318\t\u0318\x04\u0319\t\u0319\x04\u031A\t\u031A\x04" + "\u031B\t\u031B\x04\u031C\t\u031C\x04\u031D\t\u031D\x04\u031E\t\u031E\x04" + "\u031F\t\u031F\x04\u0320\t\u0320\x04\u0321\t\u0321\x04\u0322\t\u0322\x04" + - "\u0323\t\u0323\x04\u0324\t\u0324\x03\x02\x03\x02\x03\x03\x03\x03\x03\x04" + - "\x03\x04\x05\x04\u064F\n\x04\x07\x04\u0651\n\x04\f\x04\x0E\x04\u0654\v" + - "\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03" + - "\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x05\x05\u06D2" + - "\n\x05\x03\x06\x03\x06\x05\x06\u06D6\n\x06\x03\x07\x03\x07\x03\x07\x03" + - "\b\x03\b\x03\b\x03\b\x05\b\u06DF\n\b\x03\b\x03\b\x03\t\x03\t\x03\n\x07" + - "\n\u06E6\n\n\f\n\x0E\n\u06E9\v\n\x03\v\x07\v\u06EC\n\v\f\v\x0E\v\u06EF" + - "\v\v\x03\f\x03\f\x03\f\x05\f\u06F4\n\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03" + - "\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x05\f\u0703\n\f\x03\r\x03" + - "\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x05\r\u070F\n\r\x03" + - "\x0E\x03\x0E\x03\x0E\x03\x0E\x05\x0E\u0715\n\x0E\x03\x0E\x03\x0E\x03\x0F" + - "\x03\x0F\x03\x0F\x03\x0F\x05\x0F\u071D\n\x0F\x03\x0F\x03\x0F\x03\x10\x03" + - "\x10\x03\x10\x03\x10\x05\x10\u0725\n\x10\x03\x11\x03\x11\x03\x11\x05\x11" + - "\u072A\n\x11\x03\x11\x03\x11\x03\x11\x03\x11\x03\x12\x03\x12\x03\x12\x03" + - "\x12\x05\x12\u0734\n\x12\x03\x12\x03\x12\x03\x13\x03\x13\x03\x13\x03\x13" + - "\x05\x13\u073C\n\x13\x03\x13\x03\x13\x03\x14\x03\x14\x03\x14\x03\x14\x03" + - "\x14\x03\x14\x03\x14\x03\x15\x03\x15\x03\x16\x03\x16\x03\x16\x03\x16\x03" + - "\x16\x05\x16\u074E\n\x16\x03\x16\x05\x16\u0751\n\x16\x03\x16\x03\x16\x03" + - "\x16\x05\x16\u0756\n\x16\x03\x16\x03\x16\x03\x17\x03\x17\x03\x18\x07\x18" + - "\u075D\n\x18\f\x18\x0E\x18\u0760\v\x18\x03\x19\x03\x19\x03\x19\x03\x19" + - "\x03\x19\x03\x19\x05\x19\u0768\n\x19\x03\x1A\x03\x1A\x05\x1A\u076C\n\x1A" + - "\x03\x1A\x03\x1A\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B" + - "\x03\x1B\x05\x1B\u0778\n\x1B\x03\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1D\x03" + - "\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03" + - "\x1D\x03\x1D\x03\x1D\x03\x1D\x05\x1D\u078C\n\x1D\x03\x1D\x03\x1D\x03\x1D" + - "\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x05\x1D" + - "\u0799\n\x1D\x03\x1E\x03\x1E\x03\x1E\x07\x1E\u079E\n\x1E\f\x1E\x0E\x1E" + - "\u07A1\v\x1E\x03\x1F\x03\x1F\x03\x1F\x07\x1F\u07A6\n\x1F\f\x1F\x0E\x1F" + - "\u07A9\v\x1F\x03 \x03 \x05 \u07AD\n \x03!\x03!\x03!\x03!\x03!\x05!\u07B4" + - "\n!\x03\"\x03\"\x03\"\x03\"\x05\"\u07BA\n\"\x03#\x03#\x03#\x03#\x03#\x05" + - "#\u07C1\n#\x03#\x03#\x03#\x03#\x03#\x03#\x03#\x03#\x03#\x05#\u07CC\n#" + - "\x03$\x03$\x05$\u07D0\n$\x03%\x03%\x05%\u07D4\n%\x03&\x03&\x03&\x03\'" + - "\x03\'\x03\'\x03\'\x03\'\x03\'\x03\'\x03\'\x05\'\u07E1\n\'\x03(\x03(\x05" + - "(\u07E5\n(\x03)\x03)\x03)\x05)\u07EA\n)\x03*\x03*\x03*\x05*\u07EF\n*\x03" + - "+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x03+\x05+\u07FB\n+\x03,\x03" + - ",\x03,\x03,\x03,\x03-\x03-\x05-\u0804\n-\x03.\x03.\x03/\x03/\x030\x03" + - "0\x030\x031\x031\x031\x031\x051\u0811\n1\x031\x031\x031\x051\u0816\n1" + - "\x031\x031\x031\x031\x031\x031\x031\x031\x031\x051\u0821\n1\x031\x031" + - "\x031\x031\x051\u0827\n1\x031\x031\x031\x031\x051\u082D\n1\x031\x031\x03" + - "1\x051\u0832\n1\x031\x031\x031\x031\x031\x031\x031\x031\x031\x051\u083D" + - "\n1\x031\x031\x031\x031\x051\u0843\n1\x031\x031\x031\x031\x051\u0849\n" + - "1\x031\x031\x031\x031\x031\x031\x031\x051\u0852\n1\x031\x031\x031\x03" + - "1\x031\x031\x031\x031\x051\u085C\n1\x031\x031\x031\x031\x031\x031\x03" + - "1\x031\x031\x031\x031\x031\x031\x051\u086B\n1\x031\x031\x031\x031\x05" + - "1\u0871\n1\x031\x031\x031\x031\x031\x051\u0878\n1\x031\x031\x031\x051" + - "\u087D\n1\x032\x032\x032\x072\u0882\n2\f2\x0E2\u0885\v2\x033\x033\x03" + - "3\x033\x033\x033\x033\x033\x053\u088F\n3\x034\x034\x034\x034\x035\x03" + - "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + - "5\x035\x035\x055\u08A7\n5\x035\x035\x035\x035\x035\x055\u08AE\n5\x035" + - "\x035\x035\x035\x035\x035\x035\x055\u08B7\n5\x035\x035\x035\x035\x035" + - "\x035\x035\x055\u08C0\n5\x035\x035\x035\x035\x035\x035\x055\u08C8\n5\x03" + - "5\x035\x035\x035\x035\x035\x035\x035\x055\u08D2\n5\x035\x035\x035\x03" + - "5\x035\x035\x035\x055\u08DB\n5\x035\x035\x035\x035\x035\x035\x035\x05" + - "5\u08E4\n5\x035\x035\x035\x035\x035\x035\x055\u08EC\n5\x035\x035\x035" + - "\x035\x035\x035\x055\u08F4\n5\x035\x035\x035\x035\x035\x035\x035\x055" + - "\u08FD\n5\x035\x035\x035\x035\x035\x035\x035\x055\u0906\n5\x035\x035\x05" + - "5\u090A\n5\x035\x035\x035\x035\x035\x055\u0911\n5\x035\x035\x035\x035" + - "\x035\x035\x055\u0919\n5\x035\x035\x035\x035\x035\x035\x035\x035\x055" + - "\u0923\n5\x035\x035\x035\x035\x055\u0929\n5\x035\x035\x055\u092D\n5\x03" + - "5\x035\x055\u0931\n5\x035\x035\x055\u0935\n5\x035\x035\x055\u0939\n5\x03" + - "5\x035\x035\x055\u093E\n5\x035\x055\u0941\n5\x035\x035\x055\u0945\n5\x03" + - "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + - "5\x035\x035\x035\x035\x055\u095A\n5\x035\x035\x035\x035\x055\u0960\n5" + + "\u0323\t\u0323\x04\u0324\t\u0324\x04\u0325\t\u0325\x04\u0326\t\u0326\x04" + + "\u0327\t\u0327\x04\u0328\t\u0328\x04\u0329\t\u0329\x04\u032A\t\u032A\x04" + + "\u032B\t\u032B\x04\u032C\t\u032C\x04\u032D\t\u032D\x04\u032E\t\u032E\x04" + + "\u032F\t\u032F\x04\u0330\t\u0330\x04\u0331\t\u0331\x03\x02\x03\x02\x03" + + "\x03\x03\x03\x03\x04\x03\x04\x05\x04\u0669\n\x04\x07\x04\u066B\n\x04\f" + + "\x04\x0E\x04\u066E\v\x04\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05\x03\x05" + + "\x03\x05\x05\x05\u06EC\n\x05\x03\x06\x03\x06\x05\x06\u06F0\n\x06\x03\x07" + + "\x03\x07\x03\x07\x03\b\x03\b\x03\b\x03\b\x05\b\u06F9\n\b\x03\b\x03\b\x03" + + "\t\x03\t\x03\n\x07\n\u0700\n\n\f\n\x0E\n\u0703\v\n\x03\v\x07\v\u0706\n" + + "\v\f\v\x0E\v\u0709\v\v\x03\f\x03\f\x03\f\x05\f\u070E\n\f\x03\f\x03\f\x03" + + "\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03\f\x03" + + "\f\x03\f\x03\f\x05\f\u0721\n\f\x03\r\x03\r\x03\r\x03\r\x03\r\x03\r\x03" + + "\r\x03\r\x03\r\x03\r\x05\r\u072D\n\r\x03\x0E\x03\x0E\x03\x0E\x03\x0E\x05" + + "\x0E\u0733\n\x0E\x03\x0E\x03\x0E\x03\x0F\x03\x0F\x03\x0F\x03\x0F\x05\x0F" + + "\u073B\n\x0F\x03\x0F\x03\x0F\x03\x10\x03\x10\x03\x10\x03\x10\x05\x10\u0743" + + "\n\x10\x03\x11\x03\x11\x03\x11\x03\x11\x05\x11\u0749\n\x11\x03\x11\x03" + + "\x11\x03\x11\x03\x12\x03\x12\x03\x12\x03\x12\x05\x12\u0752\n\x12\x03\x12" + + "\x03\x12\x03\x13\x03\x13\x03\x13\x03\x13\x05\x13\u075A\n\x13\x03\x13\x03" + + "\x13\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x14\x03\x15\x03" + + "\x15\x03\x16\x03\x16\x03\x16\x03\x16\x03\x16\x05\x16\u076C\n\x16\x03\x16" + + "\x05\x16\u076F\n\x16\x03\x16\x03\x16\x03\x16\x05\x16\u0774\n\x16\x03\x16" + + "\x03\x16\x03\x17\x03\x17\x03\x18\x07\x18\u077B\n\x18\f\x18\x0E\x18\u077E" + + "\v\x18\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x03\x19\x05\x19\u0786\n" + + "\x19\x03\x1A\x03\x1A\x05\x1A\u078A\n\x1A\x03\x1A\x03\x1A\x03\x1B\x03\x1B" + + "\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x03\x1B\x05\x1B\u0796\n\x1B\x03" + + "\x1C\x03\x1C\x03\x1C\x03\x1C\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03" + + "\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x05" + + "\x1D\u07AA\n\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x03\x1D" + + "\x03\x1D\x03\x1D\x03\x1D\x03\x1D\x05\x1D\u07B7\n\x1D\x03\x1E\x03\x1E\x03" + + "\x1E\x07\x1E\u07BC\n\x1E\f\x1E\x0E\x1E\u07BF\v\x1E\x03\x1F\x03\x1F\x03" + + "\x1F\x07\x1F\u07C4\n\x1F\f\x1F\x0E\x1F\u07C7\v\x1F\x03 \x03 \x05 \u07CB" + + "\n \x03!\x03!\x03!\x03!\x03!\x05!\u07D2\n!\x03\"\x03\"\x03\"\x03\"\x05" + + "\"\u07D8\n\"\x03#\x03#\x03#\x03#\x03#\x05#\u07DF\n#\x03#\x03#\x03#\x03" + + "#\x03#\x03#\x03#\x03#\x03#\x05#\u07EA\n#\x03$\x03$\x05$\u07EE\n$\x03%" + + "\x03%\x05%\u07F2\n%\x03&\x03&\x03&\x03\'\x03\'\x03\'\x03\'\x03\'\x03\'" + + "\x03\'\x03\'\x05\'\u07FF\n\'\x03(\x03(\x05(\u0803\n(\x03)\x03)\x03)\x05" + + ")\u0808\n)\x03*\x03*\x03*\x05*\u080D\n*\x03+\x03+\x03+\x03+\x03+\x03+" + + "\x03+\x03+\x03+\x03+\x05+\u0819\n+\x03,\x03,\x03,\x03,\x03,\x03-\x03-" + + "\x05-\u0822\n-\x03.\x03.\x03/\x03/\x030\x030\x030\x031\x031\x031\x031" + + "\x051\u082F\n1\x031\x031\x031\x051\u0834\n1\x031\x031\x031\x031\x031\x03" + + "1\x031\x031\x031\x051\u083F\n1\x031\x031\x031\x031\x051\u0845\n1\x031" + + "\x031\x031\x031\x051\u084B\n1\x031\x031\x031\x051\u0850\n1\x031\x031\x03" + + "1\x031\x031\x031\x031\x031\x031\x051\u085B\n1\x031\x031\x031\x031\x05" + + "1\u0861\n1\x031\x031\x031\x031\x051\u0867\n1\x031\x031\x031\x031\x031" + + "\x031\x031\x051\u0870\n1\x031\x031\x031\x031\x031\x031\x031\x031\x051" + + "\u087A\n1\x031\x031\x031\x031\x031\x031\x031\x031\x031\x031\x031\x031" + + "\x031\x051\u0889\n1\x031\x031\x031\x031\x051\u088F\n1\x031\x031\x031\x03" + + "1\x031\x051\u0896\n1\x031\x031\x031\x051\u089B\n1\x032\x032\x032\x072" + + "\u08A0\n2\f2\x0E2\u08A3\v2\x033\x033\x033\x033\x033\x033\x033\x033\x05" + + "3\u08AD\n3\x034\x034\x034\x034\x035\x035\x035\x035\x035\x035\x035\x03" + + "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x055\u08C5\n5\x03" + + "5\x035\x035\x035\x035\x055\u08CC\n5\x035\x035\x035\x035\x035\x035\x03" + + "5\x055\u08D5\n5\x035\x035\x035\x035\x035\x035\x035\x055\u08DE\n5\x035" + + "\x035\x035\x035\x035\x035\x055\u08E6\n5\x035\x035\x035\x035\x035\x035" + + "\x035\x035\x055\u08F0\n5\x035\x035\x035\x035\x035\x035\x035\x055\u08F9" + + "\n5\x035\x035\x035\x035\x035\x035\x035\x055\u0902\n5\x035\x035\x035\x03" + + "5\x035\x035\x055\u090A\n5\x035\x035\x035\x035\x035\x035\x055\u0912\n5" + + "\x035\x035\x035\x035\x035\x035\x035\x055\u091B\n5\x035\x035\x035\x035" + + "\x035\x035\x035\x055\u0924\n5\x035\x035\x055\u0928\n5\x035\x035\x035\x03" + + "5\x035\x055\u092F\n5\x035\x035\x035\x035\x035\x035\x055\u0937\n5\x035" + + "\x035\x035\x035\x035\x035\x035\x035\x055\u0941\n5\x035\x035\x035\x035" + + "\x055\u0947\n5\x035\x035\x055\u094B\n5\x035\x035\x055\u094F\n5\x035\x03" + + "5\x055\u0953\n5\x035\x035\x055\u0957\n5\x035\x035\x035\x055\u095C\n5\x03" + + "5\x055\u095F\n5\x035\x035\x055\u0963\n5\x035\x035\x035\x035\x035\x035" + + "\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x05" + + "5\u0978\n5\x035\x035\x035\x035\x055\u097E\n5\x035\x035\x035\x035\x035" + "\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + - "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + - "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + - "5\x035\x035\x035\x035\x035\x035\x035\x035"; + "5\x035"; private static readonly _serializedATNSegment1: string = "\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + - "5\x035\x055\u09BF\n5\x036\x036\x036\x036\x036\x056\u09C6\n6\x037\x037" + - "\x038\x038\x038\x039\x039\x039\x03:\x03:\x03:\x03:\x03:\x03:\x05:\u09D6" + - "\n:\x03;\x03;\x03;\x03;\x03<\x03<\x03<\x03=\x03=\x03=\x07=\u09E2\n=\f" + - "=\x0E=\u09E5\v=\x03>\x03>\x03>\x03>\x03>\x03>\x03>\x05>\u09EE\n>\x05>" + - "\u09F0\n>\x03?\x06?\u09F3\n?\r?\x0E?\u09F4\x03@\x03@\x05@\u09F9\n@\x03" + - "@\x05@\u09FC\n@\x03@\x03@\x03@\x03@\x05@\u0A02\n@\x05@\u0A04\n@\x03A\x03" + - "A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03" + - "A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x05A\u0A20\nA\x03" + - "B\x03B\x03B\x03C\x03C\x03C\x07C\u0A28\nC\fC\x0EC\u0A2B\vC\x03D\x03D\x03" + - "D\x03D\x03D\x03E\x03E\x03E\x07E\u0A35\nE\fE\x0EE\u0A38\vE\x03F\x03F\x03" + - "F\x03F\x05F\u0A3E\nF\x03F\x03F\x03F\x03F\x05F\u0A44\nF\x03F\x03F\x05F" + - "\u0A48\nF\x03F\x03F\x03F\x03F\x05F\u0A4E\nF\x03F\x03F\x03F\x05F\u0A53" + - "\nF\x03F\x05F\u0A56\nF\x05F\u0A58\nF\x03G\x03G\x03G\x05G\u0A5D\nG\x03" + - "H\x03H\x05H\u0A61\nH\x03H\x03H\x05H\u0A65\nH\x03H\x03H\x05H\u0A69\nH\x03" + - "H\x03H\x05H\u0A6D\nH\x03H\x05H\u0A70\nH\x03H\x03H\x05H\u0A74\nH\x03H\x03" + - "H\x03H\x03H\x03H\x03H\x05H\u0A7C\nH\x03H\x03H\x05H\u0A80\nH\x03H\x03H" + - "\x05H\u0A84\nH\x03I\x03I\x03J\x03J\x03K\x03K\x03K\x05K\u0A8D\nK\x03L\x03" + - "L\x03L\x03L\x03L\x05L\u0A94\nL\x03M\x07M\u0A97\nM\fM\x0EM\u0A9A\vM\x03" + - "N\x03N\x03N\x03N\x05N\u0AA0\nN\x03N\x03N\x03N\x05N\u0AA5\nN\x03N\x03N" + - "\x03N\x03N\x03N\x05N\u0AAC\nN\x03N\x03N\x03N\x05N\u0AB1\nN\x03N\x03N\x03" + - "N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x05" + - "N\u0AC3\nN\x03O\x03O\x03P\x05P\u0AC8\nP\x03P\x03P\x03P\x03Q\x03Q\x03R" + - "\x03R\x03R\x07R\u0AD2\nR\fR\x0ER\u0AD5\vR\x03S\x03S\x05S\u0AD9\nS\x03" + - "T\x03T\x03T\x03T\x03T\x03T\x03T\x05T\u0AE2\nT\x03U\x03U\x03U\x07U\u0AE7" + - "\nU\fU\x0EU\u0AEA\vU\x03V\x03V\x03W\x03W\x05W\u0AF0\nW\x03W\x03W\x03W" + - "\x03W\x05W\u0AF6\nW\x03W\x03W\x03W\x05W\u0AFB\nW\x03W\x03W\x05W\u0AFF" + - "\nW\x03W\x05W\u0B02\nW\x03W\x05W\u0B05\nW\x03W\x05W\u0B08\nW\x03W\x05" + - "W\u0B0B\nW\x03W\x05W\u0B0E\nW\x03W\x03W\x03W\x05W\u0B13\nW\x03W\x05W\u0B16" + - "\nW\x03W\x05W\u0B19\nW\x03W\x05W\u0B1C\nW\x03W\x05W\u0B1F\nW\x03W\x05" + - "W\u0B22\nW\x03W\x03W\x03W\x03W\x05W\u0B28\nW\x03W\x03W\x05W\u0B2C\nW\x03" + - "W\x05W\u0B2F\nW\x03W\x05W\u0B32\nW\x03W\x05W\u0B35\nW\x03W\x05W\u0B38" + - "\nW\x05W\u0B3A\nW\x03X\x03X\x03X\x03X\x03X\x03X\x03X\x05X\u0B43\nX\x03" + - "Y\x03Y\x03Z\x03Z\x03Z\x03Z\x03[\x03[\x03[\x07[\u0B4E\n[\f[\x0E[\u0B51" + - "\v[\x03\\\x03\\\x03\\\x07\\\u0B56\n\\\f\\\x0E\\\u0B59\v\\\x03]\x03]\x03" + - "]\x05]\u0B5E\n]\x03^\x03^\x05^\u0B62\n^\x03_\x03_\x03_\x05_\u0B67\n_\x03" + - "_\x03_\x03`\x03`\x03`\x05`\u0B6E\n`\x03`\x03`\x03a\x07a\u0B73\na\fa\x0E" + - "a\u0B76\va\x03b\x03b\x03b\x03b\x03b\x03b\x03b\x03b\x05b\u0B80\nb\x03c" + - "\x03c\x03c\x03c\x03c\x05c\u0B87\nc\x03c\x05c\u0B8A\nc\x03c\x03c\x03c\x05" + - "c\u0B8F\nc\x03c\x05c\u0B92\nc\x03c\x03c\x03c\x03c\x03c\x05c\u0B99\nc\x03" + - "c\x03c\x03c\x03c\x03c\x03c\x03c\x05c\u0BA2\nc\x03c\x03c\x03c\x03c\x03" + - "c\x05c\u0BA9\nc\x03c\x03c\x03c\x05c\u0BAE\nc\x03c\x05c\u0BB1\nc\x03c\x05" + - "c\u0BB4\nc\x05c\u0BB6\nc\x03d\x03d\x03d\x05d\u0BBB\nd\x03e\x03e\x03e\x03" + - "e\x03e\x05e\u0BC2\ne\x03f\x03f\x03f\x03f\x03g\x03g\x07g\u0BCA\ng\fg\x0E" + - "g\u0BCD\vg\x03h\x03h\x03i\x03i\x03i\x03i\x03i\x05i\u0BD6\ni\x03j\x03j" + - "\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x05j\u0BE3\nj\x03j\x05j" + - "\u0BE6\nj\x03j\x05j\u0BE9\nj\x03j\x03j\x03j\x03j\x03j\x05j\u0BF0\nj\x03" + - "j\x03j\x03j\x03j\x03j\x03j\x05j\u0BF8\nj\x03j\x05j\u0BFB\nj\x03j\x05j" + - "\u0BFE\nj\x03j\x03j\x03j\x03j\x03j\x05j\u0C05\nj\x03j\x03j\x05j\u0C09" + - "\nj\x03j\x03j\x03j\x03j\x05j\u0C0F\nj\x03j\x05j\u0C12\nj\x03j\x05j\u0C15" + - "\nj\x03j\x05j\u0C18\nj\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03j\x03" + - "j\x05j\u0C24\nj\x03j\x05j\u0C27\nj\x03j\x05j\u0C2A\nj\x03j\x03j\x05j\u0C2E" + - "\nj\x03k\x03k\x03k\x03l\x03l\x03l\x03l\x03m\x03m\x03m\x07m\u0C3A\nm\f" + - "m\x0Em\u0C3D\vm\x03n\x03n\x03o\x03o\x03o\x03o\x03o\x03p\x03p\x03p\x03" + - "q\x03q\x03q\x07q\u0C4C\nq\fq\x0Eq\u0C4F\vq\x03r\x03r\x03r\x03r\x03r\x03" + - "r\x03r\x03r\x05r\u0C59\nr\x03s\x03s\x03s\x03s\x03s\x03t\x03t\x03t\x03" + - "t\x03t\x03t\x03t\x03t\x05t\u0C68\nt\x03u\x03u\x03u\x03u\x03v\x03v\x03" + - "v\x03v\x03w\x03w\x03w\x03w\x03w\x03w\x05w\u0C78\nw\x03x\x03x\x03x\x03" + - "x\x03x\x03y\x03y\x03z\x03z\x03z\x03z\x03z\x03z\x03z\x03{\x03{\x03{\x07" + - "{\u0C8B\n{\f{\x0E{\u0C8E\v{\x03|\x03|\x05|\u0C92\n|\x03|\x05|\u0C95\n" + - "|\x03|\x03|\x05|\u0C99\n|\x03|\x05|\u0C9C\n|\x03|\x03|\x03|\x03|\x05|" + - "\u0CA2\n|\x03|\x05|\u0CA5\n|\x05|\u0CA7\n|\x03}\x03}\x03}\x03~\x03~\x03" + - "~\x03~\x05~\u0CB0\n~\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03\x7F\x03" + - "\x7F\x05\x7F\u0CB9\n\x7F\x03\x80\x03\x80\x03\x80\x03\x81\x03\x81\x03\x81" + - "\x03\x81\x03\x81\x03\x82\x03\x82\x03\x82\x03\x82\x03\x83\x03\x83\x03\x83" + - "\x03\x83\x03\x83\x05\x83\u0CCC\n\x83\x03\x83\x03\x83\x05\x83\u0CD0\n\x83" + - "\x03\x83\x03\x83\x03\x83\x03\x83\x03\x83\x03\x84\x03\x84\x03\x84\x03\x84" + - "\x05\x84\u0CDB\n\x84\x03\x84\x03\x84\x03\x84\x03\x84\x03\x84\x03\x85\x03" + - "\x85\x05\x85\u0CE4\n\x85\x03\x85\x03\x85\x03\x85\x03\x85\x05\x85\u0CEA" + - "\n\x85\x03\x85\x03\x85\x03\x85\x03\x85\x05\x85\u0CF0\n\x85\x03\x86\x03" + - "\x86\x05\x86\u0CF4\n\x86\x03\x86\x05\x86\u0CF7\n\x86\x03\x86\x05\x86\u0CFA" + - "\n\x86\x03\x86\x05\x86\u0CFD\n\x86\x03\x86\x05\x86\u0D00\n\x86\x03\x87" + - "\x03\x87\x03\x87\x03\x87\x05\x87\u0D06\n\x87\x03\x88\x03\x88\x05\x88\u0D0A" + - "\n\x88\x03\x88\x03\x88\x03\x88\x03\x88\x03\x88\x05\x88\u0D11\n\x88\x03" + - "\x88\x03\x88\x03\x88\x03\x88\x05\x88\u0D17\n\x88\x03\x89\x03\x89\x05\x89" + - "\u0D1B\n\x89\x03\x89\x05\x89\u0D1E\n\x89\x03\x89\x05\x89\u0D21\n\x89\x03" + - "\x89\x05\x89\u0D24\n\x89\x03\x8A\x03\x8A\x03\x8B\x03\x8B\x03\x8B\x03\x8B" + - "\x05\x8B\u0D2C\n\x8B\x03\x8B\x03\x8B\x05\x8B\u0D30\n\x8B\x03\x8C\x03\x8C" + - "\x05\x8C\u0D34\n\x8C\x03\x8C\x03\x8C\x03\x8C\x03\x8C\x05\x8C\u0D3A\n\x8C" + - "\x03\x8C\x03\x8C\x05\x8C\u0D3E\n\x8C\x03\x8D\x03\x8D\x03\x8D\x03\x8D\x05" + - "\x8D\u0D44\n\x8D\x03\x8D\x03\x8D\x03\x8D\x03\x8E\x03\x8E\x03\x8F\x03\x8F" + - "\x03\x8F\x03\x8F\x03\x90\x06\x90\u0D50\n\x90\r\x90\x0E\x90\u0D51\x03\x91" + - "\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x05\x91\u0D5B\n\x91\x03" + - "\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03" + - "\x91\x03\x91\x03\x91\x03\x91\x03\x91\x03\x91\x05\x91\u0D6C\n\x91\x03\x91" + - "\x03\x91\x03\x91\x05\x91\u0D71\n\x91\x03\x91\x05\x91\u0D74\n\x91\x05\x91" + - "\u0D76\n\x91\x03\x92\x03\x92\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03" + - "\x93\x05\x93\u0D80\n\x93\x03\x94\x03\x94\x03\x94\x07\x94\u0D85\n\x94\f" + - "\x94\x0E\x94\u0D88\v\x94\x03\x95\x03\x95\x05\x95\u0D8C\n\x95\x03\x95\x05" + - "\x95\u0D8F\n\x95\x03\x95\x05\x95\u0D92\n\x95\x03\x95\x03\x95\x03\x95\x03" + - "\x95\x03\x95\x05\x95\u0D99\n\x95\x03\x95\x05\x95\u0D9C\n\x95\x05\x95\u0D9E" + - "\n\x95\x03\x96\x03\x96\x03\x97\x03\x97\x05\x97\u0DA4\n\x97\x03\x98\x03" + - "\x98\x03\x98\x03\x99\x03\x99\x03\x99\x03\x99\x05\x99\u0DAD\n\x99\x03\x9A" + - "\x03\x9A\x03\x9B\x03\x9B\x03\x9C\x03\x9C\x03\x9C\x03\x9C\x05\x9C\u0DB7" + - "\n\x9C\x03\x9C\x03\x9C\x03\x9C\x05\x9C\u0DBC\n\x9C\x03\x9D\x03\x9D\x03" + - "\x9D\x03\x9E\x03\x9E\x03\x9E\x03\x9E\x05\x9E\u0DC5\n\x9E\x03\x9E\x03\x9E" + - "\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x03\x9F\x05\x9F\u0DCE\n\x9F\x03\x9F\x03" + - "\x9F\x05\x9F\u0DD2\n\x9F\x03\x9F\x03\x9F\x03\xA0\x07\xA0\u0DD7\n\xA0\f" + - "\xA0\x0E\xA0\u0DDA\v\xA0\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x03\xA1" + - "\x03\xA1\x05\xA1\u0DE3\n\xA1\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03\xA2\x03" + - "\xA2\x03\xA3\x07\xA3\u0DEC\n\xA3\f\xA3\x0E\xA3\u0DEF\v\xA3\x03\xA4\x03" + - "\xA4\x03\xA4\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03" + - "\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x03\xA5\x05\xA5\u0E5C\n\xA5" + - "\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x03\xA6\x05\xA6\u0E64\n\xA6\x03" + - "\xA6\x05\xA6\u0E67\n\xA6\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + - "\x03\xA7\x03\xA7\x05\xA7\u0E71\n\xA7\x03\xA8\x06\xA8\u0E74\n\xA8\r\xA8" + - "\x0E\xA8\u0E75\x03\xA9\x03\xA9\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA" + - "\x03\xAA\x05\xAA\u0E80\n\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03\xAA\x03" + - "\xAA\x03\xAA\x03\xAA\x03\xAA\x05\xAA\u0E8B\n\xAA\x03\xAB\x03\xAB\x03\xAB" + - "\x03\xAB\x03\xAB\x03\xAC\x03\xAC\x03\xAC\x07\xAC\u0E95\n\xAC\f\xAC\x0E" + - "\xAC\u0E98\v\xAC\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAE\x03\xAE" + - "\x03\xAE\x07\xAE\u0EA2\n\xAE\f\xAE\x0E\xAE\u0EA5\v\xAE\x03\xAF\x03\xAF" + - "\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x03\xAF\x05\xAF\u0EAE\n\xAF\x03\xB0\x03" + - "\xB0\x03\xB0\x03\xB1\x03\xB1\x03\xB2\x03\xB2\x03\xB3\x03\xB3\x03\xB3\x03" + - "\xB3\x05\xB3\u0EBB\n\xB3\x03\xB3\x05\xB3\u0EBE\n\xB3\x03\xB3\x03\xB3\x03" + - "\xB3\x03\xB3\x03\xB3\x05\xB3\u0EC5\n\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3" + - "\x03\xB3\x03\xB3\x03\xB3\x05\xB3\u0ECE\n\xB3\x03\xB3\x05\xB3\u0ED1\n\xB3" + - "\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x03\xB3\x05\xB3\u0ED8\n\xB3\x05\xB3\u0EDA" + - "\n\xB3\x03\xB4\x03\xB4\x03\xB4\x03\xB5\x03\xB5\x03\xB5\x05\xB5\u0EE2\n" + - "\xB5\x03\xB6\x03\xB6\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x03\xB7\x05" + - "\xB7\u0EEC\n\xB7\x05\xB7\u0EEE\n\xB7\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03" + - "\xB8\x03\xB8\x05\xB8\u0EF6\n\xB8\x03\xB8\x03\xB8\x05\xB8\u0EFA\n\xB8\x03" + - "\xB8\x03\xB8\x03\xB8\x05\xB8\u0EFF\n\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8" + - "\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x05\xB8\u0F0A\n\xB8\x03\xB8\x03" + - "\xB8\x05\xB8\u0F0E\n\xB8\x03\xB8\x03\xB8\x03\xB8\x05\xB8\u0F13\n\xB8\x03" + - "\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x05\xB8\u0F1D" + - "\n\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x05\xB8\u0F23\n\xB8\x03\xB8\x03" + - "\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x03" + - "\xB8\x05\xB8\u0F30\n\xB8\x03\xB8\x03\xB8\x03\xB8\x03\xB8\x05\xB8\u0F36" + - "\n\xB8\x05\xB8\u0F38\n\xB8\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x05" + - "\xB9\u0F3F\n\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x03\xB9\x05\xB9" + - "\u0F47\n\xB9\x03\xBA\x03\xBA\x03\xBA\x05\xBA\u0F4C\n\xBA\x03\xBB\x03\xBB" + - "\x03\xBB\x03\xBB\x03\xBB\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC" + - "\x03\xBC\x03\xBC\x05\xBC\u0F5B\n\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03" + - "\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x03\xBC\x05\xBC\u0F68\n\xBC" + - "\x05\xBC\u0F6A\n\xBC\x03\xBD\x03\xBD\x05\xBD\u0F6E\n\xBD\x03\xBE\x03\xBE" + - "\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE" + - "\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x05\xBE\u0F82" + - "\n\xBE\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF\x03\xBF" + - "\x03\xBF\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x05\xC0\u0F93" + - "\n\xC0\x03\xC0\x05\xC0\u0F96\n\xC0\x03\xC0\x05\xC0\u0F99\n\xC0\x03\xC0" + - "\x05\xC0\u0F9C\n\xC0\x03\xC0\x05\xC0\u0F9F\n\xC0\x03\xC1\x03\xC1\x03\xC1" + - "\x03\xC1\x03\xC1\x03\xC1\x05\xC1\u0FA7\n\xC1\x03\xC1\x05\xC1\u0FAA\n\xC1" + - "\x03\xC1\x05\xC1\u0FAD\n\xC1\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03" + - "\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC4\x03\xC4\x03\xC4\x03" + - "\xC5\x03\xC5\x03\xC5\x03\xC6\x03\xC6\x03\xC6\x03\xC7\x03\xC7\x03\xC7\x03" + - "\xC8\x03\xC8\x03\xC9\x03\xC9\x03\xC9\x03\xC9\x03\xC9\x03\xC9\x03\xC9\x03" + + "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + + "5\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x035\x03" + + "5\x035\x035\x035\x055\u09DD\n5\x036\x036\x036\x036\x036\x056\u09E4\n6" + + "\x037\x037\x038\x038\x038\x039\x039\x039\x03:\x03:\x03:\x03:\x03:\x03" + + ":\x05:\u09F4\n:\x03;\x03;\x03;\x03;\x03<\x03<\x03<\x03=\x03=\x03=\x07" + + "=\u0A00\n=\f=\x0E=\u0A03\v=\x03>\x03>\x03>\x03>\x03>\x03>\x03>\x05>\u0A0C" + + "\n>\x05>\u0A0E\n>\x03?\x06?\u0A11\n?\r?\x0E?\u0A12\x03@\x03@\x05@\u0A17" + + "\n@\x03@\x05@\u0A1A\n@\x03@\x03@\x03@\x03@\x05@\u0A20\n@\x05@\u0A22\n" + + "@\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03" + + "A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x03A\x05A\u0A3E" + + "\nA\x03B\x03B\x03B\x03C\x03C\x03C\x07C\u0A46\nC\fC\x0EC\u0A49\vC\x03D" + + "\x03D\x03D\x03D\x03D\x03E\x03E\x03E\x07E\u0A53\nE\fE\x0EE\u0A56\vE\x03" + + "F\x03F\x03F\x03F\x05F\u0A5C\nF\x03F\x03F\x03F\x03F\x05F\u0A62\nF\x03F" + + "\x03F\x05F\u0A66\nF\x03F\x03F\x03F\x03F\x05F\u0A6C\nF\x03F\x03F\x03F\x05" + + "F\u0A71\nF\x03F\x05F\u0A74\nF\x05F\u0A76\nF\x03G\x03G\x03G\x05G\u0A7B" + + "\nG\x03H\x03H\x05H\u0A7F\nH\x03H\x03H\x05H\u0A83\nH\x03H\x03H\x05H\u0A87" + + "\nH\x03H\x03H\x05H\u0A8B\nH\x03H\x05H\u0A8E\nH\x03H\x03H\x05H\u0A92\n" + + "H\x03H\x03H\x03H\x03H\x03H\x03H\x05H\u0A9A\nH\x03H\x03H\x05H\u0A9E\nH" + + "\x03H\x03H\x05H\u0AA2\nH\x03I\x03I\x03J\x03J\x03K\x03K\x03K\x05K\u0AAB" + + "\nK\x03L\x03L\x03L\x03L\x03L\x05L\u0AB2\nL\x03M\x07M\u0AB5\nM\fM\x0EM" + + "\u0AB8\vM\x03N\x03N\x03N\x03N\x05N\u0ABE\nN\x03N\x03N\x03N\x05N\u0AC3" + + "\nN\x03N\x03N\x03N\x03N\x03N\x05N\u0ACA\nN\x03N\x03N\x03N\x05N\u0ACF\n" + + "N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03N\x03" + + "N\x03N\x03N\x05N\u0AE1\nN\x03O\x03O\x03P\x05P\u0AE6\nP\x03P\x03P\x03P" + + "\x03Q\x03Q\x03R\x03R\x03R\x07R\u0AF0\nR\fR\x0ER\u0AF3\vR\x03S\x03S\x05" + + "S\u0AF7\nS\x03T\x03T\x03T\x03T\x03T\x03T\x03T\x05T\u0B00\nT\x03U\x03U" + + "\x03U\x07U\u0B05\nU\fU\x0EU\u0B08\vU\x03V\x03V\x03W\x03W\x05W\u0B0E\n" + + "W\x03W\x03W\x03W\x03W\x05W\u0B14\nW\x03W\x03W\x03W\x05W\u0B19\nW\x03W" + + "\x03W\x05W\u0B1D\nW\x03W\x05W\u0B20\nW\x03W\x05W\u0B23\nW\x03W\x05W\u0B26" + + "\nW\x03W\x05W\u0B29\nW\x03W\x05W\u0B2C\nW\x03W\x03W\x03W\x05W\u0B31\n" + + "W\x03W\x05W\u0B34\nW\x03W\x05W\u0B37\nW\x03W\x05W\u0B3A\nW\x03W\x05W\u0B3D" + + "\nW\x03W\x05W\u0B40\nW\x03W\x03W\x03W\x03W\x05W\u0B46\nW\x03W\x03W\x05" + + "W\u0B4A\nW\x03W\x05W\u0B4D\nW\x03W\x05W\u0B50\nW\x03W\x05W\u0B53\nW\x03" + + "W\x05W\u0B56\nW\x05W\u0B58\nW\x03X\x03X\x03X\x03X\x03X\x03X\x03X\x05X" + + "\u0B61\nX\x03Y\x03Y\x03Z\x03Z\x03[\x03[\x03[\x03[\x03\\\x03\\\x03\\\x07" + + "\\\u0B6E\n\\\f\\\x0E\\\u0B71\v\\\x03]\x03]\x03]\x07]\u0B76\n]\f]\x0E]" + + "\u0B79\v]\x03^\x03^\x03^\x05^\u0B7E\n^\x03_\x03_\x05_\u0B82\n_\x03`\x03" + + "`\x03`\x05`\u0B87\n`\x03`\x03`\x05`\u0B8B\n`\x03`\x03`\x03a\x03a\x03a" + + "\x05a\u0B92\na\x03a\x03a\x03b\x07b\u0B97\nb\fb\x0Eb\u0B9A\vb\x03c\x03" + + "c\x05c\u0B9E\nc\x03c\x03c\x05c\u0BA2\nc\x03c\x05c\u0BA5\nc\x03c\x03c\x05" + + "c\u0BA9\nc\x03c\x05c\u0BAC\nc\x05c\u0BAE\nc\x03d\x03d\x03d\x03d\x03d\x05" + + "d\u0BB5\nd\x03d\x05d\u0BB8\nd\x03d\x03d\x03d\x05d\u0BBD\nd\x03d\x05d\u0BC0" + + "\nd\x03d\x03d\x03d\x03d\x03d\x05d\u0BC7\nd\x03d\x03d\x03d\x03d\x03d\x03" + + "d\x03d\x05d\u0BD0\nd\x03d\x03d\x03d\x03d\x03d\x05d\u0BD7\nd\x03d\x03d" + + "\x03d\x05d\u0BDC\nd\x03d\x05d\u0BDF\nd\x03d\x05d\u0BE2\nd\x05d\u0BE4\n" + + "d\x03e\x03e\x03e\x05e\u0BE9\ne\x03f\x03f\x03f\x05f\u0BEE\nf\x03g\x03g" + + "\x03g\x03h\x03h\x03h\x03h\x03i\x03i\x07i\u0BF9\ni\fi\x0Ei\u0BFC\vi\x03" + + "j\x03j\x03k\x03k\x03k\x03k\x03k\x05k\u0C05\nk\x03l\x03l\x03l\x03l\x03" + + "l\x03l\x03l\x03l\x03l\x03l\x03l\x05l\u0C12\nl\x03l\x05l\u0C15\nl\x03l" + + "\x05l\u0C18\nl\x03l\x03l\x03l\x03l\x03l\x05l\u0C1F\nl\x03l\x03l\x03l\x03" + + "l\x03l\x03l\x05l\u0C27\nl\x03l\x05l\u0C2A\nl\x03l\x05l\u0C2D\nl\x03l\x03" + + "l\x03l\x03l\x03l\x05l\u0C34\nl\x03l\x03l\x05l\u0C38\nl\x03l\x03l\x03l" + + "\x03l\x05l\u0C3E\nl\x03l\x05l\u0C41\nl\x03l\x05l\u0C44\nl\x03l\x05l\u0C47" + + "\nl\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x03l\x05l\u0C53\nl\x03" + + "l\x05l\u0C56\nl\x03l\x05l\u0C59\nl\x03l\x03l\x05l\u0C5D\nl\x03m\x03m\x03" + + "m\x03n\x03n\x03n\x03n\x03o\x03o\x03o\x07o\u0C69\no\fo\x0Eo\u0C6C\vo\x03" + + "p\x03p\x03q\x03q\x03q\x03q\x03q\x03r\x03r\x03r\x03s\x03s\x03s\x07s\u0C7B" + + "\ns\fs\x0Es\u0C7E\vs\x03t\x03t\x03t\x03t\x03t\x03t\x03t\x03t\x05t\u0C88" + + "\nt\x03u\x03u\x03u\x03u\x03u\x03v\x03v\x03v\x03v\x03v\x03v\x03v\x03v\x05" + + "v\u0C97\nv\x03w\x03w\x03w\x03w\x03x\x03x\x03x\x03x\x03y\x03y\x03y\x03" + + "y\x03y\x03y\x05y\u0CA7\ny\x03z\x03z\x03z\x03z\x03z\x03{\x03{\x03|\x03" + + "|\x03|\x03|\x03|\x03|\x03|\x03}\x03}\x03}\x07}\u0CBA\n}\f}\x0E}\u0CBD" + + "\v}\x03~\x03~\x05~\u0CC1\n~\x03~\x05~\u0CC4\n~\x03~\x03~\x05~\u0CC8\n" + + "~\x03~\x05~\u0CCB\n~\x03~\x03~\x03~\x03~\x05~\u0CD1\n~\x03~\x05~\u0CD4" + + "\n~\x05~\u0CD6\n~\x03\x7F\x03\x7F\x03\x7F\x03\x80\x03\x80\x03\x80\x03" + + "\x80\x03\x80\x03\x80\x05\x80\u0CE1\n\x80\x03\x81\x03\x81\x03\x81\x03\x81" + + "\x03\x81\x03\x81\x03\x81\x05\x81\u0CEA\n\x81\x03\x82\x03\x82\x03\x82\x03" + + "\x83\x03\x83\x03\x83\x03\x83\x03\x83\x03\x84\x03\x84\x03\x84\x03\x84\x03" + + "\x85\x03\x85\x03\x85\x03\x85\x03\x85\x05\x85\u0CFD\n\x85\x03\x85\x03\x85" + + "\x05\x85\u0D01\n\x85\x03\x85\x03\x85\x03\x85\x03\x85\x03\x85\x03\x86\x03" + + "\x86\x03\x86\x03\x86\x05\x86\u0D0C\n\x86\x03\x86\x03\x86\x03\x86\x03\x86" + + "\x03\x86\x03\x87\x03\x87\x05\x87\u0D15\n\x87\x03\x87\x03\x87\x03\x87\x03" + + "\x87\x05\x87\u0D1B\n\x87\x03\x87\x03\x87\x03\x87\x03\x87\x05\x87\u0D21" + + "\n\x87\x03\x88\x03\x88\x05\x88\u0D25\n\x88\x03\x88\x05\x88\u0D28\n\x88" + + "\x03\x88\x05\x88\u0D2B\n\x88\x03\x88\x05\x88\u0D2E\n\x88\x03\x88\x05\x88" + + "\u0D31\n\x88\x03\x89\x03\x89\x03\x89\x03\x89\x05\x89\u0D37\n\x89\x03\x8A" + + "\x03\x8A\x05\x8A\u0D3B\n\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x05" + + "\x8A\u0D42\n\x8A\x03\x8A\x03\x8A\x03\x8A\x03\x8A\x05\x8A\u0D48\n\x8A\x03" + + "\x8B\x03\x8B\x05\x8B\u0D4C\n\x8B\x03\x8B\x05\x8B\u0D4F\n\x8B\x03\x8B\x05" + + "\x8B\u0D52\n\x8B\x03\x8B\x05\x8B\u0D55\n\x8B\x03\x8C\x03\x8C\x03\x8D\x03" + + "\x8D\x03\x8D\x03\x8D\x05\x8D\u0D5D\n\x8D\x03\x8D\x03\x8D\x05\x8D\u0D61" + + "\n\x8D\x03\x8E\x03\x8E\x05\x8E\u0D65\n\x8E\x03\x8E\x03\x8E\x03\x8E\x03" + + "\x8E\x05\x8E\u0D6B\n\x8E\x03\x8E\x03\x8E\x05\x8E\u0D6F\n\x8E\x03\x8F\x03" + + "\x8F\x03\x8F\x03\x8F\x05\x8F\u0D75\n\x8F\x03\x8F\x03\x8F\x03\x8F\x03\x90" + + "\x03\x90\x03\x91\x03\x91\x03\x91\x03\x91\x03\x92\x06\x92\u0D81\n\x92\r" + + "\x92\x0E\x92\u0D82\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03" + + "\x93\x05\x93\u0D8C\n\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93" + + "\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93\x03\x93" + + "\x05\x93\u0D9D\n\x93\x03\x93\x03\x93\x03\x93\x05\x93\u0DA2\n\x93\x03\x93" + + "\x05\x93\u0DA5\n\x93\x05\x93\u0DA7\n\x93\x03\x94\x03\x94\x03\x95\x03\x95" + + "\x03\x95\x03\x95\x03\x95\x03\x95\x05\x95\u0DB1\n\x95\x03\x96\x03\x96\x03" + + "\x96\x07\x96\u0DB6\n\x96\f\x96\x0E\x96\u0DB9\v\x96\x03\x97\x03\x97\x05" + + "\x97\u0DBD\n\x97\x03\x97\x05\x97\u0DC0\n\x97\x03\x97\x05\x97\u0DC3\n\x97" + + "\x03\x97\x03\x97\x03\x97\x03\x97\x03\x97\x05\x97\u0DCA\n\x97\x03\x97\x05" + + "\x97\u0DCD\n\x97\x05\x97\u0DCF\n\x97\x03\x98\x03\x98\x03\x99\x03\x99\x05" + + "\x99\u0DD5\n\x99\x03\x9A\x03\x9A\x03\x9A\x03\x9B\x03\x9B\x03\x9B\x03\x9B" + + "\x05\x9B\u0DDE\n\x9B\x03\x9C\x03\x9C\x03\x9D\x03\x9D\x03\x9E\x03\x9E\x03" + + "\x9E\x03\x9E\x05\x9E\u0DE8\n\x9E\x03\x9E\x03\x9E\x03\x9E\x05\x9E\u0DED" + + "\n\x9E\x03\x9F\x03\x9F\x03\x9F\x03\xA0\x03\xA0\x03\xA0\x03\xA0\x05\xA0" + + "\u0DF6\n\xA0\x03\xA0\x03\xA0\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x03\xA1\x05" + + "\xA1\u0DFF\n\xA1\x03\xA1\x03\xA1\x05\xA1\u0E03\n\xA1\x03\xA1\x03\xA1\x03" + + "\xA2\x07\xA2\u0E08\n\xA2\f\xA2\x0E\xA2\u0E0B\v\xA2\x03\xA3\x03\xA3\x03" + + "\xA3\x03\xA3\x03\xA3\x03\xA3\x03\xA3\x05\xA3\u0E14\n\xA3\x03\xA4\x03\xA4" + + "\x03\xA4\x03\xA4\x03\xA4\x03\xA4\x03\xA5\x07\xA5\u0E1D\n\xA5\f\xA5\x0E" + + "\xA5\u0E20\v\xA5\x03\xA6\x03\xA6\x03\xA6\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7\x03\xA7" + + "\x03\xA7\x05\xA7\u0E8D\n\xA7\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03\xA8\x03" + + "\xA8\x05\xA8\u0E95\n\xA8\x03\xA8\x05\xA8\u0E98\n\xA8\x03\xA9\x03\xA9\x03" + + "\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x03\xA9\x05\xA9\u0EA2\n\xA9\x03\xAA" + + "\x06\xAA\u0EA5\n\xAA\r\xAA\x0E\xAA\u0EA6\x03\xAB\x03\xAB\x03\xAC\x03\xAC" + + "\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x05\xAC\u0EB1\n\xAC\x03\xAC\x03\xAC\x03" + + "\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x03\xAC\x05\xAC\u0EBC\n\xAC" + + "\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAD\x03\xAE\x03\xAE\x03\xAE\x07\xAE" + + "\u0EC6\n\xAE\f\xAE\x0E\xAE\u0EC9\v\xAE\x03\xAF\x03\xAF\x03\xAF\x03\xAF" + + "\x03\xAF\x03\xB0\x03\xB0\x03\xB0\x07\xB0\u0ED3\n\xB0\f\xB0\x0E\xB0\u0ED6" + + "\v\xB0\x03\xB1\x03\xB1\x03\xB1\x03\xB1\x03\xB1\x03\xB1\x03\xB1\x05\xB1" + + "\u0EDF\n\xB1\x03\xB2\x03\xB2\x03\xB2\x03\xB3\x03\xB3\x03\xB4\x03\xB4\x03" + + "\xB5\x03\xB5\x03\xB5\x03\xB5\x05\xB5\u0EEC\n\xB5\x03\xB5\x05\xB5\u0EEF" + + "\n\xB5\x03\xB5\x03\xB5\x03\xB5\x03\xB5\x03\xB5\x05\xB5\u0EF6\n\xB5\x03" + + "\xB5\x03\xB5\x03\xB5\x03\xB5\x03\xB5\x03\xB5\x03\xB5\x05\xB5\u0EFF\n\xB5" + + "\x03\xB5\x05\xB5\u0F02\n\xB5\x03\xB5\x03\xB5\x03\xB5\x03\xB5\x03\xB5\x05" + + "\xB5\u0F09\n\xB5\x05\xB5\u0F0B\n\xB5\x03\xB6\x03\xB6\x03\xB6\x03\xB7\x03" + + "\xB7\x03\xB7\x05\xB7\u0F13\n\xB7\x03\xB8\x03\xB8\x03\xB9\x03\xB9\x03\xB9" + + "\x03\xB9\x03\xB9\x03\xB9\x05\xB9\u0F1D\n\xB9\x05\xB9\u0F1F\n\xB9\x03\xBA" + + "\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x05\xBA\u0F27\n\xBA\x03\xBA\x03" + + "\xBA\x05\xBA\u0F2B\n\xBA\x03\xBA\x03\xBA\x03\xBA\x05\xBA\u0F30\n\xBA\x03" + + "\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x05" + + "\xBA\u0F3B\n\xBA\x03\xBA\x03\xBA\x05\xBA\u0F3F\n\xBA\x03\xBA\x03\xBA\x03" + + "\xBA\x05\xBA\u0F44\n\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA" + + "\x03\xBA\x03\xBA\x05\xBA\u0F4E\n\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x05" + + "\xBA\u0F54\n\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x03\xBA" + + "\x03\xBA\x03\xBA\x03\xBA\x03\xBA\x05\xBA\u0F61\n\xBA\x03\xBA\x03\xBA\x03" + + "\xBA\x03\xBA\x05\xBA\u0F67\n\xBA\x05\xBA\u0F69\n\xBA\x03\xBB\x03\xBB\x03" + + "\xBB\x03\xBB\x03\xBB\x05\xBB\u0F70\n\xBB\x03\xBB\x03\xBB\x03\xBB\x03\xBB" + + "\x03\xBB\x03\xBB\x05\xBB\u0F78\n\xBB\x03\xBC\x03\xBC\x03\xBC\x05\xBC\u0F7D" + + "\n\xBC\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBD\x03\xBE\x03\xBE\x03\xBE" + + "\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x05\xBE\u0F8C\n\xBE\x03\xBE\x03" + + "\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03\xBE\x03" + + "\xBE\x05\xBE\u0F99\n\xBE\x05\xBE\u0F9B\n\xBE\x03\xBF\x03\xBF\x05\xBF\u0F9F" + + "\n\xBF\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0" + + "\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0\x03\xC0" + + "\x03\xC0\x05\xC0\u0FB3\n\xC0\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC1\x03" + + "\xC1\x03\xC1\x03\xC1\x03\xC1\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03\xC2\x03" + + "\xC2\x05\xC2\u0FC4\n\xC2\x03\xC2\x05\xC2\u0FC7\n\xC2\x03\xC2\x05\xC2\u0FCA" + + "\n\xC2\x03\xC2\x05\xC2\u0FCD\n\xC2\x03\xC2\x05\xC2\u0FD0\n\xC2\x03\xC3" + + "\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x03\xC3\x05\xC3\u0FD8\n\xC3\x03\xC3\x05" + + "\xC3\u0FDB\n\xC3\x03\xC3\x05\xC3\u0FDE\n\xC3\x03\xC4\x03\xC4\x03\xC4\x03" + + "\xC4\x03\xC4\x03\xC5\x03\xC5\x03\xC5\x03\xC5\x03\xC5\x03\xC5\x03\xC6\x03" + + "\xC6\x03\xC6\x03\xC7\x03\xC7\x03\xC7\x03\xC8\x03\xC8\x03\xC8\x03\xC9\x03" + "\xC9\x03\xC9\x03\xCA\x03\xCA\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03" + - "\xCB\x03\xCB\x03\xCB\x05\xCB\u0FDB\n\xCB\x03\xCB\x05\xCB\u0FDE\n\xCB\x03" + - "\xCB\x05\xCB\u0FE1\n\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB" + - "\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB" + - "\x03\xCB\x05\xCB\u0FF3\n\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x05" + - "\xCB\u0FFA\n\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCB" + - "\x05\xCB\u1003\n\xCB\x03\xCC\x03\xCC\x03\xCC\x03\xCC\x05\xCC\u1009\n\xCC" + - "\x03\xCD\x03\xCD\x03\xCD\x07\xCD\u100E\n\xCD\f\xCD\x0E\xCD\u1011\v\xCD" + - "\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x03\xCE\x05\xCE\u101A" + - "\n\xCE\x03\xCF\x03\xCF\x03\xCF\x03\xD0\x06\xD0\u1020\n\xD0\r\xD0\x0E\xD0" + - "\u1021\x03\xD1\x03\xD1\x03\xD1\x05\xD1\u1027\n\xD1\x03\xD1\x03\xD1\x03" + - "\xD2\x03\xD2\x03\xD3\x03\xD3\x03\xD4\x03\xD4\x03\xD5\x03\xD5\x05\xD5\u1033" + - "\n\xD5\x03\xD5\x03\xD5\x03\xD6\x03\xD6\x03\xD7\x03\xD7\x03\xD8\x03\xD8" + - "\x03\xD8\x03\xD8\x03\xD8\x03\xD9\x03\xD9\x03\xDA\x03\xDA\x05\xDA\u1044" + - "\n\xDA\x03\xDA\x03\xDA\x07\xDA\u1048\n\xDA\f\xDA\x0E\xDA\u104B\v\xDA\x03" + - "\xDB\x03\xDB\x03\xDB\x03\xDB\x05\xDB\u1051\n\xDB\x03\xDC\x03\xDC\x03\xDC" + - "\x03\xDD\x07\xDD\u1057\n\xDD\f\xDD\x0E\xDD\u105A\v\xDD\x03\xDE\x03\xDE" + - "\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE\x03\xDE" + - "\x05\xDE\u1067\n\xDE\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03" + - "\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03" + - "\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x03" + - "\xDF\x03\xDF\x05\xDF\u1083\n\xDF\x03\xE0\x03\xE0\x03\xE0\x07\xE0\u1088" + - "\n\xE0\f\xE0\x0E\xE0\u108B\v\xE0\x03\xE1\x03\xE1\x03\xE1\x03\xE1\x03\xE1" + - "\x03\xE1\x03\xE2\x03\xE2\x03\xE2\x07\xE2\u1096\n\xE2\f\xE2\x0E\xE2\u1099" + - "\v\xE2\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE4\x03\xE4" + - "\x03\xE4\x03\xE4\x03\xE4\x03\xE4\x05\xE4\u10A7\n\xE4\x03\xE5\x03\xE5\x03" + - "\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE6\x03\xE6\x05" + - "\xE6\u10B4\n\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6" + - "\x05\xE6\u10BD\n\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x05\xE6\u10D6" + - "\n\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6" + - "\x03\xE6\x05\xE6\u10E1\n\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03" + - "\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x03\xE6\x05\xE6\u1124\n\xE6\x03\xE7" + - "\x03\xE7\x03\xE7\x03\xE7\x03\xE8\x03\xE8\x03\xE8\x07\xE8\u112D\n\xE8\f" + - "\xE8\x0E\xE8\u1130\v\xE8\x03\xE9\x03\xE9\x03\xE9\x05\xE9\u1135\n\xE9\x03" + - "\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x05\xEA\u113D\n\xEA\x03\xEB" + - "\x03\xEB\x03\xEB\x03\xEB\x03\xEC\x03\xEC\x03\xEC\x07\xEC\u1146\n\xEC\f" + - "\xEC\x0E\xEC\u1149\v\xEC\x03\xED\x03\xED\x03\xED\x03\xED\x03\xEE\x03\xEE" + - "\x03\xEF\x03\xEF\x03\xEF\x07\xEF\u1154\n\xEF\f\xEF\x0E\xEF\u1157\v\xEF" + - "\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x05\xF0\u115F\n\xF0\x03" + - "\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x05\xF0\u1169" + - "\n\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0" + - "\x03\xF0\x03\xF0\x05\xF0\u1175\n\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03" + - "\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x03\xF0\x05" + - "\xF0\u1184\n\xF0\x03\xF1\x03\xF1\x03\xF1\x03\xF1\x03\xF2\x03\xF2\x03\xF2" + - "\x03\xF2\x03\xF2\x05\xF2\u118F\n\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF2\x03" + - "\xF2\x03\xF2\x05\xF2\u1197\n\xF2\x03\xF2\x03\xF2\x03\xF2\x03\xF3\x03\xF3" + - "\x03\xF3\x07\xF3\u119F\n\xF3\f\xF3\x0E\xF3\u11A2\v\xF3\x03\xF4\x03\xF4" + - "\x03\xF4\x03\xF4\x05\xF4\u11A8\n\xF4\x03\xF4\x05\xF4\u11AB\n\xF4\x03\xF4" + - "\x03\xF4\x03\xF4\x03\xF4\x05\xF4\u11B1\n\xF4\x03\xF4\x05\xF4\u11B4\n\xF4" + - "\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4" + - "\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x05\xF4\u11C3\n\xF4\x03\xF5\x03\xF5\x03" + - "\xF6\x03\xF6\x03\xF6\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x03\xF7\x05" + - "\xF7\u11D0\n\xF7\x03\xF8\x03\xF8\x03\xF9\x03\xF9\x03\xF9\x03\xF9\x03\xF9" + - "\x03\xF9\x03\xF9\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA" + - "\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA\x03\xFA" + - "\x03\xFA\x03\xFA\x05\xFA\u11ED\n\xFA\x03\xFB\x03\xFB\x03\xFB\x07\xFB\u11F2" + - "\n\xFB\f\xFB\x0E\xFB\u11F5\v\xFB\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFC" + - "\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x03\xFC\x05\xFC\u1203" + - "\n\xFC\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x05\xFD" + - "\u120C\n\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03" + - "\xFD\x03\xFD\x05\xFD\u1217\n\xFD\x05\xFD\u1219\n\xFD\x03\xFE\x03\xFE\x03" + - "\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x05\xFE\u1222\n\xFE\x03\xFE\x03\xFE" + - "\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x05\xFE\u122D" + - "\n\xFE\x05\xFE\u122F\n\xFE\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x03\xFF\x05" + - "\xFF\u1236\n\xFF\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03" + - "\u0100\x03\u0100\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03" + - "\u0101\x05\u0101\u1245\n\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101" + - "\x05\u0101\u124B\n\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101" + - "\x03\u0101\x05\u0101\u1253\n\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101" + - "\x05\u0101\u1259\n\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101" + - "\x03\u0101\x05\u0101\u1261\n\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101" + - "\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x05\u0101\u126B\n\u0101\x03\u0101" + - "\x03\u0101\x03\u0101\x03\u0101\x05\u0101\u1271\n\u0101\x03\u0101\x03\u0101" + - "\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x05\u0101\u1279\n\u0101\x03\u0101" + - "\x03\u0101\x03\u0101\x03\u0101\x05\u0101\u127F\n\u0101\x03\u0101\x03\u0101" + - "\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x05\u0101\u1287\n\u0101\x03\u0101" + - "\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x05\u0101\u128E\n\u0101\x03\u0101" + - "\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x05\u0101" + - "\u1297\n\u0101\x05\u0101\u1299\n\u0101\x03\u0102\x03\u0102\x03\u0102\x03" + - "\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03" + - "\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03" + - "\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x05\u0102\u12B2" + - "\n\u0102\x03\u0103\x03\u0103\x03\u0103\x03\u0103\x03\u0103"; - private static readonly _serializedATNSegment2: string = - "\x05\u0103\u12B9\n\u0103\x03\u0104\x03\u0104\x03\u0104\x03\u0104\x03\u0104" + - "\x03\u0104\x03\u0104\x03\u0104\x03\u0104\x05\u0104\u12C4\n\u0104\x03\u0104" + - "\x03\u0104\x03\u0104\x03\u0104\x05\u0104\u12CA\n\u0104\x03\u0105\x03\u0105" + - "\x03\u0106\x03\u0106\x03\u0106\x07\u0106\u12D1\n\u0106\f\u0106\x0E\u0106" + - "\u12D4\v\u0106\x03\u0107\x03\u0107\x05\u0107\u12D8\n\u0107\x03\u0108\x03" + - "\u0108\x06\u0108\u12DC\n\u0108\r\u0108\x0E\u0108\u12DD\x03\u0109\x03\u0109" + - "\x03\u0109\x07\u0109\u12E3\n\u0109\f\u0109\x0E\u0109\u12E6\v\u0109\x03" + - "\u010A\x03\u010A\x05\u010A\u12EA\n\u010A\x03\u010A\x03\u010A\x05\u010A" + - "\u12EE\n\u010A\x03\u010A\x05\u010A\u12F1\n\u010A\x03\u010B\x03\u010B\x03" + - "\u010B\x03\u010B\x05\u010B\u12F7\n\u010B\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x03\u010C" + - "\x03\u010C\x03\u010C\x03\u010C\x03\u010C\x05\u010C\u138C\n\u010C\x03\u010D" + - "\x03\u010D\x05\u010D\u1390\n\u010D\x03\u010E\x03\u010E\x03\u010E\x05\u010E" + - "\u1395\n\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x03\u010E\x05\u010E\u13A0\n\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x05\u010E\u13AB\n\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x05\u010E\u13B6\n\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x05\u010E\u13C1\n\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x05\u010E\u13CC\n\u010E" + - "\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x05\u010E\u13D7\n\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x05\u010E" + - "\u13E2\n\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x05\u010E\u13EE\n\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x05\u010E\u13F9\n\u010E\x03\u010E\x03\u010E\x03\u010E\x03\u010E" + - "\x03\u010E\x03\u010E\x05\u010E\u1401\n\u010E\x03\u010F\x03\u010F\x03\u010F" + - "\x03\u0110\x03\u0110\x05\u0110\u1408\n\u0110\x03\u0111\x03\u0111\x03\u0111" + - "\x03\u0111\x05\u0111\u140E\n\u0111\x03\u0112\x03\u0112\x03\u0112\x03\u0112" + - "\x03\u0112\x03\u0112\x05\u0112\u1416\n\u0112\x03\u0112\x03\u0112\x03\u0112" + - "\x05\u0112\u141B\n\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u1420" + - "\n\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u1425\n\u0112\x03\u0112" + - "\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u142B\n\u0112\x03\u0112\x03\u0112" + - "\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u1432\n\u0112\x03\u0112\x03\u0112" + - "\x03\u0112\x03\u0112\x05\u0112\u1438\n\u0112\x03\u0112\x03\u0112\x03\u0112" + - "\x03\u0112\x05\u0112\u143E\n\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112" + - "\u1443\n\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u1449" + - "\n\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u1450" + - "\n\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u1455\n\u0112\x03\u0112" + - "\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u145B\n\u0112\x03\u0112\x03\u0112" + - "\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u1462\n\u0112\x03\u0112\x05\u0112" + - "\u1465\n\u0112\x03\u0113\x03\u0113\x03\u0114\x03\u0114\x03\u0115\x03\u0115" + - "\x03\u0115\x03\u0115\x03\u0115\x03\u0115\x03\u0115\x05\u0115\u1472\n\u0115" + - "\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116" + - "\x05\u0116\u147B\n\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116" + - "\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u1487\n\u0116" + - "\x05\u0116\u1489\n\u0116\x03\u0117\x03\u0117\x03\u0117\x03\u0117\x03\u0117" + - "\x03\u0117\x03\u0117\x03\u0117\x03\u0117\x03\u0117\x03\u0117\x03\u0117" + - "\x03\u0117\x03\u0117\x03\u0117\x05\u0117\u149A\n\u0117\x03\u0118\x03\u0118" + - "\x03\u0118\x07\u0118\u149F\n\u0118\f\u0118\x0E\u0118\u14A2\v\u0118\x03" + - "\u0119\x03\u0119\x05\u0119\u14A6\n\u0119\x03\u0119\x03\u0119\x05\u0119" + - "\u14AA\n\u0119\x03\u0119\x03\u0119\x05\u0119\u14AE\n\u0119\x03\u0119\x03" + - "\u0119\x05\u0119\u14B2\n\u0119\x05\u0119\u14B4\n\u0119\x03\u011A\x03\u011A" + - "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + - "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + - "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + - "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + - "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + - "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + - "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + - "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + - "\x05\u011A\u14F0\n\u011A\x03\u011B\x03\u011B\x03\u011B\x07\u011B\u14F5" + - "\n\u011B\f\u011B\x0E\u011B\u14F8\v\u011B\x03\u011C\x03\u011C\x03\u011C" + - "\x05\u011C\u14FD\n\u011C\x03\u011D\x03\u011D\x03\u011D\x03\u011D\x03\u011E" + - "\x03\u011E\x03\u011E\x03\u011E\x03\u011E\x05\u011E\u1508\n\u011E\x03\u011E" + - "\x05\u011E\u150B\n\u011E\x03\u011F\x03\u011F\x03\u011F\x03\u011F\x03\u011F" + - "\x05\u011F\u1512\n\u011F\x03\u011F\x05\u011F\u1515\n\u011F\x03\u011F\x03" + - "\u011F\x03\u011F\x03\u011F\x03\u011F\x03\u011F\x03\u011F\x03\u011F\x05" + - "\u011F\u151F\n\u011F\x03\u011F\x05\u011F\u1522\n\u011F\x05\u011F\u1524" + - "\n\u011F\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0121\x03\u0121\x03" + - "\u0121\x03\u0121\x03\u0122\x03\u0122\x03\u0122\x03\u0122\x03\u0122\x03" + - "\u0122\x03\u0123\x07\u0123\u1535\n\u0123\f\u0123\x0E\u0123\u1538\v\u0123" + - "\x03\u0124\x03\u0124\x03\u0124\x03\u0124\x03\u0124\x03\u0124\x03\u0124" + - "\x03\u0124\x03\u0124\x05\u0124\u1543\n\u0124\x03\u0125\x03\u0125\x03\u0125" + - "\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x05\u0125\u154C\n\u0125\x03\u0125" + - "\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x05\u0125" + - "\u1555\n\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125" + - "\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x05\u0125\u1561\n\u0125\x05\u0125" + - "\u1563\n\u0125\x03\u0126\x03\u0126\x03\u0127\x03\u0127\x05\u0127\u1569" + - "\n\u0127\x03\u0127\x03\u0127\x05\u0127\u156D\n\u0127\x03\u0127\x05\u0127" + - "\u1570\n\u0127\x03\u0127\x03\u0127\x03\u0127\x05\u0127\u1575\n\u0127\x03" + - "\u0127\x03\u0127\x03\u0127\x03\u0127\x05\u0127\u157B\n\u0127\x03\u0127" + - "\x05\u0127\u157E\n\u0127\x03\u0127\x05\u0127\u1581\n\u0127\x03\u0127\x05" + - "\u0127\u1584\n\u0127\x03\u0127\x03\u0127\x05\u0127\u1588\n\u0127\x03\u0127" + - "\x03\u0127\x05\u0127\u158C\n\u0127\x03\u0127\x03\u0127\x03\u0127\x03\u0127" + - "\x03\u0127\x03\u0127\x03\u0127\x05\u0127\u1595\n\u0127\x03\u0127\x03\u0127" + - "\x03\u0127\x03\u0127\x05\u0127\u159B\n\u0127\x03\u0127\x05\u0127\u159E" + - "\n\u0127\x03\u0127\x05\u0127\u15A1\n\u0127\x03\u0127\x05\u0127\u15A4\n" + - "\u0127\x05\u0127\u15A6\n\u0127\x03\u0128\x03\u0128\x03\u0129\x03\u0129" + - "\x03\u012A\x03\u012A\x03\u012B\x03\u012B\x03\u012B\x03\u012C\x03\u012C" + - "\x03\u012C\x07\u012C\u15B4\n\u012C\f\u012C\x0E\u012C\u15B7\v\u012C\x03" + - "\u012D\x05\u012D\u15BA\n\u012D\x03\u012D\x05\u012D\u15BD\n\u012D\x03\u012D" + - "\x05\u012D\u15C0\n\u012D\x03\u012D\x05\u012D\u15C3\n\u012D\x03\u012D\x05" + - "\u012D\u15C6\n\u012D\x03\u012D\x03\u012D\x03\u012D\x05\u012D\u15CB\n\u012D" + - "\x03\u012D\x05\u012D\u15CE\n\u012D\x05\u012D\u15D0\n\u012D\x03\u012E\x03" + - "\u012E\x03\u012E\x03\u012E\x03\u012E\x03\u012E\x03\u012E\x03\u012E\x03" + - "\u012E\x03\u012E\x03\u012E\x05\u012E\u15DD\n\u012E\x03\u012F\x03\u012F" + - "\x03\u012F\x03\u012F\x03\u012F\x03\u0130\x03\u0130\x03\u0130\x07\u0130" + - "\u15E7\n\u0130\f\u0130\x0E\u0130\u15EA\v\u0130\x03\u0131\x03\u0131\x03" + - "\u0131\x03\u0132\x03\u0132\x03\u0133\x03\u0133\x03\u0134\x03\u0134\x03" + - "\u0134\x03\u0134\x05\u0134\u15F7\n\u0134\x03\u0135\x03\u0135\x05\u0135" + - "\u15FB\n\u0135\x03\u0135\x03\u0135\x03\u0135\x03\u0135\x03\u0135\x03\u0135" + - "\x03\u0135\x03\u0135\x03\u0135\x03\u0135\x05\u0135\u1607\n\u0135\x05\u0135" + - "\u1609\n\u0135\x03\u0135\x03\u0135\x03\u0136\x03\u0136\x03\u0136\x03\u0137" + - "\x03\u0137\x05\u0137\u1612\n\u0137\x03\u0137\x03\u0137\x03\u0138\x03\u0138" + - "\x03\u0138\x07\u0138\u1619\n\u0138\f\u0138\x0E\u0138\u161C\v\u0138\x03" + - "\u0139\x03\u0139\x03\u0139\x07\u0139\u1621\n\u0139\f\u0139\x0E\u0139\u1624" + - "\v\u0139\x03\u013A\x03\u013A\x03\u013A\x03\u013A\x03\u013A\x03\u013A\x05" + - "\u013A\u162C\n\u013A\x05\u013A\u162E\n\u013A\x03\u013B\x03\u013B\x05\u013B" + - "\u1632\n\u013B\x03\u013B\x03\u013B\x03\u013C\x03\u013C\x03\u013C\x07\u013C" + - "\u1639\n\u013C\f\u013C\x0E\u013C\u163C\v\u013C\x03\u013D\x03\u013D\x05" + - "\u013D\u1640\n\u013D\x03\u013D\x03\u013D\x03\u013D\x03\u013D\x05\u013D" + - "\u1646\n\u013D\x03\u013D\x03\u013D\x03\u013D\x05\u013D\u164B\n\u013D\x03" + - "\u013E\x03\u013E\x05\u013E\u164F\n\u013E\x03\u013E\x03\u013E\x03\u013E" + - "\x05\u013E\u1654\n\u013E\x03\u013F\x03\u013F\x03\u0140\x03\u0140\x03\u0141" + - "\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x03\u0141" + - "\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x05\u0141\u1666\n\u0141\x03\u0142" + - "\x03\u0142\x03\u0142\x05\u0142\u166B\n\u0142\x03\u0143\x03\u0143\x03\u0144" + - "\x03\u0144\x03\u0144\x03\u0144\x03\u0144\x03\u0144\x03\u0144\x03\u0144" + - "\x03\u0144\x03\u0144\x03\u0144\x05\u0144\u167A\n\u0144\x03\u0144\x03\u0144" + - "\x03\u0145\x03\u0145\x03\u0145\x07\u0145\u1681\n\u0145\f\u0145\x0E\u0145" + - "\u1684\v\u0145\x03\u0146\x03\u0146\x03\u0146\x03\u0147\x03\u0147\x03\u0147" + - "\x07\u0147\u168C\n\u0147\f\u0147\x0E\u0147\u168F\v\u0147\x03\u0148\x06" + - "\u0148\u1692\n\u0148\r\u0148\x0E\u0148\u1693\x03\u0148\x03\u0148\x03\u0149" + - "\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149" + - "\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149" + - "\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149" + - "\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149" + - "\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x03\u0149\x05\u0149" + - "\u16BB\n\u0149\x03\u014A\x03\u014A\x03\u014A\x03\u014A\x03\u014A\x03\u014A" + - "\x03\u014A\x03\u014A\x05\u014A\u16C5\n\u014A\x03\u014B\x03\u014B\x03\u014B" + - "\x03\u014B\x03\u014B\x05\u014B\u16CC\n\u014B\x03\u014C\x03\u014C\x03\u014C" + - "\x03\u014C\x03\u014C\x03\u014C\x03\u014C\x07\u014C\u16D5\n\u014C\f\u014C" + - "\x0E\u014C\u16D8\v\u014C\x03\u014D\x03\u014D\x03\u014D\x03\u014E\x03\u014E" + - "\x03\u014E\x03\u014F\x03\u014F\x03\u014F\x07\u014F\u16E3\n\u014F\f\u014F" + - "\x0E\u014F\u16E6\v\u014F\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150" + - "\x05\u0150\u16ED\n\u0150\x03\u0151\x06\u0151\u16F0\n\u0151\r\u0151\x0E" + - "\u0151\u16F1\x03\u0152\x03\u0152\x03\u0153\x03\u0153\x03\u0153\x03\u0153" + - "\x05\u0153\u16FA\n\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153" + - "\x03\u0153\x05\u0153\u1702\n\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153" + - "\x05\u0153\u1708\n\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153" + - "\x03\u0153\x05\u0153\u1710\n\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153" + - "\x05\u0153\u1716\n\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153" + - "\x03\u0153\x05\u0153\u171E\n\u0153\x05\u0153\u1720\n\u0153\x03\u0154\x03" + - "\u0154\x03\u0154\x03\u0154\x05\u0154\u1726\n\u0154\x03\u0154\x03\u0154" + - "\x03\u0154\x03\u0154\x03\u0154\x03\u0154\x05\u0154\u172E\n\u0154\x05\u0154" + - "\u1730\n\u0154\x03\u0155\x03\u0155\x03\u0155\x03\u0155\x05\u0155\u1736" + - "\n\u0155\x03\u0155\x03\u0155\x03\u0155\x03\u0155\x03\u0155\x03\u0155\x05" + - "\u0155\u173E\n\u0155\x05\u0155\u1740\n\u0155\x03\u0156\x03\u0156\x03\u0156" + - "\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156" + - "\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156" + - "\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x03\u0156\x05\u0156\u1758\n\u0156" + - "\x03\u0157\x03\u0157\x03\u0157\x07\u0157\u175D\n\u0157\f\u0157\x0E\u0157" + - "\u1760\v\u0157\x03\u0157\x03\u0157\x03\u0158\x03\u0158\x03\u0158\x07\u0158" + - "\u1767\n\u0158\f\u0158\x0E\u0158\u176A\v\u0158\x03\u0159\x03\u0159\x03" + - "\u0159\x03\u015A\x03\u015A\x03\u015A\x03\u015B\x06\u015B\u1773\n\u015B" + - "\r\u015B\x0E\u015B\u1774\x03\u015C\x03\u015C\x03\u015C\x05\u015C\u177A" + - "\n\u015C\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03" + - "\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x05\u015D\u1787\n\u015D" + - "\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D" + - "\x03\u015D\x03\u015D\x03\u015D\x05\u015D\u1793\n\u015D\x03\u015D\x03\u015D" + - "\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D" + - "\x03\u015D\x05\u015D\u179F\n\u015D\x05\u015D\u17A1\n\u015D\x03\u015E\x03" + - "\u015E\x03\u015E\x03\u015E\x05\u015E\u17A7\n\u015E\x03\u015F\x03\u015F" + - "\x03\u015F\x05\u015F\u17AC\n\u015F\x03\u015F\x03\u015F\x03\u015F\x03\u015F" + - "\x03\u015F\x03\u015F\x05\u015F\u17B4\n\u015F\x03\u0160\x03\u0160\x03\u0160" + - "\x03\u0161\x03\u0161\x05\u0161\u17BB\n\u0161\x03\u0161\x03\u0161\x03\u0161" + - "\x03\u0161\x03\u0161\x03\u0161\x03\u0161\x03\u0161\x03\u0161\x03\u0162" + - "\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162" + - "\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162" + - "\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162" + - "\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162" + - "\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x03\u0162\x05\u0162\u17E8\n\u0162" + - "\x03\u0163\x03\u0163\x03\u0163\x05\u0163\u17ED\n\u0163\x03\u0163\x03\u0163" + - "\x03\u0163\x03\u0163\x03\u0163\x05\u0163\u17F4\n\u0163\x03\u0164\x03\u0164" + - "\x03\u0164\x05\u0164\u17F9\n\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164" + - "\x03\u0164\x05\u0164\u1800\n\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164" + - "\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x05\u0164\u180A\n\u0164\x03\u0164" + - "\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164" + - "\x05\u0164\u1814\n\u0164\x03\u0164\x03\u0164\x05\u0164\u1818\n\u0164\x03" + - "\u0165\x03\u0165\x03\u0166\x03\u0166\x03\u0167\x03\u0167\x03\u0167\x07" + - "\u0167\u1821\n\u0167\f\u0167\x0E\u0167\u1824\v\u0167\x03\u0168\x03\u0168" + - "\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169" + - "\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x05\u0169\u1834\n\u0169" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x05\u016A" + - "\u187B\n\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x05\u016A\u193E\n\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x05\u016A\u194B\n\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x05\u016A\u1956\n\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x05\u016A\u1963\n\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x05\u016A\u196F\n\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x05\u016A\u197D\n\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x05\u016A\u199D\n\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x05\u016A\u19AB\n\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A\x03\u016A" + - "\x03\u016A\x03\u016A\x05\u016A\u1A1B\n\u016A\x05\u016A\u1A1D\n\u016A\x03" + - "\u016B\x03\u016B\x03\u016C\x03\u016C\x03\u016C\x03\u016D\x03\u016D\x03" + - "\u016D\x03\u016D\x05\u016D\u1A28\n\u016D\x03\u016D\x03\u016D\x03\u016D" + - "\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x05\u016D" + - "\u1A33\n\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D" + - "\x03\u016D\x03\u016D\x03\u016D\x05\u016D\u1A3E\n\u016D\x03\u016D\x03\u016D" + - "\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D" + - "\x03\u016D\x03\u016D\x05\u016D\u1A4B\n\u016D\x03\u016D\x03\u016D\x03\u016D" + - "\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D" + - "\x05\u016D\u1A57\n\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x03\u016D" + - "\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x05\u016D\u1A62\n\u016D\x03\u016D" + - "\x03\u016D\x03\u016D\x03\u016D\x03\u016D\x05\u016D\u1A69\n\u016D\x03\u016E" + - "\x03\u016E\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F\x03\u016F" + - "\x03\u016F\x05\u016F\u1B46\n\u016F\x03\u0170\x03\u0170\x03\u0170\x03\u0170" + - "\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0171\x03\u0171\x03\u0171" + - "\x07\u0171\u1B53\n\u0171\f\u0171\x0E\u0171\u1B56\v\u0171\x03\u0172\x03" + - "\u0172\x03\u0172\x03\u0172\x03\u0172\x03\u0172\x03\u0172\x03\u0172\x05" + - "\u0172\u1B60\n\u0172\x03\u0173\x03\u0173\x03\u0173\x03\u0173\x03\u0173" + - "\x05\u0173\u1B67\n\u0173\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174" + - "\x03\u0174\x03\u0174\x03\u0174\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x05\u0175\u1B9D\n\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + - "\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175" + + "\xCB\x03\xCB\x03\xCB\x03\xCB\x03\xCC\x03\xCC\x03\xCD\x03\xCD\x03\xCD\x03" + + "\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x05\xCD\u100C\n\xCD\x03\xCD\x05\xCD" + + "\u100F\n\xCD\x03\xCD\x05\xCD\u1012\n\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD" + + "\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x05\xCD\u101D\n\xCD\x03\xCD\x03" + + "\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x05\xCD\u1026\n\xCD\x03\xCD" + + "\x03\xCD\x05\xCD\u102A\n\xCD\x03\xCD\x05\xCD\u102D\n\xCD\x03\xCD\x03\xCD" + + "\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x03\xCD\x05\xCD\u1036\n\xCD\x03\xCE\x03" + + "\xCE\x03\xCE\x03\xCE\x05\xCE\u103C\n\xCE\x03\xCF\x03\xCF\x05\xCF\u1040" + + "\n\xCF\x03\xCF\x03\xCF\x03\xD0\x03\xD0\x03\xD1\x03\xD1\x03\xD1\x07\xD1" + + "\u1049\n\xD1\f\xD1\x0E\xD1\u104C\v\xD1\x03\xD2\x03\xD2\x03\xD2\x03\xD2" + + "\x03\xD2\x03\xD2\x03\xD2\x05\xD2\u1055\n\xD2\x03\xD3\x03\xD3\x03\xD3\x03" + + "\xD4\x06\xD4\u105B\n\xD4\r\xD4\x0E\xD4\u105C\x03\xD5\x03\xD5\x03\xD5\x05" + + "\xD5\u1062\n\xD5\x03\xD5\x03\xD5\x03\xD6\x03\xD6\x03\xD7\x03\xD7\x03\xD8" + + "\x03\xD8\x03\xD9\x03\xD9\x05\xD9\u106E\n\xD9\x03\xD9\x03\xD9\x03\xDA\x03" + + "\xDA\x03\xDB\x03\xDB\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDC\x03\xDD\x03" + + "\xDD\x03\xDE\x03\xDE\x05\xDE\u107F\n\xDE\x03\xDE\x03\xDE\x07\xDE\u1083" + + "\n\xDE\f\xDE\x0E\xDE\u1086\v\xDE\x03\xDF\x03\xDF\x03\xDF\x03\xDF\x05\xDF" + + "\u108C\n\xDF\x03\xE0\x03\xE0\x03\xE0\x03\xE1\x07\xE1\u1092\n\xE1\f\xE1" + + "\x0E\xE1\u1095\v\xE1\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x03" + + "\xE2\x03\xE2\x03\xE2\x03\xE2\x03\xE2\x05\xE2\u10A2\n\xE2\x03\xE3\x03\xE3" + + "\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3" + + "\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3" + + "\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x03\xE3\x05\xE3\u10BE\n\xE3\x03" + + "\xE4\x03\xE4\x03\xE4\x07\xE4\u10C3\n\xE4\f\xE4\x0E\xE4\u10C6\v\xE4\x03" + + "\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE5\x03\xE6\x03\xE6\x03\xE6\x07" + + "\xE6\u10D1\n\xE6\f\xE6\x0E\xE6\u10D4\v\xE6\x03\xE7\x03\xE7\x03\xE7\x03" + + "\xE7\x03\xE7\x03\xE7\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x03\xE8\x05" + + "\xE8\u10E2\n\xE8\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9\x03\xE9" + + "\x03\xE9\x03\xE9\x03\xEA\x03\xEA\x05\xEA\u10EF\n\xEA\x03\xEA\x03\xEA\x03" + + "\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x05\xEA\u10F8\n\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x05\xEA\u1111\n\xEA\x03\xEA\x03\xEA\x03\xEA\x03" + + "\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x05\xEA\u111C\n\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA\x03\xEA" + + "\x03\xEA\x05\xEA\u115F\n\xEA\x03\xEB\x03\xEB\x03\xEB\x03\xEB\x03\xEC\x03" + + "\xEC\x03\xEC\x07\xEC\u1168\n\xEC\f\xEC\x0E\xEC\u116B\v\xEC\x03\xED\x03" + + "\xED\x03\xED\x05\xED\u1170\n\xED\x03\xEE\x03\xEE\x03\xEE\x03\xEE\x03\xEE" + + "\x03\xEE\x05\xEE\u1178\n\xEE\x03\xEF\x03\xEF\x03\xEF\x03\xEF\x03\xF0\x03" + + "\xF0\x03\xF0\x07\xF0\u1181\n\xF0\f\xF0\x0E\xF0\u1184\v\xF0\x03\xF1\x03" + + "\xF1\x03\xF1\x03\xF1\x03\xF2\x03\xF2\x03\xF3\x03\xF3\x03\xF3\x07\xF3\u118F" + + "\n\xF3\f\xF3\x0E\xF3\u1192\v\xF3\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4" + + "\x03\xF4\x05\xF4\u119A\n\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03" + + "\xF4\x03\xF4\x03\xF4\x05\xF4\u11A4\n\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4" + + "\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x05\xF4\u11B0\n\xF4\x03" + + "\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03\xF4\x03" + + "\xF4\x03\xF4\x03\xF4\x03\xF4\x05\xF4\u11BF\n\xF4\x03\xF5\x03\xF5\x03\xF5" + + "\x03\xF5\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x05\xF6\u11CA\n\xF6\x03" + + "\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x03\xF6\x05\xF6\u11D2\n\xF6\x03\xF6" + + "\x03\xF6\x03\xF6\x03\xF7\x03\xF7\x03\xF7\x07\xF7\u11DA\n\xF7\f\xF7\x0E" + + "\xF7\u11DD\v\xF7\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x05\xF8\u11E3\n\xF8\x03" + + "\xF8\x05\xF8\u11E6\n\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x05\xF8\u11EC" + + "\n\xF8\x03\xF8\x05\xF8\u11EF\n\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03" + + "\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x03\xF8\x05" + + "\xF8\u11FE\n\xF8\x03\xF9\x03\xF9\x03\xFA\x03\xFA\x03\xFA\x03\xFB\x03\xFB" + + "\x03\xFB\x03\xFB\x03\xFB\x03\xFB\x05\xFB\u120B\n\xFB\x03\xFC\x03\xFC\x03" + + "\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFD\x03\xFE\x03\xFE\x03" + + "\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03" + + "\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x03\xFE\x05\xFE\u1228\n\xFE" + + "\x03\xFF\x03\xFF\x03\xFF\x07\xFF\u122D\n\xFF\f\xFF\x0E\xFF\u1230\v\xFF" + + "\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0100" + + "\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x03\u0100\x05\u0100\u123E\n\u0100" + + "\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101" + + "\x05\u0101\u1247\n\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x03\u0101" + + "\x03\u0101\x03\u0101\x03\u0101\x03\u0101\x05\u0101\u1252\n\u0101\x05\u0101" + + "\u1254\n\u0101\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102" + + "\x03\u0102\x05\u0102\u125D\n\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102" + + "\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x03\u0102\x05\u0102\u1268\n\u0102" + + "\x05\u0102\u126A\n\u0102\x03\u0103\x03\u0103\x03\u0103\x03\u0103\x03\u0103" + + "\x05\u0103\u1271\n\u0103\x03\u0104\x03\u0104\x03\u0104\x03\u0104\x03\u0104" + + "\x03\u0104\x03\u0104\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105" + + "\x03\u0105\x05\u0105\u1280\n\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105" + + "\x05\u0105\u1286\n\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105" + + "\x03\u0105\x05\u0105\u128E\n\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105" + + "\x05\u0105\u1294\n\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105" + + "\x03\u0105\x05\u0105\u129C\n\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105" + + "\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x05\u0105\u12A6\n\u0105\x03\u0105" + + "\x03\u0105\x03\u0105\x03\u0105\x05\u0105\u12AC\n\u0105\x03\u0105\x03\u0105" + + "\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x05\u0105\u12B4\n\u0105\x03\u0105" + "\x03"; + private static readonly _serializedATNSegment2: string = + "\u0105\x03\u0105\x03\u0105\x05\u0105\u12BA\n\u0105\x03\u0105\x03\u0105" + + "\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x05\u0105\u12C2\n\u0105\x03\u0105" + + "\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x05\u0105\u12C9\n\u0105\x03\u0105" + + "\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x03\u0105\x05\u0105" + + "\u12D2\n\u0105\x05\u0105\u12D4\n\u0105\x03\u0106\x03\u0106\x03\u0106\x03" + + "\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03" + + "\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03" + + "\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x03\u0106\x05\u0106\u12ED" + + "\n\u0106\x03\u0107\x03\u0107\x03\u0107\x03\u0107\x03\u0107\x05\u0107\u12F4" + + "\n\u0107\x03\u0108\x03\u0108\x03\u0108\x03\u0108\x03\u0108\x03\u0108\x03" + + "\u0108\x03\u0108\x03\u0108\x05\u0108\u12FF\n\u0108\x03\u0108\x03\u0108" + + "\x03\u0108\x03\u0108\x05\u0108\u1305\n\u0108\x03\u0109\x03\u0109\x03\u010A" + + "\x03\u010A\x03\u010A\x07\u010A\u130C\n\u010A\f\u010A\x0E\u010A\u130F\v" + + "\u010A\x03\u010B\x03\u010B\x05\u010B\u1313\n\u010B\x03\u010C\x03\u010C" + + "\x06\u010C\u1317\n\u010C\r\u010C\x0E\u010C\u1318\x03\u010D\x03\u010D\x03" + + "\u010D\x07\u010D\u131E\n\u010D\f\u010D\x0E\u010D\u1321\v\u010D\x03\u010E" + + "\x03\u010E\x05\u010E\u1325\n\u010E\x03\u010E\x03\u010E\x05\u010E\u1329" + + "\n\u010E\x03\u010E\x05\u010E\u132C\n\u010E\x03\u010F\x03\u010F\x03\u010F" + + "\x03\u010F\x05\u010F\u1332\n\u010F\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110\x03\u0110" + + "\x03\u0110\x03\u0110\x03\u0110\x05\u0110\u13C7\n\u0110\x03\u0111\x03\u0111" + + "\x05\u0111\u13CB\n\u0111\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u13D0" + + "\n\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03" + + "\u0112\x03\u0112\x03\u0112\x05\u0112\u13DB\n\u0112\x03\u0112\x03\u0112" + + "\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112" + + "\x05\u0112\u13E6\n\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112" + + "\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u13F1\n\u0112\x03\u0112" + + "\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112" + + "\x03\u0112\x05\u0112\u13FC\n\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112" + + "\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u1407\n\u0112" + + "\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112" + + "\x03\u0112\x03\u0112\x05\u0112\u1412\n\u0112\x03\u0112\x03\u0112\x03\u0112" + + "\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112" + + "\u141D\n\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112" + + "\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x05\u0112\u1429\n\u0112\x03\u0112" + + "\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112" + + "\x03\u0112\x05\u0112\u1434\n\u0112\x03\u0112\x03\u0112\x03\u0112\x03\u0112" + + "\x03\u0112\x03\u0112\x05\u0112\u143C\n\u0112\x03\u0113\x03\u0113\x03\u0113" + + "\x03\u0114\x03\u0114\x05\u0114\u1443\n\u0114\x03\u0115\x03\u0115\x03\u0115" + + "\x03\u0115\x05\u0115\u1449\n\u0115\x03\u0116\x03\u0116\x03\u0116\x03\u0116" + + "\x03\u0116\x03\u0116\x05\u0116\u1451\n\u0116\x03\u0116\x03\u0116\x03\u0116" + + "\x05\u0116\u1456\n\u0116\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u145B" + + "\n\u0116\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u1460\n\u0116\x03\u0116" + + "\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u1466\n\u0116\x03\u0116\x03\u0116" + + "\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u146D\n\u0116\x03\u0116\x03\u0116" + + "\x03\u0116\x03\u0116\x05\u0116\u1473\n\u0116\x03\u0116\x03\u0116\x03\u0116" + + "\x03\u0116\x05\u0116\u1479\n\u0116\x03\u0116\x03\u0116\x03\u0116\x05\u0116" + + "\u147E\n\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u1484" + + "\n\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u148B" + + "\n\u0116\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u1490\n\u0116\x03\u0116" + + "\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u1496\n\u0116\x03\u0116\x03\u0116" + + "\x03\u0116\x03\u0116\x03\u0116\x05\u0116\u149D\n\u0116\x03\u0116\x05\u0116" + + "\u14A0\n\u0116\x03\u0117\x03\u0117\x03\u0118\x03\u0118\x03\u0119\x03\u0119" + + "\x03\u0119\x03\u0119\x03\u0119\x03\u0119\x03\u0119\x05\u0119\u14AD\n\u0119" + + "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + + "\x05\u011A\u14B6\n\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A" + + "\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x03\u011A\x05\u011A\u14C2\n\u011A" + + "\x05\u011A\u14C4\n\u011A\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011B" + + "\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x03\u011B" + + "\x03\u011B\x03\u011B\x03\u011B\x03\u011B\x05\u011B\u14D6\n\u011B\x03\u011C" + + "\x03\u011C\x03\u011C\x07\u011C\u14DB\n\u011C\f\u011C\x0E\u011C\u14DE\v" + + "\u011C\x03\u011D\x03\u011D\x03\u011E\x03\u011E\x03\u011E\x07\u011E\u14E5" + + "\n\u011E\f\u011E\x0E\u011E\u14E8\v\u011E\x03\u011F\x03\u011F\x05\u011F" + + "\u14EC\n\u011F\x03\u011F\x03\u011F\x05\u011F\u14F0\n\u011F\x03\u011F\x03" + + "\u011F\x05\u011F\u14F4\n\u011F\x03\u011F\x03\u011F\x05\u011F\u14F8\n\u011F" + + "\x05\u011F\u14FA\n\u011F\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120" + + "\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120" + + "\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120" + + "\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120" + + "\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120" + + "\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120" + + "\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120" + + "\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x03\u0120" + + "\x03\u0120\x03\u0120\x03\u0120\x03\u0120\x05\u0120\u1536\n\u0120\x03\u0121" + + "\x03\u0121\x03\u0121\x07\u0121\u153B\n\u0121\f\u0121\x0E\u0121\u153E\v" + + "\u0121\x03\u0122\x03\u0122\x03\u0122\x05\u0122\u1543\n\u0122\x03\u0123" + + "\x03\u0123\x03\u0123\x03\u0123\x03\u0124\x03\u0124\x03\u0124\x03\u0124" + + "\x03\u0124\x05\u0124\u154E\n\u0124\x03\u0124\x05\u0124\u1551\n\u0124\x03" + + "\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x05\u0125\u1558\n\u0125" + + "\x03\u0125\x05\u0125\u155B\n\u0125\x03\u0125\x03\u0125\x03\u0125\x03\u0125" + + "\x03\u0125\x03\u0125\x03\u0125\x03\u0125\x05\u0125\u1565\n\u0125\x03\u0125" + + "\x05\u0125\u1568\n\u0125\x05\u0125\u156A\n\u0125\x03\u0126\x03\u0126\x03" + + "\u0126\x03\u0126\x03\u0127\x03\u0127\x03\u0127\x03\u0127\x03\u0128\x03" + + "\u0128\x03\u0128\x03\u0128\x03\u0128\x03\u0128\x03\u0129\x07\u0129\u157B" + + "\n\u0129\f\u0129\x0E\u0129\u157E\v\u0129\x03\u012A\x03\u012A\x03\u012A" + + "\x03\u012A\x03\u012A\x03\u012A\x03\u012A\x03\u012A\x03\u012A\x05\u012A" + + "\u1589\n\u012A\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B" + + "\x03\u012B\x05\u012B\u1592\n\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B" + + "\x03\u012B\x03\u012B\x03\u012B\x05\u012B\u159B\n\u012B\x03\u012B\x03\u012B" + + "\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B\x03\u012B" + + "\x03\u012B\x05\u012B\u15A7\n\u012B\x05\u012B\u15A9\n\u012B\x03\u012C\x03" + + "\u012C\x03\u012D\x03\u012D\x05\u012D\u15AF\n\u012D\x03\u012D\x03\u012D" + + "\x05\u012D\u15B3\n\u012D\x03\u012D\x05\u012D\u15B6\n\u012D\x03\u012D\x03" + + "\u012D\x03\u012D\x05\u012D\u15BB\n\u012D\x03\u012D\x03\u012D\x03\u012D" + + "\x03\u012D\x05\u012D\u15C1\n\u012D\x03\u012D\x05\u012D\u15C4\n\u012D\x03" + + "\u012D\x05\u012D\u15C7\n\u012D\x03\u012D\x05\u012D\u15CA\n\u012D\x03\u012D" + + "\x03\u012D\x05\u012D\u15CE\n\u012D\x03\u012D\x03\u012D\x05\u012D\u15D2" + + "\n\u012D\x03\u012D\x03\u012D\x03\u012D\x03\u012D\x03\u012D\x03\u012D\x03" + + "\u012D\x05\u012D\u15DB\n\u012D\x03\u012D\x03\u012D\x03\u012D\x03\u012D" + + "\x05\u012D\u15E1\n\u012D\x03\u012D\x05\u012D\u15E4\n\u012D\x03\u012D\x05" + + "\u012D\u15E7\n\u012D\x03\u012D\x05\u012D\u15EA\n\u012D\x05\u012D\u15EC" + + "\n\u012D\x03\u012E\x03\u012E\x03\u012F\x03\u012F\x03\u0130\x03\u0130\x03" + + "\u0131\x03\u0131\x03\u0131\x03\u0132\x03\u0132\x03\u0132\x07\u0132\u15FA" + + "\n\u0132\f\u0132\x0E\u0132\u15FD\v\u0132\x03\u0133\x05\u0133\u1600\n\u0133" + + "\x03\u0133\x05\u0133\u1603\n\u0133\x03\u0133\x05\u0133\u1606\n\u0133\x03" + + "\u0133\x05\u0133\u1609\n\u0133\x03\u0133\x05\u0133\u160C\n\u0133\x03\u0133" + + "\x03\u0133\x03\u0133\x05\u0133\u1611\n\u0133\x03\u0133\x05\u0133\u1614" + + "\n\u0133\x05\u0133\u1616\n\u0133\x03\u0134\x03\u0134\x03\u0134\x03\u0134" + + "\x03\u0134\x03\u0134\x03\u0134\x03\u0134\x03\u0134\x03\u0134\x03\u0134" + + "\x05\u0134\u1623\n\u0134\x03\u0135\x03\u0135\x03\u0135\x03\u0135\x03\u0135" + + "\x03\u0136\x03\u0136\x03\u0136\x07\u0136\u162D\n\u0136\f\u0136\x0E\u0136" + + "\u1630\v\u0136\x03\u0137\x03\u0137\x03\u0137\x03\u0138\x03\u0138\x03\u0139" + + "\x03\u0139\x03\u013A\x03\u013A\x03\u013A\x03\u013A\x05\u013A\u163D\n\u013A" + + "\x03\u013B\x03\u013B\x05\u013B\u1641\n\u013B\x03\u013B\x03\u013B\x03\u013B" + + "\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013B\x03\u013B" + + "\x05\u013B\u164D\n\u013B\x05\u013B\u164F\n\u013B\x03\u013B\x03\u013B\x03" + + "\u013B\x05\u013B\u1654\n\u013B\x03\u013C\x03\u013C\x03\u013C\x03\u013C" + + "\x07\u013C\u165A\n\u013C\f\u013C\x0E\u013C\u165D\v\u013C\x03\u013C\x03" + + "\u013C\x03\u013D\x03\u013D\x03\u013D\x03\u013E\x03\u013E\x05\u013E\u1666" + + "\n\u013E\x03\u013E\x03\u013E\x03\u013F\x03\u013F\x03\u013F\x07\u013F\u166D" + + "\n\u013F\f\u013F\x0E\u013F\u1670\v\u013F\x03\u0140\x03\u0140\x03\u0140" + + "\x07\u0140\u1675\n\u0140\f\u0140\x0E\u0140\u1678\v\u0140\x03\u0141\x03" + + "\u0141\x03\u0141\x03\u0141\x03\u0141\x03\u0141\x05\u0141\u1680\n\u0141" + + "\x05\u0141\u1682\n\u0141\x03\u0142\x03\u0142\x05\u0142\u1686\n\u0142\x03" + + "\u0142\x03\u0142\x03\u0143\x03\u0143\x03\u0143\x07\u0143\u168D\n\u0143" + + "\f\u0143\x0E\u0143\u1690\v\u0143\x03\u0144\x03\u0144\x05\u0144\u1694\n" + + "\u0144\x03\u0144\x03\u0144\x03\u0144\x03\u0144\x05\u0144\u169A\n\u0144" + + "\x03\u0144\x03\u0144\x03\u0144\x05\u0144\u169F\n\u0144\x03\u0145\x03\u0145" + + "\x05\u0145\u16A3\n\u0145\x03\u0145\x03\u0145\x03\u0145\x05\u0145\u16A8" + + "\n\u0145\x03\u0146\x03\u0146\x03\u0147\x03\u0147\x03\u0148\x03\u0148\x03" + + "\u0148\x03\u0148\x03\u0148\x03\u0148\x03\u0148\x03\u0148\x03\u0148\x03" + + "\u0148\x03\u0148\x03\u0148\x05\u0148\u16BA\n\u0148\x03\u0149\x03\u0149" + + "\x03\u0149\x05\u0149\u16BF\n\u0149\x03\u014A\x03\u014A\x03\u014B\x03\u014B" + + "\x03\u014B\x03\u014B\x03\u014B\x03\u014B\x03\u014B\x03\u014B\x03\u014B" + + "\x03\u014B\x03\u014B\x05\u014B\u16CE\n\u014B\x03\u014B\x03\u014B\x03\u014C" + + "\x03\u014C\x03\u014C\x07\u014C\u16D5\n\u014C\f\u014C\x0E\u014C\u16D8\v" + + "\u014C\x03\u014D\x03\u014D\x03\u014D\x03\u014E\x03\u014E\x03\u014E\x07" + + "\u014E\u16E0\n\u014E\f\u014E\x0E\u014E\u16E3\v\u014E\x03\u014F\x06\u014F" + + "\u16E6\n\u014F\r\u014F\x0E\u014F\u16E7\x03\u0150\x03\u0150\x03\u0150\x03" + + "\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03" + + "\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03" + + "\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03" + + "\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03\u0150\x03" + + "\u0150\x03\u0150\x03\u0150\x03\u0150\x05\u0150\u170D\n\u0150\x03\u0151" + + "\x03\u0151\x03\u0151\x03\u0151\x03\u0151\x03\u0151\x03\u0151\x03\u0151" + + "\x05\u0151\u1717\n\u0151\x03\u0152\x03\u0152\x03\u0152\x03\u0152\x03\u0152" + + "\x05\u0152\u171E\n\u0152\x03\u0153\x03\u0153\x03\u0153\x03\u0153\x03\u0153" + + "\x03\u0153\x03\u0153\x07\u0153\u1727\n\u0153\f\u0153\x0E\u0153\u172A\v" + + "\u0153\x03\u0154\x03\u0154\x03\u0154\x03\u0155\x03\u0155\x03\u0155\x03" + + "\u0156\x03\u0156\x03\u0156\x07\u0156\u1735\n\u0156\f\u0156\x0E\u0156\u1738" + + "\v\u0156\x03\u0157\x03\u0157\x03\u0157\x03\u0157\x03\u0157\x05\u0157\u173F" + + "\n\u0157\x03\u0158\x06\u0158\u1742\n\u0158\r\u0158\x0E\u0158\u1743\x03" + + "\u0159\x03\u0159\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x05\u015A\u174C" + + "\n\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x05" + + "\u015A\u1754\n\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x05\u015A" + + "\u175A\n\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A" + + "\x05\u015A\u1762\n\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x05\u015A" + + "\u1768\n\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A\x03\u015A" + + "\x05\u015A\u1770\n\u015A\x05\u015A\u1772\n\u015A\x03\u015B\x03\u015B\x03" + + "\u015B\x03\u015B\x05\u015B\u1778\n\u015B\x03\u015B\x03\u015B\x03\u015B" + + "\x03\u015B\x03\u015B\x03\u015B\x05\u015B\u1780\n\u015B\x05\u015B\u1782" + + "\n\u015B\x03\u015C\x03\u015C\x03\u015C\x03\u015C\x05\u015C\u1788\n\u015C" + + "\x03\u015C\x03\u015C\x03\u015C\x03\u015C\x03\u015C\x03\u015C\x05\u015C" + + "\u1790\n\u015C\x05\u015C\u1792\n\u015C\x03\u015D\x03\u015D\x03\u015D\x03" + + "\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03" + + "\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x03" + + "\u015D\x03\u015D\x03\u015D\x03\u015D\x03\u015D\x05\u015D\u17AA\n\u015D" + + "\x03\u015E\x03\u015E\x03\u015E\x07\u015E\u17AF\n\u015E\f\u015E\x0E\u015E" + + "\u17B2\v\u015E\x03\u015E\x03\u015E\x03\u015F\x03\u015F\x03\u015F\x07\u015F" + + "\u17B9\n\u015F\f\u015F\x0E\u015F\u17BC\v\u015F\x03\u0160\x03\u0160\x03" + + "\u0160\x03\u0161\x03\u0161\x03\u0161\x03\u0162\x06\u0162\u17C5\n\u0162" + + "\r\u0162\x0E\u0162\u17C6\x03\u0163\x03\u0163\x03\u0163\x05\u0163\u17CC" + + "\n\u0163\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03" + + "\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x05\u0164\u17D9\n\u0164" + + "\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164" + + "\x03\u0164\x03\u0164\x03\u0164\x05\u0164\u17E5\n\u0164\x03\u0164\x03\u0164" + + "\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164\x03\u0164" + + "\x03\u0164\x05\u0164\u17F1\n\u0164\x05\u0164\u17F3\n\u0164\x03\u0165\x03" + + "\u0165\x03\u0165\x03\u0165\x05\u0165\u17F9\n\u0165\x03\u0166\x03\u0166" + + "\x03\u0166\x05\u0166\u17FE\n\u0166\x03\u0166\x03\u0166\x03\u0166\x03\u0166" + + "\x03\u0166\x03\u0166\x05\u0166\u1806\n\u0166\x03\u0167\x03\u0167\x03\u0167" + + "\x03\u0168\x03\u0168\x05\u0168\u180D\n\u0168\x03\u0168\x03\u0168\x03\u0168" + + "\x03\u0168\x03\u0168\x03\u0168\x03\u0168\x03\u0168\x03\u0168\x03\u0169" + + "\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169" + + "\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169" + + "\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169" + + "\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169" + + "\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x03\u0169\x05\u0169\u183A\n\u0169" + + "\x03\u016A\x03\u016A\x03\u016A\x05\u016A\u183F\n\u016A\x03\u016A\x03\u016A" + + "\x03\u016A\x03\u016A\x03\u016A\x05\u016A\u1846\n\u016A\x03\u016B\x03\u016B" + + "\x03\u016B\x05\u016B\u184B\n\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016B" + + "\x03\u016B\x05\u016B\u1852\n\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016B" + + "\x03\u016B\x03\u016B\x03\u016B\x03\u016B\x05\u016B\u185C\n\u016B\x03\u016B" + + "\x03\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016B\x03\u016B" + + "\x05\u016B\u1866\n\u016B\x03\u016B\x03\u016B\x05\u016B\u186A\n\u016B\x03" + + "\u016C\x03\u016C\x03\u016D\x03\u016D\x03\u016E\x03\u016E\x03\u016E\x07" + + "\u016E\u1873\n\u016E\f\u016E\x0E\u016E\u1876\v\u016E\x03\u016F\x03\u016F" + + "\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0170" + + "\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x03\u0170\x05\u0170\u1886\n\u0170" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x05\u0171" + + "\u18CD\n\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x05\u0171\u1990\n\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x05\u0171\u199D\n\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x05\u0171\u19A8\n\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x05\u0171\u19B5\n\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x05\u0171\u19C1\n\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x05\u0171\u19CF\n\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x05\u0171\u19EF\n\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x05\u0171\u19FD\n\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171\x03\u0171" + + "\x03\u0171\x03\u0171\x05\u0171\u1A6D\n\u0171\x05\u0171\u1A6F\n\u0171\x03" + + "\u0172\x03\u0172\x03\u0173\x03\u0173\x03\u0173\x03\u0174\x03\u0174\x03" + + "\u0174\x03\u0174\x05\u0174\u1A7A\n\u0174\x03\u0174\x03\u0174\x03\u0174" + + "\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x05\u0174" + + "\u1A85\n\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174" + + "\x03\u0174\x03\u0174\x03\u0174\x05\u0174\u1A90\n\u0174\x03\u0174\x03\u0174" + + "\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174" + + "\x03\u0174\x03\u0174\x05\u0174\u1A9D\n\u0174\x03\u0174\x03\u0174\x03\u0174" + + "\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174" + + "\x05\u0174\u1AA9\n\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x03\u0174" + + "\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x05\u0174\u1AB4\n\u0174\x03\u0174" + + "\x03\u0174\x03\u0174\x03\u0174\x03\u0174\x05\u0174\u1ABB\n\u0174\x03\u0175" + + "\x03\u0175\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x03\u0176" + + "\x03\u0176\x05\u0176\u1B98\n\u0176\x03\u0177\x03\u0177\x03\u0177\x03\u0177" + + "\x03\u0177\x03\u0177\x03\u0177\x03\u0177\x03\u0178\x03\u0178\x03\u0178" + + "\x07\u0178\u1BA5\n\u0178\f\u0178\x0E\u0178\u1BA8\v\u0178\x03\u0179\x03" + + "\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x05" + + "\u0179\u1BB2\n\u0179\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03\u017A" + + "\x05\u017A\u1BB9\n\u017A\x03\u017B\x03\u017B\x03\u017B\x03\u017B\x03\u017B" + + "\x03\u017B\x03\u017B\x03\u017B\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x05\u017C\u1BEF\n\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C" + + "\x03\u017C\x03\u017C\x03"; private static readonly _serializedATNSegment3: string = - "\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03" + - "\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03" + - "\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x03\u0175\x05\u0175\u1C2A" + - "\n\u0175\x03\u0176\x03\u0176\x03\u0176\x03\u0176\x05\u0176\u1C30\n\u0176" + - "\x03\u0176\x05\u0176\u1C33\n\u0176\x03\u0177\x03\u0177\x03\u0178\x03\u0178" + - "\x03\u0178\x03\u0178\x03\u0178\x03\u0178\x05\u0178\u1C3D\n\u0178\x03\u0179" + - "\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179" + - "\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179" + - "\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179" + - "\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x03\u0179\x05\u0179\u1C5A\n\u0179" + - "\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03\u017A\x03\u017A" + - "\x03\u017A\x05\u017A\u1C64\n\u017A\x03\u017B\x03\u017B\x03\u017B\x07\u017B" + - "\u1C69\n\u017B\f\u017B\x0E\u017B\u1C6C\v\u017B\x03\u017C\x03\u017C\x03" + - "\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03" + - "\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03" + - "\u017D\x03\u017D\x03\u017D\x03\u017D\x05\u017D\u1C82\n\u017D\x03\u017D" + - "\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x05\u017D" + - "\u1C8B\n\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x03\u017D" + - "\x03\u017D\x03\u017D\x03\u017D\x03\u017D\x05\u017D\u1C97\n\u017D\x03\u017E" + - "\x03\u017E\x03\u017E\x03\u017E\x05\u017E\u1C9D\n\u017E\x03\u017E\x03\u017E" + - "\x03\u017E\x03\u017E\x03\u017E\x03\u017E\x05\u017E\u1CA5\n\u017E\x05\u017E" + - "\u1CA7\n\u017E\x03\u017F\x03\u017F\x05\u017F\u1CAB\n\u017F\x03\u017F\x03" + - "\u017F\x03\u017F\x03\u017F\x03\u017F\x03\u017F\x03\u017F\x03\u017F\x05" + - "\u017F\u1CB5\n\u017F\x03\u017F\x03\u017F\x05\u017F\u1CB9\n\u017F\x03\u017F" + - "\x03\u017F\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180" + - "\x05\u0180\u1CC3\n\u0180\x03\u0181\x05\u0181\u1CC6\n\u0181\x03\u0181\x03" + - "\u0181\x05\u0181\u1CCA\n\u0181\x07\u0181\u1CCC\n\u0181\f\u0181\x0E\u0181" + - "\u1CCF\v\u0181\x03\u0182\x03\u0182\x03\u0182\x03\u0182\x03\u0182\x05\u0182" + - "\u1CD6\n\u0182\x03\u0183\x03\u0183\x03\u0184\x03\u0184\x03\u0185\x03\u0185" + - "\x03\u0186\x03\u0186\x03\u0186\x05\u0186\u1CE1\n\u0186\x03\u0187\x03\u0187" + - "\x03\u0187\x03\u0188\x03\u0188\x03\u0188\x03\u0189\x03\u0189\x03\u0189" + - "\x03\u0189\x05\u0189\u1CED\n\u0189\x03\u018A\x03\u018A\x05\u018A\u1CF1" + - "\n\u018A\x03\u018A\x05\u018A\u1CF4\n\u018A\x03\u018A\x03\u018A\x05\u018A" + - "\u1CF8\n\u018A\x03\u018A\x05\u018A\u1CFB\n\u018A\x03\u018A\x03\u018A\x03" + - "\u018A\x05\u018A\u1D00\n\u018A\x03\u018A\x03\u018A\x05\u018A\u1D04\n\u018A" + - "\x03\u018A\x05\u018A\u1D07\n\u018A\x03\u018A\x03\u018A\x05\u018A\u1D0B" + - "\n\u018A\x03\u018A\x05\u018A\u1D0E\n\u018A\x03\u018A\x03\u018A\x05\u018A" + - "\u1D12\n\u018A\x03\u018A\x05\u018A\u1D15\n\u018A\x03\u018A\x03\u018A\x03" + - "\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018A\x05" + - "\u018A\u1D20\n\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018A" + - "\x05\u018A\u1D27\n\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018A" + - "\x03\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018A\x03\u018A\x05\u018A" + - "\u1D34\n\u018A\x03\u018B\x03\u018B\x03\u018C\x03\u018C\x03\u018C\x03\u018C" + - "\x03\u018C\x03\u018C\x03\u018C\x03\u018C\x03\u018C\x03\u018C\x05\u018C" + - "\u1D42\n\u018C\x03\u018D\x03\u018D\x05\u018D\u1D46\n\u018D\x03\u018D\x07" + - "\u018D\u1D49\n\u018D\f\u018D\x0E\u018D\u1D4C\v\u018D\x03\u018E\x03\u018E" + - "\x03\u018F\x03\u018F\x05\u018F\u1D52\n\u018F\x03\u018F\x03\u018F\x03\u0190" + - "\x03\u0190\x03\u0190\x05\u0190\u1D59\n\u0190\x03\u0190\x05\u0190\u1D5C" + - "\n\u0190\x03\u0190\x03\u0190\x03\u0190\x05\u0190\u1D61\n\u0190\x03\u0190" + - "\x05\u0190\u1D64\n\u0190\x03\u0190\x03\u0190\x03\u0190\x03\u0190\x03\u0190" + - "\x03\u0190\x03\u0190\x05\u0190\u1D6D\n\u0190\x05\u0190\u1D6F\n\u0190\x03" + - "\u0190\x03\u0190\x03\u0190\x05\u0190\u1D74\n\u0190\x03\u0191\x03\u0191" + - "\x05\u0191\u1D78\n\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0192\x03\u0192" + - "\x03\u0192\x03\u0193\x03\u0193\x03\u0193\x03\u0193\x05\u0193\u1D84\n\u0193" + - "\x03\u0193\x05\u0193\u1D87\n\u0193\x03\u0194\x03\u0194\x03\u0195\x06\u0195" + - "\u1D8C\n\u0195\r\u0195\x0E\u0195\u1D8D\x03\u0196\x03\u0196\x05\u0196\u1D92" + - "\n\u0196\x03\u0196\x03\u0196\x03\u0196\x05\u0196\u1D97\n\u0196\x03\u0197" + - "\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x03\u0197" + - "\x05\u0197\u1DA1\n\u0197\x03\u0198\x03\u0198\x03\u0199\x03\u0199\x03\u0199" + - "\x03\u0199\x03\u0199\x05\u0199\u1DAA\n\u0199\x03\u0199\x05\u0199\u1DAD" + - "\n\u0199\x03\u0199\x03\u0199\x03\u0199\x05\u0199\u1DB2\n\u0199\x03\u019A" + - "\x03\u019A\x03\u019A\x03\u019A\x03\u019A\x03\u019B\x03\u019B\x03\u019B" + - "\x03\u019B\x05\u019B\u1DBD\n\u019B\x03\u019B\x03\u019B\x05\u019B\u1DC1" + - "\n\u019B\x03\u019B\x03\u019B\x03\u019B\x03\u019B\x05\u019B\u1DC7\n\u019B" + - "\x03\u019C\x03\u019C\x03\u019C\x07\u019C\u1DCC\n\u019C\f\u019C\x0E\u019C" + - "\u1DCF\v\u019C\x03\u019D\x03\u019D\x03\u019E\x03\u019E\x03\u019E\x03\u019E" + - "\x03\u019E\x03\u019E\x03\u019F\x03\u019F\x03\u019F\x03\u019F\x03\u019F" + - "\x03\u01A0\x03\u01A0\x03\u01A0\x03\u01A0\x05\u01A0\u1DE2\n\u01A0\x03\u01A0" + - "\x03\u01A0\x03\u01A0\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1" + - "\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1" + - "\x03\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x05\u01A1\u1DF7\n\u01A1\x03\u01A1" + - "\x03\u01A1\x05\u01A1\u1DFB\n\u01A1\x03\u01A1\x03\u01A1\x03\u01A1\x05\u01A1" + - "\u1E00\n\u01A1\x03\u01A2\x03\u01A2\x03\u01A3\x03\u01A3\x03\u01A3\x03\u01A3" + - "\x03\u01A3\x03\u01A3\x03\u01A3\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4" + - "\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x03\u01A4\x05\u01A4\u1E53\n\u01A4" + - "\x03\u01A5\x03\u01A5\x03\u01A6\x03\u01A6\x05\u01A6\u1E59\n\u01A6\x03\u01A6" + - "\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A6" + - "\x03\u01A6\x03\u01A7\x03\u01A7\x05\u01A7\u1E66\n\u01A7\x03\u01A7\x03\u01A7" + - "\x05\u01A7\u1E6A\n\u01A7\x03\u01A7\x03\u01A7\x05\u01A7\u1E6E\n\u01A7\x03" + - "\u01A7\x03\u01A7\x05\u01A7\u1E72\n\u01A7\x03\u01A7\x03\u01A7\x03\u01A7" + - "\x03\u01A7\x05\u01A7\u1E78\n\u01A7\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A9" + - "\x03\u01A9\x05\u01A9\u1E7F\n\u01A9\x03\u01A9\x05\u01A9\u1E82\n\u01A9\x03" + - "\u01A9\x05\u01A9\u1E85\n\u01A9\x03\u01A9\x05\u01A9\u1E88\n\u01A9\x03\u01A9" + - "\x05\u01A9\u1E8B\n\u01A9\x03\u01A9\x03\u01A9\x03\u01A9\x03\u01A9\x03\u01A9" + - "\x05\u01A9\u1E92\n\u01A9\x05\u01A9\u1E94\n\u01A9\x03\u01AA\x03\u01AA\x05" + - "\u01AA\u1E98\n\u01AA\x03\u01AA\x05\u01AA\u1E9B\n\u01AA\x03\u01AA\x03\u01AA" + - "\x03\u01AA\x03\u01AA\x03\u01AA\x05\u01AA\u1EA2\n\u01AA\x05\u01AA\u1EA4" + - "\n\u01AA\x03\u01AB\x03\u01AB\x03\u01AB\x07\u01AB\u1EA9\n\u01AB\f\u01AB" + - "\x0E\u01AB\u1EAC\v\u01AB\x03\u01AC\x03\u01AC\x03\u01AD\x03\u01AD\x05\u01AD" + - "\u1EB2\n\u01AD\x03\u01AE\x03\u01AE\x05\u01AE\u1EB6\n\u01AE\x03\u01AF\x03" + - "\u01AF\x05\u01AF\u1EBA\n\u01AF\x03\u01B0\x03\u01B0\x03\u01B1\x03\u01B1" + - "\x03\u01B2\x03\u01B2\x03\u01B3\x03\u01B3\x03\u01B4\x03\u01B4\x03\u01B4" + - "\x03\u01B4\x03\u01B5\x03\u01B5\x05\u01B5\u1ECA\n\u01B5\x03\u01B6\x03\u01B6" + - "\x03\u01B6\x07\u01B6\u1ECF\n\u01B6\f\u01B6\x0E\u01B6\u1ED2\v\u01B6\x03" + - "\u01B7\x03\u01B7\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x05" + - "\u01B8\u1EDB\n\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8" + - "\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x03\u01B8\x05\u01B8" + - "\u1EE8\n\u01B8\x03\u01B9\x03\u01B9\x03\u01B9\x03\u01B9\x03\u01B9\x03\u01B9" + - "\x03\u01B9\x03\u01B9\x03\u01B9\x05\u01B9\u1EF3\n\u01B9\x03\u01BA\x03\u01BA" + - "\x03\u01BA\x07\u01BA\u1EF8\n\u01BA\f\u01BA\x0E\u01BA\u1EFB\v\u01BA\x03" + - "\u01BB\x03\u01BB\x05\u01BB\u1EFF\n\u01BB\x03\u01BC\x03\u01BC\x05\u01BC" + - "\u1F03\n\u01BC\x03\u01BD\x03\u01BD\x05\u01BD\u1F07\n\u01BD\x03\u01BE\x03" + - "\u01BE\x03\u01BE\x05\u01BE\u1F0C\n\u01BE\x03\u01BE\x03\u01BE\x03\u01BE" + - "\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01C0\x03\u01C0\x03\u01C0" + - "\x03\u01C0\x05\u01C0\u1F19\n\u01C0\x03\u01C1\x03\u01C1\x03\u01C1\x05\u01C1" + - "\u1F1E\n\u01C1\x03\u01C1\x03\u01C1\x05\u01C1\u1F22\n\u01C1\x03\u01C1\x03" + - "\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x05\u01C1\u1F2A\n\u01C1" + - "\x03\u01C1\x05\u01C1\u1F2D\n\u01C1\x03\u01C1\x03\u01C1\x05\u01C1\u1F31" + - "\n\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x03\u01C1\x03" + - "\u01C1\x03\u01C1\x03\u01C1\x05\u01C1\u1F3C\n\u01C1\x03\u01C1\x05\u01C1" + - "\u1F3F\n\u01C1\x05\u01C1\u1F41\n\u01C1\x03\u01C2\x03\u01C2\x03\u01C2\x03" + - "\u01C2\x03\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x03" + - "\u01C3\x03\u01C3\x03\u01C3\x03\u01C3\x05\u01C3\u1F51\n\u01C3\x03\u01C4" + - "\x05\u01C4\u1F54\n\u01C4\x03\u01C4\x03\u01C4\x03\u01C4\x03\u01C4\x03\u01C4" + - "\x05\u01C4\u1F5B\n\u01C4\x03\u01C4\x05\u01C4\u1F5E\n\u01C4\x03\u01C5\x03" + - "\u01C5\x03\u01C5\x05\u01C5\u1F63\n\u01C5\x03\u01C6\x03\u01C6\x03\u01C6" + - "\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C6" + - "\x03\u01C6\x03\u01C6\x03\u01C6\x05\u01C6\u1F72\n\u01C6\x03\u01C6\x03\u01C6" + - "\x03\u01C6\x03\u01C6\x05\u01C6\u1F78\n\u01C6\x03\u01C7\x03\u01C7\x03\u01C8" + - "\x03\u01C8\x03\u01C8\x07\u01C8\u1F7F\n\u01C8\f\u01C8\x0E\u01C8\u1F82\v" + - "\u01C8\x03\u01C9\x03\u01C9\x03\u01C9\x03\u01CA\x03\u01CA\x03\u01CA\x05" + - "\u01CA\u1F8A\n\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CA" + - "\x05\u01CA\u1F91\n\u01CA\x03\u01CA\x05\u01CA\u1F94\n\u01CA\x03\u01CB\x03" + - "\u01CB\x03\u01CB\x03\u01CB\x05\u01CB\u1F9A\n\u01CB\x03\u01CB\x03\u01CB" + - "\x03\u01CB\x05\u01CB\u1F9F\n\u01CB\x03\u01CC\x03\u01CC\x03\u01CC\x03\u01CD" + - "\x05\u01CD\u1FA5\n\u01CD\x03\u01CD\x03\u01CD\x03\u01CD\x03\u01CD\x05\u01CD" + - "\u1FAB\n\u01CD\x03\u01CD\x05\u01CD\u1FAE\n\u01CD\x03\u01CD\x05\u01CD\u1FB1" + - "\n\u01CD\x03\u01CE\x03\u01CE\x03\u01CE\x03\u01CF\x03\u01CF\x05\u01CF\u1FB8" + - "\n\u01CF\x03\u01CF\x03\u01CF\x05\u01CF\u1FBC\n\u01CF\x03\u01CF\x05\u01CF" + - "\u1FBF\n\u01CF\x03\u01D0\x03\u01D0\x03\u01D0\x03\u01D0\x03\u01D1\x03\u01D1" + - "\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D1" + - "\x05\u01D1\u1FCE\n\u01D1\x03\u01D1\x05\u01D1\u1FD1\n\u01D1\x03\u01D2\x03" + - "\u01D2\x03\u01D3\x03\u01D3\x03\u01D3\x05\u01D3\u1FD8\n\u01D3\x03\u01D4" + - "\x05\u01D4\u1FDB\n\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4" + - "\x05\u01D4\u1FE2\n\u01D4\x03\u01D4\x05\u01D4\u1FE5\n\u01D4\x03\u01D4\x05" + - "\u01D4\u1FE8\n\u01D4\x03\u01D5\x03\u01D5\x03\u01D5\x07\u01D5\u1FED\n\u01D5" + - "\f\u01D5\x0E\u01D5\u1FF0\v\u01D5\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D6" + - "\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D6\x03\u01D6\x05\u01D6" + - "\u1FFC\n\u01D6\x03\u01D7\x03\u01D7\x03\u01D7\x03\u01D8\x03\u01D8\x03\u01D8" + - "\x07\u01D8\u2004\n\u01D8\f\u01D8\x0E\u01D8\u2007\v\u01D8\x03\u01D9\x03" + - "\u01D9\x03\u01D9\x03\u01D9\x03\u01D9\x03\u01D9\x03\u01D9\x03\u01D9\x03" + - "\u01DA\x03\u01DA\x03\u01DB\x03\u01DB\x03\u01DB\x03\u01DB\x03\u01DB\x07" + - "\u01DB\u2018\n\u01DB\f\u01DB\x0E\u01DB\u201B\v\u01DB\x03\u01DC\x03\u01DC" + - "\x03\u01DC\x03\u01DC\x03\u01DC\x05\u01DC\u2022\n\u01DC\x03\u01DD\x03\u01DD" + - "\x05\u01DD\u2026\n\u01DD\x03\u01DE\x03\u01DE\x03\u01DE\x03\u01DE\x03\u01DE" + - "\x03\u01DE\x03\u01DE\x03\u01DE\x05\u01DE\u2030\n\u01DE\x03\u01DF\x03\u01DF" + - "\x05\u01DF\u2034\n\u01DF\x03\u01DF\x03\u01DF\x05\u01DF\u2038\n\u01DF\x03" + - "\u01DF\x03\u01DF\x05\u01DF\u203C\n\u01DF\x05\u01DF\u203E\n\u01DF\x03\u01DF" + - "\x03\u01DF\x03\u01DF\x05\u01DF\u2043\n\u01DF\x03\u01DF\x03\u01DF\x05\u01DF" + - "\u2047\n\u01DF\x03\u01DF\x03\u01DF\x05\u01DF\u204B\n\u01DF\x05\u01DF\u204D" + - "\n\u01DF\x05\u01DF\u204F\n\u01DF\x03\u01E0\x03\u01E0\x05\u01E0\u2053\n" + - "\u01E0\x03\u01E1\x03\u01E1\x05\u01E1\u2057\n\u01E1\x03\u01E1\x05\u01E1" + - "\u205A\n\u01E1\x03\u01E1\x05\u01E1\u205D\n\u01E1\x03\u01E1\x03\u01E1\x03" + - "\u01E1\x05\u01E1\u2062\n\u01E1\x03\u01E1\x05\u01E1\u2065\n\u01E1\x03\u01E1" + - "\x05\u01E1\u2068\n\u01E1\x03\u01E1\x05\u01E1\u206B\n\u01E1\x03\u01E1\x05" + - "\u01E1\u206E\n\u01E1\x03\u01E1\x05\u01E1\u2071\n\u01E1\x03\u01E1\x05\u01E1" + - "\u2074\n\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03\u01E1\x03\u01E1" + - "\x03\u01E1\x05\u01E1\u207D\n\u01E1\x05\u01E1\u207F\n\u01E1\x03\u01E1\x03" + - "\u01E1\x03\u01E1\x05\u01E1\u2084\n\u01E1\x07\u01E1\u2086\n\u01E1\f\u01E1" + - "\x0E\u01E1\u2089\v\u01E1\x03\u01E2\x03\u01E2\x03\u01E2\x05\u01E2\u208E" + - "\n\u01E2\x03\u01E3\x03\u01E3\x05\u01E3\u2092\n\u01E3\x03\u01E4\x03\u01E4" + - "\x05\u01E4\u2096\n\u01E4\x03\u01E4\x03\u01E4\x03\u01E5\x03\u01E5\x03\u01E5" + - "\x07\u01E5\u209D\n\u01E5\f\u01E5\x0E\u01E5\u20A0\v\u01E5\x03\u01E6\x03" + - "\u01E6\x05\u01E6\u20A4\n\u01E6\x03\u01E6\x03\u01E6\x05\u01E6\u20A8\n\u01E6" + - "\x03\u01E6\x03\u01E6\x03\u01E6\x03\u01E6\x03\u01E7\x03\u01E7\x03\u01E7" + - "\x05\u01E7\u20B1\n\u01E7\x03\u01E8\x03\u01E8\x03\u01E9\x03\u01E9\x03\u01E9" + - "\x03\u01E9\x03\u01E9\x05\u01E9\u20BA\n\u01E9\x03\u01EA\x03\u01EA\x05\u01EA" + - "\u20BE\n\u01EA\x03\u01EB\x05\u01EB\u20C1\n\u01EB\x03\u01EB\x03\u01EB\x05" + - "\u01EB\u20C5\n\u01EB\x03\u01EB\x03\u01EB\x03\u01EB\x05\u01EB\u20CA\n\u01EB" + - "\x03\u01EB\x03\u01EB\x03\u01EB\x03\u01EB\x05\u01EB\u20D0\n\u01EB\x03\u01EC" + - "\x03\u01EC\x03\u01ED\x03\u01ED\x03\u01EE\x03\u01EE\x03\u01EE\x03\u01EE" + - "\x03\u01EE\x03\u01EE\x05\u01EE\u20DC\n\u01EE\x03\u01EF\x03\u01EF\x03\u01F0" + - "\x03\u01F0\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F1\x03\u01F2\x03\u01F2" + - "\x03\u01F2\x07\u01F2\u20E9\n\u01F2\f\u01F2\x0E\u01F2\u20EC\v\u01F2\x03" + - "\u01F3\x03\u01F3\x03\u01F3\x03\u01F3\x05\u01F3\u20F2\n\u01F3\x05\u01F3" + - "\u20F4\n\u01F3\x03\u01F3\x05\u01F3\u20F7\n\u01F3\x03\u01F4\x03\u01F4\x05" + - "\u01F4\u20FB\n\u01F4\x03\u01F4\x03\u01F4\x05\u01F4\u20FF\n\u01F4\x05\u01F4" + - "\u2101\n\u01F4\x03\u01F5\x03\u01F5\x03\u01F6\x03\u01F6\x03\u01F6\x03\u01F6" + - "\x05\u01F6\u2109\n\u01F6\x03\u01F6\x03\u01F6\x03\u01F6\x03\u01F6\x03\u01F6" + - "\x03\u01F6\x03\u01F6\x05\u01F6\u2112\n\u01F6\x03\u01F6\x03\u01F6\x03\u01F6" + - "\x03\u01F6\x05\u01F6\u2118\n\u01F6\x05\u01F6\u211A\n\u01F6\x05\u01F6\u211C" + - "\n\u01F6\x03\u01F7\x03\u01F7\x03\u01F7\x03\u01F7\x03\u01F7\x05\u01F7\u2123" + - "\n\u01F7\x03\u01F8\x03\u01F8\x05\u01F8\u2127\n\u01F8\x03\u01F9\x03\u01F9" + - "\x03\u01FA\x03\u01FA\x03\u01FA\x03\u01FA\x03\u01FA\x05\u01FA\u2130\n\u01FA" + - "\x03\u01FB\x03\u01FB\x05\u01FB\u2134\n\u01FB\x03\u01FC\x03\u01FC\x03\u01FD" + - "\x03\u01FD\x03\u01FE\x03\u01FE\x03\u01FE\x03\u01FE\x03\u01FF\x03\u01FF" + - "\x03\u01FF\x07\u01FF\u2141\n\u01FF\f\u01FF\x0E\u01FF\u2144\v\u01FF\x03" + - "\u0200\x03\u0200\x03\u0200\x03\u0200\x03\u0200\x05\u0200\u214B\n\u0200" + - "\x03\u0201\x03\u0201\x03\u0201\x03\u0202\x03\u0202\x03\u0202\x03\u0202" + - "\x03\u0202\x03\u0203\x03\u0203\x03\u0203\x03\u0203\x03\u0203\x03\u0204" + - "\x03\u0204\x03\u0204\x03\u0204\x03\u0204\x03\u0204\x03\u0205\x03\u0205" + - "\x03\u0205\x03\u0206\x03\u0206\x03\u0206\x03\u0206\x05\u0206\u2167\n\u0206" + - "\x03\u0207\x03\u0207\x03\u0208\x06\u0208\u216C\n\u0208\r\u0208\x0E\u0208" + - "\u216D\x03\u0209\x03\u0209\x05\u0209\u2172\n\u0209\x03\u0209\x05\u0209" + - "\u2175\n\u0209\x03\u020A\x03\u020A\x03\u020A\x05\u020A\u217A\n\u020A\x03" + - "\u020A\x03\u020A\x05\u020A\u217E\n\u020A\x03\u020A\x05\u020A\u2181\n\u020A" + - "\x03\u020B\x03\u020B\x03\u020B\x03\u020C\x03\u020C\x03\u020C\x03\u020C" + - "\x03\u020C\x03\u020C\x03\u020C\x03\u020C\x03\u020C\x07\u020C\u218F\n\u020C" + - "\f\u020C\x0E\u020C\u2192\v\u020C\x03\u020D\x03\u020D\x03\u020D\x03\u020E" + - "\x03\u020E\x03\u020E\x07\u020E\u219A\n\u020E\f\u020E\x0E\u020E\u219D\v" + - "\u020E\x03\u020F\x03\u020F\x05\u020F\u21A1\n\u020F\x03\u020F\x05\u020F" + - "\u21A4\n\u020F\x03\u020F\x03\u020F\x05\u020F\u21A8\n\u020F\x03\u020F\x03" + - "\u020F\x05\u020F\u21AC\n\u020F\x03\u020F\x03\u020F\x05\u020F\u21B0\n\u020F" + - "\x03\u020F\x03\u020F\x03\u020F\x05\u020F\u21B5\n\u020F\x03\u020F\x03\u020F" + - "\x05\u020F\u21B9\n\u020F\x03\u020F\x03\u020F\x05\u020F\u21BD\n\u020F\x05" + - "\u020F\u21BF\n\u020F\x03\u020F\x03\u020F\x03\u020F\x03\u020F\x03\u020F" + - "\x03\u020F\x03\u020F\x05\u020F\u21C8\n\u020F\x03\u020F\x03\u020F\x03\u020F" + - "\x05\u020F\u21CD\n\u020F\x03\u020F\x03\u020F\x03\u020F\x03\u020F\x05\u020F" + - "\u21D3\n\u020F\x03\u020F\x03\u020F\x05\u020F\u21D7\n\u020F\x05\u020F\u21D9" + - "\n\u020F\x03\u020F\x03\u020F\x03\u020F\x03\u020F\x03\u020F\x05\u020F\u21E0" + - "\n\u020F\x03\u020F\x03\u020F\x03\u020F\x05\u020F\u21E5\n\u020F\x03\u020F" + - "\x03\u020F\x03\u020F\x03\u020F\x07\u020F\u21EB\n\u020F\f\u020F\x0E\u020F" + - "\u21EE\v\u020F\x03\u0210\x05\u0210\u21F1\n\u0210\x03\u0210\x03\u0210\x03" + - "\u0210\x03\u0210\x03\u0210\x05\u0210\u21F8\n\u0210\x03\u0211\x03\u0211" + - "\x03\u0212\x03\u0212\x03\u0212\x05\u0212\u21FF\n\u0212\x03\u0212\x05\u0212" + - "\u2202\n\u0212\x03\u0212\x03\u0212\x03\u0212\x03\u0212\x05\u0212\u2208" + - "\n\u0212\x03\u0213\x03\u0213\x05\u0213\u220C\n\u0213\x03\u0214\x03\u0214" + - "\x03\u0214\x03\u0214\x03\u0214\x03\u0214\x03\u0214\x05\u0214\u2215\n\u0214" + - "\x03\u0215\x03\u0215\x05\u0215\u2219\n\u0215\x03\u0215\x03\u0215\x03\u0215" + - "\x03\u0215\x03\u0215\x03\u0215\x05\u0215\u2221\n\u0215\x05\u0215\u2223" + - "\n\u0215\x03\u0216\x03\u0216\x03\u0216\x07\u0216\u2228\n\u0216\f\u0216" + - "\x0E\u0216\u222B\v\u0216\x03\u0217\x03\u0217\x05\u0217\u222F\n\u0217\x03" + - "\u0217\x05\u0217\u2232\n\u0217\x03\u0218\x03\u0218\x03\u0218\x03\u0218" + - "\x03\u0218\x03\u0218\x05\u0218\u223A\n\u0218\x03\u0219\x03\u0219\x03\u0219" + - "\x03\u0219\x03\u0219\x03\u021A\x03\u021A\x05\u021A\u2243\n\u021A\x03\u021A" + - "\x03\u021A\x03\u021A\x03\u021A\x03\u021A\x03\u021A\x05\u021A\u224B\n\u021A" + - "\x05\u021A\u224D\n\u021A\x03\u021B\x03\u021B\x05\u021B\u2251\n\u021B\x03" + - "\u021C\x03\u021C\x03\u021C\x07\u021C\u2256\n\u021C\f\u021C\x0E\u021C\u2259" + - "\v\u021C\x03\u021D\x03\u021D\x03\u021D\x03\u021D\x03\u021D\x03\u021E\x03" + - "\u021E\x03\u021E\x03\u021F\x03\u021F\x03\u021F\x03\u0220\x03\u0220\x03" + - "\u0220\x03\u0220\x03\u0220\x05\u0220\u226B\n\u0220\x03\u0221\x03\u0221" + - "\x03\u0222\x03\u0222\x03\u0222\x07\u0222\u2272\n\u0222\f\u0222\x0E\u0222" + - "\u2275\v\u0222\x03\u0223\x03\u0223\x03\u0223\x05\u0223\u227A\n\u0223\x03" + - "\u0224\x03\u0224\x03\u0224\x03\u0224\x03\u0224\x03\u0224\x03\u0224\x03" + - "\u0224\x03\u0224\x03\u0224\x03\u0224\x03\u0224\x03\u0224\x03\u0224\x03" + - "\u0224\x03\u0224\x03\u0224\x05\u0224\u228D\n\u0224\x03\u0224\x03\u0224" + - "\x03\u0225\x03\u0225\x03\u0225\x07\u0225\u2294\n\u0225\f\u0225\x0E\u0225" + - "\u2297\v\u0225\x03\u0226\x03\u0226\x03\u0226\x05\u0226\u229C\n\u0226\x03" + - "\u0226\x03\u0226\x05\u0226\u22A0\n\u0226\x03\u0227\x06\u0227\u22A3\n\u0227" + - "\r\u0227\x0E\u0227\u22A4\x03\u0228\x03\u0228\x03\u0228\x03\u0228\x03\u0228" + - "\x03\u0228\x03\u0228\x03\u0228\x05\u0228\u22AF\n\u0228\x03\u0229\x03\u0229" + - "\x03\u0229\x07\u0229\u22B4\n\u0229\f\u0229\x0E\u0229\u22B7\v\u0229\x03" + - "\u022A\x03\u022A\x03\u022A\x03\u022A\x03\u022A\x03\u022A\x05\u022A\u22BF" + - "\n\u022A\x03\u022B\x05\u022B\u22C2\n\u022B\x03\u022B\x03\u022B\x03\u022B" + - "\x03\u022B\x03\u022B\x03\u022B\x03\u022B\x05\u022B\u22CB\n\u022B\x05\u022B" + - "\u22CD\n\u022B\x03\u022B\x03\u022B\x03\u022B\x03\u022B\x05\u022B\u22D3" + - "\n\u022B\x03\u022C\x03\u022C\x05\u022C\u22D7\n\u022C\x03\u022C\x07\u022C" + - "\u22DA\n\u022C\f\u022C\x0E\u022C\u22DD\v\u022C\x03\u022D\x03\u022D\x03" + - "\u022D\x03\u022D\x03\u022D\x03\u022D\x03\u022D\x05\u022D\u22E6\n\u022D" + - "\x03\u022D\x03\u022D\x03\u022D\x03\u022D\x05\u022D\u22EC\n\u022D\x05\u022D" + - "\u22EE\n\u022D\x03\u022E\x03\u022E\x03\u022E\x03\u022E\x05\u022E\u22F4" + - "\n\u022E\x03\u022F\x03\u022F\x05\u022F\u22F8\n\u022F\x03\u022F\x05\u022F" + - "\u22FB\n\u022F\x03\u0230\x03\u0230\x03\u0230\x03\u0230\x03\u0231\x03\u0231" + - "\x03\u0231\x03\u0231\x03\u0231\x03\u0231\x03\u0231\x05\u0231\u2308\n\u0231" + - "\x03\u0231\x03\u0231\x03\u0231\x03\u0231\x05\u0231\u230E\n\u0231\x03\u0231" + - "\x03\u0231\x05\u0231\u2312\n\u0231\x03\u0231\x03\u0231\x05\u0231\u2316" + - "\n\u0231\x03\u0231\x05\u0231\u2319\n\u0231\x03\u0232\x03\u0232\x03\u0232" + - "\x03\u0232\x03\u0233\x03\u0233\x05\u0233\u2321\n\u0233\x03\u0234\x03\u0234" + - "\x05\u0234\u2325\n\u0234\x03\u0235\x03\u0235\x05\u0235\u2329\n\u0235\x03" + - "\u0235\x03\u0235\x03\u0235\x03\u0235\x03\u0236\x03\u0236\x05\u0236\u2331" + - "\n\u0236\x03\u0237\x03\u0237\x03\u0237\x03\u0237\x03\u0237\x05\u0237\u2338" + - "\n\u0237\x03\u0238\x03\u0238\x03\u0238\x03\u0238\x03\u0238\x05\u0238\u233F" + - "\n\u0238\x03\u0239\x03\u0239\x05\u0239\u2343\n\u0239\x03\u0239\x03\u0239" + - "\x03\u0239\x03\u0239\x05\u0239\u2349\n\u0239\x05\u0239\u234B\n\u0239\x03" + - "\u023A\x03\u023A\x03\u023B\x03\u023B\x03\u023B\x03\u023B\x03\u023B\x05" + - "\u023B\u2354\n\u023B\x03\u023B\x05\u023B\u2357\n\u023B\x03\u023C\x03\u023C" + - "\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x03\u023D\x05\u023D" + - "\u2361\n\u023D\x03\u023E\x03\u023E\x03\u023E\x03\u023E\x03\u023E\x03\u023E" + - "\x03\u023E\x03\u023E\x03\u023E\x03\u023E\x03\u023E\x03\u023E\x03\u023E" + - "\x03\u023E\x05\u023E\u2371\n\u023E\x03\u023E\x03\u023E\x03\u023E\x03\u023E" + - "\x05\u023E\u2377\n\u023E\x03\u023E\x03\u023E\x03\u023E\x05\u023E\u237C" + - "\n\u023E\x03\u023F\x03\u023F\x03\u023F\x03\u023F\x03\u023F\x05\u023F\u2383" + - "\n\u023F\x03\u0240\x03\u0240\x03\u0240\x03\u0241\x03\u0241\x03\u0242\x03" + - "\u0242\x05\u0242\u238C\n\u0242\x03\u0243\x03\u0243\x03\u0243\x07\u0243" + - "\u2391\n\u0243\f\u0243\x0E\u0243\u2394\v\u0243\x03\u0244\x03\u0244\x03" + - "\u0244\x07\u0244\u2399\n\u0244\f\u0244\x0E\u0244\u239C\v\u0244\x03\u0245" + - "\x03\u0245\x03\u0245\x07\u0245\u23A1\n\u0245\f\u0245\x0E\u0245\u23A4\v" + - "\u0245\x03\u0246\x03\u0246\x05\u0246\u23A8\n\u0246\x03\u0246\x03\u0246" + - "\x05\u0246\u23AC\n\u0246\x03\u0247\x05\u0247\u23AF\n\u0247\x03\u0247\x03" + - "\u0247\x03\u0248\x03\u0248\x05\u0248\u23B5\n\u0248\x03\u0249\x03\u0249" + - "\x03\u0249\x05\u0249\u23BA\n\u0249\x03\u0249\x03\u0249\x03\u0249\x03\u0249" + - "\x03\u0249\x03\u0249\x03\u0249\x03\u0249\x03\u0249\x03\u0249\x03\u0249" + - "\x03\u0249\x03\u0249\x03\u0249\x05\u0249\u23CA\n\u0249\x03\u0249\x05\u0249" + - "\u23CD\n\u0249\x05\u0249\u23CF\n\u0249\x03\u024A\x03\u024A\x03\u024A\x03" + - "\u024A\x03\u024A\x03\u024A\x03\u024A\x03\u024A\x03\u024A\x03\u024A\x05" + - "\u024A\u23DB\n\u024A\x05\u024A\u23DD\n\u024A\x03\u024B\x03\u024B\x05\u024B" + - "\u23E1\n\u024B\x03\u024B\x03\u024B\x03\u024B\x03\u024B\x03\u024B\x03\u024B" + - "\x05\u024B\u23E9\n\u024B\x05\u024B\u23EB\n\u024B\x03\u024B\x03\u024B\x05" + - "\u024B\u23EF\n\u024B\x05\u024B\u23F1\n\u024B\x03\u024C\x03\u024C\x03\u024C" + - "\x03\u024C\x07\u024C\u23F7\n\u024C\f\u024C\x0E\u024C\u23FA\v\u024C\x03" + - "\u024D\x05\u024D\u23FD\n\u024D\x03\u024D\x03\u024D\x03\u024E\x03\u024E" + - "\x03\u024E\x07\u024E\u2404\n\u024E\f\u024E\x0E\u024E\u2407\v\u024E\x03" + - "\u024F\x03\u024F\x03\u024F\x07\u024F\u240C\n\u024F\f\u024F\x0E\u024F\u240F" + - "\v\u024F\x03\u0250\x03\u0250\x03\u0250\x05\u0250\u2414\n\u0250\x03\u0251" + - "\x05\u0251\u2417\n\u0251\x03\u0251\x03\u0251\x03\u0252\x03\u0252\x03\u0252" + - "\x03\u0252\x03\u0252\x05\u0252\u2420\n\u0252\x03\u0253\x03\u0253\x03\u0253" + - "\x05\u0253\u2425\n\u0253\x03\u0254\x03\u0254\x03\u0254\x07\u0254\u242A" + - "\n\u0254\f\u0254\x0E\u0254\u242D\v\u0254\x03\u0255\x03\u0255\x03\u0255" + - "\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x05\u0255\u2436\n\u0255\x03\u0255" + - "\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255" + - "\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255" + - "\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255" + - "\x03\u0255\x03\u0255\x05\u0255\u2450\n\u0255\x03\u0255\x03\u0255\x03\u0255" + - "\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x03\u0255\x05\u0255" + - "\u245B\n\u0255\x07\u0255\u245D\n\u0255\f\u0255\x0E\u0255\u2460\v\u0255" + - "\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x05\u0256\u2467\n\u0256" + - "\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256" + - "\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256" + - "\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256" + - "\x05\u0256\u247E\n\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256\x03\u0256" + - "\x03\u0256\x05\u0256\u2486\n\u0256\x03\u0257\x03\u0257\x03\u0258\x03\u0258" + - "\x03\u0258\x03\u0258\x03\u0258\x03\u0258\x05\u0258\u2490\n\u0258\x03\u0258" + - "\x05\u0258\u2493\n\u0258\x03\u0258\x03\u0258\x03\u0258\x05\u0258\u2498" + - "\n\u0258\x03\u0258\x03\u0258\x03\u0258\x05\u0258\u249D\n\u0258\x03\u0258" + - "\x03\u0258\x05\u0258\u24A1\n\u0258\x03\u0258\x03\u0258\x03\u0259\x03\u0259" + - "\x05\u0259\u24A7\n\u0259\x03\u0259\x05\u0259\u24AA\n\u0259\x03\u0259\x05" + - "\u0259\u24AD\n\u0259\x03\u0259\x05\u0259\u24B0\n\u0259\x03\u025A\x03\u025A" + - "\x05\u025A\u24B4\n\u025A\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x05\u025B\u24C2\n\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x05\u025B\u24C9\n\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x05\u025B\u24D0\n\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x05\u025B\u24D7\n\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x05\u025B\u24E9\n\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x05\u025B\u24F1\n\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x05\u025B\u24FD\n\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x05\u025B\u2503\n\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x05\u025B\u2510\n\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B"; - private static readonly _serializedATNSegment4: string = - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x05\u025B\u2537\n\u025B\x05\u025B\u2539" + - "\n\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03" + - "\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03" + - "\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x05\u025B\u254D\n\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x05\u025B\u2557\n\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x05\u025B\u2562\n\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B\x03\u025B" + - "\x03\u025B\x03\u025B\x03\u025B\x05\u025B\u256E\n\u025B\x03\u025C\x03\u025C" + - "\x03\u025C\x03\u025C\x03\u025C\x05\u025C\u2575\n\u025C\x03\u025D\x03\u025D" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03\u017C\x03" + + "\u017C\x03\u017C\x03\u017C\x03\u017C\x05\u017C\u1C7C\n\u017C\x03\u017D" + + "\x03\u017D\x03\u017D\x03\u017D\x05\u017D\u1C82\n\u017D\x03\u017D\x05\u017D" + + "\u1C85\n\u017D\x03\u017E\x03\u017E\x03\u017F\x03\u017F\x03\u017F\x03\u017F" + + "\x03\u017F\x03\u017F\x05\u017F\u1C8F\n\u017F\x03\u0180\x03\u0180\x03\u0180" + + "\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180" + + "\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180" + + "\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180\x03\u0180" + + "\x03\u0180\x03\u0180\x03\u0180\x05\u0180\u1CAC\n\u0180\x03\u0181\x03\u0181" + + "\x03\u0181\x03\u0181\x03\u0181\x03\u0181\x03\u0181\x03\u0181\x05\u0181" + + "\u1CB6\n\u0181\x03\u0182\x03\u0182\x03\u0182\x07\u0182\u1CBB\n\u0182\f" + + "\u0182\x0E\u0182\u1CBE\v\u0182\x03\u0183\x03\u0183\x03\u0184\x03\u0184" + + "\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184" + + "\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184" + + "\x03\u0184\x03\u0184\x05\u0184\u1CD4\n\u0184\x03\u0184\x03\u0184\x03\u0184" + + "\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x05\u0184\u1CDD\n\u0184\x03\u0184" + + "\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184\x03\u0184" + + "\x03\u0184\x03\u0184\x05\u0184\u1CE9\n\u0184\x03\u0185\x03\u0185\x03\u0185" + + "\x03\u0185\x05\u0185\u1CEF\n\u0185\x03\u0185\x03\u0185\x03\u0185\x03\u0185" + + "\x03\u0185\x03\u0185\x05\u0185\u1CF7\n\u0185\x05\u0185\u1CF9\n\u0185\x03" + + "\u0186\x03\u0186\x05\u0186\u1CFD\n\u0186\x03\u0186\x03\u0186\x03\u0186" + + "\x03\u0186\x03\u0186\x03\u0186\x03\u0186\x03\u0186\x05\u0186\u1D07\n\u0186" + + "\x03\u0186\x03\u0186\x05\u0186\u1D0B\n\u0186\x03\u0186\x03\u0186\x03\u0187" + + "\x03\u0187\x03\u0187\x03\u0187\x03\u0187\x03\u0187\x05\u0187\u1D15\n\u0187" + + "\x03\u0188\x05\u0188\u1D18\n\u0188\x03\u0188\x03\u0188\x05\u0188\u1D1C" + + "\n\u0188\x07\u0188\u1D1E\n\u0188\f\u0188\x0E\u0188\u1D21\v\u0188\x03\u0189" + + "\x03\u0189\x03\u0189\x03\u0189\x03\u0189\x05\u0189\u1D28\n\u0189\x03\u018A" + + "\x03\u018A\x03\u018B\x03\u018B\x03\u018C\x03\u018C\x03\u018D\x03\u018D" + + "\x03\u018D\x05\u018D\u1D33\n\u018D\x03\u018E\x03\u018E\x03\u018E\x03\u018F" + + "\x03\u018F\x03\u018F\x03\u0190\x03\u0190\x03\u0190\x03\u0190\x05\u0190" + + "\u1D3F\n\u0190\x03\u0191\x03\u0191\x05\u0191\u1D43\n\u0191\x03\u0191\x05" + + "\u0191\u1D46\n\u0191\x03\u0191\x03\u0191\x05\u0191\u1D4A\n\u0191\x03\u0191" + + "\x05\u0191\u1D4D\n\u0191\x03\u0191\x03\u0191\x03\u0191\x05\u0191\u1D52" + + "\n\u0191\x03\u0191\x03\u0191\x05\u0191\u1D56\n\u0191\x03\u0191\x05\u0191" + + "\u1D59\n\u0191\x03\u0191\x03\u0191\x05\u0191\u1D5D\n\u0191\x03\u0191\x05" + + "\u0191\u1D60\n\u0191\x03\u0191\x03\u0191\x05\u0191\u1D64\n\u0191\x03\u0191" + + "\x05\u0191\u1D67\n\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0191" + + "\x03\u0191\x03\u0191\x03\u0191\x03\u0191\x05\u0191\u1D72\n\u0191\x03\u0191" + + "\x03\u0191\x03\u0191\x03\u0191\x03\u0191\x05\u0191\u1D79\n\u0191\x03\u0191" + + "\x03\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0191\x03\u0191" + + "\x03\u0191\x03\u0191\x03\u0191\x05\u0191\u1D86\n\u0191\x03\u0192\x03\u0192" + + "\x03\u0193\x03\u0193\x03\u0193\x03\u0193\x03\u0193\x03\u0193\x03\u0193" + + "\x03\u0193\x03\u0193\x03\u0193\x05\u0193\u1D94\n\u0193\x03\u0194\x03\u0194" + + "\x05\u0194\u1D98\n\u0194\x03\u0194\x07\u0194\u1D9B\n\u0194\f\u0194\x0E" + + "\u0194\u1D9E\v\u0194\x03\u0195\x03\u0195\x03\u0196\x03\u0196\x05\u0196" + + "\u1DA4\n\u0196\x03\u0196\x03\u0196\x03\u0197\x03\u0197\x03\u0197\x05\u0197" + + "\u1DAB\n\u0197\x03\u0197\x05\u0197\u1DAE\n\u0197\x03\u0197\x03\u0197\x03" + + "\u0197\x05\u0197\u1DB3\n\u0197\x03\u0197\x05\u0197\u1DB6\n\u0197\x03\u0197" + + "\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x03\u0197\x05\u0197" + + "\u1DBF\n\u0197\x05\u0197\u1DC1\n\u0197\x03\u0197\x03\u0197\x03\u0197\x05" + + "\u0197\u1DC6\n\u0197\x03\u0198\x03\u0198\x05\u0198\u1DCA\n\u0198\x03\u0198" + + "\x03\u0198\x03\u0198\x03\u0199\x03\u0199\x03\u0199\x03\u019A\x03\u019A" + + "\x03\u019A\x03\u019A\x05\u019A\u1DD6\n\u019A\x03\u019A\x05\u019A\u1DD9" + + "\n\u019A\x03\u019B\x03\u019B\x03\u019C\x06\u019C\u1DDE\n\u019C\r\u019C" + + "\x0E\u019C\u1DDF\x03\u019D\x03\u019D\x05\u019D\u1DE4\n\u019D\x03\u019D" + + "\x03\u019D\x03\u019D\x05\u019D\u1DE9\n\u019D\x03\u019E\x03\u019E\x03\u019E" + + "\x03\u019E\x03\u019E\x03\u019E\x03\u019E\x03\u019E\x05\u019E\u1DF3\n\u019E" + + "\x03\u019F\x03\u019F\x03\u01A0\x03\u01A0\x03\u01A0\x03\u01A0\x03\u01A0" + + "\x05\u01A0\u1DFC\n\u01A0\x03\u01A0\x05\u01A0\u1DFF\n\u01A0\x03\u01A0\x03" + + "\u01A0\x03\u01A0\x05\u01A0\u1E04\n\u01A0\x03\u01A1\x03\u01A1\x03\u01A1" + + "\x03\u01A1\x03\u01A1\x03\u01A2\x03\u01A2\x03\u01A2\x03\u01A2\x05\u01A2" + + "\u1E0F\n\u01A2\x03\u01A2\x03\u01A2\x05\u01A2\u1E13\n\u01A2\x03\u01A2\x03" + + "\u01A2\x03\u01A2\x03\u01A2\x05\u01A2\u1E19\n\u01A2\x03\u01A3\x03\u01A3" + + "\x03\u01A3\x07\u01A3\u1E1E\n\u01A3\f\u01A3\x0E\u01A3\u1E21\v\u01A3\x03" + + "\u01A4\x03\u01A4\x03\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03\u01A5\x03" + + "\u01A5\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A6\x03\u01A7\x03" + + "\u01A7\x03\u01A7\x03\u01A7\x05\u01A7\u1E34\n\u01A7\x03\u01A7\x03\u01A7" + + "\x03\u01A7\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8" + + "\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x03\u01A8" + + "\x03\u01A8\x03\u01A8\x03\u01A8\x05\u01A8\u1E49\n\u01A8\x03\u01A8\x03\u01A8" + + "\x05\u01A8\u1E4D\n\u01A8\x03\u01A8\x03\u01A8\x03\u01A8\x05\u01A8\u1E52" + + "\n\u01A8\x03\u01A9\x03\u01A9\x03\u01AA\x03\u01AA\x03\u01AA\x03\u01AA\x03" + + "\u01AA\x03\u01AA\x03\u01AA\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03" + + "\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x03\u01AB\x05\u01AB\u1EA5\n\u01AB" + + "\x03\u01AC\x03\u01AC\x03\u01AD\x03\u01AD\x05\u01AD\u1EAB\n\u01AD\x03\u01AD" + + "\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD\x03\u01AD" + + "\x03\u01AD\x03\u01AE\x03\u01AE\x05\u01AE\u1EB8\n\u01AE\x03\u01AE\x03\u01AE" + + "\x05\u01AE\u1EBC\n\u01AE\x03\u01AE\x03\u01AE\x05\u01AE\u1EC0\n\u01AE\x03" + + "\u01AE\x03\u01AE\x05\u01AE\u1EC4\n\u01AE\x03\u01AE\x03\u01AE\x03\u01AE" + + "\x03\u01AE\x05\u01AE\u1ECA\n\u01AE\x03\u01AF\x03\u01AF\x03\u01AF\x03\u01B0" + + "\x03\u01B0\x05\u01B0\u1ED1\n\u01B0\x03\u01B0\x05\u01B0\u1ED4\n\u01B0\x03" + + "\u01B0\x05\u01B0\u1ED7\n\u01B0\x03\u01B0\x05\u01B0\u1EDA\n\u01B0\x03\u01B0" + + "\x05\u01B0\u1EDD\n\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03\u01B0\x03\u01B0" + + "\x05\u01B0\u1EE4\n\u01B0\x05\u01B0\u1EE6\n\u01B0\x03\u01B1\x03\u01B1\x05" + + "\u01B1\u1EEA\n\u01B1\x03\u01B1\x05\u01B1\u1EED\n\u01B1\x03\u01B1\x03\u01B1" + + "\x03\u01B1\x03\u01B1\x03\u01B1\x05\u01B1\u1EF4\n\u01B1\x05\u01B1\u1EF6" + + "\n\u01B1\x03\u01B2\x03\u01B2\x03\u01B2\x07\u01B2\u1EFB\n\u01B2\f\u01B2" + + "\x0E\u01B2\u1EFE\v\u01B2\x03\u01B3\x03\u01B3\x03\u01B4\x03\u01B4\x05\u01B4" + + "\u1F04\n\u01B4\x03\u01B5\x03\u01B5\x05\u01B5\u1F08\n\u01B5\x03\u01B6\x03" + + "\u01B6\x05\u01B6\u1F0C\n\u01B6\x03\u01B7\x03\u01B7\x03\u01B8\x03\u01B8" + + "\x03\u01B9\x03\u01B9\x03\u01BA\x03\u01BA\x03\u01BB\x03\u01BB\x03\u01BB" + + "\x03\u01BB\x03\u01BC\x03\u01BC\x05\u01BC\u1F1C\n\u01BC\x03\u01BD\x03\u01BD" + + "\x03\u01BD\x07\u01BD\u1F21\n\u01BD\f\u01BD\x0E\u01BD\u1F24\v\u01BD\x03" + + "\u01BE\x03\u01BE\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x05" + + "\u01BF\u1F2D\n\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF" + + "\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x03\u01BF\x05\u01BF" + + "\u1F3A\n\u01BF\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0\x03\u01C0" + + "\x03\u01C0\x03\u01C0\x03\u01C0\x05\u01C0\u1F45\n\u01C0\x03\u01C1\x03\u01C1" + + "\x03\u01C1\x07\u01C1\u1F4A\n\u01C1\f\u01C1\x0E\u01C1\u1F4D\v\u01C1\x03" + + "\u01C2\x03\u01C2\x05\u01C2\u1F51\n\u01C2\x03\u01C3\x03\u01C3\x05\u01C3" + + "\u1F55\n\u01C3\x03\u01C4\x03\u01C4\x05\u01C4\u1F59\n\u01C4\x03\u01C5\x03" + + "\u01C5\x03\u01C5\x05\u01C5\u1F5E\n\u01C5\x03\u01C5\x03\u01C5\x03\u01C5" + + "\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C6\x03\u01C7\x03\u01C7\x03\u01C7" + + "\x03\u01C7\x05\u01C7\u1F6B\n\u01C7\x03\u01C8\x03\u01C8\x03\u01C8\x05\u01C8" + + "\u1F70\n\u01C8\x03\u01C8\x03\u01C8\x05\u01C8\u1F74\n\u01C8\x03\u01C8\x03" + + "\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x05\u01C8\u1F7C\n\u01C8" + + "\x03\u01C8\x05\u01C8\u1F7F\n\u01C8\x03\u01C8\x03\u01C8\x05\u01C8\u1F83" + + "\n\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03\u01C8\x03" + + "\u01C8\x03\u01C8\x03\u01C8\x05\u01C8\u1F8E\n\u01C8\x03\u01C8\x05\u01C8" + + "\u1F91\n\u01C8\x05\u01C8\u1F93\n\u01C8\x03\u01C9\x03\u01C9\x03\u01C9\x03" + + "\u01C9\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x03" + + "\u01CA\x03\u01CA\x03\u01CA\x03\u01CA\x05\u01CA\u1FA3\n\u01CA\x03\u01CB" + + "\x05\u01CB\u1FA6\n\u01CB\x03\u01CB\x03\u01CB\x03\u01CB\x03\u01CB\x03\u01CB" + + "\x05\u01CB\u1FAD\n\u01CB\x03\u01CB\x05\u01CB\u1FB0\n\u01CB\x03\u01CC\x03" + + "\u01CC\x03\u01CC\x05\u01CC\u1FB5\n\u01CC\x03\u01CD\x03\u01CD\x03\u01CD" + + "\x03\u01CD\x03\u01CD\x03\u01CD\x03\u01CD\x03\u01CD\x03\u01CD\x03\u01CD" + + "\x03\u01CD\x03\u01CD\x03\u01CD\x05\u01CD\u1FC4\n\u01CD\x03\u01CD\x03\u01CD" + + "\x03\u01CD\x03\u01CD\x05\u01CD\u1FCA\n\u01CD\x03\u01CE\x03\u01CE\x03\u01CF" + + "\x03\u01CF\x03\u01CF\x07\u01CF\u1FD1\n\u01CF\f\u01CF\x0E\u01CF\u1FD4\v" + + "\u01CF\x03\u01D0\x03\u01D0\x03\u01D0\x03\u01D1\x03\u01D1\x03\u01D1\x05" + + "\u01D1\u1FDC\n\u01D1\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D1\x03\u01D1" + + "\x05\u01D1\u1FE3\n\u01D1\x03\u01D1\x05\u01D1\u1FE6\n\u01D1\x03\u01D2\x03" + + "\u01D2\x03\u01D2\x03\u01D2\x05\u01D2\u1FEC\n\u01D2\x03\u01D2\x03\u01D2" + + "\x03\u01D2\x05\u01D2\u1FF1\n\u01D2\x03\u01D3\x03\u01D3\x03\u01D3\x03\u01D4" + + "\x05\u01D4\u1FF7\n\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x03\u01D4\x05\u01D4" + + "\u1FFD\n\u01D4\x03\u01D4\x05\u01D4\u2000\n\u01D4\x03\u01D4\x05\u01D4\u2003" + + "\n\u01D4\x03\u01D5\x03\u01D5\x03\u01D5\x03\u01D6\x03\u01D6\x05\u01D6\u200A" + + "\n\u01D6\x03\u01D6\x03\u01D6\x05\u01D6\u200E\n\u01D6\x03\u01D6\x05\u01D6" + + "\u2011\n\u01D6\x03\u01D7\x03\u01D7\x03\u01D7\x03\u01D7\x03\u01D8\x03\u01D8" + + "\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D8\x03\u01D8" + + "\x05\u01D8\u2020\n\u01D8\x03\u01D8\x05\u01D8\u2023\n\u01D8\x03\u01D9\x03" + + "\u01D9\x03\u01DA\x03\u01DA\x03\u01DA\x05\u01DA\u202A\n\u01DA\x03\u01DB" + + "\x05\u01DB\u202D\n\u01DB\x03\u01DB\x03\u01DB\x03\u01DB\x03\u01DB\x03\u01DB" + + "\x05\u01DB\u2034\n\u01DB\x03\u01DB\x05\u01DB\u2037\n\u01DB\x03\u01DB\x05" + + "\u01DB\u203A\n\u01DB\x03\u01DC\x03\u01DC\x03\u01DC\x07\u01DC\u203F\n\u01DC" + + "\f\u01DC\x0E\u01DC\u2042\v\u01DC\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DD" + + "\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x03\u01DD\x05\u01DD" + + "\u204E\n\u01DD\x03\u01DE\x03\u01DE\x03\u01DE\x03\u01DF\x03\u01DF\x03\u01DF" + + "\x07\u01DF\u2056\n\u01DF\f\u01DF\x0E\u01DF\u2059\v\u01DF\x03\u01E0\x03" + + "\u01E0\x03\u01E0\x03\u01E0\x03\u01E0\x03\u01E0\x03\u01E0\x03\u01E0\x03" + + "\u01E1\x03\u01E1\x03\u01E2\x03\u01E2\x03\u01E2\x03\u01E2\x03\u01E2\x07" + + "\u01E2\u206A\n\u01E2\f\u01E2\x0E\u01E2\u206D\v\u01E2\x03\u01E3\x03\u01E3" + + "\x03\u01E3\x03\u01E3\x03\u01E3\x05\u01E3\u2074\n\u01E3\x03\u01E4\x03\u01E4" + + "\x05\u01E4\u2078\n\u01E4\x03\u01E5\x03\u01E5\x03\u01E5\x03\u01E5\x03\u01E5" + + "\x03\u01E5\x03\u01E5\x03\u01E5\x05\u01E5\u2082\n\u01E5\x03\u01E6\x03\u01E6" + + "\x05\u01E6\u2086\n\u01E6\x03\u01E6\x03\u01E6\x05\u01E6\u208A\n\u01E6\x03" + + "\u01E6\x03\u01E6\x05\u01E6\u208E\n\u01E6\x05\u01E6\u2090\n\u01E6\x03\u01E6" + + "\x03\u01E6\x03\u01E6\x05\u01E6\u2095\n\u01E6\x03\u01E6\x03\u01E6\x05\u01E6" + + "\u2099\n\u01E6\x03\u01E6\x03\u01E6\x05\u01E6\u209D\n\u01E6\x05\u01E6\u209F" + + "\n\u01E6\x05\u01E6\u20A1\n\u01E6\x03\u01E7\x03\u01E7\x05\u01E7\u20A5\n" + + "\u01E7\x03\u01E8\x03\u01E8\x05\u01E8\u20A9\n\u01E8\x03\u01E8\x05\u01E8" + + "\u20AC\n\u01E8\x03\u01E8\x05\u01E8\u20AF\n\u01E8\x03\u01E8\x05\u01E8\u20B2" + + "\n\u01E8\x03\u01E8\x05\u01E8\u20B5\n\u01E8\x05\u01E8\u20B7\n\u01E8\x03" + + "\u01E8\x05\u01E8\u20BA\n\u01E8\x03\u01E8\x05\u01E8\u20BD\n\u01E8\x03\u01E8" + + "\x05\u01E8\u20C0\n\u01E8\x03\u01E8\x05\u01E8\u20C3\n\u01E8\x03\u01E8\x05" + + "\u01E8\u20C6\n\u01E8\x03\u01E8\x05\u01E8\u20C9\n\u01E8\x03\u01E8\x03\u01E8" + + "\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x05\u01E8\u20D2\n\u01E8" + + "\x05\u01E8\u20D4\n\u01E8\x03\u01E8\x03\u01E8\x03\u01E8\x05\u01E8\u20D9" + + "\n\u01E8\x07\u01E8\u20DB\n\u01E8\f\u01E8\x0E\u01E8\u20DE\v\u01E8\x03\u01E9" + + "\x03\u01E9\x03\u01E9\x05\u01E9\u20E3\n\u01E9\x03\u01EA\x03\u01EA\x05\u01EA" + + "\u20E7\n\u01EA\x03\u01EB\x03\u01EB\x05\u01EB\u20EB\n\u01EB\x03\u01EB\x03" + + "\u01EB\x03\u01EC\x03\u01EC\x03\u01EC\x07\u01EC\u20F2\n\u01EC\f\u01EC\x0E" + + "\u01EC\u20F5\v\u01EC\x03\u01ED\x03\u01ED\x05\u01ED\u20F9\n\u01ED\x03\u01ED" + + "\x03\u01ED\x05\u01ED\u20FD\n\u01ED\x03\u01ED\x03\u01ED\x03\u01ED\x03\u01ED" + + "\x03\u01EE\x03\u01EE\x03\u01EE\x05\u01EE\u2106\n\u01EE\x03\u01EF\x03\u01EF" + + "\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x03\u01F0\x05\u01F0\u210F\n\u01F0" + + "\x03\u01F1\x03\u01F1\x05\u01F1\u2113\n\u01F1\x03\u01F2\x05\u01F2\u2116" + + "\n\u01F2\x03\u01F2\x03\u01F2\x05\u01F2\u211A\n\u01F2\x03\u01F2\x03\u01F2" + + "\x03\u01F2\x05\u01F2\u211F\n\u01F2\x03\u01F2\x03\u01F2\x03\u01F2\x03\u01F2" + + "\x05\u01F2\u2125\n\u01F2\x03\u01F3\x03\u01F3\x03\u01F4\x03\u01F4\x03\u01F5" + + "\x03\u01F5\x03\u01F5\x03\u01F5\x03\u01F5\x03\u01F5\x05\u01F5\u2131\n\u01F5" + + "\x03\u01F6\x03\u01F6\x03\u01F7\x03\u01F7\x03\u01F8\x03\u01F8\x03\u01F8" + + "\x03\u01F8\x03\u01F9\x03\u01F9\x03\u01F9\x07\u01F9\u213E\n\u01F9\f\u01F9" + + "\x0E\u01F9\u2141\v\u01F9\x03\u01FA\x03\u01FA\x03\u01FA\x03\u01FA\x05\u01FA" + + "\u2147\n\u01FA\x03\u01FA\x05\u01FA\u214A\n\u01FA\x03\u01FB\x03\u01FB\x05" + + "\u01FB\u214E\n\u01FB\x03\u01FB\x03\u01FB\x05\u01FB\u2152\n\u01FB\x05\u01FB" + + "\u2154\n\u01FB\x03\u01FC\x03\u01FC\x03\u01FD\x03\u01FD\x03\u01FD\x03\u01FD" + + "\x05\u01FD\u215C\n\u01FD\x03\u01FD\x03\u01FD\x03\u01FD\x03\u01FD\x03\u01FD" + + "\x03\u01FD\x03\u01FD\x05\u01FD\u2165\n\u01FD\x03\u01FD\x03\u01FD\x03\u01FD" + + "\x03\u01FD\x05\u01FD\u216B\n\u01FD\x05\u01FD\u216D\n\u01FD\x05\u01FD\u216F" + + "\n\u01FD\x03\u01FE\x03\u01FE\x03\u01FE\x03\u01FE\x03\u01FE\x05\u01FE\u2176" + + "\n\u01FE\x03\u01FF\x03\u01FF\x05\u01FF\u217A\n\u01FF\x03\u0200\x03\u0200" + + "\x03\u0201\x03\u0201\x03\u0201\x03\u0201\x03\u0201\x05\u0201\u2183\n\u0201" + + "\x03\u0202\x03\u0202\x05\u0202\u2187\n\u0202\x03\u0203\x03\u0203\x03\u0204" + + "\x03\u0204\x03\u0205\x03\u0205\x03\u0205\x03\u0205\x03\u0206\x03\u0206" + + "\x03\u0206\x07\u0206\u2194\n\u0206\f\u0206\x0E\u0206\u2197\v\u0206\x03" + + "\u0207\x03\u0207\x03\u0207\x03\u0207\x03\u0207\x05\u0207\u219E\n\u0207" + + "\x03\u0208\x03\u0208\x03\u0208\x03\u0209\x03\u0209\x03\u0209\x03\u0209" + + "\x03\u0209\x03\u020A\x03\u020A\x03\u020A\x03\u020A\x03\u020A\x03\u020B" + + "\x03\u020B\x03\u020B\x03\u020B\x03\u020B\x03\u020B\x03\u020C\x03\u020C" + + "\x03\u020C\x03\u020D\x03\u020D\x03\u020D\x03\u020D\x05\u020D\u21BA\n\u020D" + + "\x03\u020E\x03\u020E\x03\u020F\x06\u020F\u21BF\n\u020F\r\u020F\x0E\u020F" + + "\u21C0\x03\u0210\x03\u0210\x05\u0210\u21C5\n\u0210\x03\u0210\x05\u0210" + + "\u21C8\n\u0210\x03\u0211\x03\u0211\x03\u0211\x05\u0211\u21CD\n\u0211\x03" + + "\u0211\x03\u0211\x05\u0211\u21D1\n\u0211\x03\u0211\x05\u0211\u21D4\n\u0211" + + "\x03\u0212\x03\u0212\x03\u0212\x03\u0213\x03\u0213\x03\u0213\x03\u0213" + + "\x03\u0213\x03\u0213\x03\u0213\x03\u0213\x03\u0213\x07\u0213\u21E2\n\u0213" + + "\f\u0213\x0E\u0213\u21E5\v\u0213\x03\u0214\x03\u0214\x03\u0214\x03\u0215" + + "\x03\u0215\x03\u0215\x07\u0215\u21ED\n\u0215\f\u0215\x0E\u0215\u21F0\v" + + "\u0215\x03\u0216\x03\u0216\x05\u0216\u21F4\n\u0216\x03\u0216\x05\u0216" + + "\u21F7\n\u0216\x03\u0216\x03\u0216\x05\u0216\u21FB\n\u0216\x03\u0216\x03" + + "\u0216\x05\u0216\u21FF\n\u0216\x03\u0216\x03\u0216\x05\u0216\u2203\n\u0216" + + "\x03\u0216\x03\u0216\x03\u0216\x05\u0216\u2208\n\u0216\x03\u0216\x03\u0216" + + "\x05\u0216\u220C\n\u0216\x03\u0216\x03\u0216\x05\u0216\u2210\n\u0216\x05" + + "\u0216\u2212\n\u0216\x03\u0216\x03\u0216\x03\u0216\x03\u0216\x03\u0216" + + "\x03\u0216\x03\u0216\x05\u0216\u221B\n\u0216\x03\u0216\x03\u0216\x03\u0216" + + "\x05\u0216\u2220\n\u0216\x03\u0216\x03\u0216\x03\u0216\x03\u0216\x05\u0216" + + "\u2226\n\u0216\x03\u0216\x03\u0216\x05\u0216\u222A\n\u0216\x05\u0216\u222C" + + "\n\u0216\x03\u0216\x03\u0216\x03\u0216\x03\u0216\x03\u0216\x05\u0216\u2233" + + "\n\u0216\x03\u0216\x03\u0216\x03\u0216\x05\u0216\u2238\n\u0216\x03\u0216" + + "\x03\u0216\x03\u0216\x03\u0216\x07\u0216\u223E\n\u0216\f\u0216\x0E\u0216" + + "\u2241\v\u0216\x03\u0217\x05\u0217\u2244\n\u0217\x03\u0217\x03\u0217\x03" + + "\u0217\x03\u0217\x03\u0217\x05\u0217\u224B\n\u0217\x03\u0218\x03\u0218" + + "\x03\u0219\x03\u0219\x03\u0219\x05\u0219\u2252\n\u0219\x03\u0219\x05\u0219" + + "\u2255\n\u0219\x03\u0219\x03\u0219\x03\u0219\x03\u0219\x05\u0219\u225B" + + "\n\u0219\x03\u021A\x03\u021A\x05\u021A\u225F\n\u021A\x03\u021B\x03\u021B" + + "\x03\u021B\x03\u021B\x03\u021B\x03\u021B\x03\u021B\x05\u021B\u2268\n\u021B" + + "\x03\u021C\x05\u021C\u226B\n\u021C\x03\u021C\x03\u021C\x05\u021C\u226F" + + "\n\u021C\x03\u021C\x03\u021C\x03\u021C\x03\u021C\x03\u021C\x03\u021C\x05" + + "\u021C\u2277\n\u021C\x05\u021C\u2279\n\u021C\x03\u021D\x03\u021D\x03\u021D" + + "\x07\u021D\u227E\n\u021D\f\u021D\x0E\u021D\u2281\v\u021D\x03\u021E\x03" + + "\u021E\x05\u021E\u2285\n\u021E\x03\u021E\x05\u021E\u2288\n\u021E\x03\u021F" + + "\x03\u021F\x03\u021F\x03\u021F\x03\u021F\x03\u021F\x05\u021F\u2290\n\u021F" + + "\x03\u0220\x03\u0220\x03\u0220\x03\u0220\x03\u0220\x03\u0221\x03\u0221" + + "\x05\u0221\u2299\n\u0221\x03\u0221\x03\u0221\x03\u0221\x03\u0221\x03\u0221" + + "\x03\u0221\x05\u0221\u22A1\n\u0221\x05\u0221\u22A3\n\u0221\x03\u0222\x03" + + "\u0222\x05\u0222\u22A7\n\u0222\x03\u0223\x03\u0223\x03\u0223\x07\u0223" + + "\u22AC\n\u0223\f\u0223\x0E\u0223\u22AF\v\u0223\x03\u0224\x03\u0224\x03" + + "\u0224\x03\u0224\x03\u0224\x03\u0225\x03\u0225\x03\u0225\x03\u0226\x03" + + "\u0226\x03\u0226\x03\u0227\x03\u0227\x03\u0227\x03\u0227\x03\u0227\x05" + + "\u0227\u22C1\n\u0227\x03\u0228\x03\u0228\x03\u0229\x03\u0229\x03\u0229" + + "\x07\u0229\u22C8\n\u0229\f\u0229\x0E\u0229\u22CB\v\u0229\x03\u022A\x03" + + "\u022A\x03\u022A\x05\u022A\u22D0\n\u022A\x03\u022B\x03\u022B\x03\u022B" + + "\x03\u022B\x03\u022B\x03\u022B\x03\u022B\x03\u022B\x03\u022B\x03\u022B" + + "\x03\u022B\x03\u022B\x03\u022B\x03\u022B\x03\u022B\x03\u022B\x03\u022B" + + "\x05\u022B\u22E3\n\u022B\x03\u022B\x03\u022B\x03\u022C\x03\u022C\x03\u022C" + + "\x07\u022C\u22EA\n\u022C\f\u022C\x0E\u022C\u22ED\v\u022C\x03\u022D\x03" + + "\u022D\x03\u022D\x05\u022D\u22F2\n\u022D\x03\u022D\x03\u022D\x05\u022D" + + "\u22F6\n\u022D\x03\u022E\x06\u022E\u22F9\n\u022E\r\u022E\x0E\u022E\u22FA" + + "\x03\u022F\x03\u022F\x03\u022F\x03\u022F\x03\u022F\x03\u022F\x03\u022F" + + "\x03\u022F\x05\u022F\u2305\n\u022F\x03\u0230\x03\u0230\x03\u0230\x07\u0230" + + "\u230A\n\u0230\f\u0230\x0E\u0230\u230D\v\u0230\x03\u0231\x03\u0231\x03" + + "\u0231\x03\u0231\x03\u0231\x03\u0231\x05\u0231\u2315\n\u0231\x03\u0232" + + "\x05\u0232\u2318\n\u0232\x03\u0232\x03\u0232\x03\u0232\x03\u0232\x03\u0232" + + "\x03\u0232\x03\u0232\x05\u0232\u2321\n\u0232\x05\u0232\u2323\n\u0232\x03" + + "\u0232\x03\u0232\x03\u0232\x03\u0232\x05\u0232\u2329\n\u0232\x03\u0233" + + "\x03\u0233\x05\u0233\u232D\n\u0233\x03\u0233\x07\u0233\u2330\n\u0233\f" + + "\u0233\x0E\u0233\u2333\v\u0233\x03\u0234\x03\u0234\x03\u0234\x03\u0234" + + "\x03\u0234\x03\u0234\x03\u0234\x05\u0234\u233C\n\u0234\x03\u0234\x03\u0234" + + "\x03\u0234\x03\u0234\x05\u0234\u2342\n\u0234\x05\u0234\u2344\n\u0234\x03" + + "\u0235\x03\u0235\x03\u0235\x03\u0235\x05\u0235\u234A\n\u0235\x03\u0236" + + "\x03\u0236\x05\u0236\u234E\n\u0236\x03\u0236\x05\u0236\u2351\n\u0236\x03" + + "\u0237\x03\u0237\x03\u0237\x03\u0237\x03\u0238\x03\u0238\x03\u0238\x03" + + "\u0238\x03\u0238\x03\u0238\x03\u0238\x05\u0238\u235E\n\u0238\x03\u0238" + + "\x03\u0238\x03\u0238\x03\u0238\x05\u0238\u2364\n\u0238\x03\u0238\x03\u0238" + + "\x05\u0238\u2368\n\u0238\x03\u0238\x03\u0238\x05\u0238\u236C\n\u0238\x03" + + "\u0238\x05\u0238\u236F\n\u0238\x03\u0239\x03\u0239\x03\u0239\x03\u0239" + + "\x03\u023A\x03\u023A\x05\u023A\u2377\n\u023A\x03\u023B\x03\u023B\x05\u023B" + + "\u237B\n\u023B\x03\u023C\x03\u023C\x05\u023C\u237F\n\u023C\x03\u023C\x03" + + "\u023C\x03\u023C\x03\u023C\x03\u023D\x03\u023D\x05\u023D\u2387\n\u023D" + + "\x03\u023E\x03\u023E\x03\u023E\x03\u023E\x03\u023E\x05\u023E\u238E\n\u023E" + + "\x03\u023F\x03\u023F\x03\u023F\x03\u023F\x03\u023F\x05\u023F\u2395\n\u023F" + + "\x03\u0240\x03\u0240\x05\u0240\u2399\n\u0240\x03\u0240\x03\u0240\x03\u0240" + + "\x03\u0240\x05\u0240\u239F\n\u0240\x05\u0240\u23A1\n\u0240\x03\u0241\x03" + + "\u0241\x03\u0242\x03\u0242\x03\u0242\x03\u0242\x03\u0242\x05\u0242\u23AA" + + "\n\u0242\x03\u0242\x05\u0242\u23AD\n\u0242\x03\u0243\x03\u0243\x03\u0244" + + "\x03\u0244\x03\u0244\x03\u0244\x03\u0244\x03\u0244\x05\u0244\u23B7\n\u0244" + + "\x03\u0245\x03\u0245\x03\u0245\x03\u0245\x03\u0245\x03\u0245\x03\u0245" + + "\x03\u0245\x03\u0245\x03\u0245\x03\u0245\x03\u0245\x03\u0245\x03\u0245" + + "\x05\u0245\u23C7\n\u0245\x03\u0245\x03\u0245\x03\u0245\x03\u0245\x05\u0245" + + "\u23CD\n\u0245\x03\u0245\x03\u0245\x03\u0245\x05\u0245\u23D2\n\u0245\x03" + + "\u0246\x03\u0246\x03\u0246\x03\u0246\x03\u0246\x05\u0246\u23D9\n\u0246" + + "\x03\u0247\x03\u0247\x03\u0247\x03\u0248\x03\u0248\x03\u0249\x03\u0249" + + "\x05\u0249\u23E2\n\u0249\x03\u024A\x03\u024A\x03\u024A\x07\u024A\u23E7" + + "\n\u024A\f\u024A\x0E\u024A\u23EA\v\u024A\x03\u024B\x03\u024B\x03\u024B" + + "\x07\u024B\u23EF\n\u024B\f\u024B\x0E\u024B\u23F2\v\u024B\x03\u024C\x03" + + "\u024C\x03\u024C\x07\u024C\u23F7\n\u024C\f\u024C\x0E\u024C\u23FA\v\u024C" + + "\x03\u024D\x03\u024D\x05\u024D\u23FE\n\u024D\x03\u024D\x03\u024D\x05\u024D" + + "\u2402\n\u024D\x03\u024E\x05\u024E\u2405\n\u024E\x03\u024E\x03\u024E\x03" + + "\u024F\x03\u024F\x05\u024F\u240B\n\u024F\x03\u0250\x03\u0250\x03\u0250" + + "\x05\u0250\u2410\n\u0250\x03\u0250\x03\u0250\x03\u0250\x03\u0250\x03\u0250" + + "\x03\u0250\x03\u0250\x03\u0250\x03\u0250\x03\u0250\x03\u0250\x03\u0250" + + "\x03\u0250\x03\u0250\x05\u0250\u2420\n\u0250\x03\u0250\x05\u0250\u2423" + + "\n\u0250\x05\u0250\u2425\n\u0250\x03\u0251\x03\u0251\x03\u0251\x03\u0251" + + "\x03\u0251\x03\u0251\x03\u0251\x03\u0251\x03\u0251\x03\u0251\x05\u0251" + + "\u2431\n\u0251\x05\u0251\u2433\n\u0251\x03\u0252\x03\u0252\x05\u0252\u2437" + + "\n\u0252\x03\u0252\x03\u0252\x03\u0252\x03\u0252\x03\u0252\x03\u0252\x05" + + "\u0252\u243F\n\u0252\x05\u0252\u2441\n\u0252\x03\u0252\x03\u0252\x05\u0252" + + "\u2445\n\u0252\x05\u0252\u2447\n\u0252\x03\u0253\x03\u0253\x03\u0253\x03" + + "\u0253\x07\u0253\u244D\n\u0253\f\u0253\x0E\u0253\u2450\v\u0253\x03\u0254" + + "\x05\u0254\u2453\n\u0254\x03\u0254\x03\u0254\x03\u0255\x03\u0255\x03\u0255" + + "\x07\u0255\u245A\n\u0255\f\u0255\x0E\u0255\u245D\v\u0255\x03\u0256\x03" + + "\u0256\x03\u0256\x07\u0256\u2462\n\u0256\f\u0256\x0E\u0256\u2465\v\u0256" + + "\x03\u0257\x03\u0257\x03\u0257\x05\u0257\u246A\n\u0257\x03\u0258\x05\u0258" + + "\u246D\n\u0258\x03\u0258\x03\u0258\x03\u0259\x03\u0259\x03\u0259\x03\u0259" + + "\x03\u0259\x05\u0259\u2476\n\u0259\x03\u025A\x03\u025A\x03\u025A\x05\u025A" + + "\u247B\n\u025A\x03\u025B\x03\u025B\x03\u025B\x07\u025B\u2480\n\u025B\f" + + "\u025B\x0E\u025B\u2483\v\u025B\x03\u025C\x03\u025C\x03\u025C\x03\u025C" + + "\x03\u025C\x03\u025C\x03\u025C\x05\u025C\u248C\n\u025C\x03\u025C\x03\u025C" + + "\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C" + + "\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C" + + "\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C" + + "\x03\u025C\x05\u025C\u24A6\n\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C" + + "\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x03\u025C\x05\u025C\u24B1\n\u025C" + + "\x07\u025C\u24B3\n\u025C\f\u025C\x0E\u025C\u24B6\v\u025C\x03\u025D\x03" + + "\u025D\x03\u025D\x03\u025D\x03\u025D\x05\u025D\u24BD\n\u025D\x03\u025D" + "\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D" + - "\x03\u025D\x05\u025D\u2581\n\u025D\x03\u025E\x03\u025E\x03\u025E\x03\u025E" + - "\x03\u025E\x03\u025F\x03\u025F\x03\u025F\x07\u025F\u258B\n\u025F\f\u025F" + - "\x0E\u025F\u258E\v\u025F\x03\u0260\x03\u0260\x03\u0260\x05\u0260\u2593" + - "\n\u0260\x03\u0261\x03\u0261\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x05" + - "\u0262\u259B\n\u0262\x03\u0263\x03\u0263\x03\u0263\x03\u0263\x03\u0263" + - "\x03\u0263\x03\u0263\x03\u0263\x03\u0263\x03\u0263\x03\u0263\x03\u0263" + - "\x03\u0263\x03\u0263\x03\u0263\x05\u0263\u25AC\n\u0263\x03\u0264\x03\u0264" + - "\x03\u0264\x03\u0265\x03\u0265\x03\u0265\x03\u0265\x03\u0265\x03\u0265" + - "\x03\u0266\x03\u0266\x03\u0266\x03\u0266\x03\u0266\x03\u0266\x03\u0267" + - "\x03\u0267\x03\u0267\x03\u0268\x03\u0268\x03\u0268\x07\u0268\u25C3\n\u0268" + - "\f\u0268\x0E\u0268\u25C6\v\u0268\x03\u0269\x03\u0269\x03\u0269\x03\u0269" + - "\x03\u026A\x03\u026A\x03\u026A\x05\u026A\u25CF\n\u026A\x03\u026B\x03\u026B" + - "\x05\u026B\u25D3\n\u026B\x03\u026B\x05\u026B\u25D6\n\u026B\x03\u026B\x05" + - "\u026B\u25D9\n\u026B\x03\u026B\x05\u026B\u25DC\n\u026B\x03\u026B\x03\u026B" + - "\x03\u026C\x03\u026C\x03\u026D\x03\u026D\x03\u026D\x03\u026D\x03\u026E" + - "\x03\u026E\x03\u026E\x05\u026E\u25E9\n\u026E\x03\u026E\x03\u026E\x03\u026E" + - "\x05\u026E\u25EE\n\u026E\x03\u026E\x03\u026E\x03\u026E\x05\u026E\u25F3" + - "\n\u026E\x05\u026E\u25F5\n\u026E\x03\u026F\x03\u026F\x03\u026F\x03\u026F" + - "\x03\u026F\x03\u026F\x05\u026F\u25FD\n\u026F\x03\u0270\x03\u0270\x03\u0270" + - "\x03\u0270\x03\u0270\x03\u0270\x03\u0270\x05\u0270\u2606\n\u0270\x03\u0271" + - "\x03\u0271\x03\u0271\x03\u0271\x03\u0271\x03\u0271\x03\u0271\x05\u0271" + - "\u260F\n\u0271\x03\u0272\x03\u0272\x03\u0272\x05\u0272\u2614\n\u0272\x03" + - "\u0272\x03\u0272\x03\u0272\x03\u0272\x03\u0272\x03\u0272\x03\u0272\x05" + - "\u0272\u261D\n\u0272\x03\u0273\x03\u0273\x03\u0273\x05\u0273\u2622\n\u0273" + - "\x03\u0273\x03\u0273\x03\u0274\x03\u0274\x03\u0274\x03\u0274\x03\u0274" + - "\x03\u0274\x03\u0275\x03\u0275\x03\u0276\x03\u0276\x05\u0276\u2630\n\u0276" + - "\x03\u0277\x03\u0277\x03\u0278\x03\u0278\x03\u0278\x03\u0278\x03\u0278" + - "\x03\u0278\x05\u0278\u263A\n\u0278\x03\u0279\x03\u0279\x03\u0279\x03\u0279" + - "\x03\u0279\x03\u0279\x05\u0279\u2642\n\u0279\x03\u027A\x03\u027A\x03\u027A" + - "\x03\u027A\x03\u027A\x03\u027A\x03\u027A\x03\u027A\x03\u027A\x03\u027A" + - "\x03\u027A\x03\u027A\x05\u027A\u2650\n\u027A\x03\u027B\x03\u027B\x03\u027B" + - "\x07\u027B\u2655\n\u027B\f\u027B\x0E\u027B\u2658\v\u027B\x03\u027C\x03" + - "\u027C\x03\u027C\x07\u027C\u265D\n\u027C\f\u027C\x0E\u027C\u2660\v\u027C" + - "\x03\u027D\x03\u027D\x03\u027D\x03\u027D\x03\u027D\x05\u027D\u2667\n\u027D" + - "\x03\u027E\x03\u027E\x03\u027E\x07\u027E\u266C\n\u027E\f\u027E\x0E\u027E" + - "\u266F\v\u027E\x03\u027F\x03\u027F\x03\u027F\x05\u027F\u2674\n\u027F\x03" + - "\u027F\x03\u027F\x03\u0280\x03\u0280\x03\u0280\x07\u0280\u267B\n\u0280" + - "\f\u0280\x0E\u0280\u267E\v\u0280\x03\u0281\x03\u0281\x03\u0281\x03\u0281" + - "\x03\u0282\x03\u0282\x03\u0282\x03\u0282\x03\u0282\x03\u0282\x03\u0282" + - "\x03\u0282\x05\u0282\u268C\n\u0282\x03\u0283\x03\u0283\x03\u0284\x03\u0284" + - "\x03\u0284\x03\u0284\x03\u0284\x03\u0284\x03\u0284\x05\u0284\u2697\n\u0284" + - "\x03\u0285\x03\u0285\x03\u0285\x03\u0285\x03\u0286\x03\u0286\x03\u0286" + - "\x03\u0286\x03\u0286\x03\u0286\x03\u0286\x03\u0286\x03\u0286\x03\u0286" + - "\x03\u0286\x03\u0286\x03\u0286\x03\u0286\x03\u0286\x03\u0286\x03\u0286" + - "\x03\u0286\x03\u0286\x03\u0286\x03\u0286\x03\u0286\x03\u0286\x03\u0286" + - "\x03\u0286\x03\u0286\x03\u0286\x05\u0286\u26B8\n\u0286\x03\u0287\x03\u0287" + - "\x03\u0287\x03\u0287\x03\u0287\x03\u0287\x03\u0287\x05\u0287\u26C1\n\u0287" + - "\x03\u0288\x03\u0288\x03\u0288\x03\u0288\x03\u0288\x05\u0288\u26C8\n\u0288" + - "\x03\u0289\x03\u0289\x05\u0289\u26CC\n\u0289\x03\u0289\x03\u0289\x05\u0289" + - "\u26D0\n\u0289\x03\u0289\x03\u0289\x03\u028A\x06\u028A\u26D5\n\u028A\r" + - "\u028A\x0E\u028A\u26D6\x03\u028B\x03\u028B\x03\u028B\x03\u028B\x03\u028B" + - "\x03\u028C\x03\u028C\x03\u028C\x03\u028D\x03\u028D\x03\u028E\x03\u028E" + - "\x05\u028E\u26E5\n\u028E\x03\u028F\x03\u028F\x03\u028F\x05\u028F\u26EA" + - "\n\u028F\x03\u028F\x03\u028F\x03\u028F\x05\u028F\u26EF\n\u028F\x03\u028F" + - "\x03\u028F\x05\u028F\u26F3\n\u028F\x05\u028F\u26F5\n\u028F\x03\u028F\x05" + - "\u028F\u26F8\n\u028F\x03\u0290\x03\u0290\x03\u0291\x06\u0291\u26FD\n\u0291" + - "\r\u0291\x0E\u0291\u26FE\x03\u0292\x07\u0292\u2702\n\u0292\f\u0292\x0E" + - "\u0292\u2705\v\u0292\x03\u0293\x03\u0293\x03\u0294\x03\u0294\x03\u0294" + - "\x07\u0294\u270C\n\u0294\f\u0294\x0E\u0294\u270F\v\u0294\x03\u0295\x03" + - "\u0295\x03\u0295\x03\u0295\x03\u0295\x05\u0295\u2716\n\u0295\x03\u0295" + - "\x05\u0295\u2719\n\u0295\x03\u0296\x03\u0296\x03\u0296\x07\u0296\u271E" + - "\n\u0296\f\u0296\x0E\u0296\u2721\v\u0296\x03\u0297\x03\u0297\x05\u0297" + - "\u2725\n\u0297\x03\u0298\x03\u0298\x03\u0298\x07\u0298\u272A\n\u0298\f" + - "\u0298\x0E\u0298\u272D\v\u0298\x03\u0299\x03\u0299\x03\u029A\x03\u029A" + - "\x03\u029B\x03\u029B\x03\u029C\x03\u029C\x03\u029C\x03\u029C\x05\u029C" + - "\u2739\n\u029C\x03\u029D\x03\u029D\x03\u029D\x03\u029D\x03\u029D\x03\u029D" + - "\x03\u029D\x03\u029D\x03\u029D\x03\u029D\x05\u029D\u2745\n\u029D\x03\u029D" + - "\x03\u029D\x03\u029D\x05\u029D\u274A\n\u029D\x03\u029D\x03\u029D\x03\u029D" + - "\x03\u029D\x03\u029D\x03\u029D\x05\u029D\u2752\n\u029D\x03\u029D\x03\u029D" + - "\x03\u029D\x03\u029D\x03\u029D\x05\u029D\u2759\n\u029D\x03\u029D\x03\u029D" + - "\x03\u029D\x05\u029D\u275E\n\u029D\x03\u029E\x03\u029E\x03\u029F\x03\u029F" + - "\x03\u02A0\x03\u02A0\x03\u02A1\x03\u02A1\x03\u02A2\x03\u02A2\x05\u02A2" + - "\u276A\n\u02A2\x03\u02A3\x03\u02A3\x03\u02A3\x03\u02A3\x07\u02A3\u2770" + - "\n\u02A3\f\u02A3\x0E\u02A3\u2773\v\u02A3\x03\u02A3\x03\u02A3\x05\u02A3" + - "\u2777\n\u02A3\x03\u02A4\x03\u02A4\x03\u02A4\x03\u02A5\x03\u02A5\x03\u02A5" + - "\x03\u02A5\x03\u02A5\x05\u02A5\u2781\n\u02A5\x03\u02A6\x03\u02A6\x03\u02A7" + - "\x03\u02A7\x03\u02A7\x05\u02A7\u2788\n\u02A7\x03\u02A8\x03\u02A8\x03\u02A8" + - "\x07\u02A8\u278D\n\u02A8\f\u02A8\x0E\u02A8\u2790\v\u02A8\x03\u02A9\x03" + - "\u02A9\x03\u02A9\x03\u02A9\x05\u02A9\u2796\n\u02A9\x03\u02AA\x03\u02AA" + - "\x03\u02AA\x03\u02AA\x05\u02AA\u279C\n\u02AA\x03\u02AB\x03\u02AB\x03\u02AB" + - "\x03\u02AB\x05\u02AB\u27A2\n\u02AB\x03\u02AC\x03\u02AC\x03\u02AC\x03\u02AC" + - "\x03\u02AC\x03\u02AC\x05\u02AC\u27AA\n\u02AC\x03\u02AD\x03\u02AD\x05\u02AD" + - "\u27AE\n\u02AD\x03\u02AD\x03\u02AD\x03\u02AD\x03\u02AD\x03\u02AD\x05\u02AD" + - "\u27B5\n\u02AD\x03\u02AE\x03\u02AE\x03\u02AF\x03\u02AF\x03\u02B0\x03\u02B0" + - "\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0" + - "\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0" + - "\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0" + - "\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0" + - "\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0" + - "\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0" + - "\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0\x03\u02B0" + - "\x05\u02B0\u27EE\n\u02B0\x03\u02B1\x03\u02B1\x03\u02B2\x03\u02B2\x03\u02B3" + - "\x03\u02B3\x03\u02B3\x03\u02B3\x03\u02B4\x07\u02B4\u27F9\n\u02B4\f\u02B4" + - "\x0E\u02B4\u27FC\v\u02B4\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5" + - "\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5" + - "\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5\x03\u02B5" + - "\x03\u02B5\x05\u02B5\u2812\n\u02B5\x03\u02B6\x03\u02B6\x03\u02B7\x03\u02B7" + - "\x03\u02B7\x03\u02B7\x05\u02B7\u281A\n\u02B7\x03\u02B8\x03\u02B8\x05\u02B8" + - "\u281E\n\u02B8\x03\u02B9\x03\u02B9\x03\u02B9\x03\u02B9\x03\u02B9\x03\u02B9" + - "\x03\u02B9\x03\u02BA\x03\u02BA\x03\u02BA\x05\u02BA\u282A\n\u02BA\x05\u02BA" + - "\u282C\n\u02BA\x03\u02BB\x03\u02BB\x03\u02BC\x06\u02BC\u2831\n\u02BC\r" + - "\u02BC\x0E\u02BC\u2832\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BE" + - "\x03\u02BE\x03\u02BE\x05\u02BE\u283C\n\u02BE\x03\u02BF\x03\u02BF\x03\u02BF" + - "\x03\u02BF\x03\u02BF\x03\u02BF\x03\u02BF\x03\u02BF\x03\u02BF\x03\u02BF" + - "\x03\u02BF\x03\u02BF\x03\u02BF\x03\u02BF\x03\u02BF\x03\u02BF\x05\u02BF" + - "\u284E\n\u02BF\x03\u02BF\x03\u02BF\x03\u02C0\x03\u02C0\x03\u02C0\x03\u02C0" + - "\x05\u02C0\u2856\n\u02C0\x03\u02C1\x03\u02C1\x03\u02C2\x03\u02C2\x03\u02C2" + - "\x03\u02C2\x03\u02C2\x05\u02C2\u285F\n\u02C2\x03\u02C3\x03\u02C3\x03\u02C3" + - "\x07\u02C3\u2864\n\u02C3\f\u02C3\x0E\u02C3\u2867\v\u02C3\x03\u02C4\x03" + - "\u02C4\x03\u02C4\x03\u02C5\x03\u02C5\x03\u02C6\x03\u02C6\x05\u02C6\u2870" + - "\n\u02C6\x03\u02C7\x03\u02C7\x03\u02C8\x03\u02C8\x05\u02C8\u2876\n\u02C8" + - "\x03\u02C9\x03\u02C9\x03\u02CA\x03\u02CA\x03\u02CA\x05\u02CA\u287D\n\u02CA" + - "\x03\u02CB\x03\u02CB\x03\u02CB\x05\u02CB\u2882\n\u02CB\x03\u02CC\x03\u02CC" + - "\x03\u02CC\x03\u02CC\x05\u02CC\u2888\n\u02CC\x03\u02CD\x03\u02CD\x05\u02CD" + - "\u288C\n\u02CD\x03\u02CE\x03\u02CE\x03\u02CF\x07\u02CF\u2891\n\u02CF\f" + - "\u02CF\x0E\u02CF\u2894\v\u02CF\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0" + - "\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0" + - "\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0" + - "\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0\x03\u02D0" + - "\x03\u02D0\x03\u02D0\x05\u02D0\u28B1\n\u02D0\x03\u02D1\x03\u02D1\x03\u02D1" + - "\x03\u02D1\x03\u02D2\x03\u02D2\x03\u02D2\x03\u02D2\x03\u02D2\x03\u02D2" + - "\x03\u02D2\x03\u02D2\x03\u02D2\x03\u02D2\x03\u02D2\x03\u02D2\x03\u02D2" + - "\x03\u02D2\x05\u02D2\u28C5\n\u02D2\x03\u02D3\x03\u02D3\x05\u02D3\u28C9" + - "\n\u02D3\x03\u02D4\x03\u02D4\x03\u02D4\x03\u02D4\x03\u02D4\x03\u02D5\x03" + - "\u02D5\x03\u02D5\x03\u02D5\x03\u02D5\x03\u02D5\x03\u02D6\x03\u02D6\x03" + - "\u02D6\x05\u02D6\u28D9\n\u02D6\x03\u02D7\x03\u02D7\x03\u02D7\x07\u02D7" + - "\u28DE\n\u02D7\f\u02D7\x0E\u02D7\u28E1\v\u02D7\x03\u02D8\x03\u02D8\x03" + - "\u02D8\x03\u02D8\x03\u02D9\x03\u02D9\x03\u02DA\x03\u02DA\x03\u02DB\x03" + - "\u02DB\x05\u02DB\u28ED\n\u02DB\x03\u02DB\x03\u02DB\x03\u02DB\x03\u02DB" + - "\x07\u02DB\u28F3\n\u02DB\f\u02DB\x0E\u02DB\u28F6\v\u02DB\x03\u02DC\x03" + - "\u02DC\x03\u02DC\x03\u02DC\x03\u02DC\x03\u02DC\x03\u02DC\x03\u02DC\x03" + - "\u02DC\x03\u02DC\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x07" + - "\u02DD\u2907\n\u02DD\f\u02DD\x0E\u02DD\u290A\v\u02DD\x03\u02DE\x03\u02DE" + - "\x03\u02DE\x05\u02DE\u290F\n\u02DE\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02DF" + - "\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02E0\x03\u02E0\x05\u02E0" + - "\u291B\n\u02E0\x03\u02E1\x06\u02E1\u291E\n\u02E1\r\u02E1\x0E\u02E1\u291F" + - "\x03\u02E2\x03\u02E2\x03\u02E2\x03\u02E2\x03\u02E2\x03\u02E3\x03\u02E3" + - "\x03\u02E3\x05\u02E3\u292A\n\u02E3\x03\u02E4\x03\u02E4\x03\u02E4\x03\u02E5" + - "\x03\u02E5\x03\u02E5\x03\u02E5\x03\u02E5\x03\u02E6\x03\u02E6\x03\u02E6" + - "\x03\u02E6\x03\u02E6\x03\u02E7\x03\u02E7\x03\u02E7\x03\u02E7\x03\u02E7" + - "\x03\u02E7\x03\u02E7\x03\u02E7\x03\u02E7\x03\u02E7\x03\u02E7\x03\u02E7" + - "\x03\u02E7\x03\u02E7\x03\u02E7\x03\u02E7\x03\u02E7\x05\u02E7\u294A\n\u02E7" + - "\x03\u02E8\x03\u02E8\x03\u02E8\x05\u02E8\u294F\n\u02E8\x03\u02E9\x03\u02E9" + - "\x03\u02E9\x03\u02E9\x03\u02E9\x07\u02E9\u2956\n\u02E9\f\u02E9\x0E\u02E9" + - "\u2959\v\u02E9\x03\u02E9\x03\u02E9\x05\u02E9\u295D\n\u02E9\x03\u02EA\x03" + - "\u02EA\x05\u02EA\u2961\n\u02EA\x03\u02EB\x03\u02EB\x03\u02EB\x05\u02EB" + - "\u2966\n\u02EB\x03\u02EC\x03\u02EC\x03\u02ED\x03\u02ED\x03\u02ED\x03\u02ED" + - "\x03\u02ED\x03\u02ED\x03\u02ED\x03\u02ED\x03\u02ED\x03\u02EE\x03\u02EE" + - "\x03\u02EE\x05\u02EE\u2976\n\u02EE\x03\u02EF\x03\u02EF\x03\u02EF\x05\u02EF" + - "\u297B\n\u02EF\x03\u02EF\x03\u02EF\x03\u02F0\x03\u02F0\x03\u02F1\x03\u02F1" + - "\x03\u02F1\x03\u02F1\x03\u02F1\x03\u02F1\x03\u02F1\x03\u02F1\x03\u02F1" + - "\x05\u02F1\u298A\n\u02F1\x03\u02F1\x05\u02F1\u298D\n\u02F1\x03\u02F1\x03" + - "\u02F1\x03\u02F2\x03\u02F2\x05\u02F2\u2993\n\u02F2\x03\u02F3\x03\u02F3" + - "\x05\u02F3\u2997\n\u02F3\x03\u02F3\x03\u02F3\x03\u02F3\x03\u02F3\x03\u02F3" + - "\x03\u02F3\x03\u02F3\x05\u02F3\u29A0\n\u02F3\x03\u02F3\x03\u02F3\x03\u02F3" + - "\x03\u02F3\x03\u02F3\x03\u02F3\x05\u02F3\u29A8\n\u02F3\x03\u02F3\x03\u02F3" + - "\x03\u02F3\x03\u02F3\x03\u02F3\x03\u02F3\x03\u02F3\x05\u02F3\u29B1\n\u02F3" + - "\x03\u02F3\x03\u02F3\x03\u02F3\x03\u02F3\x05\u02F3\u29B7\n\u02F3\x03\u02F4" + - "\x03\u02F4\x03\u02F5\x03\u02F5\x03\u02F5\x06\u02F5\u29BE\n\u02F5\r\u02F5" + - "\x0E\u02F5\u29BF\x05\u02F5\u29C2\n\u02F5\x03\u02F6\x03\u02F6\x03\u02F6" + - "\x05\u02F6\u29C7\n\u02F6\x03\u02F7\x03\u02F7\x03\u02F7\x03\u02F7\x03\u02F8" + - "\x03\u02F8\x03\u02F8\x07\u02F8\u29D0\n\u02F8\f\u02F8\x0E\u02F8\u29D3\v" + - "\u02F8\x03\u02F9\x03\u02F9\x03\u02F9\x03\u02F9\x03\u02F9\x03\u02FA\x03" + - "\u02FA\x03\u02FA\x05\u02FA\u29DD\n\u02FA\x03\u02FB\x03\u02FB\x03\u02FB" + - "\x03\u02FB\x03\u02FB\x03\u02FB\x03\u02FB\x03\u02FC\x03\u02FC\x03\u02FC" + - "\x03\u02FD\x03\u02FD\x03\u02FD\x03\u02FD\x03\u02FD\x03\u02FD\x03\u02FD" + - "\x03\u02FD\x03\u02FD\x05\u02FD\u29F2\n\u02FD\x03\u02FD\x03\u02FD\x03\u02FE" + - "\x03\u02FE\x03\u02FE\x05\u02FE\u29F9\n\u02FE\x03\u02FF\x03\u02FF\x03\u02FF" + - "\x07\u02FF\u29FE\n\u02FF\f\u02FF\x0E\u02FF\u2A01\v\u02FF\x03\u0300\x03" + - "\u0300\x03\u0300\x05\u0300\u2A06\n\u0300\x03\u0300\x05\u0300\u2A09\n\u0300" + - "\x03\u0301\x03\u0301\x03\u0301\x03\u0301\x03\u0301\x03\u0301\x03\u0301" + - "\x03\u0301\x03\u0301\x05\u0301\u2A14\n\u0301\x03\u0301\x03\u0301\x03\u0301" + - "\x03\u0301\x03\u0301\x05\u0301\u2A1B\n\u0301\x05\u0301\u2A1D\n\u0301\x03" + - "\u0301\x03\u0301\x03\u0302\x03\u0302\x03\u0302\x03\u0302\x03\u0302\x05" + - "\u0302\u2A26\n\u0302\x03\u0303\x03\u0303\x03\u0303\x07\u0303\u2A2B\n\u0303" + - "\f\u0303\x0E\u0303\u2A2E\v\u0303\x03\u0304\x03\u0304\x03\u0304\x05\u0304" + - "\u2A33\n\u0304\x03\u0305\x03\u0305\x03\u0305\x03\u0305\x05\u0305\u2A39" + - "\n\u0305\x03\u0306\x03\u0306\x05\u0306\u2A3D\n\u0306\x03\u0307\x03\u0307" + - "\x05\u0307\u2A41\n\u0307\x03\u0307\x03\u0307\x03\u0307\x03\u0307\x03\u0307" + - "\x03\u0307\x03\u0308\x03\u0308\x03\u0309\x03\u0309\x03\u0309\x05\u0309" + - "\u2A4E\n\u0309\x03\u030A\x03\u030A\x03\u030A\x03\u030A\x03\u030A\x03\u030A" + + "\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D" + + "\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x05\u025D" + + "\u24D4\n\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D\x03\u025D" + + "\x05\u025D\u24DC\n\u025D\x03\u025E\x03\u025E\x03\u025F\x03\u025F\x03\u025F" + + "\x03\u025F\x03\u025F\x03\u025F\x05\u025F\u24E6\n\u025F\x03\u025F\x05\u025F" + + "\u24E9\n\u025F\x03\u025F\x03\u025F\x03\u025F\x05\u025F\u24EE\n\u025F\x03" + + "\u025F\x03\u025F\x03\u025F\x05\u025F\u24F3\n\u025F\x03\u025F\x03\u025F" + + "\x05\u025F\u24F7\n\u025F\x03\u025F\x03\u025F\x03\u0260\x03\u0260\x05\u0260" + + "\u24FD\n\u0260\x03\u0260\x05\u0260\u2500\n\u0260\x03\u0260\x05\u0260\u2503" + + "\n\u0260\x03\u0260\x05\u0260\u2506\n\u0260\x03\u0261\x03\u0261\x05\u0261" + + "\u250A\n\u0261\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x05\u0262" + + "\u2518\n\u0262\x03\u0262"; + private static readonly _serializedATNSegment4: string = + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x05\u0262\u251F\n\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x05\u0262\u2526\n\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x05\u0262\u252D\n\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x05\u0262\u253F\n\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x05\u0262\u2547\n\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x05\u0262\u2553\n\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x05\u0262" + + "\u2559\n\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x05\u0262\u2566\n\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x05\u0262\u258D\n\u0262\x05\u0262\u258F\n\u0262\x03" + + "\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03" + + "\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03" + + "\u0262\x03\u0262\x03\u0262\x03\u0262\x05\u0262\u25A3\n\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x05\u0262\u25AD\n\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x05\u0262\u25B8\n\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262\x03\u0262" + + "\x03\u0262\x03\u0262\x05\u0262\u25C4\n\u0262\x03\u0263\x03\u0263\x03\u0263" + + "\x03\u0263\x03\u0263\x05\u0263\u25CB\n\u0263\x03\u0264\x03\u0264\x03\u0264" + + "\x03\u0264\x03\u0264\x03\u0264\x03\u0264\x03\u0264\x03\u0264\x03\u0264" + + "\x05\u0264\u25D7\n\u0264\x03\u0265\x03\u0265\x03\u0265\x03\u0265\x03\u0265" + + "\x03\u0266\x03\u0266\x03\u0266\x07\u0266\u25E1\n\u0266\f\u0266\x0E\u0266" + + "\u25E4\v\u0266\x03\u0267\x03\u0267\x03\u0267\x05\u0267\u25E9\n\u0267\x03" + + "\u0268\x03\u0268\x03\u0269\x03\u0269\x03\u0269\x03\u0269\x05\u0269\u25F1" + + "\n\u0269\x03\u026A\x03\u026A\x03\u026A\x03\u026A\x03\u026A\x03\u026A\x03" + + "\u026A\x03\u026A\x03\u026A\x03\u026A\x03\u026A\x03\u026A\x03\u026A\x03" + + "\u026A\x03\u026A\x05\u026A\u2602\n\u026A\x03\u026B\x03\u026B\x03\u026B" + + "\x03\u026C\x03\u026C\x03\u026C\x03\u026C\x03\u026C\x03\u026C\x03\u026D" + + "\x03\u026D\x03\u026D\x03\u026D\x03\u026D\x03\u026D\x03\u026E\x03\u026E" + + "\x03\u026E\x03\u026F\x03\u026F\x03\u026F\x07\u026F\u2619\n\u026F\f\u026F" + + "\x0E\u026F\u261C\v\u026F\x03\u0270\x03\u0270\x03\u0270\x03\u0270\x03\u0271" + + "\x03\u0271\x03\u0271\x05\u0271\u2625\n\u0271\x03\u0272\x03\u0272\x05\u0272" + + "\u2629\n\u0272\x03\u0272\x05\u0272\u262C\n\u0272\x03\u0272\x05\u0272\u262F" + + "\n\u0272\x03\u0272\x05\u0272\u2632\n\u0272\x03\u0272\x03\u0272\x03\u0273" + + "\x03\u0273\x03\u0274\x03\u0274\x03\u0274\x03\u0274\x03\u0275\x03\u0275" + + "\x03\u0275\x05\u0275\u263F\n\u0275\x03\u0275\x03\u0275\x03\u0275\x05\u0275" + + "\u2644\n\u0275\x03\u0275\x03\u0275\x03\u0275\x05\u0275\u2649\n\u0275\x05" + + "\u0275\u264B\n\u0275\x03\u0276\x03\u0276\x03\u0276\x03\u0276\x03\u0276" + + "\x03\u0276\x05\u0276\u2653\n\u0276\x03\u0277\x03\u0277\x03\u0277\x03\u0277" + + "\x03\u0277\x03\u0277\x03\u0277\x05\u0277\u265C\n\u0277\x03\u0278\x03\u0278" + + "\x03\u0278\x03\u0278\x03\u0278\x03\u0278\x03\u0278\x05\u0278\u2665\n\u0278" + + "\x03\u0279\x03\u0279\x03\u0279\x05\u0279\u266A\n\u0279\x03\u0279\x03\u0279" + + "\x03\u0279\x03\u0279\x03\u0279\x03\u0279\x03\u0279\x05\u0279\u2673\n\u0279" + + "\x03\u027A\x03\u027A\x03\u027A\x05\u027A\u2678\n\u027A\x03\u027A\x03\u027A" + + "\x03\u027B\x03\u027B\x03\u027B\x03\u027B\x03\u027B\x03\u027B\x03\u027C" + + "\x03\u027C\x03\u027D\x03\u027D\x05\u027D\u2686\n\u027D\x03\u027E\x03\u027E" + + "\x03\u027F\x03\u027F\x03\u027F\x03\u027F\x03\u027F\x03\u027F\x05\u027F" + + "\u2690\n\u027F\x03\u0280\x03\u0280\x03\u0280\x03\u0280\x03\u0280\x03\u0280" + + "\x05\u0280\u2698\n\u0280\x03\u0281\x03\u0281\x03\u0281\x03\u0281\x03\u0281" + + "\x03\u0281\x03\u0281\x03\u0281\x03\u0281\x03\u0281\x03\u0281\x03\u0281" + + "\x05\u0281\u26A6\n\u0281\x03\u0282\x03\u0282\x03\u0282\x07\u0282\u26AB" + + "\n\u0282\f\u0282\x0E\u0282\u26AE\v\u0282\x03\u0283\x03\u0283\x03\u0283" + + "\x07\u0283\u26B3\n\u0283\f\u0283\x0E\u0283\u26B6\v\u0283\x03\u0284\x03" + + "\u0284\x03\u0284\x03\u0284\x03\u0284\x05\u0284\u26BD\n\u0284\x03\u0285" + + "\x03\u0285\x03\u0285\x07\u0285\u26C2\n\u0285\f\u0285\x0E\u0285\u26C5\v" + + "\u0285\x03\u0286\x03\u0286\x03\u0286\x05\u0286\u26CA\n\u0286\x03\u0286" + + "\x03\u0286\x03\u0287\x03\u0287\x03\u0287\x07\u0287\u26D1\n\u0287\f\u0287" + + "\x0E\u0287\u26D4\v\u0287\x03\u0288\x03\u0288\x03\u0288\x03\u0288\x03\u0289" + + "\x03\u0289\x03\u0289\x03\u0289\x03\u0289\x03\u0289\x03\u0289\x03\u0289" + + "\x05\u0289\u26E2\n\u0289\x03\u028A\x03\u028A\x03\u028B\x03\u028B\x03\u028B" + + "\x03\u028B\x03\u028B\x03\u028B\x03\u028B\x05\u028B\u26ED\n\u028B\x03\u028C" + + "\x03\u028C\x03\u028C\x03\u028C\x03\u028D\x03\u028D\x03\u028D\x03\u028D" + + "\x03\u028D\x03\u028D\x03\u028D\x03\u028D\x03\u028D\x03\u028D\x03\u028D" + + "\x03\u028D\x03\u028D\x03\u028D\x03\u028D\x03\u028D\x03\u028D\x03\u028D" + + "\x03\u028D\x03\u028D\x03\u028D\x03\u028D\x03\u028D\x03\u028D\x03\u028D" + + "\x03\u028D\x03\u028D\x05\u028D\u270E\n\u028D\x03\u028E\x03\u028E\x03\u028E" + + "\x03\u028E\x03\u028E\x03\u028E\x03\u028E\x05\u028E\u2717\n\u028E\x03\u028F" + + "\x03\u028F\x03\u028F\x03\u028F\x03\u028F\x05\u028F\u271E\n\u028F\x03\u0290" + + "\x03\u0290\x05\u0290\u2722\n\u0290\x03\u0290\x03\u0290\x05\u0290\u2726" + + "\n\u0290\x03\u0290\x03\u0290\x03\u0291\x06\u0291\u272B\n\u0291\r\u0291" + + "\x0E\u0291\u272C\x03\u0292\x03\u0292\x03\u0292\x03\u0292\x03\u0292\x03" + + "\u0293\x03\u0293\x03\u0293\x03\u0294\x03\u0294\x03\u0295\x03\u0295\x05" + + "\u0295\u273B\n\u0295\x03\u0296\x03\u0296\x03\u0296\x05\u0296\u2740\n\u0296" + + "\x03\u0296\x03\u0296\x03\u0296\x05\u0296\u2745\n\u0296\x03\u0296\x03\u0296" + + "\x05\u0296\u2749\n\u0296\x05\u0296\u274B\n\u0296\x03\u0296\x05\u0296\u274E" + + "\n\u0296\x03\u0297\x03\u0297\x03\u0298\x06\u0298\u2753\n\u0298\r\u0298" + + "\x0E\u0298\u2754\x03\u0299\x07\u0299\u2758\n\u0299\f\u0299\x0E\u0299\u275B" + + "\v\u0299\x03\u029A\x03\u029A\x03\u029B\x03\u029B\x03\u029B\x07\u029B\u2762" + + "\n\u029B\f\u029B\x0E\u029B\u2765\v\u029B\x03\u029C\x03\u029C\x03\u029C" + + "\x03\u029C\x03\u029C\x05\u029C\u276C\n\u029C\x03\u029C\x05\u029C\u276F" + + "\n\u029C\x03\u029D\x03\u029D\x03\u029D\x07\u029D\u2774\n\u029D\f\u029D" + + "\x0E\u029D\u2777\v\u029D\x03\u029E\x03\u029E\x05\u029E\u277B\n\u029E\x03" + + "\u029F\x03\u029F\x05\u029F\u277F\n\u029F\x03\u02A0\x03\u02A0\x03\u02A0" + + "\x07\u02A0\u2784\n\u02A0\f\u02A0\x0E\u02A0\u2787\v\u02A0\x03\u02A1\x03" + + "\u02A1\x03\u02A2\x03\u02A2\x03\u02A3\x03\u02A3\x03\u02A4\x03\u02A4\x03" + + "\u02A4\x03\u02A4\x05\u02A4\u2793\n\u02A4\x03\u02A5\x03\u02A5\x03\u02A5" + + "\x03\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x03\u02A5" + + "\x05\u02A5\u279F\n\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x05\u02A5\u27A4" + + "\n\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x05" + + "\u02A5\u27AC\n\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x03\u02A5" + + "\x05\u02A5\u27B3\n\u02A5\x03\u02A5\x03\u02A5\x03\u02A5\x05\u02A5\u27B8" + + "\n\u02A5\x03\u02A6\x03\u02A6\x03\u02A7\x03\u02A7\x03\u02A8\x03\u02A8\x03" + + "\u02A9\x03\u02A9\x03\u02AA\x03\u02AA\x05\u02AA\u27C4\n\u02AA\x03\u02AB" + + "\x03\u02AB\x03\u02AB\x03\u02AB\x07\u02AB\u27CA\n\u02AB\f\u02AB\x0E\u02AB" + + "\u27CD\v\u02AB\x03\u02AB\x03\u02AB\x05\u02AB\u27D1\n\u02AB\x03\u02AC\x03" + + "\u02AC\x03\u02AC\x03\u02AD\x03\u02AD\x03\u02AD\x03\u02AD\x03\u02AD\x05" + + "\u02AD\u27DB\n\u02AD\x03\u02AE\x03\u02AE\x03\u02AF\x03\u02AF\x03\u02B0" + + "\x03\u02B0\x03\u02B0\x03\u02B0\x05\u02B0\u27E5\n\u02B0\x03\u02B1\x03\u02B1" + + "\x03\u02B1\x07\u02B1\u27EA\n\u02B1\f\u02B1\x0E\u02B1\u27ED\v\u02B1\x03" + + "\u02B2\x03\u02B2\x03\u02B2\x03\u02B2\x05\u02B2\u27F3\n\u02B2\x03\u02B3" + + "\x03\u02B3\x03\u02B4\x03\u02B4\x03\u02B4\x03\u02B4\x03\u02B4\x03\u02B4" + + "\x03\u02B4\x05\u02B4\u27FE\n\u02B4\x03\u02B4\x05\u02B4\u2801\n\u02B4\x05" + + "\u02B4\u2803\n\u02B4\x03\u02B5\x03\u02B5\x05\u02B5\u2807\n\u02B5\x03\u02B5" + + "\x05\u02B5\u280A\n\u02B5\x03\u02B6\x03\u02B6\x03\u02B6\x03\u02B7\x03\u02B7" + + "\x03\u02B7\x03\u02B7\x05\u02B7\u2813\n\u02B7\x03\u02B8\x03\u02B8\x03\u02B8" + + "\x03\u02B8\x05\u02B8\u2819\n\u02B8\x03\u02B9\x03\u02B9\x03\u02B9\x03\u02B9" + + "\x03\u02B9\x03\u02B9\x05\u02B9\u2821\n\u02B9\x03\u02BA\x03\u02BA\x05\u02BA" + + "\u2825\n\u02BA\x03\u02BA\x03\u02BA\x03\u02BA\x03\u02BA\x03\u02BA\x05\u02BA" + + "\u282C\n\u02BA\x03\u02BB\x03\u02BB\x03\u02BC\x03\u02BC\x03\u02BD\x03\u02BD" + + "\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD" + + "\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD" + + "\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD" + + "\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD" + + "\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD" + + "\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD" + + "\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD\x03\u02BD" + + "\x05\u02BD\u2865\n\u02BD\x03\u02BE\x03\u02BE\x03\u02BF\x03\u02BF\x03\u02C0" + + "\x03\u02C0\x03\u02C0\x03\u02C0\x03\u02C1\x07\u02C1\u2870\n\u02C1\f\u02C1" + + "\x0E\u02C1\u2873\v\u02C1\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2" + + "\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2" + + "\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2\x03\u02C2" + + "\x03\u02C2\x05\u02C2\u2889\n\u02C2\x03\u02C3\x03\u02C3\x03\u02C4\x03\u02C4" + + "\x03\u02C4\x03\u02C4\x05\u02C4\u2891\n\u02C4\x03\u02C5\x03\u02C5\x05\u02C5" + + "\u2895\n\u02C5\x03\u02C6\x03\u02C6\x03\u02C6\x03\u02C6\x03\u02C6\x03\u02C6" + + "\x03\u02C6\x03\u02C7\x03\u02C7\x03\u02C7\x05\u02C7\u28A1\n\u02C7\x05\u02C7" + + "\u28A3\n\u02C7\x03\u02C8\x03\u02C8\x03\u02C9\x06\u02C9\u28A8\n\u02C9\r" + + "\u02C9\x0E\u02C9\u28A9\x03\u02CA\x03\u02CA\x03\u02CA\x03\u02CA\x03\u02CB" + + "\x03\u02CB\x03\u02CB\x05\u02CB\u28B3\n\u02CB\x03\u02CC\x03\u02CC\x03\u02CC" + + "\x03\u02CC\x03\u02CC\x03\u02CC\x03\u02CC\x03\u02CC\x03\u02CC\x03\u02CC" + + "\x03\u02CC\x03\u02CC\x03\u02CC\x03\u02CC\x03\u02CC\x03\u02CC\x05\u02CC" + + "\u28C5\n\u02CC\x03\u02CC\x03\u02CC\x03\u02CD\x03\u02CD\x03\u02CD\x03\u02CD" + + "\x05\u02CD\u28CD\n\u02CD\x03\u02CE\x03\u02CE\x03\u02CF\x03\u02CF\x03\u02CF" + + "\x03\u02CF\x03\u02CF\x05\u02CF\u28D6\n\u02CF\x03\u02D0\x03\u02D0\x03\u02D0" + + "\x07\u02D0\u28DB\n\u02D0\f\u02D0\x0E\u02D0\u28DE\v\u02D0\x03\u02D1\x03" + + "\u02D1\x03\u02D1\x03\u02D2\x03\u02D2\x03\u02D3\x03\u02D3\x05\u02D3\u28E7" + + "\n\u02D3\x03\u02D4\x03\u02D4\x03\u02D5\x03\u02D5\x05\u02D5\u28ED\n\u02D5" + + "\x03\u02D6\x03\u02D6\x03\u02D7\x03\u02D7\x03\u02D7\x05\u02D7\u28F4\n\u02D7" + + "\x03\u02D8\x03\u02D8\x03\u02D8\x05\u02D8\u28F9\n\u02D8\x03\u02D9\x03\u02D9" + + "\x03\u02D9\x03\u02D9\x05\u02D9\u28FF\n\u02D9\x03\u02DA\x03\u02DA\x05\u02DA" + + "\u2903\n\u02DA\x03\u02DB\x03\u02DB\x03\u02DC\x07\u02DC\u2908\n\u02DC\f" + + "\u02DC\x0E\u02DC\u290B\v\u02DC\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD" + + "\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD" + + "\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD" + + "\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD\x03\u02DD" + + "\x03\u02DD\x03\u02DD\x05\u02DD\u2928\n\u02DD\x03\u02DE\x03\u02DE\x03\u02DE" + + "\x03\u02DE\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02DF" + + "\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02DF\x03\u02DF" + + "\x03\u02DF\x05\u02DF\u293C\n\u02DF\x03\u02E0\x03\u02E0\x05\u02E0\u2940" + + "\n\u02E0\x03\u02E1\x03\u02E1\x03\u02E1\x03\u02E1\x03\u02E1\x03\u02E2\x03" + + "\u02E2\x03\u02E2\x03\u02E2\x03\u02E2\x03\u02E2\x03\u02E3\x03\u02E3\x03" + + "\u02E3\x05\u02E3\u2950\n\u02E3\x03\u02E4\x03\u02E4\x03\u02E4\x07\u02E4" + + "\u2955\n\u02E4\f\u02E4\x0E\u02E4\u2958\v\u02E4\x03\u02E5\x03\u02E5\x03" + + "\u02E5\x03\u02E5\x03\u02E6\x03\u02E6\x03\u02E7\x03\u02E7\x03\u02E8\x03" + + "\u02E8\x05\u02E8\u2964\n\u02E8\x03\u02E8\x03\u02E8\x03\u02E8\x03\u02E8" + + "\x07\u02E8\u296A\n\u02E8\f\u02E8\x0E\u02E8\u296D\v\u02E8\x03\u02E9\x03" + + "\u02E9\x03\u02E9\x03\u02E9\x03\u02E9\x03\u02E9\x03\u02E9\x03\u02E9\x03" + + "\u02E9\x03\u02E9\x03\u02EA\x03\u02EA\x03\u02EA\x03\u02EA\x03\u02EA\x07" + + "\u02EA\u297E\n\u02EA\f\u02EA\x0E\u02EA\u2981\v\u02EA\x03\u02EB\x03\u02EB" + + "\x03\u02EB\x05\u02EB\u2986\n\u02EB\x03\u02EC\x03\u02EC\x03\u02EC\x03\u02EC" + + "\x03\u02EC\x03\u02EC\x03\u02EC\x03\u02EC\x03\u02ED\x03\u02ED\x05\u02ED" + + "\u2992\n\u02ED\x03\u02EE\x06\u02EE\u2995\n\u02EE\r\u02EE\x0E\u02EE\u2996" + + "\x03\u02EF\x03\u02EF\x03\u02EF\x03\u02EF\x03\u02EF\x03\u02F0\x03\u02F0" + + "\x03\u02F0\x05\u02F0\u29A1\n\u02F0\x03\u02F1\x03\u02F1\x03\u02F1\x03\u02F2" + + "\x03\u02F2\x03\u02F2\x03\u02F2\x03\u02F2\x03\u02F3\x03\u02F3\x03\u02F3" + + "\x03\u02F3\x03\u02F3\x03\u02F4\x03\u02F4\x03\u02F4\x03\u02F4\x03\u02F4" + + "\x03\u02F4\x03\u02F4\x03\u02F4\x03\u02F4\x03\u02F4\x03\u02F4\x03\u02F4" + + "\x03\u02F4\x03\u02F4\x03\u02F4\x03\u02F4\x03\u02F4\x05\u02F4\u29C1\n\u02F4" + + "\x03\u02F5\x03\u02F5\x03\u02F5\x05\u02F5\u29C6\n\u02F5\x03\u02F6\x03\u02F6" + + "\x03\u02F6\x03\u02F6\x03\u02F6\x07\u02F6\u29CD\n\u02F6\f\u02F6\x0E\u02F6" + + "\u29D0\v\u02F6\x03\u02F6\x03\u02F6\x05\u02F6\u29D4\n\u02F6\x03\u02F7\x03" + + "\u02F7\x05\u02F7\u29D8\n\u02F7\x03\u02F8\x03\u02F8\x03\u02F8\x05\u02F8" + + "\u29DD\n\u02F8\x03\u02F9\x03\u02F9\x03\u02FA\x03\u02FA\x03\u02FA\x03\u02FA" + + "\x03\u02FA\x03\u02FA\x03\u02FA\x03\u02FA\x03\u02FA\x03\u02FB\x03\u02FB" + + "\x03\u02FB\x05\u02FB\u29ED\n\u02FB\x03\u02FC\x03\u02FC\x03\u02FC\x05\u02FC" + + "\u29F2\n\u02FC\x03\u02FC\x03\u02FC\x03\u02FD\x03\u02FD\x03\u02FE\x03\u02FE" + + "\x03\u02FE\x03\u02FE\x03\u02FE\x03\u02FE\x03\u02FE\x03\u02FE\x03\u02FE" + + "\x05\u02FE\u2A01\n\u02FE\x03\u02FE\x05\u02FE\u2A04\n\u02FE\x03\u02FE\x03" + + "\u02FE\x03\u02FF\x03\u02FF\x05\u02FF\u2A0A\n\u02FF\x03\u0300\x03\u0300" + + "\x05\u0300\u2A0E\n\u0300\x03\u0300\x03\u0300\x03\u0300\x03\u0300\x03\u0300" + + "\x03\u0300\x03\u0300\x05\u0300\u2A17\n\u0300\x03\u0300\x03\u0300\x03\u0300" + + "\x03\u0300\x03\u0300\x03\u0300\x05\u0300\u2A1F\n\u0300\x03\u0300\x03\u0300" + + "\x03\u0300\x03\u0300\x03\u0300\x03\u0300\x03\u0300\x05\u0300\u2A28\n\u0300" + + "\x03\u0300\x03\u0300\x03\u0300\x03\u0300\x05\u0300\u2A2E\n\u0300\x03\u0301" + + "\x03\u0301\x03\u0302\x03\u0302\x03\u0302\x06\u0302\u2A35\n\u0302\r\u0302" + + "\x0E\u0302\u2A36\x05\u0302\u2A39\n\u0302\x03\u0303\x03\u0303\x03\u0303" + + "\x05\u0303\u2A3E\n\u0303\x03\u0304\x03\u0304\x03\u0304\x03\u0304\x03\u0305" + + "\x03\u0305\x03\u0305\x07\u0305\u2A47\n\u0305\f\u0305\x0E\u0305\u2A4A\v" + + "\u0305\x03\u0306\x03\u0306\x03\u0306\x03\u0306\x03\u0306\x03\u0307\x03" + + "\u0307\x03\u0307\x05\u0307\u2A54\n\u0307\x03\u0308\x03\u0308\x03\u0308" + + "\x03\u0308\x03\u0308\x03\u0308\x03\u0308\x03\u0309\x03\u0309\x03\u0309" + "\x03\u030A\x03\u030A\x03\u030A\x03\u030A\x03\u030A\x03\u030A\x03\u030A" + - "\x05\u030A\u2A5D\n\u030A\x05\u030A\u2A5F\n\u030A\x03\u030B\x03\u030B\x05" + - "\u030B\u2A63\n\u030B\x03\u030B\x03\u030B\x03\u030B\x03\u030C\x03\u030C" + - "\x03\u030C\x03\u030C\x03\u030D\x03\u030D\x03\u030D\x03\u030E\x03\u030E" + - "\x05\u030E\u2A71\n\u030E\x03\u030E\x03\u030E\x03\u030F\x03\u030F\x05\u030F" + - "\u2A77\n\u030F\x03\u030F\x03\u030F\x03\u0310\x03\u0310\x05\u0310\u2A7D" + - "\n\u0310\x03\u0310\x03\u0310\x03\u0311\x03\u0311\x03\u0311\x03\u0311\x03" + - "\u0311\x03\u0311\x03\u0311\x03\u0311\x03\u0311\x05\u0311\u2A8A\n\u0311" + - "\x03\u0311\x05\u0311\u2A8D\n\u0311\x03\u0312\x03\u0312\x05\u0312\u2A91" + - "\n\u0312\x03\u0313\x03\u0313\x03\u0313\x05\u0313\u2A96\n\u0313\x03\u0314" + - "\x06\u0314\u2A99\n\u0314\r\u0314\x0E\u0314\u2A9A\x03\u0315\x03\u0315\x03" + - "\u0315\x03\u0315\x03\u0315\x03\u0316\x03\u0316\x03\u0316\x07\u0316\u2AA5" + - "\n\u0316\f\u0316\x0E\u0316\u2AA8\v\u0316\x03\u0317\x03\u0317\x03\u0317" + - "\x05\u0317\u2AAD\n\u0317\x03\u0318\x03\u0318\x05\u0318\u2AB1\n\u0318\x03" + - "\u0319\x03\u0319\x05\u0319\u2AB5\n\u0319\x03\u031A\x03\u031A\x05\u031A" + - "\u2AB9\n\u031A\x03\u031B\x03\u031B\x03\u031B\x03\u031C\x03\u031C\x05\u031C" + - "\u2AC0\n\u031C\x03\u031D\x03\u031D\x03\u031E\x05\u031E\u2AC5\n\u031E\x03" + - "\u031E\x05\u031E\u2AC8\n\u031E\x03\u031E\x05\u031E\u2ACB\n\u031E\x03\u031E" + - "\x05\u031E\u2ACE\n\u031E\x03\u031E\x05\u031E\u2AD1\n\u031E\x03\u031E\x05" + - "\u031E\u2AD4\n\u031E\x03\u031E\x05\u031E\u2AD7\n\u031E\x03\u031F\x03\u031F" + - "\x03\u0320\x03\u0320\x03\u0321\x03\u0321\x03\u0322\x03\u0322\x03\u0323" + - "\x03\u0323\x05\u0323\u2AE3\n\u0323\x03\u0324\x03\u0324\x03\u0324\x03\u0324" + - "\x03\u0324\x02\x02\x03\u04A8\u0325\x02\x02\x04\x02\x06\x02\b\x02\n\x02" + + "\x03\u030A\x03\u030A\x05\u030A\u2A69\n\u030A\x03\u030A\x03\u030A\x03\u030B" + + "\x03\u030B\x03\u030B\x05\u030B\u2A70\n\u030B\x03\u030C\x03\u030C\x03\u030C" + + "\x07\u030C\u2A75\n\u030C\f\u030C\x0E\u030C\u2A78\v\u030C\x03\u030D\x03" + + "\u030D\x03\u030D\x05\u030D\u2A7D\n\u030D\x03\u030D\x05\u030D\u2A80\n\u030D" + + "\x03\u030E\x03\u030E\x03\u030E\x03\u030E\x03\u030E\x03\u030E\x03\u030E" + + "\x03\u030E\x03\u030E\x05\u030E\u2A8B\n\u030E\x03\u030E\x03\u030E\x03\u030E" + + "\x03\u030E\x03\u030E\x05\u030E\u2A92\n\u030E\x05\u030E\u2A94\n\u030E\x03" + + "\u030E\x03\u030E\x03\u030F\x03\u030F\x03\u030F\x03\u030F\x03\u030F\x05" + + "\u030F\u2A9D\n\u030F\x03\u0310\x03\u0310\x03\u0310\x07\u0310\u2AA2\n\u0310" + + "\f\u0310\x0E\u0310\u2AA5\v\u0310\x03\u0311\x03\u0311\x03\u0311\x05\u0311" + + "\u2AAA\n\u0311\x03\u0312\x03\u0312\x03\u0312\x03\u0312\x05\u0312\u2AB0" + + "\n\u0312\x03\u0313\x03\u0313\x05\u0313\u2AB4\n\u0313\x03\u0314\x03\u0314" + + "\x05\u0314\u2AB8\n\u0314\x03\u0314\x03\u0314\x03\u0314\x03\u0314\x03\u0314" + + "\x03\u0314\x03\u0315\x03\u0315\x03\u0316\x03\u0316\x03\u0316\x05\u0316" + + "\u2AC5\n\u0316\x03\u0317\x03\u0317\x03\u0317\x03\u0317\x03\u0317\x03\u0317" + + "\x03\u0317\x03\u0317\x03\u0317\x03\u0317\x03\u0317\x03\u0317\x03\u0317" + + "\x05\u0317\u2AD4\n\u0317\x05\u0317\u2AD6\n\u0317\x03\u0318\x03\u0318\x05" + + "\u0318\u2ADA\n\u0318\x03\u0318\x03\u0318\x03\u0318\x03\u0319\x03\u0319" + + "\x03\u0319\x03\u0319\x03\u031A\x03\u031A\x03\u031A\x03\u031B\x03\u031B" + + "\x05\u031B\u2AE8\n\u031B\x03\u031B\x03\u031B\x03\u031C\x03\u031C\x05\u031C" + + "\u2AEE\n\u031C\x03\u031C\x03\u031C\x03\u031D\x03\u031D\x05\u031D\u2AF4" + + "\n\u031D\x03\u031D\x03\u031D\x03\u031E\x03\u031E\x03\u031E\x03\u031E\x03" + + "\u031E\x03\u031E\x03\u031E\x03\u031E\x03\u031E\x05\u031E\u2B01\n\u031E" + + "\x03\u031E\x05\u031E\u2B04\n\u031E\x03\u031F\x03\u031F\x05\u031F\u2B08" + + "\n\u031F\x03\u0320\x03\u0320\x03\u0320\x05\u0320\u2B0D\n\u0320\x03\u0321" + + "\x06\u0321\u2B10\n\u0321\r\u0321\x0E\u0321\u2B11\x03\u0322\x03\u0322\x03" + + "\u0322\x03\u0322\x03\u0322\x03\u0323\x03\u0323\x03\u0323\x07\u0323\u2B1C" + + "\n\u0323\f\u0323\x0E\u0323\u2B1F\v\u0323\x03\u0324\x03\u0324\x03\u0324" + + "\x05\u0324\u2B24\n\u0324\x03\u0325\x03\u0325\x05\u0325\u2B28\n\u0325\x03" + + "\u0326\x03\u0326\x05\u0326\u2B2C\n\u0326\x03\u0327\x03\u0327\x05\u0327" + + "\u2B30\n\u0327\x03\u0328\x03\u0328\x03\u0328\x03\u0329\x03\u0329\x05\u0329" + + "\u2B37\n\u0329\x03\u032A\x03\u032A\x03\u032B\x05\u032B\u2B3C\n\u032B\x03" + + "\u032B\x05\u032B\u2B3F\n\u032B\x03\u032B\x05\u032B\u2B42\n\u032B\x03\u032B" + + "\x05\u032B\u2B45\n\u032B\x03\u032B\x05\u032B\u2B48\n\u032B\x03\u032B\x05" + + "\u032B\u2B4B\n\u032B\x03\u032B\x05\u032B\u2B4E\n\u032B\x03\u032C\x03\u032C" + + "\x03\u032D\x03\u032D\x03\u032E\x03\u032E\x03\u032F\x03\u032F\x03\u0330" + + "\x03\u0330\x05\u0330\u2B5A\n\u0330\x03\u0331\x03\u0331\x03\u0331\x03\u0331" + + "\x03\u0331\x02\x02\x03\u04B6\u0332\x02\x02\x04\x02\x06\x02\b\x02\n\x02" + "\f\x02\x0E\x02\x10\x02\x12\x02\x14\x02\x16\x02\x18\x02\x1A\x02\x1C\x02" + "\x1E\x02 \x02\"\x02$\x02&\x02(\x02*\x02,\x02.\x020\x022\x024\x026\x02" + "8\x02:\x02<\x02>\x02@\x02B\x02D\x02F\x02H\x02J\x02L\x02N\x02P\x02R\x02" + @@ -67299,5004 +67588,5072 @@ export class PostgreSQLParser extends PostgreSQLParserBase { "\x02\u05F2\x02\u05F4\x02\u05F6\x02\u05F8\x02\u05FA\x02\u05FC\x02\u05FE" + "\x02\u0600\x02\u0602\x02\u0604\x02\u0606\x02\u0608\x02\u060A\x02\u060C" + "\x02\u060E\x02\u0610\x02\u0612\x02\u0614\x02\u0616\x02\u0618\x02\u061A" + - "\x02\u061C\x02\u061E\x02\u0620\x02\u0622\x02\u0624\x02\u0626\x02\u0628" + - "\x02\u062A\x02\u062C\x02\u062E\x02\u0630\x02\u0632\x02\u0634\x02\u0636" + - "\x02\u0638\x02\u063A\x02\u063C\x02\u063E\x02\u0640\x02\u0642\x02\u0644" + - "\x02\u0646\x02\x02H\x04\x02\xC5\xC5\u0165\u0165\x04\x02DD\u0137\u0137" + - "\x04\x02ee\u0137\u0137\x05\x02DDee\u0137\u0137\x04\x02\x87\x87\xC1\xC1" + - "\x04\x02\xF7\xF7\u0145\u0145\x04\x02\f\f``\x04\x02\xA4\xA4\u0164\u0164" + - "\x04\x02\xB6\xB6\xDF\xDF\x07\x02 \u0119\u0119\u0142\u0142\u0159\u0159" + - "\u015B\u015B\x04\x02\x98\x98\u0134\u0134\x04\x02BB``\x04\x02\u0159\u0159" + - "\u015B\u015B\x04\x02\xCA\xCA\xE2\xE2\v\x02 \xA2\xA2\xA7\xA7\xB5\xB5\xDD" + - "\xDD\xE5\xE5\u014F\u014F\u0152\u0152\u01AF\u01AF\x05\x02ss\u0115\u0115" + - "\u0149\u0149\x04\x0277PP\x05\x02\xAF\xAF\xFD\xFD\xFF\xFF\x07\x02 ZZ\xB8" + - "\xB8\xEA\xEA\u016A\u016A\x04\x02^^\xE4\xE4\x03\x02\u01B9\u01BA\x04\x02" + - "^^\u0197\u0197\x04\x02\u014E\u014E\u0197\u0197\x04\x02\xD5\xD5\u0121\u0121" + - "\x05\x02\u013A\u013A\u015E\u015E\u01B6\u01B6\x04\x02BBFF\x07\x02\xD6\xD6" + - "\u0142\u0142\u0157\u0157\u0162\u0162\u01C0\u01C1\x04\x02\'\'99\x04\x02" + - "\f\f77\x05\x02\xD5\xD5\u0121\u0121\u01B3\u01B3\x05"; + "\x02\u061C\x02\u061E\x02\u0620\x02\u0622"; private static readonly _serializedATNSegment5: string = - "\x02\xB1\xB1\u013C\u013C\u0156\u0156\x06\x02ZZ\xB8\xB8\xEA\xEA\u016A\u016A" + - "\x04\x02\x8B\x8B\xEB\xEB\x04\x02\u015D\u015D\u0175\u0175\x04\x02\x99\x99" + - "\xF7\xF7\x04\x02\u0132\u0132\u0146\u0146\x03\x02!\"\x04\x02ee\u0156\u0156" + - "\x04\x02\xCB\xCB\u0147\u0147\x04\x02\xD7\xD7\xF7\xF7\x04\x02 ::\x04\x02" + - "\u0139\u0139\u0197\u0197\x04\x02\xD1\xD1\u0105\u0105\x06\x02ssuuyy\x80" + - "\x80\x04\x02\u0161\u0161\u01D6\u01D6\x04\x02\u0180\u0181\u018F\u018F\x03" + - "\x02\u0180\u0181\x03\x02\u019B\u019C\x03\x02\x14\x15\x04\x02ww||\x07\x02" + - "\f\f\x12\x13\x17\x17\x19\x19\x1B\x1B\x03\x02\x0E\x0F\x05\x02\v\v\x10\x10" + - "\x1D\x1D\x05\x02))KKaa\x04\x02\xA8\xA8\xBE\xBE\x04\x02\u0129\u0129\u01BB" + - "\u01BB\x04\x02\xD2\xD2\u011A\u011A\x05\x02 $$\\\\\b\x02\v\f\x0E\x13\x17" + - "\x17\x19\x19\x1B\x1B\x1D\x1D\x04\x02\x16\x16\x18\x18\x03\x02\u01DC\u01DF" + - "\n\x02~~\x83\u017B\u01AA\u01BD\u01C0\u01CE\u01D0\u01D0\u01D2\u01D2\u01D4" + - "\u01D4\u01D7\u01E1\x05\x02l}\x7F\x82\u01D1\u01D1\x06\x02 68HJk\u01BF\u01BF" + - "\x04\x02@@vv\x04\x02\f\f\x16\x16\x04\x02\xA9\xA9\u01F4\u01F4\x03\x02\u01F9" + - "\u01FE\x04\x02\x92\x92\xD4\xD4&\x02##%%-/77;;??^^vv}}\x84\x84\x92\x92" + - "\x9B\x9B\x9F\x9F\xA3\xA3\xA9\xA9\xAE\xAE\xD1\xD1\xD4\xD4\xEA\xEA\xF2\xF2" + - "\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\x02\u2F64\x02\u0648\x03" + - "\x02\x02\x02\x04\u064A\x03\x02\x02\x02\x06\u0652\x03\x02\x02\x02\b\u06D1" + - "\x03\x02\x02\x02\n\u06D3\x03\x02\x02\x02\f\u06D7\x03\x02\x02\x02\x0E\u06DA" + - "\x03\x02\x02\x02\x10\u06E2\x03\x02\x02\x02\x12\u06E7\x03\x02\x02\x02\x14" + - "\u06ED\x03\x02\x02\x02\x16\u0702\x03\x02\x02\x02\x18\u070E\x03\x02\x02" + - "\x02\x1A\u0710\x03\x02\x02\x02\x1C\u0718\x03\x02\x02\x02\x1E\u0724\x03" + - "\x02\x02\x02 \u0726\x03\x02\x02\x02\"\u072F\x03\x02\x02\x02$\u0737\x03" + - "\x02\x02\x02&\u073F\x03\x02\x02\x02(\u0746\x03\x02\x02\x02*\u0748\x03" + - "\x02\x02\x02,\u0759\x03\x02\x02\x02.\u075E\x03\x02\x02\x020\u0767\x03" + - "\x02\x02\x022\u0769\x03\x02\x02\x024\u0777\x03\x02\x02\x026\u0779\x03" + - "\x02\x02\x028\u0798\x03\x02\x02\x02:\u079A\x03\x02\x02\x02<\u07A2\x03" + - "\x02\x02\x02>\u07AC\x03\x02\x02\x02@\u07B3\x03\x02\x02\x02B\u07B9\x03" + - "\x02\x02\x02D\u07CB\x03\x02\x02\x02F\u07CF\x03\x02\x02\x02H\u07D3\x03" + - "\x02\x02\x02J\u07D5\x03\x02\x02\x02L\u07E0\x03\x02\x02\x02N\u07E4\x03" + - "\x02\x02\x02P\u07E9\x03\x02\x02\x02R\u07EE\x03\x02\x02\x02T\u07F0\x03" + - "\x02\x02\x02V\u07FC\x03\x02\x02\x02X\u0803\x03\x02\x02\x02Z\u0805\x03" + - "\x02\x02\x02\\\u0807\x03\x02\x02\x02^\u0809\x03\x02\x02\x02`\u087C\x03" + - "\x02\x02\x02b\u087E\x03\x02\x02\x02d\u088E\x03\x02\x02\x02f\u0890\x03" + - "\x02\x02\x02h\u09BE\x03\x02\x02\x02j\u09C5\x03\x02\x02\x02l\u09C7\x03" + - "\x02\x02\x02n\u09C9\x03\x02\x02\x02p\u09CC\x03\x02\x02\x02r\u09D5\x03" + - "\x02\x02\x02t\u09D7\x03\x02\x02\x02v\u09DB\x03\x02\x02\x02x\u09DE\x03" + - "\x02\x02\x02z\u09E6\x03\x02\x02\x02|\u09F2\x03\x02\x02\x02~\u0A03\x03" + - "\x02\x02\x02\x80\u0A1F\x03\x02\x02\x02\x82\u0A21\x03\x02\x02\x02\x84\u0A24" + - "\x03\x02\x02\x02\x86\u0A2C\x03\x02\x02\x02\x88\u0A31\x03\x02\x02\x02\x8A" + - "\u0A57\x03\x02\x02\x02\x8C\u0A59\x03\x02\x02\x02\x8E\u0A83\x03\x02\x02" + - "\x02\x90\u0A85\x03\x02\x02\x02\x92\u0A87\x03\x02\x02\x02\x94\u0A8C\x03" + - "\x02\x02\x02\x96\u0A93\x03\x02\x02\x02\x98\u0A98\x03\x02\x02\x02\x9A\u0AC2" + - "\x03\x02\x02\x02\x9C\u0AC4\x03\x02\x02\x02\x9E\u0AC7\x03\x02\x02\x02\xA0" + - "\u0ACC\x03\x02\x02\x02\xA2\u0ACE\x03\x02\x02\x02\xA4\u0AD6\x03\x02\x02" + - "\x02\xA6\u0AE1\x03\x02\x02\x02\xA8\u0AE3\x03\x02\x02\x02\xAA\u0AEB\x03" + - "\x02\x02\x02\xAC\u0AED\x03\x02\x02\x02\xAE\u0B42\x03\x02\x02\x02\xB0\u0B44" + - "\x03\x02\x02\x02\xB2\u0B46\x03\x02\x02\x02\xB4\u0B4A\x03\x02\x02\x02\xB6" + - "\u0B52\x03\x02\x02\x02\xB8\u0B5D\x03\x02\x02\x02\xBA\u0B61\x03\x02\x02" + - "\x02\xBC\u0B63\x03\x02\x02\x02\xBE\u0B6A\x03\x02\x02\x02\xC0\u0B74\x03" + - "\x02\x02\x02\xC2\u0B7F\x03\x02\x02\x02\xC4\u0BB5\x03\x02\x02\x02\xC6\u0BBA" + - "\x03\x02\x02\x02\xC8\u0BC1\x03\x02\x02\x02\xCA\u0BC3\x03\x02\x02\x02\xCC" + - "\u0BCB\x03\x02\x02\x02\xCE\u0BCE\x03\x02\x02\x02\xD0\u0BD5\x03\x02\x02" + - "\x02\xD2\u0C2D\x03\x02\x02\x02\xD4\u0C2F\x03\x02\x02\x02\xD6\u0C32\x03" + - "\x02\x02\x02\xD8\u0C36\x03\x02\x02\x02\xDA\u0C3E\x03\x02\x02\x02\xDC\u0C40" + - "\x03\x02\x02\x02\xDE\u0C45\x03\x02\x02\x02\xE0\u0C48\x03\x02\x02\x02\xE2" + - "\u0C50\x03\x02\x02\x02\xE4\u0C5A\x03\x02\x02\x02\xE6\u0C67\x03\x02\x02" + - "\x02\xE8\u0C69\x03\x02\x02\x02\xEA\u0C6D\x03\x02\x02\x02\xEC\u0C77\x03" + - "\x02\x02\x02\xEE\u0C79\x03\x02\x02\x02\xF0\u0C7E\x03\x02\x02\x02\xF2\u0C80" + - "\x03\x02\x02\x02\xF4\u0C87\x03\x02\x02\x02\xF6\u0CA6\x03\x02\x02\x02\xF8" + - "\u0CA8\x03\x02\x02\x02\xFA\u0CAF\x03\x02\x02\x02\xFC\u0CB1\x03\x02\x02" + - "\x02\xFE\u0CBA\x03\x02\x02\x02\u0100\u0CBD\x03\x02\x02\x02\u0102\u0CC2" + - "\x03\x02\x02\x02\u0104\u0CC6\x03\x02\x02\x02\u0106\u0CD6\x03\x02\x02\x02" + - "\u0108\u0CE1\x03\x02\x02\x02\u010A\u0CF1\x03\x02\x02\x02\u010C\u0D01\x03" + - "\x02\x02\x02\u010E\u0D07\x03\x02\x02\x02\u0110\u0D18\x03\x02\x02\x02\u0112" + - "\u0D25\x03\x02\x02\x02\u0114\u0D27\x03\x02\x02\x02\u0116\u0D31\x03\x02" + - "\x02\x02\u0118\u0D3F\x03\x02\x02\x02\u011A\u0D48\x03\x02\x02\x02\u011C" + - "\u0D4A\x03\x02\x02\x02\u011E\u0D4F\x03\x02\x02\x02\u0120\u0D75\x03\x02" + - "\x02\x02\u0122\u0D77\x03\x02\x02\x02\u0124\u0D7F\x03\x02\x02\x02\u0126" + - "\u0D81\x03\x02\x02\x02\u0128\u0D89\x03\x02\x02\x02\u012A\u0D9F\x03\x02" + - "\x02\x02\u012C\u0DA1\x03\x02\x02\x02\u012E\u0DA5\x03\x02\x02\x02\u0130" + - "\u0DAC\x03\x02\x02\x02\u0132\u0DAE\x03\x02\x02\x02\u0134\u0DB0\x03\x02" + - "\x02\x02\u0136\u0DB2\x03\x02\x02\x02\u0138\u0DBD\x03\x02\x02\x02\u013A" + - "\u0DC0\x03\x02\x02\x02\u013C\u0DC8\x03\x02\x02\x02\u013E\u0DD8\x03\x02" + - "\x02\x02\u0140\u0DE2\x03\x02\x02\x02\u0142\u0DE4\x03\x02\x02\x02\u0144" + - "\u0DED\x03\x02\x02\x02\u0146\u0DF0\x03\x02\x02\x02\u0148\u0E5B\x03\x02" + - "\x02\x02\u014A\u0E5D\x03\x02\x02\x02\u014C\u0E70\x03\x02\x02\x02\u014E" + - "\u0E73\x03\x02\x02\x02\u0150\u0E77\x03\x02\x02\x02\u0152\u0E8A\x03\x02" + - "\x02\x02\u0154\u0E8C\x03\x02\x02\x02\u0156\u0E91\x03\x02\x02\x02\u0158" + - "\u0E99\x03\x02\x02\x02\u015A\u0E9E\x03\x02\x02\x02\u015C\u0EAD\x03\x02" + - "\x02\x02\u015E\u0EAF\x03\x02\x02\x02\u0160\u0EB2\x03\x02\x02\x02\u0162" + - "\u0EB4\x03\x02\x02\x02\u0164\u0ED9\x03\x02\x02\x02\u0166\u0EDB\x03\x02" + - "\x02\x02\u0168\u0EDE\x03\x02\x02\x02\u016A\u0EE3\x03\x02\x02\x02\u016C" + - "\u0EE5\x03\x02\x02\x02\u016E\u0F37\x03\x02\x02\x02\u0170\u0F39\x03\x02" + - "\x02\x02\u0172\u0F4B\x03\x02\x02\x02\u0174\u0F4D\x03\x02\x02\x02\u0176" + - "\u0F69\x03\x02\x02\x02\u0178\u0F6D\x03\x02\x02\x02\u017A\u0F81\x03\x02" + - "\x02\x02\u017C\u0F83\x03\x02\x02\x02\u017E\u0F8C\x03\x02\x02\x02\u0180" + - "\u0FA0\x03\x02\x02\x02\u0182\u0FAE\x03\x02\x02\x02\u0184\u0FB3\x03\x02" + - "\x02\x02\u0186\u0FB9\x03\x02\x02\x02\u0188\u0FBC\x03\x02\x02\x02\u018A" + - "\u0FBF\x03\x02\x02\x02\u018C\u0FC2\x03\x02\x02\x02\u018E\u0FC5\x03\x02" + - "\x02\x02\u0190\u0FC7\x03\x02\x02\x02\u0192\u0FD0\x03\x02\x02\x02\u0194" + - "\u1002\x03\x02\x02\x02\u0196\u1008\x03\x02\x02\x02\u0198\u100A\x03\x02" + - "\x02\x02\u019A\u1019\x03\x02\x02\x02\u019C\u101B\x03\x02\x02\x02\u019E" + - "\u101F\x03\x02\x02\x02\u01A0\u1023\x03\x02\x02\x02\u01A2\u102A\x03\x02" + - "\x02\x02\u01A4\u102C\x03\x02\x02\x02\u01A6\u102E\x03\x02\x02\x02\u01A8" + - "\u1030\x03\x02\x02\x02\u01AA\u1036\x03\x02\x02\x02\u01AC\u1038\x03\x02" + - "\x02\x02\u01AE\u103A\x03\x02\x02\x02\u01B0\u103F\x03\x02\x02\x02\u01B2" + - "\u1043\x03\x02\x02\x02\u01B4\u1050\x03\x02\x02\x02\u01B6\u1052\x03\x02" + - "\x02\x02\u01B8\u1058\x03\x02\x02\x02\u01BA\u1066\x03\x02\x02\x02\u01BC" + - "\u1082\x03\x02\x02\x02\u01BE\u1084\x03\x02\x02\x02\u01C0\u108C\x03\x02" + - "\x02\x02\u01C2\u1092\x03\x02\x02\x02\u01C4\u109A\x03\x02\x02\x02\u01C6" + - "\u10A6\x03\x02\x02\x02\u01C8\u10A8\x03\x02\x02\x02\u01CA\u1123\x03\x02" + - "\x02\x02\u01CC\u1125\x03\x02\x02\x02\u01CE\u1129\x03\x02\x02\x02\u01D0" + - "\u1131\x03\x02\x02\x02\u01D2\u113C\x03\x02\x02\x02\u01D4\u113E\x03\x02" + - "\x02\x02\u01D6\u1142\x03\x02\x02\x02\u01D8\u114A\x03\x02\x02\x02\u01DA" + - "\u114E\x03\x02\x02\x02\u01DC\u1150\x03\x02\x02\x02\u01DE\u1183\x03\x02" + - "\x02\x02\u01E0\u1185\x03\x02\x02\x02\u01E2\u1189\x03\x02\x02\x02\u01E4" + - "\u119B\x03\x02\x02\x02\u01E6\u11C2\x03\x02\x02\x02\u01E8\u11C4\x03\x02" + - "\x02\x02\u01EA\u11C6\x03\x02\x02\x02\u01EC\u11CF\x03\x02\x02\x02\u01EE" + - "\u11D1\x03\x02\x02\x02\u01F0\u11D3\x03\x02\x02\x02\u01F2\u11EC\x03\x02" + - "\x02\x02\u01F4\u11EE\x03\x02\x02\x02\u01F6\u1202\x03\x02\x02\x02\u01F8" + - "\u1218\x03\x02\x02\x02\u01FA\u122E\x03\x02\x02\x02\u01FC\u1230\x03\x02" + - "\x02\x02\u01FE\u1237\x03\x02\x02\x02\u0200\u1298\x03\x02\x02\x02\u0202" + - "\u12B1\x03\x02\x02\x02\u0204\u12B8\x03\x02\x02\x02\u0206\u12C9\x03\x02" + - "\x02\x02\u0208\u12CB\x03\x02\x02\x02\u020A\u12CD\x03\x02\x02\x02\u020C" + - "\u12D5\x03\x02\x02\x02\u020E\u12DB\x03\x02\x02\x02\u0210\u12DF\x03\x02" + - "\x02\x02\u0212\u12E7\x03\x02\x02\x02\u0214\u12F6\x03\x02\x02\x02\u0216" + - "\u138B\x03\x02\x02\x02\u0218\u138F\x03\x02\x02\x02\u021A\u1400\x03\x02" + - "\x02\x02\u021C\u1402\x03\x02\x02\x02\u021E\u1407\x03\x02\x02\x02\u0220" + - "\u140D\x03\x02\x02\x02\u0222\u1464\x03\x02\x02\x02\u0224\u1466\x03\x02" + - "\x02\x02\u0226\u1468\x03\x02\x02\x02\u0228\u146A\x03\x02\x02\x02\u022A" + - "\u1488\x03\x02\x02\x02\u022C\u1499\x03\x02\x02\x02\u022E\u149B\x03\x02" + - "\x02\x02\u0230\u14B3\x03\x02\x02\x02\u0232\u14EF\x03\x02\x02\x02\u0234" + - "\u14F1\x03\x02\x02\x02\u0236\u14FC\x03\x02\x02\x02\u0238\u14FE\x03\x02" + - "\x02\x02\u023A\u1502\x03\x02\x02\x02\u023C\u1523\x03\x02\x02\x02\u023E" + - "\u1525\x03\x02\x02\x02\u0240\u1529\x03\x02\x02\x02\u0242\u152D\x03\x02" + - "\x02\x02\u0244\u1536\x03\x02\x02\x02\u0246\u1542\x03\x02\x02\x02\u0248" + - "\u1562\x03\x02\x02\x02\u024A\u1564\x03\x02\x02\x02\u024C\u15A5\x03\x02" + - "\x02\x02\u024E\u15A7\x03\x02\x02\x02\u0250\u15A9\x03\x02\x02\x02\u0252" + - "\u15AB\x03\x02\x02\x02\u0254\u15AD\x03\x02\x02\x02\u0256\u15B0\x03\x02" + - "\x02\x02\u0258\u15CF\x03\x02\x02\x02\u025A\u15DC\x03\x02\x02\x02\u025C" + - "\u15DE\x03\x02\x02\x02\u025E\u15E3\x03\x02\x02\x02\u0260\u15EB\x03\x02" + - "\x02\x02\u0262\u15EE\x03\x02\x02\x02\u0264\u15F0\x03\x02\x02\x02\u0266" + - "\u15F6\x03\x02\x02\x02\u0268\u15F8\x03\x02\x02\x02\u026A\u160C\x03\x02" + - "\x02\x02\u026C\u160F\x03\x02\x02\x02\u026E\u1615\x03\x02\x02\x02\u0270" + - "\u161D\x03\x02\x02\x02\u0272\u162D\x03\x02\x02\x02\u0274\u162F\x03\x02" + - "\x02\x02\u0276\u1635\x03\x02\x02\x02\u0278\u164A\x03\x02\x02\x02\u027A" + - "\u1653\x03\x02\x02\x02\u027C\u1655\x03\x02\x02\x02\u027E\u1657\x03\x02" + - "\x02\x02\u0280\u1665\x03\x02\x02\x02\u0282\u1667\x03\x02\x02\x02\u0284" + - "\u166C\x03\x02\x02\x02\u0286\u166E\x03\x02\x02\x02\u0288\u167D\x03\x02" + - "\x02\x02\u028A\u1685\x03\x02\x02\x02\u028C\u1688\x03\x02\x02\x02\u028E" + - "\u1691\x03\x02\x02\x02\u0290\u16BA\x03\x02\x02\x02\u0292\u16C4\x03\x02" + - "\x02\x02\u0294\u16CB\x03\x02\x02\x02\u0296\u16CD\x03\x02\x02\x02\u0298" + - "\u16D9\x03\x02\x02\x02\u029A\u16DC\x03\x02\x02\x02\u029C\u16DF\x03\x02" + - "\x02\x02\u029E\u16E7\x03\x02\x02\x02\u02A0\u16EF\x03\x02\x02\x02\u02A2" + - "\u16F3\x03\x02\x02\x02\u02A4\u171F\x03\x02\x02\x02\u02A6\u172F\x03\x02" + - "\x02\x02\u02A8\u173F\x03\x02\x02\x02\u02AA\u1757\x03\x02\x02\x02\u02AC" + - "\u175E\x03\x02\x02\x02\u02AE\u1763\x03\x02\x02\x02\u02B0\u176B\x03\x02" + - "\x02\x02\u02B2\u176E\x03\x02\x02\x02\u02B4\u1772\x03\x02\x02\x02\u02B6" + - "\u1779\x03\x02\x02\x02\u02B8\u17A0\x03\x02\x02\x02\u02BA\u17A6\x03\x02" + - "\x02\x02\u02BC\u17A8\x03\x02\x02\x02\u02BE\u17B5\x03\x02\x02\x02\u02C0" + - "\u17B8\x03\x02\x02\x02\u02C2\u17E7\x03\x02\x02\x02\u02C4\u17E9\x03\x02" + - "\x02\x02\u02C6\u1817\x03\x02\x02\x02\u02C8\u1819\x03\x02\x02\x02\u02CA" + - "\u181B\x03\x02\x02\x02\u02CC\u181D\x03\x02\x02\x02\u02CE\u1825\x03\x02" + - "\x02\x02\u02D0\u1833\x03\x02\x02\x02\u02D2\u1A1C\x03\x02\x02\x02\u02D4" + - "\u1A1E\x03\x02\x02\x02\u02D6\u1A20\x03\x02\x02\x02\u02D8\u1A68\x03\x02" + - "\x02\x02\u02DA\u1A6A\x03\x02\x02\x02\u02DC\u1B45\x03\x02\x02\x02\u02DE" + - "\u1B47\x03\x02\x02\x02\u02E0\u1B4F\x03\x02\x02\x02\u02E2\u1B5F\x03\x02" + - "\x02\x02\u02E4\u1B66\x03\x02\x02\x02\u02E6\u1B68\x03\x02\x02\x02\u02E8" + - "\u1C29\x03\x02\x02\x02\u02EA\u1C2B\x03\x02\x02\x02\u02EC\u1C34\x03\x02" + - "\x02\x02\u02EE\u1C3C\x03\x02\x02\x02\u02F0\u1C59\x03\x02\x02\x02\u02F2" + - "\u1C5B\x03\x02\x02\x02\u02F4\u1C65\x03\x02\x02\x02\u02F6\u1C6D\x03\x02" + - "\x02\x02\u02F8\u1C96\x03\x02\x02\x02\u02FA\u1CA6\x03\x02\x02\x02\u02FC" + - "\u1CA8\x03\x02\x02\x02\u02FE\u1CC2\x03\x02\x02\x02\u0300\u1CC5\x03\x02" + - "\x02\x02\u0302\u1CD5\x03\x02\x02\x02\u0304\u1CD7\x03\x02\x02\x02\u0306" + - "\u1CD9\x03\x02\x02\x02\u0308\u1CDB\x03\x02\x02\x02\u030A\u1CDD\x03\x02" + - "\x02\x02\u030C\u1CE2\x03\x02\x02\x02\u030E\u1CE5\x03\x02\x02\x02\u0310" + - "\u1CEC\x03\x02\x02\x02\u0312\u1D33\x03\x02\x02\x02\u0314\u1D35\x03\x02" + - "\x02\x02\u0316\u1D41\x03\x02\x02\x02\u0318\u1D43\x03\x02\x02\x02\u031A" + - "\u1D4D\x03\x02\x02\x02\u031C\u1D4F\x03\x02\x02\x02\u031E\u1D55\x03\x02" + - "\x02\x02\u0320\u1D75\x03\x02\x02\x02\u0322\u1D7C\x03\x02\x02\x02\u0324" + - "\u1D7F\x03\x02\x02\x02\u0326\u1D88\x03\x02\x02\x02\u0328\u1D8B\x03\x02" + - "\x02\x02\u032A\u1D8F\x03\x02\x02\x02\u032C\u1DA0\x03\x02\x02\x02\u032E" + - "\u1DA2\x03\x02\x02\x02\u0330\u1DA4\x03\x02\x02\x02\u0332\u1DB3\x03\x02" + - "\x02\x02\u0334\u1DB8\x03\x02\x02\x02\u0336\u1DC8\x03\x02\x02\x02\u0338" + - "\u1DD0\x03\x02\x02\x02\u033A\u1DD2\x03\x02\x02\x02\u033C\u1DD8\x03\x02" + - "\x02\x02\u033E\u1DDD\x03\x02\x02\x02\u0340\u1DE6\x03\x02\x02\x02\u0342" + - "\u1E01\x03\x02\x02\x02\u0344\u1E03\x03\x02\x02\x02\u0346\u1E52\x03\x02" + - "\x02\x02\u0348\u1E54\x03\x02\x02\x02\u034A\u1E56\x03\x02\x02\x02\u034C" + - "\u1E77\x03\x02\x02\x02\u034E\u1E79\x03\x02\x02\x02\u0350\u1E93\x03\x02" + - "\x02\x02\u0352\u1EA3\x03\x02\x02\x02\u0354\u1EA5\x03\x02\x02\x02\u0356" + - "\u1EAD\x03\x02\x02\x02\u0358\u1EAF\x03\x02\x02\x02\u035A\u1EB5\x03\x02" + - "\x02\x02\u035C\u1EB9\x03\x02\x02\x02\u035E\u1EBB\x03\x02\x02\x02\u0360" + - "\u1EBD\x03\x02\x02\x02\u0362\u1EBF\x03\x02\x02\x02\u0364\u1EC1\x03\x02" + - "\x02\x02\u0366\u1EC3\x03\x02\x02\x02\u0368\u1EC7\x03\x02\x02\x02\u036A" + - "\u1ECB\x03\x02\x02\x02\u036C\u1ED3\x03\x02\x02\x02\u036E\u1EE7\x03\x02" + - "\x02\x02\u0370\u1EF2\x03\x02\x02\x02\u0372\u1EF4\x03\x02\x02\x02\u0374" + - "\u1EFC\x03\x02\x02\x02\u0376\u1F02\x03\x02\x02\x02\u0378\u1F06\x03\x02" + - "\x02\x02\u037A\u1F08\x03\x02\x02\x02\u037C\u1F10\x03\x02\x02\x02\u037E" + - "\u1F18\x03\x02\x02\x02\u0380\u1F40\x03\x02\x02\x02\u0382\u1F42\x03\x02" + - "\x02\x02\u0384\u1F50\x03\x02\x02\x02\u0386\u1F53\x03\x02\x02\x02\u0388" + - "\u1F5F\x03\x02\x02\x02\u038A\u1F77\x03\x02\x02\x02\u038C\u1F79\x03\x02" + - "\x02\x02\u038E\u1F7B\x03\x02\x02\x02\u0390\u1F83\x03\x02\x02\x02\u0392" + - "\u1F86\x03\x02\x02\x02\u0394\u1F9E\x03\x02\x02\x02\u0396\u1FA0\x03\x02" + - "\x02\x02\u0398\u1FA4\x03\x02\x02\x02\u039A\u1FB2\x03\x02\x02\x02\u039C" + - "\u1FB5\x03\x02\x02\x02\u039E\u1FC0\x03\x02\x02\x02\u03A0\u1FD0\x03\x02" + - "\x02\x02\u03A2\u1FD2\x03\x02\x02\x02\u03A4\u1FD7\x03\x02\x02\x02\u03A6" + - "\u1FDA\x03\x02\x02\x02\u03A8\u1FE9\x03\x02\x02\x02\u03AA\u1FFB\x03\x02" + - "\x02\x02\u03AC\u1FFD\x03\x02\x02\x02\u03AE\u2000\x03\x02\x02\x02\u03B0" + - "\u2008\x03\x02\x02\x02\u03B2\u2010\x03\x02\x02\x02\u03B4\u2019\x03\x02" + - "\x02\x02\u03B6\u2021\x03\x02\x02\x02\u03B8\u2025\x03\x02\x02\x02\u03BA" + - "\u202F\x03\x02\x02\x02\u03BC\u204E\x03\x02\x02\x02\u03BE\u2052\x03\x02" + - "\x02\x02\u03C0\u207E\x03\x02\x02\x02\u03C2\u208D\x03\x02\x02\x02\u03C4" + - "\u208F\x03\x02\x02\x02\u03C6\u2093\x03\x02\x02\x02\u03C8\u2099\x03\x02" + - "\x02\x02\u03CA\u20A1\x03\x02\x02\x02\u03CC\u20B0\x03\x02\x02\x02\u03CE" + - "\u20B2\x03\x02\x02\x02\u03D0\u20B4\x03\x02\x02\x02\u03D2\u20BD\x03\x02" + - "\x02\x02\u03D4\u20CF\x03\x02\x02\x02\u03D6\u20D1\x03\x02\x02\x02\u03D8" + - "\u20D3\x03\x02\x02\x02\u03DA\u20D5\x03\x02\x02\x02\u03DC\u20DD\x03\x02" + - "\x02\x02\u03DE\u20DF\x03\x02\x02\x02\u03E0\u20E1\x03\x02\x02\x02\u03E2" + - "\u20E5\x03\x02\x02\x02\u03E4\u20ED\x03\x02\x02\x02\u03E6\u2100\x03\x02" + - "\x02\x02\u03E8\u2102\x03\x02\x02\x02\u03EA\u211B\x03\x02\x02\x02\u03EC" + - "\u211D\x03\x02\x02\x02\u03EE\u2126\x03\x02\x02\x02\u03F0\u2128\x03\x02" + - "\x02\x02\u03F2\u212F\x03\x02\x02\x02\u03F4\u2133\x03\x02\x02\x02\u03F6" + - "\u2135\x03\x02\x02\x02\u03F8\u2137\x03\x02\x02\x02\u03FA\u2139\x03\x02" + - "\x02\x02\u03FC\u213D\x03\x02\x02\x02\u03FE\u214A\x03\x02\x02\x02\u0400" + - "\u214C\x03\x02\x02\x02\u0402\u214F\x03\x02\x02\x02\u0404\u2154\x03\x02" + - "\x02\x02\u0406\u2159\x03\x02\x02\x02\u0408\u215F\x03\x02\x02\x02\u040A" + - "\u2166\x03\x02\x02\x02\u040C\u2168\x03\x02\x02\x02\u040E\u216B\x03\x02" + - "\x02\x02\u0410\u216F\x03\x02\x02\x02\u0412\u2176\x03\x02\x02\x02\u0414" + - "\u2182\x03\x02\x02\x02\u0416\u2185\x03\x02\x02\x02\u0418\u2193\x03\x02" + - "\x02\x02\u041A\u2196\x03\x02\x02\x02\u041C\u21D8\x03\x02\x02\x02\u041E" + - "\u21F0\x03\x02\x02\x02\u0420\u21F9\x03\x02\x02\x02\u0422\u2207\x03\x02" + - "\x02\x02\u0424\u2209\x03\x02\x02\x02\u0426\u2214\x03\x02\x02\x02\u0428" + - "\u2222\x03\x02\x02\x02\u042A\u2224\x03\x02\x02\x02\u042C\u222C\x03\x02" + - "\x02\x02\u042E\u2233\x03\x02\x02\x02\u0430\u223B\x03\x02\x02\x02\u0432" + - "\u224C\x03\x02\x02\x02\u0434\u224E\x03\x02\x02\x02\u0436\u2252\x03\x02" + - "\x02\x02\u0438\u225A\x03\x02\x02\x02\u043A\u225F\x03\x02\x02\x02\u043C" + - "\u2262\x03\x02\x02\x02\u043E\u2265\x03\x02\x02\x02\u0440\u226C\x03\x02" + - "\x02\x02\u0442\u226E\x03\x02\x02\x02\u0444\u2276\x03\x02\x02\x02\u0446" + - "\u227B\x03\x02\x02\x02\u0448\u2290\x03\x02\x02\x02\u044A\u2298\x03\x02" + - "\x02\x02\u044C\u22A2\x03\x02\x02\x02\u044E\u22AE\x03\x02\x02\x02\u0450" + - "\u22B0\x03\x02\x02\x02\u0452\u22BE\x03\x02\x02\x02\u0454\u22D2\x03\x02" + - "\x02\x02\u0456\u22DB\x03\x02\x02\x02\u0458\u22ED\x03\x02\x02\x02\u045A" + - "\u22F3\x03\x02\x02\x02\u045C\u22F5\x03\x02\x02\x02\u045E\u22FC\x03\x02" + - "\x02\x02\u0460\u2318\x03\x02\x02\x02\u0462\u231A\x03\x02\x02\x02\u0464" + - "\u2320\x03\x02\x02\x02\u0466\u2324\x03\x02\x02\x02\u0468\u2326\x03\x02" + - "\x02\x02\u046A\u232E\x03\x02\x02\x02\u046C\u2332\x03\x02\x02\x02\u046E" + - "\u2339\x03\x02\x02\x02\u0470\u234A\x03\x02\x02\x02\u0472\u234C\x03\x02" + - "\x02\x02\u0474\u234E\x03\x02\x02\x02\u0476\u2358\x03\x02\x02\x02\u0478" + - "\u2360\x03\x02\x02\x02\u047A\u237B\x03\x02\x02\x02\u047C\u237D\x03\x02" + - "\x02\x02\u047E\u2384\x03\x02\x02\x02\u0480\u2387\x03\x02\x02\x02\u0482" + - "\u2389\x03\x02\x02\x02\u0484\u238D\x03\x02\x02\x02\u0486\u2395\x03\x02" + - "\x02\x02\u0488\u239D\x03\x02\x02\x02\u048A\u23A5\x03\x02\x02\x02\u048C" + - "\u23AE\x03\x02\x02\x02\u048E\u23B2\x03\x02\x02\x02\u0490\u23B6\x03\x02" + - "\x02\x02\u0492\u23D0\x03\x02\x02\x02\u0494\u23DE\x03\x02\x02\x02\u0496" + - "\u23F2\x03\x02\x02\x02\u0498\u23FC\x03\x02\x02\x02\u049A\u2400\x03\x02" + - "\x02\x02\u049C\u2408\x03\x02\x02\x02\u049E\u2410\x03\x02\x02\x02\u04A0" + - "\u2416\x03\x02\x02\x02\u04A2\u241A\x03\x02\x02\x02\u04A4\u2421\x03\x02" + - "\x02\x02\u04A6\u2426\x03\x02\x02\x02\u04A8\u2435\x03\x02\x02\x02\u04AA" + - "\u2485\x03\x02\x02\x02\u04AC\u2487\x03\x02\x02\x02\u04AE\u2489\x03\x02" + - "\x02\x02\u04B0\u24AF\x03\x02\x02\x02\u04B2\u24B3\x03\x02\x02\x02\u04B4" + - "\u256D\x03\x02\x02\x02\u04B6\u2574\x03\x02\x02\x02\u04B8\u2580\x03\x02" + - "\x02\x02\u04BA\u2582\x03\x02\x02\x02\u04BC\u2587\x03\x02\x02\x02\u04BE" + - "\u258F\x03\x02\x02\x02\u04C0\u2594\x03\x02\x02\x02\u04C2\u259A\x03\x02" + - "\x02\x02\u04C4\u25AB\x03\x02\x02\x02\u04C6\u25AD\x03\x02\x02\x02\u04C8" + - "\u25B0\x03\x02\x02\x02\u04CA\u25B6\x03\x02\x02\x02\u04CC\u25BC\x03\x02" + - "\x02\x02\u04CE\u25BF\x03\x02\x02\x02\u04D0\u25C7\x03\x02\x02\x02\u04D2" + - "\u25CB\x03\x02\x02\x02\u04D4\u25D0\x03\x02\x02\x02\u04D6\u25DF\x03\x02" + - "\x02\x02\u04D8\u25E1\x03\x02\x02\x02\u04DA\u25F4\x03\x02\x02\x02\u04DC" + - "\u25FC\x03\x02\x02\x02\u04DE\u2605\x03\x02\x02\x02\u04E0\u2607\x03\x02" + - "\x02\x02\u04E2\u261C\x03\x02\x02\x02\u04E4\u261E\x03\x02\x02\x02\u04E6" + - "\u2625\x03\x02\x02\x02\u04E8\u262B\x03\x02\x02\x02\u04EA\u262F\x03\x02" + - "\x02\x02\u04EC\u2631\x03\x02\x02\x02\u04EE\u2639\x03\x02\x02\x02\u04F0" + - "\u2641\x03\x02\x02\x02\u04F2\u264F\x03\x02\x02\x02\u04F4\u2651\x03\x02" + - "\x02\x02\u04F6\u2659\x03\x02\x02\x02\u04F8\u2666\x03\x02\x02\x02\u04FA" + - "\u2668\x03\x02\x02\x02\u04FC\u2670\x03\x02\x02\x02\u04FE\u2677\x03\x02" + - "\x02\x02\u0500\u267F\x03\x02\x02\x02\u0502\u268B\x03\x02\x02\x02\u0504" + - "\u268D\x03\x02\x02\x02\u0506\u268F\x03\x02\x02\x02\u0508\u2698\x03\x02" + - "\x02\x02\u050A\u26B7\x03\x02\x02\x02\u050C\u26C0\x03\x02\x02\x02\u050E" + - "\u26C7\x03\x02\x02\x02\u0510\u26C9\x03\x02\x02\x02\u0512\u26D4\x03\x02" + - "\x02\x02\u0514\u26D8\x03\x02\x02\x02\u0516\u26DD\x03\x02\x02\x02\u0518" + - "\u26E0\x03\x02\x02\x02\u051A\u26E2\x03\x02\x02\x02\u051C\u26F7\x03\x02" + - "\x02\x02\u051E\u26F9\x03\x02\x02\x02\u0520\u26FC\x03\x02\x02\x02\u0522" + - "\u2703\x03\x02\x02\x02\u0524\u2706\x03\x02\x02\x02\u0526\u2708\x03\x02" + - "\x02\x02\u0528\u2718\x03\x02\x02\x02\u052A\u271A\x03\x02\x02\x02\u052C" + - "\u2722\x03\x02\x02\x02\u052E\u2726\x03\x02\x02\x02\u0530\u272E\x03\x02" + - "\x02\x02\u0532\u2730\x03\x02\x02\x02\u0534\u2732\x03\x02\x02\x02\u0536" + - "\u2738\x03\x02\x02\x02\u0538\u275D\x03\x02\x02\x02\u053A\u275F\x03\x02" + - "\x02\x02\u053C\u2761\x03\x02\x02\x02\u053E\u2763\x03\x02\x02\x02\u0540" + - "\u2765\x03\x02\x02\x02\u0542\u2767\x03\x02\x02\x02\u0544\u2776\x03\x02" + - "\x02\x02\u0546\u2778\x03\x02\x02\x02\u0548\u2780\x03\x02\x02\x02\u054A" + - "\u2782\x03\x02\x02\x02\u054C\u2787\x03\x02\x02\x02\u054E\u2789\x03\x02" + - "\x02\x02\u0550\u2795\x03\x02\x02\x02\u0552\u279B\x03\x02\x02\x02\u0554" + - "\u27A1\x03\x02\x02\x02\u0556\u27A9\x03\x02\x02\x02\u0558\u27B4\x03\x02" + - "\x02\x02\u055A\u27B6\x03\x02\x02\x02\u055C\u27B8\x03\x02\x02\x02\u055E" + - "\u27ED\x03\x02\x02\x02\u0560\u27EF\x03\x02\x02\x02\u0562\u27F1\x03\x02" + - "\x02\x02\u0564\u27F3\x03\x02\x02\x02\u0566\u27FA\x03\x02\x02\x02\u0568" + - "\u2811\x03\x02\x02\x02\u056A\u2813\x03\x02\x02\x02\u056C\u2819\x03\x02" + - "\x02\x02\u056E\u281D\x03\x02\x02\x02\u0570\u281F\x03\x02\x02\x02\u0572" + - "\u2826\x03\x02\x02\x02\u0574\u282D\x03\x02\x02\x02\u0576\u2830\x03\x02" + - "\x02\x02\u0578\u2834\x03\x02\x02\x02\u057A\u283B\x03\x02\x02\x02\u057C" + - "\u283D\x03\x02\x02\x02\u057E\u2855\x03\x02\x02\x02\u0580\u2857\x03\x02" + - "\x02\x02\u0582\u285E\x03\x02\x02\x02\u0584\u2860\x03\x02\x02\x02\u0586" + - "\u2868\x03\x02\x02\x02\u0588\u286B\x03\x02\x02\x02\u058A\u286F\x03\x02" + - "\x02\x02\u058C\u2871\x03\x02\x02\x02\u058E\u2875\x03\x02\x02\x02\u0590" + - "\u2877\x03\x02\x02\x02\u0592\u287C\x03\x02\x02\x02\u0594\u2881\x03\x02" + - "\x02\x02\u0596\u2887\x03\x02\x02\x02\u0598\u288B\x03\x02\x02\x02\u059A" + - "\u288D\x03\x02\x02\x02\u059C\u2892\x03\x02\x02\x02\u059E\u28B0\x03\x02" + - "\x02\x02\u05A0\u28B2\x03\x02\x02\x02\u05A2\u28C4\x03\x02\x02\x02\u05A4" + - "\u28C8\x03\x02\x02\x02\u05A6\u28CA\x03\x02\x02\x02\u05A8\u28CF\x03\x02" + - "\x02\x02\u05AA\u28D8\x03\x02\x02\x02\u05AC\u28DA\x03\x02\x02\x02\u05AE" + - "\u28E2\x03\x02\x02\x02\u05B0\u28E6\x03\x02\x02\x02\u05B2\u28E8\x03\x02" + - "\x02\x02\u05B4\u28EC\x03\x02\x02\x02\u05B6\u28F7\x03\x02\x02\x02\u05B8" + - "\u2908\x03\x02\x02\x02\u05BA\u290E\x03\x02\x02\x02\u05BC\u2910\x03\x02" + - "\x02\x02\u05BE\u291A\x03\x02\x02\x02\u05C0\u291D\x03\x02\x02\x02\u05C2" + - "\u2921\x03\x02\x02\x02\u05C4\u2929\x03\x02\x02\x02\u05C6\u292B\x03\x02" + - "\x02\x02\u05C8\u292E\x03\x02\x02\x02\u05CA\u2933\x03\x02\x02\x02\u05CC" + - "\u2938\x03\x02\x02\x02\u05CE\u294E\x03\x02\x02\x02\u05D0\u295C\x03\x02" + - "\x02\x02\u05D2\u2960\x03\x02\x02\x02\u05D4\u2965\x03\x02\x02\x02\u05D6" + - "\u2967\x03\x02\x02\x02\u05D8\u2969\x03\x02\x02\x02\u05DA\u2975\x03\x02" + - "\x02\x02\u05DC\u2977\x03\x02\x02\x02\u05DE\u297E\x03\x02\x02\x02\u05E0" + - "\u2980\x03\x02\x02\x02\u05E2\u2992\x03\x02\x02\x02\u05E4\u29B6\x03\x02" + - "\x02\x02\u05E6\u29B8\x03\x02\x02\x02\u05E8\u29C1\x03\x02\x02\x02\u05EA" + - "\u29C6\x03\x02\x02\x02\u05EC\u29C8\x03\x02\x02\x02\u05EE\u29CC\x03\x02" + - "\x02\x02\u05F0\u29D4\x03\x02\x02\x02\u05F2\u29DC\x03\x02\x02\x02\u05F4" + - "\u29DE\x03\x02\x02\x02\u05F6\u29E5\x03\x02\x02\x02\u05F8\u29E8\x03\x02" + - "\x02\x02\u05FA\u29F8\x03\x02\x02\x02\u05FC\u29FA\x03\x02\x02\x02\u05FE" + - "\u2A08\x03\x02\x02\x02\u0600\u2A0A\x03\x02\x02\x02\u0602\u2A25\x03\x02" + - "\x02\x02\u0604\u2A27\x03\x02\x02\x02\u0606\u2A32\x03\x02\x02\x02\u0608" + - "\u2A38\x03\x02\x02\x02\u060A\u2A3C\x03\x02\x02\x02\u060C\u2A3E\x03\x02" + - "\x02\x02\u060E\u2A48\x03\x02\x02\x02\u0610\u2A4D\x03\x02\x02\x02\u0612"; + "\x02\u0624\x02\u0626\x02\u0628\x02\u062A\x02\u062C\x02\u062E\x02\u0630" + + "\x02\u0632\x02\u0634\x02\u0636\x02\u0638\x02\u063A\x02\u063C\x02\u063E" + + "\x02\u0640\x02\u0642\x02\u0644\x02\u0646\x02\u0648\x02\u064A\x02\u064C" + + "\x02\u064E\x02\u0650\x02\u0652\x02\u0654\x02\u0656\x02\u0658\x02\u065A" + + "\x02\u065C\x02\u065E\x02\u0660\x02\x02N\x04\x02\xC5\xC5\u016E\u016E\x03" + + "\x02\xE6\xE7\x03\x02\xEE\xEF\x03\x02\xEC\xED\x03\x02\xEA\xEB\x03\x02\xE8" + + "\xE9\x04\x02DD\u0140\u0140\x04\x02ee\u0140\u0140\x05\x02DDee\u0140\u0140" + + "\x04\x02\x87\x87\xC1\xC1\x04\x02\u0100\u0100\u014E\u014E\x04\x02\f\f`" + + "`\x04\x02\xA4\xA4\u016D\u016D\x04\x02\xB6\xB6\xDF\xDF\x07\x02 \u0122" + + "\u0122\u014B\u014B\u0162\u0162\u0164\u0164\x04\x02\x98\x98\u013D\u013D" + + "\x04\x02BB``\x04\x02\u0162\u0162\u0164\u0164\x04\x02\xCA\xCA\xE2\xE2\v" + + "\x02 \xA2\xA2\xA7\xA7\xB5\xB5\xDD\xDD\xE5\xE5\u0158\u0158\u015B\u015B" + + "\u01B8\u01B8\x05\x02ss\u011E\u011E\u0152\u0152\x04\x0277PP\x05\x02\xAF" + + "\xAF\u0106\u0106\u0108\u0108\x07\x02 ZZ\xB8\xB8\xF3\xF3\u0173\u0173\x04" + + "\x02^^\xE4\xE4\x04\x02\u0157\u0157\u01A0\u01A0\x03\x02\u01C2\u01C3\x04" + + "\x02^^\u01A0\u01A0\x04\x02\xD5\xD5\u012A\u012A\x05\x02\u0143\u0143\u0167" + + "\u0167\u01BF\u01BF\x04\x02BBFF\f\x0200ZZ\xB8\xB8\xCC\xCC\xF3\xF3\u0162" + + "\u0162\u0164\u0164\u0167\u0168\u0173\u0173\u020B\u020D\x07\x02\xD6\xD6" + + "\u014B\u014B\u0160\u0160\u016B\u016B\u01C9\u01CA\x04\x02\'\'99\x04\x02" + + "\f\f77\x05\x02\xD5\xD5\u012A\u012A\u01BC\u01BC\x05\x02\xB1\xB1\u0145\u0145" + + "\u015F\u015F\x06\x02ZZ\xB8\xB8\xF3\xF3\u0173\u0173\x04\x02\x8B\x8B\xF4" + + "\xF4\x04\x02\u0166\u0166\u017E\u017E\x04\x02\x99\x99\u0100\u0100\x04\x02" + + "\u013B\u013B\u014F\u014F\x03\x02!\"\x04\x02ee\u015F\u015F\x04\x02\xCB" + + "\xCB\u0150\u0150\x04\x02\xD7\xD7\u0100\u0100\x04\x02 ::\x04\x02\u0142" + + "\u0142\u01A0\u01A0\x04\x02\xD1\xD1\u010E\u010E\x06\x02ssuuyy\x80\x80\x04" + + "\x02\u016A\u016A\u01DF\u01DF\x04\x02\u0189\u018A\u0198\u0198\x03\x02\u0189" + + "\u018A\x03\x02\u01A4\u01A5\x03\x02\x14\x15\x04\x02ww||\x07\x02\f\f\x12" + + "\x13\x17\x17\x19\x19\x1B\x1B\x03\x02\x0E\x0F\x05\x02\v\v\x10\x10\x1D\x1D" + + "\x05\x02))KKaa\x04\x02\xA8\xA8\xBE\xBE\x04\x02\u0132\u0132\u01C4\u01C4" + + "\x04\x02\xD2\xD2\u0123\u0123\x05\x02 $$\\\\\b\x02\v\f\x0E\x13\x17\x17" + + "\x19\x19\x1B\x1B\x1D\x1D\x04\x02\x16\x16\x18\x18\x03\x02\u01E5\u01E8\v" + + "\x02~~\x83\xE6\xF0\u0184\u01B3\u01C6\u01C9\u01D7\u01D9\u01D9\u01DB\u01DB" + + "\u01DD\u01DD\u01E0\u01EA\x05\x02l}\x7F\x82\u01DA\u01DA\x06\x02 68HJk\u01C8" + + "\u01C8\x04\x02@@vv\x04\x02\f\f\x16\x16\x04\x02\xA9\xA9\u01FD\u01FD\x03" + + "\x02\u0202\u0207\x04\x02\x92\x92\xD4\xD4&\x02##%%-/77;;??^^vv}}\x84\x84" + + "\x92\x92\x9B\x9B\x9F\x9F\xA3\xA3\xA9\xA9\xAE\xAE\xD1\xD1\xD4\xD4\xF3\xF3" + + "\xFB\xFB\u010B\u010B\u010E\u010F\u0119\u0119\u0127\u0127\u0135\u0135\u013B" + + "\u013B\u0141\u0141\u0145\u0146\u014F\u014F\u016A\u016A\u01B3\u01B4\u01DF" + + "\u01DF\u01EC\u01F8\u01FA\u01FA\u01FC\u0208\u020A\u020A\x02\u2FE7\x02\u0662" + + "\x03\x02\x02\x02\x04\u0664\x03\x02\x02\x02\x06\u066C\x03\x02\x02\x02\b" + + "\u06EB\x03\x02\x02\x02\n\u06ED\x03\x02\x02\x02\f\u06F1\x03\x02\x02\x02" + + "\x0E\u06F4\x03\x02\x02\x02\x10\u06FC\x03\x02\x02\x02\x12\u0701\x03\x02" + + "\x02\x02\x14\u0707\x03\x02\x02\x02\x16\u0720\x03\x02\x02\x02\x18\u072C" + + "\x03\x02\x02\x02\x1A\u072E\x03\x02\x02\x02\x1C\u0736\x03\x02\x02\x02\x1E" + + "\u0742\x03\x02\x02\x02 \u0744\x03\x02\x02\x02\"\u074D\x03\x02\x02\x02" + + "$\u0755\x03\x02\x02\x02&\u075D\x03\x02\x02\x02(\u0764\x03\x02\x02\x02" + + "*\u0766\x03\x02\x02\x02,\u0777\x03\x02\x02\x02.\u077C\x03\x02\x02\x02" + + "0\u0785\x03\x02\x02\x022\u0787\x03\x02\x02\x024\u0795\x03\x02\x02\x02" + + "6\u0797\x03\x02\x02\x028\u07B6\x03\x02\x02\x02:\u07B8\x03\x02\x02\x02" + + "<\u07C0\x03\x02\x02\x02>\u07CA\x03\x02\x02\x02@\u07D1\x03\x02\x02\x02" + + "B\u07D7\x03\x02\x02\x02D\u07E9\x03\x02\x02\x02F\u07ED\x03\x02\x02\x02" + + "H\u07F1\x03\x02\x02\x02J\u07F3\x03\x02\x02\x02L\u07FE\x03\x02\x02\x02" + + "N\u0802\x03\x02\x02\x02P\u0807\x03\x02\x02\x02R\u080C\x03\x02\x02\x02" + + "T\u080E\x03\x02\x02\x02V\u081A\x03\x02\x02\x02X\u0821\x03\x02\x02\x02" + + "Z\u0823\x03\x02\x02\x02\\\u0825\x03\x02\x02\x02^\u0827\x03\x02\x02\x02" + + "`\u089A\x03\x02\x02\x02b\u089C\x03\x02\x02\x02d\u08AC\x03\x02\x02\x02" + + "f\u08AE\x03\x02\x02\x02h\u09DC\x03\x02\x02\x02j\u09E3\x03\x02\x02\x02" + + "l\u09E5\x03\x02\x02\x02n\u09E7\x03\x02\x02\x02p\u09EA\x03\x02\x02\x02" + + "r\u09F3\x03\x02\x02\x02t\u09F5\x03\x02\x02\x02v\u09F9\x03\x02\x02\x02" + + "x\u09FC\x03\x02\x02\x02z\u0A04\x03\x02\x02\x02|\u0A10\x03\x02\x02\x02" + + "~\u0A21\x03\x02\x02\x02\x80\u0A3D\x03\x02\x02\x02\x82\u0A3F\x03\x02\x02" + + "\x02\x84\u0A42\x03\x02\x02\x02\x86\u0A4A\x03\x02\x02\x02\x88\u0A4F\x03" + + "\x02\x02\x02\x8A\u0A75\x03\x02\x02\x02\x8C\u0A77\x03\x02\x02\x02\x8E\u0AA1" + + "\x03\x02\x02\x02\x90\u0AA3\x03\x02\x02\x02\x92\u0AA5\x03\x02\x02\x02\x94" + + "\u0AAA\x03\x02\x02\x02\x96\u0AB1\x03\x02\x02\x02\x98\u0AB6\x03\x02\x02" + + "\x02\x9A\u0AE0\x03\x02\x02\x02\x9C\u0AE2\x03\x02\x02\x02\x9E\u0AE5\x03" + + "\x02\x02\x02\xA0\u0AEA\x03\x02\x02\x02\xA2\u0AEC\x03\x02\x02\x02\xA4\u0AF4" + + "\x03\x02\x02\x02\xA6\u0AFF\x03\x02\x02\x02\xA8\u0B01\x03\x02\x02\x02\xAA" + + "\u0B09\x03\x02\x02\x02\xAC\u0B0B\x03\x02\x02\x02\xAE\u0B60\x03\x02\x02" + + "\x02\xB0\u0B62\x03\x02\x02\x02\xB2\u0B64\x03\x02\x02\x02\xB4\u0B66\x03" + + "\x02\x02\x02\xB6\u0B6A\x03\x02\x02\x02\xB8\u0B72\x03\x02\x02\x02\xBA\u0B7D" + + "\x03\x02\x02\x02\xBC\u0B81\x03\x02\x02\x02\xBE\u0B83\x03\x02\x02\x02\xC0" + + "\u0B8E\x03\x02\x02\x02\xC2\u0B98\x03\x02\x02\x02\xC4\u0BAD\x03\x02\x02" + + "\x02\xC6\u0BE3\x03\x02\x02\x02\xC8\u0BE8\x03\x02\x02\x02\xCA\u0BED\x03" + + "\x02\x02\x02\xCC\u0BEF\x03\x02\x02\x02\xCE\u0BF2\x03\x02\x02\x02\xD0\u0BFA" + + "\x03\x02\x02\x02\xD2\u0BFD\x03\x02\x02\x02\xD4\u0C04\x03\x02\x02\x02\xD6" + + "\u0C5C\x03\x02\x02\x02\xD8\u0C5E\x03\x02\x02\x02\xDA\u0C61\x03\x02\x02" + + "\x02\xDC\u0C65\x03\x02\x02\x02\xDE\u0C6D\x03\x02\x02\x02\xE0\u0C6F\x03" + + "\x02\x02\x02\xE2\u0C74\x03\x02\x02\x02\xE4\u0C77\x03\x02\x02\x02\xE6\u0C7F" + + "\x03\x02\x02\x02\xE8\u0C89\x03\x02\x02\x02\xEA\u0C96\x03\x02\x02\x02\xEC" + + "\u0C98\x03\x02\x02\x02\xEE\u0C9C\x03\x02\x02\x02\xF0\u0CA6\x03\x02\x02" + + "\x02\xF2\u0CA8\x03\x02\x02\x02\xF4\u0CAD\x03\x02\x02\x02\xF6\u0CAF\x03" + + "\x02\x02\x02\xF8\u0CB6\x03\x02\x02\x02\xFA\u0CD5\x03\x02\x02\x02\xFC\u0CD7" + + "\x03\x02\x02\x02\xFE\u0CE0\x03\x02\x02\x02\u0100\u0CE2\x03\x02\x02\x02" + + "\u0102\u0CEB\x03\x02\x02\x02\u0104\u0CEE\x03\x02\x02\x02\u0106\u0CF3\x03" + + "\x02\x02\x02\u0108\u0CF7\x03\x02\x02\x02\u010A\u0D07\x03\x02\x02\x02\u010C" + + "\u0D12\x03\x02\x02\x02\u010E\u0D22\x03\x02\x02\x02\u0110\u0D32\x03\x02" + + "\x02\x02\u0112\u0D38\x03\x02\x02\x02\u0114\u0D49\x03\x02\x02\x02\u0116" + + "\u0D56\x03\x02\x02\x02\u0118\u0D58\x03\x02\x02\x02\u011A\u0D62\x03\x02" + + "\x02\x02\u011C\u0D70\x03\x02\x02\x02\u011E\u0D79\x03\x02\x02\x02\u0120" + + "\u0D7B\x03\x02\x02\x02\u0122\u0D80\x03\x02\x02\x02\u0124\u0DA6\x03\x02" + + "\x02\x02\u0126\u0DA8\x03\x02\x02\x02\u0128\u0DB0\x03\x02\x02\x02\u012A" + + "\u0DB2\x03\x02\x02\x02\u012C\u0DBA\x03\x02\x02\x02\u012E\u0DD0\x03\x02" + + "\x02\x02\u0130\u0DD2\x03\x02\x02\x02\u0132\u0DD6\x03\x02\x02\x02\u0134" + + "\u0DDD\x03\x02\x02\x02\u0136\u0DDF\x03\x02\x02\x02\u0138\u0DE1\x03\x02" + + "\x02\x02\u013A\u0DE3\x03\x02\x02\x02\u013C\u0DEE\x03\x02\x02\x02\u013E" + + "\u0DF1\x03\x02\x02\x02\u0140\u0DF9\x03\x02\x02\x02\u0142\u0E09\x03\x02" + + "\x02\x02\u0144\u0E13\x03\x02\x02\x02\u0146\u0E15\x03\x02\x02\x02\u0148" + + "\u0E1E\x03\x02\x02\x02\u014A\u0E21\x03\x02\x02\x02\u014C\u0E8C\x03\x02" + + "\x02\x02\u014E\u0E8E\x03\x02\x02\x02\u0150\u0EA1\x03\x02\x02\x02\u0152" + + "\u0EA4\x03\x02\x02\x02\u0154\u0EA8\x03\x02\x02\x02\u0156\u0EBB\x03\x02" + + "\x02\x02\u0158\u0EBD\x03\x02\x02\x02\u015A\u0EC2\x03\x02\x02\x02\u015C" + + "\u0ECA\x03\x02\x02\x02\u015E\u0ECF\x03\x02\x02\x02\u0160\u0EDE\x03\x02" + + "\x02\x02\u0162\u0EE0\x03\x02\x02\x02\u0164\u0EE3\x03\x02\x02\x02\u0166" + + "\u0EE5\x03\x02\x02\x02\u0168\u0F0A\x03\x02\x02\x02\u016A\u0F0C\x03\x02" + + "\x02\x02\u016C\u0F0F\x03\x02\x02\x02\u016E\u0F14\x03\x02\x02\x02\u0170" + + "\u0F16\x03\x02\x02\x02\u0172\u0F68\x03\x02\x02\x02\u0174\u0F6A\x03\x02" + + "\x02\x02\u0176\u0F7C\x03\x02\x02\x02\u0178\u0F7E\x03\x02\x02\x02\u017A" + + "\u0F9A\x03\x02\x02\x02\u017C\u0F9E\x03\x02\x02\x02\u017E\u0FB2\x03\x02" + + "\x02\x02\u0180\u0FB4\x03\x02\x02\x02\u0182\u0FBD\x03\x02\x02\x02\u0184" + + "\u0FD1\x03\x02\x02\x02\u0186\u0FDF\x03\x02\x02\x02\u0188\u0FE4\x03\x02" + + "\x02\x02\u018A\u0FEA\x03\x02\x02\x02\u018C\u0FED\x03\x02\x02\x02\u018E" + + "\u0FF0\x03\x02\x02\x02\u0190\u0FF3\x03\x02\x02\x02\u0192\u0FF6\x03\x02" + + "\x02\x02\u0194\u0FF8\x03\x02\x02\x02\u0196\u1001\x03\x02\x02\x02\u0198" + + "\u1035\x03\x02\x02\x02\u019A\u103B\x03\x02\x02\x02\u019C\u103D\x03\x02" + + "\x02\x02\u019E\u1043\x03\x02\x02\x02\u01A0\u1045\x03\x02\x02\x02\u01A2" + + "\u1054\x03\x02\x02\x02\u01A4\u1056\x03\x02\x02\x02\u01A6\u105A\x03\x02" + + "\x02\x02\u01A8\u105E\x03\x02\x02\x02\u01AA\u1065\x03\x02\x02\x02\u01AC" + + "\u1067\x03\x02\x02\x02\u01AE\u1069\x03\x02\x02\x02\u01B0\u106B\x03\x02" + + "\x02\x02\u01B2\u1071\x03\x02\x02\x02\u01B4\u1073\x03\x02\x02\x02\u01B6" + + "\u1075\x03\x02\x02\x02\u01B8\u107A\x03\x02\x02\x02\u01BA\u107E\x03\x02" + + "\x02\x02\u01BC\u108B\x03\x02\x02\x02\u01BE\u108D\x03\x02\x02\x02\u01C0" + + "\u1093\x03\x02\x02\x02\u01C2\u10A1\x03\x02\x02\x02\u01C4\u10BD\x03\x02" + + "\x02\x02\u01C6\u10BF\x03\x02\x02\x02\u01C8\u10C7\x03\x02\x02\x02\u01CA" + + "\u10CD\x03\x02\x02\x02\u01CC\u10D5\x03\x02\x02\x02\u01CE\u10E1\x03\x02" + + "\x02\x02\u01D0\u10E3\x03\x02\x02\x02\u01D2\u115E\x03\x02\x02\x02\u01D4" + + "\u1160\x03\x02\x02\x02\u01D6\u1164\x03\x02\x02\x02\u01D8\u116C\x03\x02" + + "\x02\x02\u01DA\u1177\x03\x02\x02\x02\u01DC\u1179\x03\x02\x02\x02\u01DE" + + "\u117D\x03\x02\x02\x02\u01E0\u1185\x03\x02\x02\x02\u01E2\u1189\x03\x02" + + "\x02\x02\u01E4\u118B\x03\x02\x02\x02\u01E6\u11BE\x03\x02\x02\x02\u01E8" + + "\u11C0\x03\x02\x02\x02\u01EA\u11C4\x03\x02\x02\x02\u01EC\u11D6\x03\x02" + + "\x02\x02\u01EE\u11FD\x03\x02\x02\x02\u01F0\u11FF\x03\x02\x02\x02\u01F2" + + "\u1201\x03\x02\x02\x02\u01F4\u120A\x03\x02\x02\x02\u01F6\u120C\x03\x02" + + "\x02\x02\u01F8\u120E\x03\x02\x02\x02\u01FA\u1227\x03\x02\x02\x02\u01FC" + + "\u1229\x03\x02\x02\x02\u01FE\u123D\x03\x02\x02\x02\u0200\u1253\x03\x02" + + "\x02\x02\u0202\u1269\x03\x02\x02\x02\u0204\u126B\x03\x02\x02\x02\u0206" + + "\u1272\x03\x02\x02\x02\u0208\u12D3\x03\x02\x02\x02\u020A\u12EC\x03\x02" + + "\x02\x02\u020C\u12F3\x03\x02\x02\x02\u020E\u1304\x03\x02\x02\x02\u0210" + + "\u1306\x03\x02\x02\x02\u0212\u1308\x03\x02\x02\x02\u0214\u1310\x03\x02" + + "\x02\x02\u0216\u1316\x03\x02\x02\x02\u0218\u131A\x03\x02\x02\x02\u021A" + + "\u1322\x03\x02\x02\x02\u021C\u1331\x03\x02\x02\x02\u021E\u13C6\x03\x02" + + "\x02\x02\u0220\u13CA\x03\x02\x02\x02\u0222\u143B\x03\x02\x02\x02\u0224" + + "\u143D\x03\x02\x02\x02\u0226\u1442\x03\x02\x02\x02\u0228\u1448\x03\x02" + + "\x02\x02\u022A\u149F\x03\x02\x02\x02\u022C\u14A1\x03\x02\x02\x02\u022E" + + "\u14A3\x03\x02\x02\x02\u0230\u14A5\x03\x02\x02\x02\u0232\u14C3\x03\x02" + + "\x02\x02\u0234\u14D5\x03\x02\x02\x02\u0236\u14D7\x03\x02\x02\x02\u0238" + + "\u14DF\x03\x02\x02\x02\u023A\u14E1\x03\x02\x02\x02\u023C\u14F9\x03\x02" + + "\x02\x02\u023E\u1535\x03\x02\x02\x02\u0240\u1537\x03\x02\x02\x02\u0242" + + "\u1542\x03\x02\x02\x02\u0244\u1544\x03\x02\x02\x02\u0246\u1548\x03\x02" + + "\x02\x02\u0248\u1569\x03\x02\x02\x02\u024A\u156B\x03\x02\x02\x02\u024C" + + "\u156F\x03\x02\x02\x02\u024E\u1573\x03\x02\x02\x02\u0250\u157C\x03\x02" + + "\x02\x02\u0252\u1588\x03\x02\x02\x02\u0254\u15A8\x03\x02\x02\x02\u0256" + + "\u15AA\x03\x02\x02\x02\u0258\u15EB\x03\x02\x02\x02\u025A\u15ED\x03\x02" + + "\x02\x02\u025C\u15EF\x03\x02\x02\x02\u025E\u15F1\x03\x02\x02\x02\u0260" + + "\u15F3\x03\x02\x02\x02\u0262\u15F6\x03\x02\x02\x02\u0264\u1615\x03\x02" + + "\x02\x02\u0266\u1622\x03\x02\x02\x02\u0268\u1624\x03\x02\x02\x02\u026A" + + "\u1629\x03\x02\x02\x02\u026C\u1631\x03\x02\x02\x02\u026E\u1634\x03\x02" + + "\x02\x02\u0270\u1636\x03\x02\x02\x02\u0272\u163C\x03\x02\x02\x02\u0274" + + "\u163E\x03\x02\x02\x02\u0276\u1655\x03\x02\x02\x02\u0278\u1660\x03\x02" + + "\x02\x02\u027A\u1663\x03\x02\x02\x02\u027C\u1669\x03\x02\x02\x02\u027E" + + "\u1671\x03\x02\x02\x02\u0280\u1681\x03\x02\x02\x02\u0282\u1683\x03\x02" + + "\x02\x02\u0284\u1689\x03\x02\x02\x02\u0286\u169E\x03\x02\x02\x02\u0288" + + "\u16A7\x03\x02\x02\x02\u028A\u16A9\x03\x02\x02\x02\u028C\u16AB\x03\x02" + + "\x02\x02\u028E\u16B9\x03\x02\x02\x02\u0290\u16BB\x03\x02\x02\x02\u0292" + + "\u16C0\x03\x02\x02\x02\u0294\u16C2\x03\x02\x02\x02\u0296\u16D1\x03\x02" + + "\x02\x02\u0298\u16D9\x03\x02\x02\x02\u029A\u16DC\x03\x02\x02\x02\u029C" + + "\u16E5\x03\x02\x02\x02\u029E\u170C\x03\x02\x02\x02\u02A0\u1716\x03\x02" + + "\x02\x02\u02A2\u171D\x03\x02\x02\x02\u02A4\u171F\x03\x02\x02\x02\u02A6" + + "\u172B\x03\x02\x02\x02\u02A8\u172E\x03\x02\x02\x02\u02AA\u1731\x03\x02" + + "\x02\x02\u02AC\u1739\x03\x02\x02\x02\u02AE\u1741\x03\x02\x02\x02\u02B0" + + "\u1745\x03\x02\x02\x02\u02B2\u1771\x03\x02\x02\x02\u02B4\u1781\x03\x02" + + "\x02\x02\u02B6\u1791\x03\x02\x02\x02\u02B8\u17A9\x03\x02\x02\x02\u02BA" + + "\u17B0\x03\x02\x02\x02\u02BC\u17B5\x03\x02\x02\x02\u02BE\u17BD\x03\x02" + + "\x02\x02\u02C0\u17C0\x03\x02\x02\x02\u02C2\u17C4\x03\x02\x02\x02\u02C4" + + "\u17CB\x03\x02\x02\x02\u02C6\u17F2\x03\x02\x02\x02\u02C8\u17F8\x03\x02" + + "\x02\x02\u02CA\u17FA\x03\x02\x02\x02\u02CC\u1807\x03\x02\x02\x02\u02CE" + + "\u180A\x03\x02\x02\x02\u02D0\u1839\x03\x02\x02\x02\u02D2\u183B\x03\x02" + + "\x02\x02\u02D4\u1869\x03\x02\x02\x02\u02D6\u186B\x03\x02\x02\x02\u02D8" + + "\u186D\x03\x02\x02\x02\u02DA\u186F\x03\x02\x02\x02\u02DC\u1877\x03\x02" + + "\x02\x02\u02DE\u1885\x03\x02\x02\x02\u02E0\u1A6E\x03\x02\x02\x02\u02E2" + + "\u1A70\x03\x02\x02\x02\u02E4\u1A72\x03\x02\x02\x02\u02E6\u1ABA\x03\x02" + + "\x02\x02\u02E8\u1ABC\x03\x02\x02\x02\u02EA\u1B97\x03\x02\x02\x02\u02EC" + + "\u1B99\x03\x02\x02\x02\u02EE\u1BA1\x03\x02\x02\x02\u02F0\u1BB1\x03\x02" + + "\x02\x02\u02F2\u1BB8\x03\x02\x02\x02\u02F4\u1BBA\x03\x02\x02\x02\u02F6" + + "\u1C7B\x03\x02\x02\x02\u02F8\u1C7D\x03\x02\x02\x02\u02FA\u1C86\x03\x02" + + "\x02\x02\u02FC\u1C8E\x03\x02\x02\x02\u02FE\u1CAB\x03\x02\x02\x02\u0300" + + "\u1CAD\x03\x02\x02\x02\u0302\u1CB7\x03\x02\x02\x02\u0304\u1CBF\x03\x02" + + "\x02\x02\u0306\u1CE8\x03\x02\x02\x02\u0308\u1CF8\x03\x02\x02\x02\u030A" + + "\u1CFA\x03\x02\x02\x02\u030C\u1D14\x03\x02\x02\x02\u030E\u1D17\x03\x02" + + "\x02\x02\u0310\u1D27\x03\x02\x02\x02\u0312\u1D29\x03\x02\x02\x02\u0314" + + "\u1D2B\x03\x02\x02\x02\u0316\u1D2D\x03\x02\x02\x02\u0318\u1D2F\x03\x02" + + "\x02\x02\u031A\u1D34\x03\x02\x02\x02\u031C\u1D37\x03\x02\x02\x02\u031E" + + "\u1D3E\x03\x02\x02\x02\u0320\u1D85\x03\x02\x02\x02\u0322\u1D87\x03\x02" + + "\x02\x02\u0324\u1D93\x03\x02\x02\x02\u0326\u1D95\x03\x02\x02\x02\u0328" + + "\u1D9F\x03\x02\x02\x02\u032A\u1DA1\x03\x02\x02\x02\u032C\u1DA7\x03\x02" + + "\x02\x02\u032E\u1DC7\x03\x02\x02\x02\u0330\u1DCE\x03\x02\x02\x02\u0332" + + "\u1DD1\x03\x02\x02\x02\u0334\u1DDA\x03\x02\x02\x02\u0336\u1DDD\x03\x02" + + "\x02\x02\u0338\u1DE1\x03\x02\x02\x02\u033A\u1DF2\x03\x02\x02\x02\u033C" + + "\u1DF4\x03\x02\x02\x02\u033E\u1DF6\x03\x02\x02\x02\u0340\u1E05\x03\x02" + + "\x02\x02\u0342\u1E0A\x03\x02\x02\x02\u0344\u1E1A\x03\x02\x02\x02\u0346" + + "\u1E22\x03\x02\x02\x02\u0348\u1E24\x03\x02\x02\x02\u034A\u1E2A\x03\x02" + + "\x02\x02\u034C\u1E2F\x03\x02\x02\x02\u034E\u1E38\x03\x02\x02\x02\u0350" + + "\u1E53\x03\x02\x02\x02\u0352\u1E55\x03\x02\x02\x02\u0354\u1EA4\x03\x02" + + "\x02\x02\u0356\u1EA6\x03\x02\x02\x02\u0358\u1EA8\x03\x02\x02\x02\u035A" + + "\u1EC9\x03\x02\x02\x02\u035C\u1ECB\x03\x02\x02\x02\u035E\u1EE5\x03\x02" + + "\x02\x02\u0360\u1EF5\x03\x02\x02\x02\u0362\u1EF7\x03\x02\x02\x02\u0364" + + "\u1EFF\x03\x02\x02\x02\u0366\u1F01\x03\x02\x02\x02\u0368\u1F07\x03\x02" + + "\x02\x02\u036A\u1F0B\x03\x02\x02\x02\u036C\u1F0D\x03\x02\x02\x02\u036E" + + "\u1F0F\x03\x02\x02\x02\u0370\u1F11\x03\x02\x02\x02\u0372\u1F13\x03\x02" + + "\x02\x02\u0374\u1F15\x03\x02\x02\x02\u0376\u1F19\x03\x02\x02\x02\u0378" + + "\u1F1D\x03\x02\x02\x02\u037A\u1F25\x03\x02\x02\x02\u037C\u1F39\x03\x02" + + "\x02\x02\u037E\u1F44\x03\x02\x02\x02\u0380\u1F46\x03\x02\x02\x02\u0382" + + "\u1F4E\x03\x02\x02\x02\u0384\u1F54\x03\x02\x02\x02\u0386\u1F58\x03\x02" + + "\x02\x02\u0388\u1F5A\x03\x02\x02\x02\u038A\u1F62\x03\x02\x02\x02\u038C" + + "\u1F6A\x03\x02\x02\x02\u038E\u1F92\x03\x02\x02\x02\u0390\u1F94\x03\x02" + + "\x02\x02\u0392\u1FA2\x03\x02\x02\x02\u0394\u1FA5\x03\x02\x02\x02\u0396" + + "\u1FB1\x03\x02\x02\x02\u0398\u1FC9\x03\x02\x02\x02\u039A\u1FCB\x03\x02" + + "\x02\x02\u039C\u1FCD\x03\x02\x02\x02\u039E\u1FD5\x03\x02\x02\x02\u03A0" + + "\u1FD8\x03\x02\x02\x02\u03A2\u1FF0\x03\x02\x02\x02\u03A4\u1FF2\x03\x02" + + "\x02\x02\u03A6\u1FF6\x03\x02\x02\x02\u03A8\u2004\x03\x02\x02\x02\u03AA" + + "\u2007\x03\x02\x02\x02\u03AC\u2012\x03\x02\x02\x02\u03AE\u2022\x03\x02" + + "\x02\x02\u03B0\u2024\x03\x02\x02\x02\u03B2\u2029\x03\x02\x02\x02\u03B4" + + "\u202C\x03\x02\x02\x02\u03B6\u203B\x03\x02\x02\x02\u03B8\u204D\x03\x02" + + "\x02\x02\u03BA\u204F\x03\x02\x02\x02\u03BC\u2052\x03\x02\x02\x02\u03BE" + + "\u205A\x03\x02\x02\x02\u03C0\u2062\x03\x02\x02\x02\u03C2\u206B\x03\x02" + + "\x02\x02\u03C4\u2073\x03\x02\x02\x02\u03C6\u2077\x03\x02\x02\x02\u03C8" + + "\u2081\x03\x02\x02\x02\u03CA\u20A0\x03\x02\x02\x02\u03CC\u20A4\x03\x02" + + "\x02\x02\u03CE\u20D3\x03\x02\x02\x02\u03D0\u20E2\x03\x02\x02\x02\u03D2" + + "\u20E4\x03\x02\x02\x02\u03D4\u20E8\x03\x02\x02\x02\u03D6\u20EE\x03\x02" + + "\x02\x02\u03D8\u20F6\x03\x02\x02\x02\u03DA\u2105\x03\x02\x02\x02\u03DC" + + "\u2107\x03\x02\x02\x02\u03DE\u2109\x03\x02\x02\x02\u03E0\u2112\x03\x02" + + "\x02\x02\u03E2\u2124\x03\x02\x02\x02\u03E4\u2126\x03\x02\x02\x02\u03E6" + + "\u2128\x03\x02\x02\x02\u03E8\u212A\x03\x02\x02\x02\u03EA\u2132\x03\x02" + + "\x02\x02\u03EC\u2134\x03\x02\x02\x02\u03EE\u2136\x03\x02\x02\x02\u03F0" + + "\u213A\x03\x02\x02\x02\u03F2\u2142\x03\x02\x02\x02\u03F4\u2153\x03\x02" + + "\x02\x02\u03F6\u2155\x03\x02\x02\x02\u03F8\u216E\x03\x02\x02\x02\u03FA" + + "\u2170\x03\x02\x02\x02\u03FC\u2179\x03\x02\x02\x02\u03FE\u217B\x03\x02" + + "\x02\x02\u0400\u2182\x03\x02\x02\x02\u0402\u2186\x03\x02\x02\x02\u0404" + + "\u2188\x03\x02\x02\x02\u0406\u218A\x03\x02\x02\x02\u0408\u218C\x03\x02" + + "\x02\x02\u040A\u2190\x03\x02\x02\x02\u040C\u219D\x03\x02\x02\x02\u040E" + + "\u219F\x03\x02\x02\x02\u0410\u21A2\x03\x02\x02\x02\u0412\u21A7\x03\x02" + + "\x02\x02\u0414\u21AC\x03\x02\x02\x02\u0416\u21B2\x03\x02\x02\x02\u0418" + + "\u21B9\x03\x02\x02\x02\u041A\u21BB\x03\x02\x02\x02\u041C\u21BE\x03\x02" + + "\x02\x02\u041E\u21C2\x03\x02\x02\x02\u0420\u21C9\x03\x02\x02\x02\u0422" + + "\u21D5\x03\x02\x02\x02\u0424\u21D8\x03\x02\x02\x02\u0426\u21E6\x03\x02" + + "\x02\x02\u0428\u21E9\x03\x02\x02\x02\u042A\u222B\x03\x02\x02\x02\u042C" + + "\u2243\x03\x02\x02\x02\u042E\u224C\x03\x02\x02\x02\u0430\u225A\x03\x02" + + "\x02\x02\u0432\u225C\x03\x02\x02\x02\u0434\u2267\x03\x02\x02\x02\u0436" + + "\u2278\x03\x02\x02\x02\u0438\u227A\x03\x02\x02\x02\u043A\u2282\x03\x02" + + "\x02\x02\u043C\u2289\x03\x02\x02\x02\u043E\u2291\x03\x02\x02\x02\u0440" + + "\u22A2\x03\x02\x02\x02\u0442\u22A4\x03\x02\x02\x02\u0444\u22A8\x03\x02" + + "\x02\x02\u0446\u22B0\x03\x02\x02\x02\u0448\u22B5\x03\x02\x02\x02\u044A" + + "\u22B8\x03\x02\x02\x02\u044C\u22BB\x03\x02\x02\x02\u044E\u22C2\x03\x02" + + "\x02\x02\u0450\u22C4\x03\x02\x02\x02\u0452\u22CC\x03\x02\x02\x02\u0454" + + "\u22D1\x03\x02\x02\x02\u0456\u22E6\x03\x02\x02\x02\u0458\u22EE\x03\x02" + + "\x02\x02\u045A\u22F8\x03\x02\x02\x02\u045C\u2304\x03\x02\x02\x02\u045E" + + "\u2306\x03\x02\x02\x02\u0460\u2314\x03\x02\x02\x02\u0462\u2328\x03\x02" + + "\x02\x02\u0464\u2331\x03\x02\x02\x02\u0466\u2343\x03\x02\x02\x02\u0468" + + "\u2349\x03\x02\x02\x02\u046A\u234B\x03\x02\x02\x02\u046C\u2352\x03\x02" + + "\x02\x02\u046E\u236E\x03\x02\x02\x02\u0470\u2370\x03\x02\x02\x02\u0472" + + "\u2376\x03\x02\x02\x02\u0474\u237A\x03\x02\x02\x02\u0476\u237C\x03\x02" + + "\x02\x02\u0478\u2384\x03\x02\x02\x02\u047A\u2388\x03\x02\x02\x02\u047C" + + "\u238F\x03\x02\x02\x02\u047E\u23A0\x03\x02\x02\x02\u0480\u23A2\x03\x02" + + "\x02\x02\u0482\u23A4\x03\x02\x02\x02\u0484\u23AE\x03\x02\x02\x02\u0486" + + "\u23B6\x03\x02\x02\x02\u0488\u23D1\x03\x02\x02\x02\u048A\u23D3\x03\x02" + + "\x02\x02\u048C\u23DA\x03\x02\x02\x02\u048E\u23DD\x03\x02\x02\x02\u0490" + + "\u23DF\x03\x02\x02\x02\u0492\u23E3\x03\x02\x02\x02\u0494\u23EB\x03\x02" + + "\x02\x02\u0496\u23F3\x03\x02\x02\x02\u0498\u23FB\x03\x02\x02\x02\u049A" + + "\u2404\x03\x02\x02\x02\u049C\u2408\x03\x02\x02\x02\u049E\u240C\x03\x02" + + "\x02\x02\u04A0\u2426\x03\x02\x02\x02\u04A2\u2434\x03\x02\x02\x02\u04A4" + + "\u2448\x03\x02\x02\x02\u04A6\u2452\x03\x02\x02\x02\u04A8\u2456\x03\x02" + + "\x02\x02\u04AA\u245E\x03\x02\x02\x02\u04AC\u2466\x03\x02\x02\x02\u04AE" + + "\u246C\x03\x02\x02\x02\u04B0\u2470\x03\x02\x02\x02\u04B2\u2477\x03\x02" + + "\x02\x02\u04B4\u247C\x03\x02\x02\x02\u04B6\u248B\x03\x02\x02\x02\u04B8" + + "\u24DB\x03\x02\x02\x02\u04BA\u24DD\x03\x02\x02\x02\u04BC\u24DF\x03\x02" + + "\x02\x02\u04BE\u2505\x03\x02\x02\x02\u04C0\u2509\x03\x02\x02\x02\u04C2" + + "\u25C3\x03\x02\x02\x02\u04C4\u25CA\x03\x02\x02\x02\u04C6\u25D6\x03\x02" + + "\x02\x02\u04C8\u25D8\x03\x02\x02\x02\u04CA\u25DD\x03\x02\x02\x02\u04CC" + + "\u25E5\x03\x02\x02\x02\u04CE\u25EA\x03\x02\x02\x02\u04D0\u25F0\x03\x02" + + "\x02\x02\u04D2\u2601\x03\x02\x02\x02\u04D4\u2603\x03\x02\x02\x02\u04D6" + + "\u2606\x03\x02\x02\x02\u04D8\u260C\x03\x02\x02\x02\u04DA\u2612\x03\x02" + + "\x02\x02\u04DC\u2615\x03\x02\x02\x02\u04DE\u261D\x03\x02\x02\x02\u04E0" + + "\u2621\x03\x02\x02\x02\u04E2\u2626\x03\x02\x02\x02\u04E4\u2635\x03\x02" + + "\x02\x02\u04E6\u2637\x03\x02\x02\x02\u04E8\u264A\x03\x02\x02\x02\u04EA" + + "\u2652\x03\x02\x02\x02\u04EC\u265B\x03\x02\x02\x02\u04EE\u265D\x03\x02" + + "\x02\x02\u04F0\u2672\x03\x02\x02\x02\u04F2\u2674\x03\x02\x02\x02\u04F4" + + "\u267B\x03\x02\x02\x02\u04F6\u2681\x03\x02\x02\x02\u04F8\u2685\x03\x02" + + "\x02\x02\u04FA\u2687\x03\x02\x02\x02\u04FC\u268F\x03\x02\x02\x02\u04FE" + + "\u2697\x03\x02\x02\x02\u0500\u26A5\x03\x02\x02\x02\u0502\u26A7\x03\x02" + + "\x02\x02\u0504\u26AF\x03\x02\x02\x02\u0506\u26BC\x03\x02\x02\x02\u0508" + + "\u26BE\x03\x02\x02\x02\u050A\u26C6\x03\x02\x02\x02\u050C\u26CD\x03\x02" + + "\x02\x02\u050E\u26D5\x03\x02\x02\x02\u0510\u26E1\x03\x02\x02\x02\u0512" + + "\u26E3\x03\x02\x02\x02\u0514\u26E5\x03\x02\x02\x02\u0516\u26EE\x03\x02" + + "\x02\x02\u0518\u270D\x03\x02\x02\x02\u051A\u2716\x03\x02\x02\x02\u051C" + + "\u271D\x03\x02\x02\x02\u051E\u271F\x03\x02\x02\x02\u0520\u272A\x03\x02" + + "\x02\x02\u0522\u272E\x03\x02\x02\x02\u0524\u2733\x03\x02\x02\x02\u0526" + + "\u2736\x03\x02\x02\x02\u0528\u2738\x03\x02\x02\x02\u052A\u274D\x03\x02" + + "\x02\x02\u052C\u274F\x03\x02\x02\x02\u052E\u2752\x03\x02\x02\x02\u0530" + + "\u2759\x03\x02\x02\x02\u0532\u275C\x03\x02\x02\x02\u0534\u275E\x03\x02" + + "\x02\x02\u0536\u276E\x03\x02\x02\x02\u0538\u2770\x03\x02\x02\x02\u053A" + + "\u2778\x03\x02\x02\x02\u053C\u277C\x03\x02\x02\x02\u053E\u2780\x03\x02" + + "\x02\x02\u0540\u2788\x03\x02\x02\x02\u0542\u278A\x03\x02\x02\x02\u0544" + + "\u278C\x03\x02\x02\x02\u0546\u2792\x03\x02\x02\x02\u0548\u27B7\x03\x02" + + "\x02\x02\u054A\u27B9\x03\x02\x02\x02\u054C\u27BB\x03\x02\x02\x02\u054E" + + "\u27BD\x03\x02\x02\x02\u0550\u27BF\x03\x02\x02\x02\u0552\u27C1\x03\x02" + + "\x02\x02\u0554\u27D0\x03\x02\x02\x02\u0556\u27D2\x03\x02\x02\x02\u0558" + + "\u27DA\x03\x02\x02\x02\u055A\u27DC\x03\x02\x02\x02\u055C\u27DE\x03\x02" + + "\x02\x02\u055E\u27E4\x03\x02\x02\x02\u0560\u27E6\x03\x02\x02\x02\u0562" + + "\u27F2\x03\x02\x02\x02\u0564\u27F4\x03\x02\x02\x02\u0566\u2802\x03\x02" + + "\x02\x02\u0568\u2806\x03\x02\x02\x02\u056A\u280B\x03\x02\x02\x02\u056C" + + "\u2812\x03\x02\x02\x02\u056E\u2818\x03\x02\x02\x02\u0570\u2820\x03\x02" + + "\x02\x02\u0572\u282B\x03\x02\x02\x02\u0574\u282D\x03\x02\x02\x02\u0576" + + "\u282F\x03\x02\x02\x02\u0578\u2864\x03\x02\x02\x02\u057A\u2866\x03\x02" + + "\x02\x02\u057C\u2868\x03\x02\x02\x02\u057E\u286A\x03\x02\x02\x02\u0580" + + "\u2871\x03\x02\x02\x02\u0582\u2888\x03\x02\x02\x02\u0584\u288A\x03\x02" + + "\x02\x02\u0586\u2890\x03\x02\x02\x02\u0588\u2894\x03\x02\x02\x02\u058A" + + "\u2896\x03\x02\x02\x02\u058C\u289D\x03\x02\x02\x02\u058E\u28A4\x03\x02" + + "\x02\x02\u0590\u28A7\x03\x02\x02\x02\u0592\u28AB\x03\x02\x02\x02\u0594" + + "\u28B2\x03\x02\x02\x02\u0596\u28B4\x03\x02\x02\x02\u0598\u28CC\x03\x02" + + "\x02\x02\u059A\u28CE\x03\x02\x02\x02\u059C\u28D5\x03\x02\x02\x02\u059E" + + "\u28D7\x03\x02\x02\x02\u05A0\u28DF\x03\x02\x02\x02\u05A2\u28E2\x03\x02" + + "\x02\x02\u05A4"; private static readonly _serializedATNSegment6: string = - "\u2A5E\x03\x02\x02\x02\u0614\u2A60\x03\x02\x02\x02\u0616\u2A67\x03\x02" + - "\x02\x02\u0618\u2A6B\x03\x02\x02\x02\u061A\u2A6E\x03\x02\x02\x02\u061C" + - "\u2A74\x03\x02\x02\x02\u061E\u2A7A\x03\x02\x02\x02\u0620\u2A8C\x03\x02" + - "\x02\x02\u0622\u2A90\x03\x02\x02\x02\u0624\u2A95\x03\x02\x02\x02\u0626" + - "\u2A98\x03\x02\x02\x02\u0628\u2A9C\x03\x02\x02\x02\u062A\u2AA1\x03\x02" + - "\x02\x02\u062C\u2AAC\x03\x02\x02\x02\u062E\u2AB0\x03\x02\x02\x02\u0630" + - "\u2AB4\x03\x02\x02\x02\u0632\u2AB8\x03\x02\x02\x02\u0634\u2ABA\x03\x02" + - "\x02\x02\u0636\u2ABF\x03\x02\x02\x02\u0638\u2AC1\x03\x02\x02\x02\u063A" + - "\u2AC4\x03\x02\x02\x02\u063C\u2AD8\x03\x02\x02\x02\u063E\u2ADA\x03\x02" + - "\x02\x02\u0640\u2ADC\x03\x02\x02\x02\u0642\u2ADE\x03\x02\x02\x02\u0644" + - "\u2AE0\x03\x02\x02\x02\u0646\u2AE4\x03\x02\x02\x02\u0648\u0649\x05\x06" + - "\x04\x02\u0649\x03\x03\x02\x02\x02\u064A\u064B\x05\u0564\u02B3\x02\u064B" + - "\x05\x03\x02\x02\x02\u064C\u064E\x05\b\x05\x02\u064D\u064F\x07\t\x02\x02" + - "\u064E\u064D\x03\x02\x02\x02\u064E\u064F\x03\x02\x02\x02\u064F\u0651\x03" + - "\x02\x02\x02\u0650\u064C\x03\x02\x02\x02\u0651\u0654\x03\x02\x02\x02\u0652" + - "\u0650\x03\x02\x02\x02\u0652\u0653\x03\x02\x02\x02\u0653\x07\x03\x02\x02" + - "\x02\u0654\u0652\x03\x02\x02\x02\u0655\u06D2\x05\u01C4\xE3\x02\u0656\u06D2" + - "\x05\u033A\u019E\x02\u0657\u06D2\x05\u0330\u0199\x02\u0658\u06D2\x05\u0332" + - "\u019A\x02\u0659\u06D2\x05\u0242\u0122\x02\u065A\u06D2\x05\u0340\u01A1" + - "\x02\u065B\u06D2\x05\u01DE\xF0\x02\u065C\u06D2\x05\u0142\xA2\x02\u065D" + - "\u06D2\x05\u0148\xA5\x02\u065E\u06D2\x05\u0152\xAA\x02\u065F\u06D2\x05" + - "\u016C\xB7\x02\u0660\u06D2\x05\u029E\u0150\x02\u0661\u06D2\x05&\x14\x02" + - "\u0662\u06D2\x05\u02D8\u016D\x02\u0663\u06D2\x05\u02DC\u016F\x02\u0664" + - "\u06D2\x05\u02E8\u0175\x02\u0665\u06D2\x05\u02DE\u0170\x02\u0666\u06D2" + - "\x05\u02E6\u0174\x02\u0667\u06D2\x05\u0180\xC1\x02\u0668\u06D2\x05\u0118" + - "\x8D\x02\u0669\u06D2\x05\u033C\u019F\x02\u066A\u06D2\x05`1\x02\u066B\u06D2" + - "\x05\u02D0\u0169\x02\u066C\u06D2\x05\x86D\x02\u066D\u06D2\x05\u02F0\u0179" + - "\x02\u066E\u06D2\x05 \x11\x02\u066F\u06D2\x05\x1C\x0F\x02\u0670\u06D2" + - "\x05\u02F8\u017D\x02\u0671\u06D2\x05\u0106\x84\x02\u0672\u06D2\x05\u0346" + - "\u01A4\x02\u0673\u06D2\x05\u0344\u01A3\x02\u0674\u06D2\x05\u017C\xBF\x02" + - "\u0675\u06D2\x05\u0352\u01AA\x02\u0676\u06D2\x05\f\x07\x02\u0677\u06D2" + - "\x05\\/\x02\u0678\u06D2\x05\x8CG\x02\u0679\u06D2\x05\u034C\u01A7\x02\u067A" + - "\u06D2\x05\u0216\u010C\x02\u067B\u06D2\x05V,\x02\u067C\u06D2\x05\x8EH" + - "\x02\u067D\u06D2\x05\u0190\xC9\x02\u067E\u06D2\x05\u0108\x85\x02\u067F" + - "\u06D2\x05\u01C8\xE5\x02\u0680\u06D2\x05\u02B8\u015D\x02\u0681\u06D2\x05" + - "\u034A\u01A6\x02\u0682\u06D2\x05\u033E\u01A0\x02\u0683\u06D2\x05\u013C" + - "\x9F\x02\u0684\u06D2\x05\u014A\xA6\x02\u0685\u06D2\x05\u0164\xB3\x02\u0686" + - "\u06D2\x05\u016E\xB8\x02\u0687\u06D2\x05\u0268\u0135\x02\u0688\u06D2\x05" + - "$\x13\x02\u0689\u06D2\x05\u010E\x88\x02\u068A\u06D2\x05\u01E2\xF2\x02" + - "\u068B\u06D2\x05\u01F0\xF9\x02\u068C\u06D2\x05\u02EA\u0176\x02\u068D\u06D2" + - "\x05\u01F2\xFA\x02\u068E\u06D2\x05\u017E\xC0\x02\u068F\u06D2\x05\u0128" + - "\x95\x02\u0690\u06D2\x05*\x16\x02\u0691\u06D2\x05\u0116\x8C\x02\u0692" + - "\u06D2\x05\xACW\x02\u0693\u06D2\x05\u02F2\u017A\x02\u0694\u06D2\x05\u0104" + - "\x83\x02\u0695\u06D2\x05\u0136\x9C\x02\u0696\u06D2\x05\u02C0\u0161\x02" + - "\u0697\u06D2\x05\u0194\xCB\x02\u0698\u06D2\x05\u01BC\xDF\x02\u0699\u06D2" + - "\x05\x0E\b\x02\u069A\u06D2\x05\x1A\x0E\x02\u069B\u06D2\x05\u0176\xBC\x02" + - "\u069C\u06D2\x05\u0324\u0193\x02\u069D\u06D2\x05\u0384\u01C3\x02\u069E" + - "\u06D2\x05\u03B0\u01D9\x02\u069F\u06D2\x05\u01CA\xE6\x02\u06A0\u06D2\x05" + - "\u0398\u01CD\x02\u06A1\u06D2\x05^0\x02\u06A2\u06D2\x05\u02B2\u015A\x02" + - "\u06A3\u06D2\x05\u02BC\u015F\x02\u06A4\u06D2\x05\u01F8\xFD\x02\u06A5\u06D2" + - "\x05\u01FA\xFE\x02\u06A6\u06D2\x05\u01FC\xFF\x02\u06A7\u06D2\x05\u0200" + - "\u0101\x02\u06A8\u06D2\x05\u02FA\u017E\x02\u06A9\u06D2\x05\u013A\x9E\x02" + - "\u06AA\u06D2\x05\u02C4\u0163\x02\u06AB\u06D2\x05\"\x12\x02\u06AC\u06D2" + - "\x05\u017A\xBE\x02\u06AD\u06D2\x05\u0334\u019B\x02\u06AE\u06D2\x05\u0380" + - "\u01C1\x02\u06AF\u06D2\x05\u036E\u01B8\x02\u06B0\u06D2\x05\u0220\u0111" + - "\x02\u06B1\u06D2\x05\u0228\u0115\x02\u06B2\u06D2\x05\u023A\u011E\x02\u06B3" + - "\u06D2\x05\u0170\xB9\x02\u06B4\u06D2\x05\u024C\u0127\x02\u06B5\u06D2\x05" + - "\u0386\u01C4\x02\u06B6\u06D2\x05\u030E\u0188\x02\u06B7\u06D2\x05\u0114" + - "\x8B\x02\u06B8\u06D2\x05\u0322\u0192\x02\u06B9\u06D2\x05\u039C\u01CF\x02" + - "\u06BA\u06D2\x05\u030A\u0186\x02\u06BB\u06D2\x05\u037A\u01BE\x02\u06BC" + - "\u06D2\x05\u01FE\u0100\x02\u06BD\u06D2\x05\u02C6\u0164\x02\u06BE\u06D2" + - "\x05\u02A6\u0154\x02\u06BF\u06D2\x05\u02A4\u0153\x02\u06C0\u06D2\x05\u02A8" + - "\u0155\x02\u06C1\u06D2\x05\u02D2\u016A\x02\u06C2\u06D2\x05\u022A\u0116" + - "\x02\u06C3\u06D2\x05\u023C\u011F\x02\u06C4\u06D2\x05\u02FC\u017F\x02\u06C5" + - "\u06D2\x05\u021A\u010E\x02\u06C6\u06D2\x05\u03B8\u01DD\x02\u06C7\u06D2" + - "\x05\u0312\u018A\x02\u06C8\u06D2\x05\u0212\u010A\x02\u06C9\u06D2\x05\u0310" + - "\u0189\x02\u06CA\u06D2\x05\u03A6\u01D4\x02\u06CB\u06D2\x05\u0350\u01A9" + - "\x02\u06CC\u06D2\x05J&\x02\u06CD\u06D2\x052\x1A\x02\u06CE\u06D2\x05T+" + - "\x02\u06CF\u06D2\x05\u031E\u0190\x02\u06D0\u06D2\x05\n\x06\x02\u06D1\u0655" + - "\x03\x02\x02\x02\u06D1\u0656\x03\x02\x02\x02\u06D1\u0657\x03\x02\x02\x02" + - "\u06D1\u0658\x03\x02\x02\x02\u06D1\u0659\x03\x02\x02\x02\u06D1\u065A\x03" + - "\x02\x02\x02\u06D1\u065B\x03\x02\x02\x02\u06D1\u065C\x03\x02\x02\x02\u06D1" + - "\u065D\x03\x02\x02\x02\u06D1\u065E\x03\x02\x02\x02\u06D1\u065F\x03\x02" + - "\x02\x02\u06D1\u0660\x03\x02\x02\x02\u06D1\u0661\x03\x02\x02\x02\u06D1" + - "\u0662\x03\x02\x02\x02\u06D1\u0663\x03\x02\x02\x02\u06D1\u0664\x03\x02" + - "\x02\x02\u06D1\u0665\x03\x02\x02\x02\u06D1\u0666\x03\x02\x02\x02\u06D1" + - "\u0667\x03\x02\x02\x02\u06D1\u0668\x03\x02\x02\x02\u06D1\u0669\x03\x02" + - "\x02\x02\u06D1\u066A\x03\x02\x02\x02\u06D1\u066B\x03\x02\x02\x02\u06D1" + - "\u066C\x03\x02\x02\x02\u06D1\u066D\x03\x02\x02\x02\u06D1\u066E\x03\x02" + - "\x02\x02\u06D1\u066F\x03\x02\x02\x02\u06D1\u0670\x03\x02\x02\x02\u06D1" + - "\u0671\x03\x02\x02\x02\u06D1\u0672\x03\x02\x02\x02\u06D1\u0673\x03\x02" + - "\x02\x02\u06D1\u0674\x03\x02\x02\x02\u06D1\u0675\x03\x02\x02\x02\u06D1" + - "\u0676\x03\x02\x02\x02\u06D1\u0677\x03\x02\x02\x02\u06D1\u0678\x03\x02" + - "\x02\x02\u06D1\u0679\x03\x02\x02\x02\u06D1\u067A\x03\x02\x02\x02\u06D1" + - "\u067B\x03\x02\x02\x02\u06D1\u067C\x03\x02\x02\x02\u06D1\u067D\x03\x02" + - "\x02\x02\u06D1\u067E\x03\x02\x02\x02\u06D1\u067F\x03\x02\x02\x02\u06D1" + - "\u0680\x03\x02\x02\x02\u06D1\u0681\x03\x02\x02\x02\u06D1\u0682\x03\x02" + - "\x02\x02\u06D1\u0683\x03\x02\x02\x02\u06D1\u0684\x03\x02\x02\x02\u06D1" + - "\u0685\x03\x02\x02\x02\u06D1\u0686\x03\x02\x02\x02\u06D1\u0687\x03\x02" + - "\x02\x02\u06D1\u0688\x03\x02\x02\x02\u06D1\u0689\x03\x02\x02\x02\u06D1" + - "\u068A\x03\x02\x02\x02\u06D1\u068B\x03\x02\x02\x02\u06D1\u068C\x03\x02" + - "\x02\x02\u06D1\u068D\x03\x02\x02\x02\u06D1\u068E\x03\x02\x02\x02\u06D1" + - "\u068F\x03\x02\x02\x02\u06D1\u0690\x03\x02\x02\x02\u06D1\u0691\x03\x02" + - "\x02\x02\u06D1\u0692\x03\x02\x02\x02\u06D1\u0693\x03\x02\x02\x02\u06D1" + - "\u0694\x03\x02\x02\x02\u06D1\u0695\x03\x02\x02\x02\u06D1\u0696\x03\x02" + - "\x02\x02\u06D1\u0697\x03\x02\x02\x02\u06D1\u0698\x03\x02\x02\x02\u06D1" + - "\u0699\x03\x02\x02\x02\u06D1\u069A\x03\x02\x02\x02\u06D1\u069B\x03\x02" + - "\x02\x02\u06D1\u069C\x03\x02\x02\x02\u06D1\u069D\x03\x02\x02\x02\u06D1" + - "\u069E\x03\x02\x02\x02\u06D1\u069F\x03\x02\x02\x02\u06D1\u06A0\x03\x02" + - "\x02\x02\u06D1\u06A1\x03\x02\x02\x02\u06D1\u06A2\x03\x02\x02\x02\u06D1" + - "\u06A3\x03\x02\x02\x02\u06D1\u06A4\x03\x02\x02\x02\u06D1\u06A5\x03\x02" + - "\x02\x02\u06D1\u06A6\x03\x02\x02\x02\u06D1\u06A7\x03\x02\x02\x02\u06D1" + - "\u06A8\x03\x02\x02\x02\u06D1\u06A9\x03\x02\x02\x02\u06D1\u06AA\x03\x02" + - "\x02\x02\u06D1\u06AB\x03\x02\x02\x02\u06D1\u06AC\x03\x02\x02\x02\u06D1" + - "\u06AD\x03\x02\x02\x02\u06D1\u06AE\x03\x02\x02\x02\u06D1\u06AF\x03\x02" + - "\x02\x02\u06D1\u06B0\x03\x02\x02\x02\u06D1\u06B1\x03\x02\x02\x02\u06D1" + - "\u06B2\x03\x02\x02\x02\u06D1\u06B3\x03\x02\x02\x02\u06D1\u06B4\x03\x02" + - "\x02\x02\u06D1\u06B5\x03\x02\x02\x02\u06D1\u06B6\x03\x02\x02\x02\u06D1" + - "\u06B7\x03\x02\x02\x02\u06D1\u06B8\x03\x02\x02\x02\u06D1\u06B9\x03\x02" + - "\x02\x02\u06D1\u06BA\x03\x02\x02\x02\u06D1\u06BB\x03\x02\x02\x02\u06D1" + - "\u06BC\x03\x02\x02\x02\u06D1\u06BD\x03\x02\x02\x02\u06D1\u06BE\x03\x02" + - "\x02\x02\u06D1\u06BF\x03\x02\x02\x02\u06D1\u06C0\x03\x02\x02\x02\u06D1" + - "\u06C1\x03\x02\x02\x02\u06D1\u06C2\x03\x02\x02\x02\u06D1\u06C3\x03\x02" + - "\x02\x02\u06D1\u06C4\x03\x02\x02\x02\u06D1\u06C5\x03\x02\x02\x02\u06D1" + - "\u06C6\x03\x02\x02\x02\u06D1\u06C7\x03\x02\x02\x02\u06D1\u06C8\x03\x02" + - "\x02\x02\u06D1\u06C9\x03\x02\x02\x02\u06D1\u06CA\x03\x02\x02\x02\u06D1" + - "\u06CB\x03\x02\x02\x02\u06D1\u06CC\x03\x02\x02\x02\u06D1\u06CD\x03\x02" + - "\x02\x02\u06D1\u06CE\x03\x02\x02\x02\u06D1\u06CF\x03\x02\x02\x02\u06D1" + - "\u06D0\x03\x02\x02\x02\u06D2\t\x03\x02\x02\x02\u06D3\u06D5\x07\u0222\x02" + - "\x02\u06D4\u06D6\x07\u0223\x02\x02\u06D5\u06D4\x03\x02\x02\x02\u06D5\u06D6" + - "\x03\x02\x02\x02\u06D6\v\x03\x02\x02\x02\u06D7\u06D8\x07\u01AA\x02\x02" + - "\u06D8\u06D9\x05\u04AE\u0258\x02\u06D9\r\x03\x02\x02\x02\u06DA\u06DB\x07" + - "0\x02\x02\u06DB\u06DC\x07\u0137\x02\x02\u06DC\u06DE\x05\u054A\u02A6\x02" + - "\u06DD\u06DF\x05\x10\t\x02\u06DE\u06DD\x03\x02\x02\x02\u06DE\u06DF\x03" + - "\x02\x02\x02\u06DF\u06E0\x03\x02\x02\x02\u06E0\u06E1\x05\x12\n\x02\u06E1" + - "\x0F\x03\x02\x02\x02\u06E2\u06E3\x07k\x02\x02\u06E3\x11\x03\x02\x02\x02" + - "\u06E4\u06E6\x05\x18\r\x02\u06E5\u06E4\x03\x02\x02\x02\u06E6\u06E9\x03" + - "\x02\x02\x02\u06E7\u06E5\x03\x02\x02\x02\u06E7\u06E8\x03\x02\x02\x02\u06E8" + - "\x13\x03\x02\x02\x02\u06E9\u06E7\x03\x02\x02\x02\u06EA\u06EC\x05\x16\f" + - "\x02\u06EB\u06EA\x03\x02\x02\x02\u06EC\u06EF\x03\x02\x02\x02\u06ED\u06EB" + - "\x03\x02\x02\x02\u06ED\u06EE\x03\x02\x02\x02\u06EE\x15\x03\x02\x02\x02" + - "\u06EF\u06ED\x03\x02\x02\x02\u06F0\u06F3\x07\u0118\x02\x02\u06F1\u06F4" + - "\x05\u0542\u02A2\x02\u06F2\u06F4\x07P\x02\x02\u06F3\u06F1\x03\x02\x02" + - "\x02\u06F3\u06F2\x03\x02\x02\x02\u06F4\u0703\x03\x02\x02\x02\u06F5\u06F6" + - "\t\x02\x02\x02\u06F6\u06F7\x07\u0118\x02\x02\u06F7\u0703\x05\u0542\u02A2" + - "\x02\u06F8\u0703\x07\xE6\x02\x02\u06F9\u06FA\x07\xA6\x02\x02\u06FA\u06FB" + - "\x07L\x02\x02\u06FB\u0703\x05\u0548\u02A5\x02\u06FC\u06FD\x07\u016C\x02" + - "\x02\u06FD\u06FE\x07\u0169\x02\x02\u06FE\u0703\x05\u0542\u02A2\x02\u06FF" + - "\u0700\x07e\x02\x02\u0700\u0703\x05\u054E\u02A8\x02\u0701\u0703\x05\u0558" + - "\u02AD\x02\u0702\u06F0\x03\x02\x02\x02\u0702\u06F5\x03\x02\x02\x02\u0702" + - "\u06F8\x03\x02\x02\x02\u0702\u06F9\x03\x02\x02\x02\u0702\u06FC\x03\x02" + - "\x02\x02\u0702\u06FF\x03\x02\x02\x02\u0702\u0701\x03\x02\x02\x02\u0703" + - "\x17\x03\x02\x02\x02\u0704\u070F\x05\x16\f\x02\u0705\u0706\x07\u0155\x02" + - "\x02\u0706\u070F\x05\u0540\u02A1\x02\u0707\u0708\x07\x88\x02\x02\u0708" + - "\u070F\x05\u054E\u02A8\x02\u0709\u070A\x07\u0137\x02\x02\u070A\u070F\x05" + - "\u054E\u02A8\x02\u070B\u070C\x07F\x02\x02\u070C\u070D\t\x03\x02\x02\u070D" + - "\u070F\x05\u054E\u02A8\x02\u070E\u0704\x03\x02\x02\x02\u070E\u0705\x03" + - "\x02\x02\x02\u070E\u0707\x03\x02\x02\x02\u070E\u0709\x03\x02\x02\x02\u070E" + - "\u070B\x03\x02\x02\x02\u070F\x19\x03\x02\x02\x02\u0710\u0711\x070\x02" + - "\x02\u0711\u0712\x07e\x02\x02\u0712\u0714\x05\u054A\u02A6\x02\u0713\u0715" + - "\x05\x10\t\x02\u0714\u0713\x03\x02\x02\x02\u0714\u0715\x03\x02\x02\x02" + - "\u0715\u0716\x03\x02\x02\x02\u0716\u0717\x05\x12\n\x02\u0717\x1B\x03\x02" + - "\x02\x02\u0718\u0719\x07\x8C\x02\x02\u0719\u071A\t\x04\x02\x02\u071A\u071C" + - "\x05\u054C\u02A7\x02\u071B\u071D\x05\x10\t\x02\u071C\u071B\x03\x02\x02" + - "\x02\u071C\u071D\x03\x02\x02\x02\u071D\u071E\x03\x02\x02\x02\u071E\u071F" + - "\x05\x14\v\x02\u071F\x1D\x03\x02\x02\x02\u0720\u0725\x03\x02\x02\x02\u0721" + - "\u0722\x07F\x02\x02\u0722\u0723\x07\xB1\x02\x02\u0723\u0725\x05\u0530" + - "\u0299\x02\u0724\u0720\x03\x02\x02\x02\u0724\u0721\x03\x02\x02\x02\u0725" + - "\x1F\x03\x02\x02\x02\u0726\u0727\x07\x8C\x02\x02\u0727\u0729\t\x04\x02" + - "\x02\u0728\u072A\x07 \x02\x02\u0729\u0728\x03\x02\x02\x02\u0729\u072A" + - "\x03\x02\x02\x02\u072A\u072B\x03\x02\x02\x02\u072B\u072C\x05\u054C\u02A7" + - "\x02\u072C\u072D\x05\x1E\x10\x02\u072D\u072E\x05P)\x02\u072E!\x03\x02" + - "\x02\x02\u072F\u0730\x07\xC1\x02\x02\u0730\u0733\t\x05\x02\x02\u0731\u0732" + - "\x07\xDE\x02\x02\u0732\u0734\x07\u0185\x02\x02\u0733\u0731\x03\x02\x02" + - "\x02\u0733\u0734\x03\x02\x02\x02\u0734\u0735\x03\x02\x02\x02\u0735\u0736" + - "\x05\u054E\u02A8\x02\u0736#\x03\x02\x02\x02\u0737\u0738\x070\x02\x02\u0738" + - "\u0739\x07D\x02\x02\u0739\u073B\x05\u054A\u02A6\x02\u073A\u073C\x05\x10" + - "\t\x02\u073B\u073A\x03\x02\x02\x02\u073B\u073C\x03\x02\x02\x02\u073C\u073D" + - "\x03\x02\x02\x02\u073D\u073E\x05\x12\n\x02\u073E%\x03\x02\x02\x02\u073F" + - "\u0740\x07\x8C\x02\x02\u0740\u0741\x07D\x02\x02\u0741\u0742\x05\u054C" + - "\u02A7\x02\u0742\u0743\x05(\x15\x02\u0743\u0744\x07e\x02\x02\u0744\u0745" + - "\x05\u054E\u02A8\x02\u0745\'\x03\x02\x02\x02\u0746\u0747\t\x06\x02\x02" + - "\u0747)\x03\x02\x02\x02\u0748\u0749\x070\x02\x02\u0749\u074D\x07\u013C" + - "\x02\x02\u074A\u074B\x07\xDE\x02\x02\u074B\u074C\x07O\x02\x02\u074C\u074E" + - "\x07\u0185\x02\x02\u074D\u074A\x03\x02\x02\x02\u074D\u074E\x03\x02\x02" + - "\x02\u074E\u0755\x03\x02\x02\x02\u074F\u0751\x05,\x17\x02\u0750\u074F" + - "\x03\x02\x02\x02\u0750\u0751\x03\x02\x02\x02\u0751\u0752\x03\x02\x02\x02" + - "\u0752\u0753\x07l\x02\x02\u0753\u0756\x05\u054C\u02A7\x02\u0754\u0756" + - "\x05\u0550\u02A9\x02\u0755\u0750\x03\x02\x02\x02\u0755\u0754\x03\x02\x02" + - "\x02\u0756\u0757\x03\x02\x02\x02\u0757\u0758\x05.\x18\x02\u0758+\x03\x02" + - "\x02\x02\u0759\u075A\x05\u0550\u02A9\x02\u075A-\x03\x02\x02\x02\u075B" + - "\u075D\x050\x19\x02\u075C\u075B\x03\x02\x02\x02\u075D\u0760\x03\x02\x02" + - "\x02\u075E\u075C\x03\x02\x02\x02\u075E\u075F\x03\x02\x02\x02\u075F/\x03" + - "\x02\x02\x02\u0760\u075E\x03\x02\x02\x02\u0761\u0768\x05\xACW\x02\u0762" + - "\u0768\x05\u024C\u0127\x02\u0763\u0768\x05\u0116\x8C\x02\u0764\u0768\x05" + - "\u0194\xCB\x02\u0765\u0768\x05\u0228\u0115\x02\u0766\u0768\x05\u031E\u0190" + - "\x02\u0767\u0761\x03\x02\x02\x02\u0767\u0762\x03\x02\x02\x02\u0767\u0763" + - "\x03\x02\x02\x02\u0767\u0764\x03\x02\x02\x02\u0767\u0765\x03\x02\x02\x02" + - "\u0767\u0766\x03\x02\x02\x02\u07681\x03\x02\x02\x02\u0769\u076B\x07\u0146" + - "\x02\x02\u076A\u076C\t\x07\x02\x02\u076B\u076A\x03\x02\x02\x02\u076B\u076C" + - "\x03\x02\x02\x02\u076C\u076D\x03\x02\x02\x02\u076D\u076E\x054\x1B\x02" + - "\u076E3\x03\x02\x02\x02\u076F\u0770\x07\u015D\x02\x02\u0770\u0778\x05" + - "\u0318\u018D\x02\u0771\u0772\x07\u0145\x02\x02\u0772\u0773\x07\x9C\x02" + - "\x02\u0773\u0774\x07&\x02\x02\u0774\u0775\x07\u015D\x02\x02\u0775\u0778" + - "\x05\u0318\u018D\x02\u0776\u0778\x058\x1D\x02\u0777\u076F\x03\x02\x02" + - "\x02\u0777\u0771\x03\x02\x02\x02\u0777\u0776\x03\x02\x02\x02\u07785\x03" + - "\x02\x02\x02\u0779\u077A\x05:\x1E\x02\u077A\u077B\t\b\x02\x02\u077B\u077C" + - "\x05<\x1F\x02\u077C7\x03\x02\x02\x02\u077D\u0799\x056\x1C\x02\u077E\u077F" + - "\x05:\x1E\x02\u077F\u0780\x07B\x02\x02\u0780\u0781\x07\u01AB\x02\x02\u0781" + - "\u0799\x03\x02\x02\x02\u0782\u0783\x07\u019B\x02\x02\u0783\u0784\x07\u017B" + - "\x02\x02\u0784\u0799\x05D#\x02\u0785\u0786\x07\x9A\x02\x02\u0786\u0799" + - "\x05\u0542\u02A2\x02\u0787\u0788\x07\u013C\x02\x02\u0788\u0799\x05\u0542" + - "\u02A2\x02\u0789\u078B\x07\u0104\x02\x02\u078A\u078C\x05F$\x02\u078B\u078A" + - "\x03\x02\x02\x02\u078B\u078C\x03\x02\x02\x02\u078C\u0799\x03\x02\x02\x02" + - "\u078D\u078E\x07\u0137\x02\x02\u078E\u0799\x05H%\x02\u078F\u0790\x07\u0145" + - "\x02\x02\u0790\u0791\x07l\x02\x02\u0791\u0799\x05H%\x02\u0792\u0793\x07" + - "\u0178\x02\x02\u0793\u0794\x07\u0110\x02\x02\u0794\u0799\x05\u04C0\u0261" + - "\x02\u0795\u0796\x07\u015D\x02\x02\u0796\u0797\x07\u014A\x02\x02\u0797" + - "\u0799\x05\u0542\u02A2\x02\u0798\u077D\x03\x02\x02\x02\u0798\u077E\x03" + - "\x02\x02\x02\u0798\u0782\x03\x02\x02\x02\u0798\u0785\x03\x02\x02\x02\u0798" + - "\u0787\x03\x02\x02\x02\u0798\u0789\x03\x02\x02\x02\u0798\u078D\x03\x02" + - "\x02\x02\u0798\u078F\x03\x02\x02\x02\u0798\u0792\x03\x02\x02\x02\u0798" + - "\u0795\x03\x02\x02\x02\u07999\x03\x02\x02\x02\u079A\u079F\x05\u0550\u02A9" + - "\x02\u079B\u079C\x07\r\x02\x02\u079C\u079E\x05\u0550\u02A9\x02\u079D\u079B" + - "\x03\x02\x02\x02\u079E\u07A1\x03\x02\x02\x02\u079F\u079D\x03\x02\x02\x02" + - "\u079F\u07A0\x03\x02\x02\x02\u07A0;\x03\x02\x02\x02\u07A1\u079F\x03\x02" + - "\x02\x02\u07A2\u07A7\x05> \x02\u07A3\u07A4\x07\b\x02\x02\u07A4\u07A6\x05" + - "> \x02\u07A5\u07A3\x03\x02\x02\x02\u07A6\u07A9\x03\x02\x02\x02\u07A7\u07A5" + - "\x03\x02\x02\x02\u07A7\u07A8\x03\x02\x02\x02\u07A8=\x03\x02\x02\x02\u07A9" + - "\u07A7\x03\x02\x02\x02\u07AA\u07AD\x05B\"\x02\u07AB\u07AD\x05\u0124\x93" + - "\x02\u07AC\u07AA\x03\x02\x02\x02\u07AC\u07AB\x03\x02\x02\x02\u07AD?\x03" + - "\x02\x02\x02\u07AE\u07AF\x07\u0125\x02\x02\u07AF\u07B4\t\t\x02\x02\u07B0" + - "\u07B1\x07\u012F\x02\x02\u07B1\u07B4\x07\u0125\x02\x02\u07B2\u07B4\x07" + - "\u0143\x02\x02\u07B3\u07AE\x03\x02\x02\x02\u07B3\u07B0\x03\x02\x02\x02" + - "\u07B3\u07B2\x03\x02\x02\x02\u07B4A\x03\x02\x02\x02\u07B5\u07BA\x07b\x02" + - "\x02\u07B6\u07BA\x07>\x02\x02\u07B7\u07BA\x07R\x02\x02\u07B8\u07BA\x05" + - "H%\x02\u07B9\u07B5\x03\x02\x02\x02\u07B9\u07B6\x03\x02\x02\x02\u07B9\u07B7" + - "\x03\x02\x02\x02\u07B9\u07B8\x03\x02\x02\x02\u07BAC\x03\x02\x02\x02\u07BB" + - "\u07CC\x05\u0542\u02A2\x02\u07BC\u07CC\x05\u0558\u02AD\x02\u07BD\u07BE" + - "\x05\u0476\u023C\x02\u07BE\u07C0\x05\u0542\u02A2\x02\u07BF\u07C1\x05\u047A" + - "\u023E\x02\u07C0\u07BF\x03\x02\x02\x02\u07C0\u07C1\x03\x02\x02\x02\u07C1" + - "\u07CC\x03\x02\x02\x02\u07C2\u07C3\x05\u0476\u023C\x02\u07C3\u07C4\x07" + - "\x04\x02\x02\u07C4\u07C5\x05\u0540\u02A1\x02\u07C5\u07C6\x07\x05\x02\x02" + - "\u07C6\u07C7\x05\u0542\u02A2\x02\u07C7\u07CC\x03\x02\x02\x02\u07C8\u07CC" + - "\x05\u0124\x93\x02\u07C9\u07CC\x077\x02\x02\u07CA\u07CC\x07\xF7\x02\x02" + - "\u07CB\u07BB\x03\x02\x02\x02\u07CB\u07BC\x03\x02\x02\x02\u07CB\u07BD\x03" + - "\x02\x02\x02\u07CB\u07C2\x03\x02\x02\x02\u07CB\u07C8\x03\x02\x02\x02\u07CB" + - "\u07C9\x03\x02\x02\x02\u07CB\u07CA\x03\x02\x02\x02\u07CCE\x03\x02\x02" + - "\x02\u07CD\u07D0\x05\u0542\u02A2\x02\u07CE\u07D0\x077\x02\x02\u07CF\u07CD" + - "\x03\x02\x02\x02\u07CF\u07CE\x03\x02\x02\x02\u07D0G\x03\x02\x02\x02\u07D1" + - "\u07D4\x05\u0554\u02AB\x02\u07D2\u07D4\x05\u0542\u02A2\x02\u07D3\u07D1" + - "\x03\x02\x02\x02\u07D3\u07D2\x03\x02\x02\x02\u07D4I\x03\x02\x02\x02\u07D5" + - "\u07D6\x07\u0132\x02\x02\u07D6\u07D7\x05L\'\x02\u07D7K\x03\x02\x02\x02" + - "\u07D8\u07E1\x05N(\x02\u07D9\u07DA\x07\u019B\x02\x02\u07DA\u07E1\x07\u017B" + - "\x02\x02\u07DB\u07DC\x07\u015D\x02\x02\u07DC\u07DD\x07\xED\x02\x02\u07DD" + - "\u07E1\x07\xF4\x02\x02\u07DE\u07DF\x07\u0145\x02\x02\u07DF\u07E1\x07l" + - "\x02\x02\u07E0\u07D8\x03\x02\x02\x02\u07E0\u07D9\x03\x02\x02\x02\u07E0" + - "\u07DB\x03\x02\x02\x02\u07E0\u07DE\x03\x02\x02\x02\u07E1M\x03\x02\x02" + - "\x02\u07E2\u07E5\x05:\x1E\x02\u07E3\u07E5\x07 \x02\x02\u07E4\u07E2\x03" + - "\x02\x02\x02\u07E4\u07E3\x03\x02\x02\x02\u07E5O\x03\x02\x02\x02\u07E6" + - "\u07E7\x07\u0146\x02\x02\u07E7\u07EA\x054\x1B\x02\u07E8\u07EA\x05J&\x02" + - "\u07E9\u07E6\x03\x02\x02\x02\u07E9\u07E8\x03\x02\x02\x02\u07EAQ\x03\x02" + - "\x02\x02\u07EB\u07EC\x07\u0146\x02\x02\u07EC\u07EF\x058\x1D\x02\u07ED" + - "\u07EF\x05J&\x02\u07EE\u07EB\x03\x02\x02\x02\u07EE\u07ED\x03\x02\x02\x02" + - "\u07EFS\x03\x02\x02\x02\u07F0\u07FA\x07\u0148\x02\x02\u07F1\u07FB\x05" + - ":\x1E\x02\u07F2\u07F3\x07\u019B\x02\x02\u07F3\u07FB\x07\u017B\x02\x02" + - "\u07F4\u07F5\x07\u015D\x02\x02\u07F5\u07F6\x07\xED\x02\x02\u07F6\u07FB" + - "\x07\xF4\x02\x02\u07F7\u07F8\x07\u0145\x02\x02\u07F8\u07FB\x07l\x02\x02" + - "\u07F9\u07FB\x07 \x02\x02\u07FA\u07F1\x03\x02\x02\x02\u07FA\u07F2\x03" + - "\x02\x02\x02\u07FA\u07F4\x03\x02\x02\x02\u07FA\u07F7\x03\x02\x02\x02\u07FA" + - "\u07F9\x03\x02\x02\x02\u07FBU\x03\x02\x02\x02\u07FC\u07FD\x07\u0146\x02" + - "\x02\u07FD\u07FE\x07\xA7\x02\x02\u07FE\u07FF\x05X-\x02\u07FF\u0800\x05" + - "Z.\x02\u0800W\x03\x02\x02\x02\u0801\u0804\x07 \x02\x02\u0802\u0804\x05" + - "\u052A\u0296\x02\u0803\u0801\x03\x02\x02\x02\u0803\u0802\x03\x02\x02\x02" + - "\u0804Y\x03\x02\x02\x02\u0805\u0806\t\n\x02\x02\u0806[\x03\x02\x02\x02" + - "\u0807\u0808\x07\x9D\x02\x02\u0808]\x03\x02\x02\x02\u0809\u080A\x07\xBD" + - "\x02\x02\u080A\u080B\t\v\x02\x02\u080B_\x03\x02\x02\x02\u080C\u080D\x07" + - "\x8C\x02\x02\u080D\u0810\x07^\x02\x02\u080E\u080F\x07\xDE\x02\x02\u080F" + - "\u0811\x07\u0185\x02\x02\u0810\u080E\x03\x02\x02\x02\u0810\u0811\x03\x02" + - "\x02\x02\u0811\u0812\x03\x02\x02\x02\u0812\u0815\x05\u0428\u0215\x02\u0813" + - "\u0816\x05b2\x02\u0814\u0816\x05d3\x02\u0815\u0813\x03\x02\x02\x02\u0815" + - "\u0814\x03\x02\x02\x02\u0816\u087D\x03\x02\x02\x02\u0817\u0818\x07\x8C" + - "\x02\x02\u0818\u0819\x07^\x02\x02\u0819\u081A\x07 \x02\x02\u081A\u081B" + - "\x07F\x02\x02\u081B\u081C\x07\u0158\x02\x02\u081C\u0820\x05\u0530\u0299" + - "\x02\u081D\u081E\x07\u0112\x02\x02\u081E\u081F\x07\x95\x02\x02\u081F\u0821" + - "\x05\u054E\u02A8\x02\u0820\u081D\x03\x02\x02\x02\u0820\u0821\x03\x02\x02" + - "\x02\u0821\u0822\x03\x02\x02\x02\u0822\u0823\x07\u0146\x02\x02\u0823\u0824" + - "\x07\u0158\x02\x02\u0824\u0826\x05\u0530\u0299\x02\u0825\u0827\x05\u03A2" + - "\u01D2\x02\u0826\u0825\x03\x02\x02\x02\u0826\u0827\x03\x02\x02\x02\u0827" + - "\u087D\x03\x02\x02\x02\u0828\u0829\x07\x8C\x02\x02\u0829\u082C\x07\xE4" + - "\x02\x02\u082A\u082B\x07\xDE\x02\x02\u082B\u082D\x07\u0185\x02\x02\u082C" + - "\u082A\x03\x02\x02\x02\u082C\u082D\x03\x02\x02\x02\u082D\u082E\x03\x02" + - "\x02\x02\u082E\u0831\x05\u052C\u0297\x02\u082F\u0832\x05b2\x02\u0830\u0832" + - "\x05f4\x02\u0831\u082F\x03\x02\x02\x02\u0831\u0830\x03\x02\x02\x02\u0832" + - "\u087D\x03\x02\x02\x02\u0833\u0834\x07\x8C\x02\x02\u0834\u0835\x07\xE4" + - "\x02\x02\u0835\u0836\x07 \x02\x02\u0836\u0837\x07F\x02\x02\u0837\u0838" + - "\x07\u0158\x02\x02\u0838\u083C\x05\u0530\u0299\x02\u0839\u083A\x07\u0112" + - "\x02\x02\u083A\u083B\x07\x95\x02\x02\u083B\u083D\x05\u054E\u02A8\x02\u083C" + - "\u0839\x03\x02\x02\x02\u083C\u083D\x03\x02\x02\x02\u083D\u083E\x03\x02" + - "\x02\x02\u083E\u083F\x07\u0146\x02\x02\u083F\u0840\x07\u0158\x02\x02\u0840" + - "\u0842\x05\u0530\u0299\x02\u0841\u0843\x05\u03A2\u01D2\x02\u0842\u0841" + - "\x03\x02\x02\x02\u0842\u0843\x03\x02\x02\x02\u0843\u087D\x03\x02\x02\x02" + - "\u0844\u0845\x07\x8C\x02\x02\u0845\u0848\x07\u0141\x02\x02\u0846\u0847" + - "\x07\xDE\x02\x02\u0847\u0849\x07\u0185\x02\x02\u0848\u0846\x03\x02\x02" + - "\x02\u0848\u0849\x03\x02\x02\x02\u0849\u084A\x03\x02\x02\x02\u084A\u084B" + - "\x05\u052C\u0297\x02\u084B\u084C\x05b2\x02\u084C\u087D\x03\x02\x02\x02" + - "\u084D\u084E\x07\x8C\x02\x02\u084E\u0851\x07\u0171\x02\x02\u084F\u0850" + - "\x07\xDE\x02\x02\u0850\u0852\x07\u0185\x02\x02\u0851\u084F\x03\x02\x02" + - "\x02\u0851\u0852\x03\x02\x02\x02\u0852\u0853\x03\x02\x02\x02\u0853\u0854" + - "\x05\u052C\u0297\x02\u0854\u0855\x05b2\x02\u0855\u087D\x03\x02\x02\x02" + - "\u0856\u0857\x07\x8C\x02\x02\u0857\u0858\x07\xFC\x02\x02\u0858\u085B\x07" + - "\u0171\x02\x02\u0859\u085A\x07\xDE\x02\x02\u085A\u085C\x07\u0185\x02\x02" + - "\u085B\u0859\x03\x02\x02\x02\u085B\u085C\x03\x02\x02\x02\u085C\u085D\x03" + - "\x02\x02\x02\u085D\u085E\x05\u052C\u0297\x02\u085E\u085F\x05b2\x02\u085F" + - "\u087D\x03\x02\x02\x02\u0860\u0861\x07\x8C\x02\x02\u0861\u0862\x07\xFC" + - "\x02\x02\u0862\u0863\x07\u0171\x02\x02\u0863\u0864\x07 \x02\x02\u0864" + - "\u0865\x07F\x02\x02\u0865\u0866\x07\u0158\x02\x02\u0866\u086A\x05\u0530" + - "\u0299\x02\u0867\u0868\x07\u0112\x02\x02\u0868\u0869\x07\x95\x02\x02\u0869" + - "\u086B\x05\u054E\u02A8\x02\u086A\u0867\x03\x02\x02\x02\u086A\u086B\x03" + - "\x02\x02\x02\u086B\u086C\x03\x02\x02\x02\u086C\u086D\x07\u0146\x02\x02" + - "\u086D\u086E\x07\u0158\x02\x02\u086E\u0870\x05\u0530\u0299\x02\u086F\u0871" + - "\x05\u03A2\u01D2\x02\u0870\u086F\x03\x02\x02\x02\u0870\u0871\x03\x02\x02" + - "\x02\u0871\u087D\x03\x02\x02\x02\u0872\u0873\x07\x8C\x02\x02\u0873\u0874" + - "\x07A\x02\x02\u0874\u0877\x07^\x02\x02\u0875\u0876\x07\xDE\x02\x02\u0876" + - "\u0878\x07\u0185\x02\x02\u0877\u0875\x03\x02\x02\x02\u0877\u0878\x03\x02" + - "\x02\x02\u0878\u0879\x03\x02\x02\x02\u0879\u087A\x05\u0428\u0215\x02\u087A" + - "\u087B\x05b2\x02\u087B\u087D\x03\x02\x02\x02\u087C\u080C\x03\x02\x02\x02" + - "\u087C\u0817\x03\x02\x02\x02\u087C\u0828\x03\x02\x02\x02\u087C\u0833\x03" + - "\x02\x02\x02\u087C\u0844\x03\x02\x02\x02\u087C\u084D\x03\x02\x02\x02\u087C" + - "\u0856\x03\x02\x02\x02\u087C\u0860\x03\x02\x02\x02\u087C\u0872\x03\x02" + - "\x02\x02\u087Da\x03\x02\x02\x02\u087E\u0883\x05h5\x02\u087F\u0880\x07" + - "\b\x02\x02\u0880\u0882\x05h5\x02\u0881\u087F\x03\x02\x02\x02\u0882\u0885" + - "\x03\x02\x02\x02\u0883\u0881\x03\x02\x02\x02\u0883\u0884\x03\x02\x02\x02" + - "\u0884c\x03\x02\x02\x02\u0885\u0883\x03\x02\x02\x02\u0886\u0887\x07\u01AC" + - "\x02\x02\u0887\u0888\x07\u0116\x02\x02\u0888\u0889\x05\u052C\u0297\x02" + - "\u0889\u088A\x05\x80A\x02\u088A\u088F\x03\x02\x02\x02\u088B\u088C\x07" + - "\u01AD\x02\x02\u088C\u088D\x07\u0116\x02\x02\u088D\u088F\x05\u052C\u0297" + - "\x02\u088E\u0886\x03\x02\x02\x02\u088E\u088B\x03\x02\x02\x02\u088Fe\x03" + - "\x02\x02\x02\u0890\u0891\x07\u01AC\x02\x02\u0891\u0892\x07\u0116\x02\x02" + - "\u0892\u0893\x05"; + "\u28E6\x03\x02\x02\x02\u05A6\u28E8\x03\x02\x02\x02\u05A8\u28EC\x03\x02" + + "\x02\x02\u05AA\u28EE\x03\x02\x02\x02\u05AC\u28F3\x03\x02\x02\x02\u05AE" + + "\u28F8\x03\x02\x02\x02\u05B0\u28FE\x03\x02\x02\x02\u05B2\u2902\x03\x02" + + "\x02\x02\u05B4\u2904\x03\x02\x02\x02\u05B6\u2909\x03\x02\x02\x02\u05B8" + + "\u2927\x03\x02\x02\x02\u05BA\u2929\x03\x02\x02\x02\u05BC\u293B\x03\x02" + + "\x02\x02\u05BE\u293F\x03\x02\x02\x02\u05C0\u2941\x03\x02\x02\x02\u05C2" + + "\u2946\x03\x02\x02\x02\u05C4\u294F\x03\x02\x02\x02\u05C6\u2951\x03\x02" + + "\x02\x02\u05C8\u2959\x03\x02\x02\x02\u05CA\u295D\x03\x02\x02\x02\u05CC" + + "\u295F\x03\x02\x02\x02\u05CE\u2963\x03\x02\x02\x02\u05D0\u296E\x03\x02" + + "\x02\x02\u05D2\u297F\x03\x02\x02\x02\u05D4\u2985\x03\x02\x02\x02\u05D6" + + "\u2987\x03\x02\x02\x02\u05D8\u2991\x03\x02\x02\x02\u05DA\u2994\x03\x02" + + "\x02\x02\u05DC\u2998\x03\x02\x02\x02\u05DE\u29A0\x03\x02\x02\x02\u05E0" + + "\u29A2\x03\x02\x02\x02\u05E2\u29A5\x03\x02\x02\x02\u05E4\u29AA\x03\x02" + + "\x02\x02\u05E6\u29AF\x03\x02\x02\x02\u05E8\u29C5\x03\x02\x02\x02\u05EA" + + "\u29D3\x03\x02\x02\x02\u05EC\u29D7\x03\x02\x02\x02\u05EE\u29DC\x03\x02" + + "\x02\x02\u05F0\u29DE\x03\x02\x02\x02\u05F2\u29E0\x03\x02\x02\x02\u05F4" + + "\u29EC\x03\x02\x02\x02\u05F6\u29EE\x03\x02\x02\x02\u05F8\u29F5\x03\x02" + + "\x02\x02\u05FA\u29F7\x03\x02\x02\x02\u05FC\u2A09\x03\x02\x02\x02\u05FE" + + "\u2A2D\x03\x02\x02\x02\u0600\u2A2F\x03\x02\x02\x02\u0602\u2A38\x03\x02" + + "\x02\x02\u0604\u2A3D\x03\x02\x02\x02\u0606\u2A3F\x03\x02\x02\x02\u0608" + + "\u2A43\x03\x02\x02\x02\u060A\u2A4B\x03\x02\x02\x02\u060C\u2A53\x03\x02" + + "\x02\x02\u060E\u2A55\x03\x02\x02\x02\u0610\u2A5C\x03\x02\x02\x02\u0612" + + "\u2A5F\x03\x02\x02\x02\u0614\u2A6F\x03\x02\x02\x02\u0616\u2A71\x03\x02" + + "\x02\x02\u0618\u2A7F\x03\x02\x02\x02\u061A\u2A81\x03\x02\x02\x02\u061C" + + "\u2A9C\x03\x02\x02\x02\u061E\u2A9E\x03\x02\x02\x02\u0620\u2AA9\x03\x02" + + "\x02\x02\u0622\u2AAF\x03\x02\x02\x02\u0624\u2AB3\x03\x02\x02\x02\u0626" + + "\u2AB5\x03\x02\x02\x02\u0628\u2ABF\x03\x02\x02\x02\u062A\u2AC4\x03\x02" + + "\x02\x02\u062C\u2AD5\x03\x02\x02\x02\u062E\u2AD7\x03\x02\x02\x02\u0630" + + "\u2ADE\x03\x02\x02\x02\u0632\u2AE2\x03\x02\x02\x02\u0634\u2AE5\x03\x02" + + "\x02\x02\u0636\u2AEB\x03\x02\x02\x02\u0638\u2AF1\x03\x02\x02\x02\u063A" + + "\u2B03\x03\x02\x02\x02\u063C\u2B07\x03\x02\x02\x02\u063E\u2B0C\x03\x02" + + "\x02\x02\u0640\u2B0F\x03\x02\x02\x02\u0642\u2B13\x03\x02\x02\x02\u0644" + + "\u2B18\x03\x02\x02\x02\u0646\u2B23\x03\x02\x02\x02\u0648\u2B27\x03\x02" + + "\x02\x02\u064A\u2B2B\x03\x02\x02\x02\u064C\u2B2F\x03\x02\x02\x02\u064E" + + "\u2B31\x03\x02\x02\x02\u0650\u2B36\x03\x02\x02\x02\u0652\u2B38\x03\x02" + + "\x02\x02\u0654\u2B3B\x03\x02\x02\x02\u0656\u2B4F\x03\x02\x02\x02\u0658" + + "\u2B51\x03\x02\x02\x02\u065A\u2B53\x03\x02\x02\x02\u065C\u2B55\x03\x02" + + "\x02\x02\u065E\u2B57\x03\x02\x02\x02\u0660\u2B5B\x03\x02\x02\x02\u0662" + + "\u0663\x05\x06\x04\x02\u0663\x03\x03\x02\x02\x02\u0664\u0665\x05\u057E" + + "\u02C0\x02\u0665\x05\x03\x02\x02\x02\u0666\u0668\x05\b\x05\x02\u0667\u0669" + + "\x07\t\x02\x02\u0668\u0667\x03\x02\x02\x02\u0668\u0669\x03\x02\x02\x02" + + "\u0669\u066B\x03\x02\x02\x02\u066A\u0666\x03\x02\x02\x02\u066B\u066E\x03" + + "\x02\x02\x02\u066C\u066A\x03\x02\x02\x02\u066C\u066D\x03\x02\x02\x02\u066D" + + "\x07\x03\x02\x02\x02\u066E\u066C\x03\x02\x02\x02\u066F\u06EC\x05\u01CC" + + "\xE7\x02\u0670\u06EC\x05\u0348\u01A5\x02\u0671\u06EC\x05\u033E\u01A0\x02" + + "\u0672\u06EC\x05\u0340\u01A1\x02\u0673\u06EC\x05\u024E\u0128\x02\u0674" + + "\u06EC\x05\u034E\u01A8\x02\u0675\u06EC\x05\u01E6\xF4\x02\u0676\u06EC\x05" + + "\u0146\xA4\x02\u0677\u06EC\x05\u014C\xA7\x02\u0678\u06EC\x05\u0156\xAC" + + "\x02\u0679\u06EC\x05\u0170\xB9\x02\u067A\u06EC\x05\u02AC\u0157\x02\u067B" + + "\u06EC\x05&\x14\x02\u067C\u06EC\x05\u02E6\u0174\x02\u067D\u06EC\x05\u02EA" + + "\u0176\x02\u067E\u06EC\x05\u02F6\u017C\x02\u067F\u06EC\x05\u02EC\u0177" + + "\x02\u0680\u06EC\x05\u02F4\u017B\x02\u0681\u06EC\x05\u0184\xC3\x02\u0682" + + "\u06EC\x05\u011C\x8F\x02\u0683\u06EC\x05\u034A\u01A6\x02\u0684\u06EC\x05" + + "`1\x02\u0685\u06EC\x05\u02DE\u0170\x02\u0686\u06EC\x05\x86D\x02\u0687" + + "\u06EC\x05\u02FE\u0180\x02\u0688\u06EC\x05 \x11\x02\u0689\u06EC\x05\x1C" + + "\x0F\x02\u068A\u06EC\x05\u0306\u0184\x02\u068B\u06EC\x05\u010A\x86\x02" + + "\u068C\u06EC\x05\u0354\u01AB\x02\u068D\u06EC\x05\u0352\u01AA\x02\u068E" + + "\u06EC\x05\u0180\xC1\x02\u068F\u06EC\x05\u0360\u01B1\x02\u0690\u06EC\x05" + + "\f\x07\x02\u0691\u06EC\x05\\/\x02\u0692\u06EC\x05\x8CG\x02\u0693\u06EC" + + "\x05\u035A\u01AE\x02\u0694\u06EC\x05\u021E\u0110\x02\u0695\u06EC\x05V" + + ",\x02\u0696\u06EC\x05\x8EH\x02\u0697\u06EC\x05\u0194\xCB\x02\u0698\u06EC" + + "\x05\u010C\x87\x02\u0699\u06EC\x05\u01D0\xE9\x02\u069A\u06EC\x05\u02C6" + + "\u0164\x02\u069B\u06EC\x05\u0358\u01AD\x02\u069C\u06EC\x05\u034C\u01A7" + + "\x02\u069D\u06EC\x05\u0140\xA1\x02\u069E\u06EC\x05\u014E\xA8\x02\u069F" + + "\u06EC\x05\u0168\xB5\x02\u06A0\u06EC\x05\u0172\xBA\x02\u06A1\u06EC\x05" + + "\u0274\u013B\x02\u06A2\u06EC\x05$\x13\x02\u06A3\u06EC\x05\u0112\x8A\x02" + + "\u06A4\u06EC\x05\u01EA\xF6\x02\u06A5\u06EC\x05\u01F8\xFD\x02\u06A6\u06EC" + + "\x05\u02F8\u017D\x02\u06A7\u06EC\x05\u01FA\xFE\x02\u06A8\u06EC\x05\u0182" + + "\xC2\x02\u06A9\u06EC\x05\u012C\x97\x02\u06AA\u06EC\x05*\x16\x02\u06AB" + + "\u06EC\x05\u011A\x8E\x02\u06AC\u06EC\x05\xACW\x02\u06AD\u06EC\x05\u0300" + + "\u0181\x02\u06AE\u06EC\x05\u0108\x85\x02\u06AF\u06EC\x05\u013A\x9E\x02" + + "\u06B0\u06EC\x05\u02CE\u0168\x02\u06B1\u06EC\x05\u0198\xCD\x02\u06B2\u06EC" + + "\x05\u01C4\xE3\x02\u06B3\u06EC\x05\x0E\b\x02\u06B4\u06EC\x05\x1A\x0E\x02" + + "\u06B5\u06EC\x05\u017A\xBE\x02\u06B6\u06EC\x05\u0332\u019A\x02\u06B7\u06EC" + + "\x05\u0392\u01CA\x02\u06B8\u06EC\x05\u03BE\u01E0\x02\u06B9\u06EC\x05\u01D2" + + "\xEA\x02\u06BA\u06EC\x05\u03A6\u01D4\x02\u06BB\u06EC\x05^0\x02\u06BC\u06EC" + + "\x05\u02C0\u0161\x02\u06BD\u06EC\x05\u02CA\u0166\x02\u06BE\u06EC\x05\u0200" + + "\u0101\x02\u06BF\u06EC\x05\u0202\u0102\x02\u06C0\u06EC\x05\u0204\u0103" + + "\x02\u06C1\u06EC\x05\u0208\u0105\x02\u06C2\u06EC\x05\u0308\u0185\x02\u06C3" + + "\u06EC\x05\u013E\xA0\x02\u06C4\u06EC\x05\u02D2\u016A\x02\u06C5\u06EC\x05" + + "\"\x12\x02\u06C6\u06EC\x05\u017E\xC0\x02\u06C7\u06EC\x05\u0342\u01A2\x02" + + "\u06C8\u06EC\x05\u038E\u01C8\x02\u06C9\u06EC\x05\u037C\u01BF\x02\u06CA" + + "\u06EC\x05\u0228\u0115\x02\u06CB\u06EC\x05\u0230\u0119\x02\u06CC\u06EC" + + "\x05\u0246\u0124\x02\u06CD\u06EC\x05\u0174\xBB\x02\u06CE\u06EC\x05\u0258" + + "\u012D\x02\u06CF\u06EC\x05\u0394\u01CB\x02\u06D0\u06EC\x05\u031C\u018F" + + "\x02\u06D1\u06EC\x05\u0118\x8D\x02\u06D2\u06EC\x05\u0330\u0199\x02\u06D3" + + "\u06EC\x05\u03AA\u01D6\x02\u06D4\u06EC\x05\u0318\u018D\x02\u06D5\u06EC" + + "\x05\u0388\u01C5\x02\u06D6\u06EC\x05\u0206\u0104\x02\u06D7\u06EC\x05\u02D4" + + "\u016B\x02\u06D8\u06EC\x05\u02B4\u015B\x02\u06D9\u06EC\x05\u02B2\u015A" + + "\x02\u06DA\u06EC\x05\u02B6\u015C\x02\u06DB\u06EC\x05\u02E0\u0171\x02\u06DC" + + "\u06EC\x05\u0232\u011A\x02\u06DD\u06EC\x05\u0248\u0125\x02\u06DE\u06EC" + + "\x05\u030A\u0186\x02\u06DF\u06EC\x05\u0222\u0112\x02\u06E0\u06EC\x05\u03C6" + + "\u01E4\x02\u06E1\u06EC\x05\u0320\u0191\x02\u06E2\u06EC\x05\u021A\u010E" + + "\x02\u06E3\u06EC\x05\u031E\u0190\x02\u06E4\u06EC\x05\u03B4\u01DB\x02\u06E5" + + "\u06EC\x05\u035E\u01B0\x02\u06E6\u06EC\x05J&\x02\u06E7\u06EC\x052\x1A" + + "\x02\u06E8\u06EC\x05T+\x02\u06E9\u06EC\x05\u032C\u0197\x02\u06EA\u06EC" + + "\x05\n\x06\x02\u06EB\u066F\x03\x02\x02\x02\u06EB\u0670\x03\x02\x02\x02" + + "\u06EB\u0671\x03\x02\x02\x02\u06EB\u0672\x03\x02\x02\x02\u06EB\u0673\x03" + + "\x02\x02\x02\u06EB\u0674\x03\x02\x02\x02\u06EB\u0675\x03\x02\x02\x02\u06EB" + + "\u0676\x03\x02\x02\x02\u06EB\u0677\x03\x02\x02\x02\u06EB\u0678\x03\x02" + + "\x02\x02\u06EB\u0679\x03\x02\x02\x02\u06EB\u067A\x03\x02\x02\x02\u06EB" + + "\u067B\x03\x02\x02\x02\u06EB\u067C\x03\x02\x02\x02\u06EB\u067D\x03\x02" + + "\x02\x02\u06EB\u067E\x03\x02\x02\x02\u06EB\u067F\x03\x02\x02\x02\u06EB" + + "\u0680\x03\x02\x02\x02\u06EB\u0681\x03\x02\x02\x02\u06EB\u0682\x03\x02" + + "\x02\x02\u06EB\u0683\x03\x02\x02\x02\u06EB\u0684\x03\x02\x02\x02\u06EB" + + "\u0685\x03\x02\x02\x02\u06EB\u0686\x03\x02\x02\x02\u06EB\u0687\x03\x02" + + "\x02\x02\u06EB\u0688\x03\x02\x02\x02\u06EB\u0689\x03\x02\x02\x02\u06EB" + + "\u068A\x03\x02\x02\x02\u06EB\u068B\x03\x02\x02\x02\u06EB\u068C\x03\x02" + + "\x02\x02\u06EB\u068D\x03\x02\x02\x02\u06EB\u068E\x03\x02\x02\x02\u06EB" + + "\u068F\x03\x02\x02\x02\u06EB\u0690\x03\x02\x02\x02\u06EB\u0691\x03\x02" + + "\x02\x02\u06EB\u0692\x03\x02\x02\x02\u06EB\u0693\x03\x02\x02\x02\u06EB" + + "\u0694\x03\x02\x02\x02\u06EB\u0695\x03\x02\x02\x02\u06EB\u0696\x03\x02" + + "\x02\x02\u06EB\u0697\x03\x02\x02\x02\u06EB\u0698\x03\x02\x02\x02\u06EB" + + "\u0699\x03\x02\x02\x02\u06EB\u069A\x03\x02\x02\x02\u06EB\u069B\x03\x02" + + "\x02\x02\u06EB\u069C\x03\x02\x02\x02\u06EB\u069D\x03\x02\x02\x02\u06EB" + + "\u069E\x03\x02\x02\x02\u06EB\u069F\x03\x02\x02\x02\u06EB\u06A0\x03\x02" + + "\x02\x02\u06EB\u06A1\x03\x02\x02\x02\u06EB\u06A2\x03\x02\x02\x02\u06EB" + + "\u06A3\x03\x02\x02\x02\u06EB\u06A4\x03\x02\x02\x02\u06EB\u06A5\x03\x02" + + "\x02\x02\u06EB\u06A6\x03\x02\x02\x02\u06EB\u06A7\x03\x02\x02\x02\u06EB" + + "\u06A8\x03\x02\x02\x02\u06EB\u06A9\x03\x02\x02\x02\u06EB\u06AA\x03\x02" + + "\x02\x02\u06EB\u06AB\x03\x02\x02\x02\u06EB\u06AC\x03\x02\x02\x02\u06EB" + + "\u06AD\x03\x02\x02\x02\u06EB\u06AE\x03\x02\x02\x02\u06EB\u06AF\x03\x02" + + "\x02\x02\u06EB\u06B0\x03\x02\x02\x02\u06EB\u06B1\x03\x02\x02\x02\u06EB" + + "\u06B2\x03\x02\x02\x02\u06EB\u06B3\x03\x02\x02\x02\u06EB\u06B4\x03\x02" + + "\x02\x02\u06EB\u06B5\x03\x02\x02\x02\u06EB\u06B6\x03\x02\x02\x02\u06EB" + + "\u06B7\x03\x02\x02\x02\u06EB\u06B8\x03\x02\x02\x02\u06EB\u06B9\x03\x02" + + "\x02\x02\u06EB\u06BA\x03\x02\x02\x02\u06EB\u06BB\x03\x02\x02\x02\u06EB" + + "\u06BC\x03\x02\x02\x02\u06EB\u06BD\x03\x02\x02\x02\u06EB\u06BE\x03\x02" + + "\x02\x02\u06EB\u06BF\x03\x02\x02\x02\u06EB\u06C0\x03\x02\x02\x02\u06EB" + + "\u06C1\x03\x02\x02\x02\u06EB\u06C2\x03\x02\x02\x02\u06EB\u06C3\x03\x02" + + "\x02\x02\u06EB\u06C4\x03\x02\x02\x02\u06EB\u06C5\x03\x02\x02\x02\u06EB" + + "\u06C6\x03\x02\x02\x02\u06EB\u06C7\x03\x02\x02\x02\u06EB\u06C8\x03\x02" + + "\x02\x02\u06EB\u06C9\x03\x02\x02\x02\u06EB\u06CA\x03\x02\x02\x02\u06EB" + + "\u06CB\x03\x02\x02\x02\u06EB\u06CC\x03\x02\x02\x02\u06EB\u06CD\x03\x02" + + "\x02\x02\u06EB\u06CE\x03\x02\x02\x02\u06EB\u06CF\x03\x02\x02\x02\u06EB" + + "\u06D0\x03\x02\x02\x02\u06EB\u06D1\x03\x02\x02\x02\u06EB\u06D2\x03\x02" + + "\x02\x02\u06EB\u06D3\x03\x02\x02\x02\u06EB\u06D4\x03\x02\x02\x02\u06EB" + + "\u06D5\x03\x02\x02\x02\u06EB\u06D6\x03\x02\x02\x02\u06EB\u06D7\x03\x02" + + "\x02\x02\u06EB\u06D8\x03\x02\x02\x02\u06EB\u06D9\x03\x02\x02\x02\u06EB" + + "\u06DA\x03\x02\x02\x02\u06EB\u06DB\x03\x02\x02\x02\u06EB\u06DC\x03\x02" + + "\x02\x02\u06EB\u06DD\x03\x02\x02\x02\u06EB\u06DE\x03\x02\x02\x02\u06EB" + + "\u06DF\x03\x02\x02\x02\u06EB\u06E0\x03\x02\x02\x02\u06EB\u06E1\x03\x02" + + "\x02\x02\u06EB\u06E2\x03\x02\x02\x02\u06EB\u06E3\x03\x02\x02\x02\u06EB" + + "\u06E4\x03\x02\x02\x02\u06EB\u06E5\x03\x02\x02\x02\u06EB\u06E6\x03\x02" + + "\x02\x02\u06EB\u06E7\x03\x02\x02\x02\u06EB\u06E8\x03\x02\x02\x02\u06EB" + + "\u06E9\x03\x02\x02\x02\u06EB\u06EA\x03\x02\x02\x02\u06EC\t\x03\x02\x02" + + "\x02\u06ED\u06EF\x07\u022F\x02\x02\u06EE\u06F0\x07\u0230\x02\x02\u06EF" + + "\u06EE\x03\x02\x02\x02\u06EF\u06F0\x03\x02\x02\x02\u06F0\v\x03\x02\x02" + + "\x02\u06F1\u06F2\x07\u01B3\x02\x02\u06F2\u06F3\x05\u04BC\u025F\x02\u06F3" + + "\r\x03\x02\x02\x02\u06F4\u06F5\x070\x02\x02\u06F5\u06F6\x07\u0140\x02" + + "\x02\u06F6\u06F8\x05\u055C\u02AF\x02\u06F7\u06F9\x05\x10\t\x02\u06F8\u06F7" + + "\x03\x02\x02\x02\u06F8\u06F9\x03\x02\x02\x02\u06F9\u06FA\x03\x02\x02\x02" + + "\u06FA\u06FB\x05\x12\n\x02\u06FB\x0F\x03\x02\x02\x02\u06FC\u06FD\x07k" + + "\x02\x02\u06FD\x11\x03\x02\x02\x02\u06FE\u0700\x05\x18\r\x02\u06FF\u06FE" + + "\x03\x02\x02\x02\u0700\u0703\x03\x02\x02\x02\u0701\u06FF\x03\x02\x02\x02" + + "\u0701\u0702\x03\x02\x02\x02\u0702\x13\x03\x02\x02\x02\u0703\u0701\x03" + + "\x02\x02\x02\u0704\u0706\x05\x16\f\x02\u0705\u0704\x03\x02\x02\x02\u0706" + + "\u0709\x03\x02\x02\x02\u0707\u0705\x03\x02\x02\x02\u0707\u0708\x03\x02" + + "\x02\x02\u0708\x15\x03\x02\x02\x02\u0709\u0707\x03\x02\x02\x02\u070A\u070D" + + "\x07\u0121\x02\x02\u070B\u070E\x05\u0552\u02AA\x02\u070C\u070E\x07P\x02" + + "\x02\u070D\u070B\x03\x02\x02\x02\u070D\u070C\x03\x02\x02\x02\u070E\u0721" + + "\x03\x02\x02\x02\u070F\u0710\t\x02\x02\x02\u0710\u0711\x07\u0121\x02\x02" + + "\u0711\u0721\x05\u0552\u02AA\x02\u0712\u0721\t\x03\x02\x02\u0713\u0721" + + "\t\x04\x02\x02\u0714\u0721\t\x05\x02\x02\u0715\u0721\t\x06\x02\x02\u0716" + + "\u0721\t\x07\x02\x02\u0717\u0718\x07\xA6\x02\x02\u0718\u0719\x07L\x02" + + "\x02\u0719\u0721\x05\u0558\u02AD\x02\u071A\u071B\x07\u0175\x02\x02\u071B" + + "\u071C\x07\u0172\x02\x02\u071C\u0721\x05\u0552\u02AA\x02\u071D\u071E\x07" + + "e\x02\x02\u071E\u0721\x05\u0560\u02B1\x02\u071F\u0721\x05\u0572\u02BA" + + "\x02\u0720\u070A\x03\x02\x02\x02\u0720\u070F\x03\x02\x02\x02\u0720\u0712" + + "\x03\x02\x02\x02\u0720\u0713\x03\x02\x02\x02\u0720\u0714\x03\x02\x02\x02" + + "\u0720\u0715\x03\x02\x02\x02\u0720\u0716\x03\x02\x02\x02\u0720\u0717\x03" + + "\x02\x02\x02\u0720\u071A\x03\x02\x02\x02\u0720\u071D\x03\x02\x02\x02\u0720" + + "\u071F\x03\x02\x02\x02\u0721\x17\x03\x02\x02\x02\u0722\u072D\x05\x16\f" + + "\x02\u0723\u0724\x07\u015E\x02\x02\u0724\u072D\x05\u0550\u02A9\x02\u0725" + + "\u0726\x07\x88\x02\x02\u0726\u072D\x05\u0560\u02B1\x02\u0727\u0728\x07" + + "\u0140\x02\x02\u0728\u072D\x05\u0560\u02B1\x02\u0729\u072A\x07F\x02\x02" + + "\u072A\u072B\t\b\x02\x02\u072B\u072D\x05\u0560\u02B1\x02\u072C\u0722\x03" + + "\x02\x02\x02\u072C\u0723\x03\x02\x02\x02\u072C\u0725\x03\x02\x02\x02\u072C" + + "\u0727\x03\x02\x02\x02\u072C\u0729\x03\x02\x02\x02\u072D\x19\x03\x02\x02" + + "\x02\u072E\u072F\x070\x02\x02\u072F\u0730\x07e\x02\x02\u0730\u0732\x05" + + "\u055C\u02AF\x02\u0731\u0733\x05\x10\t\x02\u0732\u0731\x03\x02\x02\x02" + + "\u0732\u0733\x03\x02\x02\x02\u0733\u0734\x03\x02\x02\x02\u0734\u0735\x05" + + "\x12\n\x02\u0735\x1B\x03\x02\x02\x02\u0736\u0737\x07\x8C\x02\x02\u0737" + + "\u0738\t\t\x02\x02\u0738\u073A\x05\u055E\u02B0\x02\u0739\u073B\x05\x10" + + "\t\x02\u073A\u0739\x03\x02\x02\x02\u073A\u073B\x03\x02\x02\x02\u073B\u073C" + + "\x03\x02\x02\x02\u073C\u073D\x05\x14\v\x02\u073D\x1D\x03\x02\x02\x02\u073E" + + "\u0743\x03\x02\x02\x02\u073F\u0740\x07F\x02\x02\u0740\u0741\x07\xB1\x02" + + "\x02\u0741\u0743\x05\u0540\u02A1\x02\u0742\u073E\x03\x02\x02\x02\u0742" + + "\u073F\x03\x02\x02\x02\u0743\x1F\x03\x02\x02\x02\u0744\u0745\x07\x8C\x02" + + "\x02\u0745\u0748\t\t\x02\x02\u0746\u0749\x07 \x02\x02\u0747\u0749\x05" + + "\u055E\u02B0\x02\u0748\u0746\x03\x02\x02\x02\u0748\u0747\x03\x02\x02\x02" + + "\u0749\u074A\x03\x02\x02\x02\u074A\u074B\x05\x1E\x10\x02\u074B\u074C\x05" + + "P)\x02\u074C!\x03\x02\x02\x02\u074D\u074E\x07\xC1\x02\x02\u074E\u0751" + + "\t\n\x02\x02\u074F\u0750\x07\xDE\x02\x02\u0750\u0752\x07\u018E\x02\x02" + + "\u0751\u074F\x03\x02\x02\x02\u0751\u0752\x03\x02\x02\x02\u0752\u0753\x03" + + "\x02\x02\x02\u0753\u0754\x05\u0560\u02B1\x02\u0754#\x03\x02\x02\x02\u0755" + + "\u0756\x070\x02\x02\u0756\u0757\x07D\x02\x02\u0757\u0759\x05\u055A\u02AE" + + "\x02\u0758\u075A\x05\x10\t\x02\u0759\u0758\x03\x02\x02\x02\u0759\u075A" + + "\x03\x02\x02\x02\u075A\u075B\x03\x02\x02\x02\u075B\u075C\x05\x12\n\x02" + + "\u075C%\x03\x02\x02\x02\u075D\u075E\x07\x8C\x02\x02\u075E\u075F\x07D\x02" + + "\x02\u075F\u0760\x05\u055E\u02B0\x02\u0760\u0761\x05(\x15\x02\u0761\u0762" + + "\x07e\x02\x02\u0762\u0763\x05\u0560\u02B1\x02\u0763\'\x03\x02\x02\x02" + + "\u0764\u0765\t\v\x02\x02\u0765)\x03\x02\x02\x02\u0766\u0767\x070\x02\x02" + + "\u0767\u076B\x07\u0145\x02\x02\u0768\u0769\x07\xDE\x02\x02\u0769\u076A" + + "\x07O\x02\x02\u076A\u076C\x07\u018E\x02\x02\u076B\u0768\x03\x02\x02\x02" + + "\u076B\u076C\x03\x02\x02\x02\u076C\u0773\x03\x02\x02\x02\u076D\u076F\x05" + + ",\x17\x02\u076E\u076D\x03\x02\x02\x02\u076E\u076F\x03\x02\x02\x02\u076F" + + "\u0770\x03\x02\x02\x02\u0770\u0771\x07l\x02\x02\u0771\u0774\x05\u055E" + + "\u02B0\x02\u0772\u0774\x05\u0562\u02B2\x02\u0773\u076E\x03\x02\x02\x02" + + "\u0773\u0772\x03\x02\x02\x02\u0774\u0775\x03\x02\x02\x02\u0775\u0776\x05" + + ".\x18\x02\u0776+\x03\x02\x02\x02\u0777\u0778\x05\u0562\u02B2\x02\u0778" + + "-\x03\x02\x02\x02\u0779\u077B\x050\x19\x02\u077A\u0779\x03\x02\x02\x02" + + "\u077B\u077E\x03\x02\x02\x02\u077C\u077A\x03\x02\x02\x02\u077C\u077D\x03" + + "\x02\x02\x02\u077D/\x03\x02\x02\x02\u077E\u077C\x03\x02\x02\x02\u077F" + + "\u0786\x05\xACW\x02\u0780\u0786\x05\u0258\u012D\x02\u0781\u0786\x05\u011A" + + "\x8E\x02\u0782\u0786\x05\u0198\xCD\x02\u0783\u0786\x05\u0230\u0119\x02" + + "\u0784\u0786\x05\u032C\u0197\x02\u0785\u077F\x03\x02\x02\x02\u0785\u0780" + + "\x03\x02\x02\x02\u0785\u0781\x03\x02\x02\x02\u0785\u0782\x03\x02\x02\x02" + + "\u0785\u0783\x03\x02\x02\x02\u0785\u0784\x03\x02\x02\x02\u07861\x03\x02" + + "\x02\x02\u0787\u0789\x07\u014F\x02\x02\u0788\u078A\t\f\x02\x02\u0789\u0788" + + "\x03\x02\x02\x02\u0789\u078A\x03\x02\x02\x02\u078A\u078B\x03\x02\x02\x02" + + "\u078B\u078C\x054\x1B\x02\u078C3\x03\x02\x02\x02\u078D\u078E\x07\u0166" + + "\x02\x02\u078E\u0796\x05\u0326\u0194\x02\u078F\u0790\x07\u014E\x02\x02" + + "\u0790\u0791\x07\x9C\x02\x02\u0791\u0792\x07&\x02\x02\u0792\u0793\x07" + + "\u0166\x02\x02\u0793\u0796\x05\u0326\u0194\x02\u0794\u0796\x058\x1D\x02" + + "\u0795\u078D\x03\x02\x02\x02\u0795\u078F\x03\x02\x02\x02\u0795\u0794\x03" + + "\x02\x02\x02\u07965\x03\x02\x02\x02\u0797\u0798\x05:\x1E\x02\u0798\u0799" + + "\t\r\x02\x02\u0799\u079A\x05<\x1F\x02\u079A7\x03\x02\x02\x02\u079B\u07B7" + + "\x056\x1C\x02\u079C\u079D\x05:\x1E\x02\u079D\u079E\x07B\x02\x02\u079E" + + "\u079F\x07\u01B4\x02\x02\u079F\u07B7\x03\x02\x02\x02\u07A0\u07A1\x07\u01A4" + + "\x02\x02\u07A1\u07A2\x07\u0184\x02\x02\u07A2\u07B7\x05D#\x02\u07A3\u07A4" + + "\x07\x9A\x02\x02\u07A4\u07B7\x05\u0552\u02AA\x02\u07A5\u07A6\x07\u0145" + + "\x02\x02\u07A6\u07B7\x05\u0552\u02AA\x02\u07A7\u07A9\x07\u010D\x02\x02" + + "\u07A8\u07AA\x05F$\x02\u07A9\u07A8\x03\x02\x02\x02\u07A9\u07AA\x03\x02" + + "\x02\x02\u07AA\u07B7\x03\x02\x02\x02\u07AB\u07AC\x07\u0140\x02\x02\u07AC" + + "\u07B7\x05H%\x02\u07AD\u07AE\x07\u014E\x02\x02\u07AE\u07AF\x07l\x02\x02" + + "\u07AF\u07B7\x05H%\x02\u07B0\u07B1\x07\u0181\x02\x02\u07B1\u07B2\x07\u0119" + + "\x02\x02\u07B2\u07B7\x05\u04CE\u0268\x02\u07B3\u07B4\x07\u0166\x02\x02" + + "\u07B4\u07B5\x07\u0153\x02\x02\u07B5\u07B7\x05\u0552\u02AA\x02\u07B6\u079B" + + "\x03\x02\x02\x02\u07B6\u079C\x03\x02\x02\x02\u07B6\u07A0\x03\x02\x02\x02" + + "\u07B6\u07A3\x03\x02\x02\x02\u07B6\u07A5\x03\x02\x02\x02\u07B6\u07A7\x03" + + "\x02\x02\x02\u07B6\u07AB\x03\x02\x02\x02\u07B6\u07AD\x03\x02\x02\x02\u07B6" + + "\u07B0\x03\x02\x02\x02\u07B6\u07B3\x03\x02\x02\x02\u07B79\x03\x02\x02" + + "\x02\u07B8\u07BD\x05\u0562\u02B2\x02\u07B9\u07BA\x07\r\x02\x02\u07BA\u07BC" + + "\x05\u0562\u02B2\x02\u07BB\u07B9\x03\x02\x02\x02\u07BC\u07BF\x03\x02\x02" + + "\x02\u07BD\u07BB\x03\x02\x02\x02\u07BD\u07BE\x03\x02\x02\x02\u07BE;\x03" + + "\x02\x02\x02\u07BF\u07BD\x03\x02\x02\x02\u07C0\u07C5\x05> \x02\u07C1\u07C2" + + "\x07\b\x02\x02\u07C2\u07C4\x05> \x02\u07C3\u07C1\x03\x02\x02\x02\u07C4" + + "\u07C7\x03\x02\x02\x02\u07C5\u07C3\x03\x02\x02\x02\u07C5\u07C6\x03\x02" + + "\x02\x02\u07C6=\x03\x02\x02\x02\u07C7\u07C5\x03\x02\x02\x02\u07C8\u07CB" + + "\x05B\"\x02\u07C9\u07CB\x05\u0128\x95\x02\u07CA\u07C8\x03\x02\x02\x02" + + "\u07CA\u07C9\x03\x02\x02\x02\u07CB?\x03\x02\x02\x02\u07CC\u07CD\x07\u012E" + + "\x02\x02\u07CD\u07D2\t\x0E\x02\x02\u07CE\u07CF\x07\u0138\x02\x02\u07CF" + + "\u07D2\x07\u012E\x02\x02\u07D0\u07D2\x07\u014C\x02\x02\u07D1\u07CC\x03" + + "\x02\x02\x02\u07D1\u07CE\x03\x02\x02\x02\u07D1\u07D0\x03\x02\x02\x02\u07D2" + + "A\x03\x02\x02\x02\u07D3\u07D8\x07b\x02\x02\u07D4\u07D8\x07>\x02\x02\u07D5" + + "\u07D8\x07R\x02\x02\u07D6\u07D8\x05H%\x02\u07D7\u07D3\x03\x02\x02\x02" + + "\u07D7\u07D4\x03\x02\x02\x02\u07D7\u07D5\x03\x02\x02\x02\u07D7\u07D6\x03" + + "\x02\x02\x02\u07D8C\x03\x02\x02\x02\u07D9\u07EA\x05\u0552\u02AA\x02\u07DA" + + "\u07EA\x05\u0572\u02BA\x02\u07DB\u07DC\x05\u0484\u0243\x02\u07DC\u07DE" + + "\x05\u0552\u02AA\x02\u07DD\u07DF\x05\u0488\u0245\x02\u07DE\u07DD\x03\x02" + + "\x02\x02\u07DE\u07DF\x03\x02\x02\x02\u07DF\u07EA\x03\x02\x02\x02\u07E0" + + "\u07E1\x05\u0484\u0243\x02\u07E1\u07E2\x07\x04\x02\x02\u07E2\u07E3\x05" + + "\u0550\u02A9\x02\u07E3\u07E4\x07\x05\x02\x02\u07E4\u07E5\x05\u0552\u02AA" + + "\x02\u07E5\u07EA\x03\x02\x02\x02\u07E6\u07EA\x05\u0128\x95\x02\u07E7\u07EA" + + "\x077\x02\x02\u07E8\u07EA\x07\u0100\x02\x02\u07E9\u07D9\x03\x02\x02\x02" + + "\u07E9\u07DA\x03\x02\x02\x02\u07E9\u07DB\x03\x02\x02\x02\u07E9\u07E0\x03" + + "\x02\x02\x02\u07E9\u07E6\x03\x02\x02\x02\u07E9\u07E7\x03\x02\x02\x02\u07E9" + + "\u07E8\x03\x02\x02\x02\u07EAE\x03\x02\x02\x02\u07EB\u07EE\x05\u0552\u02AA" + + "\x02\u07EC\u07EE\x077\x02\x02\u07ED\u07EB\x03\x02\x02\x02\u07ED\u07EC" + + "\x03\x02\x02\x02\u07EEG\x03\x02\x02\x02\u07EF\u07F2\x05\u056E\u02B8\x02" + + "\u07F0\u07F2\x05\u0552\u02AA\x02\u07F1\u07EF\x03\x02\x02\x02\u07F1\u07F0" + + "\x03\x02\x02\x02\u07F2I\x03\x02\x02\x02\u07F3\u07F4\x07\u013B\x02\x02" + + "\u07F4\u07F5\x05L\'\x02\u07F5K\x03\x02\x02\x02\u07F6\u07FF\x05N(\x02\u07F7" + + "\u07F8\x07\u01A4\x02\x02\u07F8\u07FF\x07\u0184\x02\x02\u07F9\u07FA\x07" + + "\u0166\x02\x02\u07FA\u07FB\x07\xF6\x02\x02\u07FB\u07FF\x07\xFD\x02\x02" + + "\u07FC\u07FD\x07\u014E\x02\x02\u07FD\u07FF\x07l\x02\x02\u07FE\u07F6\x03" + + "\x02\x02\x02\u07FE\u07F7\x03\x02\x02\x02\u07FE\u07F9\x03\x02\x02\x02\u07FE" + + "\u07FC\x03\x02\x02\x02\u07FFM\x03\x02\x02\x02\u0800\u0803\x05:\x1E\x02" + + "\u0801\u0803\x07 \x02\x02\u0802\u0800\x03\x02\x02\x02\u0802\u0801\x03" + + "\x02\x02\x02\u0803O\x03\x02\x02\x02\u0804\u0805\x07\u014F\x02\x02\u0805" + + "\u0808\x054\x1B\x02\u0806\u0808\x05J&\x02\u0807\u0804\x03\x02\x02\x02" + + "\u0807\u0806\x03\x02\x02\x02\u0808Q\x03\x02\x02\x02\u0809\u080A\x07\u014F" + + "\x02\x02\u080A\u080D\x058\x1D\x02\u080B\u080D\x05J&\x02\u080C\u0809\x03" + + "\x02\x02\x02\u080C\u080B\x03\x02\x02\x02\u080DS\x03\x02\x02\x02\u080E" + + "\u0818\x07\u0151\x02\x02\u080F\u0819\x05:\x1E\x02\u0810\u0811\x07\u01A4" + + "\x02\x02\u0811\u0819\x07\u0184\x02\x02\u0812\u0813\x07\u0166\x02\x02\u0813" + + "\u0814\x07\xF6\x02\x02\u0814\u0819\x07\xFD\x02\x02\u0815\u0816\x07\u014E" + + "\x02\x02\u0816\u0819\x07l\x02\x02\u0817\u0819\x07 \x02\x02\u0818\u080F" + + "\x03\x02\x02\x02\u0818\u0810\x03\x02\x02\x02\u0818\u0812\x03\x02\x02\x02" + + "\u0818\u0815\x03\x02\x02\x02\u0818\u0817\x03\x02\x02\x02\u0819U\x03\x02" + + "\x02\x02\u081A\u081B\x07\u014F\x02\x02\u081B\u081C\x07\xA7\x02\x02\u081C" + + "\u081D\x05X-\x02\u081D\u081E\x05Z.\x02\u081EW\x03\x02\x02\x02\u081F\u0822" + + "\x07 \x02\x02\u0820\u0822\x05\u0538\u029D\x02\u0821\u081F\x03\x02\x02" + + "\x02\u0821\u0820\x03\x02\x02\x02\u0822Y\x03\x02\x02\x02\u0823\u0824\t" + + "\x0F\x02\x02\u0824[\x03\x02\x02\x02\u0825\u0826\x07\x9D\x02\x02\u0826" + + "]\x03\x02\x02\x02\u0827\u0828\x07\xBD\x02\x02\u0828\u0829\t\x10\x02\x02" + + "\u0829_\x03\x02\x02\x02\u082A\u082B\x07\x8C\x02\x02\u082B\u082E\x07^\x02" + + "\x02\u082C\u082D\x07\xDE\x02\x02\u082D\u082F\x07\u018E\x02\x02\u082E\u082C" + + "\x03\x02\x02\x02\u082E\u082F\x03\x02\x02\x02\u082F\u0830\x03\x02\x02\x02" + + "\u0830\u0833\x05\u0436\u021C\x02\u0831\u0834\x05b2\x02\u0832\u0834\x05" + + "d3\x02\u0833\u0831\x03\x02\x02\x02\u0833\u0832\x03\x02\x02\x02\u0834\u089B" + + "\x03\x02\x02\x02\u0835\u0836\x07\x8C\x02\x02\u0836\u0837\x07^\x02\x02" + + "\u0837\u0838\x07 \x02\x02\u0838\u0839\x07F\x02\x02\u0839\u083A\x07\u0161" + + "\x02\x02\u083A\u083E\x05\u0540\u02A1\x02\u083B\u083C\x07\u011B\x02\x02" + + "\u083C\u083D\x07\x95\x02\x02\u083D\u083F\x05\u0560\u02B1\x02\u083E\u083B" + + "\x03\x02\x02\x02\u083E\u083F\x03\x02\x02\x02\u083F\u0840\x03\x02\x02\x02" + + "\u0840\u0841\x07\u014F\x02\x02\u0841\u0842\x07\u0161\x02\x02\u0842\u0844" + + "\x05\u0540\u02A1\x02\u0843\u0845\x05\u03B0\u01D9\x02\u0844\u0843\x03\x02" + + "\x02\x02\u0844\u0845\x03\x02\x02\x02\u0845\u089B\x03\x02\x02\x02\u0846" + + "\u0847\x07\x8C\x02\x02\u0847\u084A\x07\xE4\x02\x02\u0848\u0849\x07\xDE" + + "\x02\x02\u0849\u084B\x07\u018E\x02\x02\u084A\u0848\x03\x02\x02\x02\u084A" + + "\u084B\x03\x02\x02\x02\u084B\u084C\x03\x02\x02\x02\u084C\u084F\x05\u053C" + + "\u029F\x02\u084D\u0850\x05b2\x02\u084E\u0850\x05f4\x02\u084F\u084D\x03" + + "\x02\x02\x02\u084F\u084E\x03\x02\x02\x02\u0850\u089B\x03\x02\x02\x02\u0851" + + "\u0852\x07\x8C\x02\x02\u0852\u0853\x07\xE4\x02\x02\u0853\u0854\x07 \x02" + + "\x02\u0854\u0855\x07F\x02\x02\u0855\u0856\x07\u0161\x02\x02\u0856\u085A" + + "\x05\u0540\u02A1\x02\u0857\u0858\x07\u011B\x02\x02\u0858\u0859\x07\x95" + + "\x02\x02\u0859\u085B\x05\u0560\u02B1\x02\u085A\u0857\x03\x02\x02\x02\u085A" + + "\u085B\x03\x02\x02\x02\u085B\u085C\x03\x02\x02\x02\u085C\u085D\x07\u014F" + + "\x02\x02\u085D\u085E\x07\u0161\x02\x02\u085E\u0860\x05\u0540\u02A1\x02" + + "\u085F\u0861\x05\u03B0\u01D9\x02\u0860\u085F\x03\x02\x02\x02\u0860\u0861" + + "\x03\x02\x02\x02\u0861\u089B\x03\x02\x02\x02\u0862\u0863\x07\x8C\x02\x02" + + "\u0863\u0866\x07\u014A\x02\x02\u0864\u0865\x07\xDE\x02\x02\u0865\u0867" + + "\x07\u018E\x02\x02\u0866\u0864\x03\x02\x02\x02\u0866\u0867\x03\x02\x02" + + "\x02\u0867\u0868\x03\x02\x02\x02\u0868\u0869\x05\u053C\u029F\x02\u0869" + + "\u086A\x05b2\x02\u086A\u089B\x03\x02\x02\x02\u086B\u086C\x07\x8C\x02\x02" + + "\u086C\u086F\x07\u017A\x02\x02\u086D\u086E\x07\xDE\x02\x02\u086E\u0870" + + "\x07\u018E\x02\x02\u086F\u086D\x03\x02\x02\x02\u086F\u0870\x03\x02\x02" + + "\x02\u0870\u0871\x03\x02\x02\x02\u0871\u0872\x05\u053C\u029F\x02\u0872" + + "\u0873\x05"; private static readonly _serializedATNSegment7: string = - "\u052C\u0297\x02\u0893g\x03\x02\x02\x02\u0894\u0895\x07\x87\x02\x02\u0895" + - "\u09BF\x05\xBC_\x02\u0896\u0897\x07\x87\x02\x02\u0897\u0898\x07\xDE\x02" + - "\x02\u0898\u0899\x07O\x02\x02\u0899\u089A\x07\u0185\x02\x02\u089A\u09BF" + - "\x05\xBC_\x02\u089B\u089C\x07\x87\x02\x02\u089C\u089D\x07.\x02\x02\u089D" + - "\u09BF\x05\xBC_\x02\u089E\u089F\x07\x87\x02\x02\u089F\u08A0\x07.\x02\x02" + - "\u08A0\u08A1\x07\xDE\x02\x02\u08A1\u08A2\x07O\x02\x02\u08A2\u08A3\x07" + - "\u0185\x02\x02\u08A3\u09BF\x05\xBC_\x02\u08A4\u08A6\x07\x8C\x02\x02\u08A5" + - "\u08A7\x05\u02D4\u016B\x02\u08A6\u08A5\x03\x02\x02\x02\u08A6\u08A7\x03" + - "\x02\x02\x02\u08A7\u08A8\x03\x02\x02\x02\u08A8\u08A9\x05\u0550\u02A9\x02" + - "\u08A9\u08AA\x05j6\x02\u08AA\u09BF\x03\x02\x02\x02\u08AB\u08AD\x07\x8C" + - "\x02\x02\u08AC\u08AE\x05\u02D4\u016B\x02\u08AD\u08AC\x03\x02\x02\x02\u08AD" + - "\u08AE\x03\x02\x02\x02\u08AE\u08AF\x03\x02\x02\x02\u08AF\u08B0\x05\u0550" + - "\u02A9\x02\u08B0\u08B1\x07\xC1\x02\x02\u08B1\u08B2\x07O\x02\x02\u08B2" + - "\u08B3\x07P\x02\x02\u08B3\u09BF\x03\x02\x02\x02\u08B4\u08B6\x07\x8C\x02" + - "\x02\u08B5\u08B7\x05\u02D4\u016B\x02\u08B6\u08B5\x03\x02\x02\x02\u08B6" + - "\u08B7\x03\x02\x02\x02\u08B7\u08B8\x03\x02\x02\x02\u08B8\u08B9\x05\u0550" + - "\u02A9\x02\u08B9\u08BA\x07\u0146\x02\x02\u08BA\u08BB\x07O\x02\x02\u08BB" + - "\u08BC\x07P\x02\x02\u08BC\u09BF\x03\x02\x02\x02\u08BD\u08BF\x07\x8C\x02" + - "\x02\u08BE\u08C0\x05\u02D4\u016B\x02\u08BF\u08BE\x03\x02\x02\x02\u08BF" + - "\u08C0\x03\x02\x02\x02\u08C0\u08C1\x03\x02\x02\x02\u08C1\u08C2\x05\u0550" + - "\u02A9\x02\u08C2\u08C3\x07\xC1\x02\x02\u08C3\u08C4\x07\u01AE\x02\x02\u08C4" + - "\u09BF\x03\x02\x02\x02\u08C5\u08C7\x07\x8C\x02\x02\u08C6\u08C8\x05\u02D4" + - "\u016B\x02\u08C7\u08C6\x03\x02\x02\x02\u08C7\u08C8\x03\x02\x02\x02\u08C8" + - "\u08C9\x03\x02\x02\x02\u08C9\u08CA\x05\u0550\u02A9\x02\u08CA\u08CB\x07" + - "\xC1\x02\x02\u08CB\u08CC\x07\u01AE\x02\x02\u08CC\u08CD\x07\xDE\x02\x02" + - "\u08CD\u08CE\x07\u0185\x02\x02\u08CE\u09BF\x03\x02\x02\x02\u08CF\u08D1" + - "\x07\x8C\x02\x02\u08D0\u08D2\x05\u02D4\u016B\x02\u08D1\u08D0\x03\x02\x02" + - "\x02\u08D1\u08D2\x03\x02\x02\x02\u08D2\u08D3\x03\x02\x02\x02\u08D3\u08D4" + - "\x05\u0550\u02A9\x02\u08D4\u08D5\x07\u0146\x02\x02\u08D5\u08D6\x07\u014F" + - "\x02\x02\u08D6\u08D7\x05\u0548\u02A5\x02\u08D7\u09BF\x03\x02\x02\x02\u08D8" + - "\u08DA\x07\x8C\x02\x02\u08D9\u08DB\x05\u02D4\u016B\x02\u08DA\u08D9\x03" + - "\x02\x02\x02\u08DA\u08DB\x03\x02\x02\x02\u08DB\u08DC\x03\x02\x02\x02\u08DC" + - "\u08DD\x05\u0540\u02A1\x02\u08DD\u08DE\x07\u0146\x02\x02\u08DE\u08DF\x07" + - "\u014F\x02\x02\u08DF\u08E0\x05\u0548\u02A5\x02\u08E0\u09BF\x03\x02\x02" + - "\x02\u08E1\u08E3\x07\x8C\x02\x02\u08E2\u08E4\x05\u02D4\u016B\x02\u08E3" + - "\u08E2\x03\x02\x02\x02\u08E3\u08E4\x03\x02\x02\x02\u08E4\u08E5\x03\x02" + - "\x02\x02\u08E5\u08E6\x05\u0550\u02A9\x02\u08E6\u08E7\x07\u0146\x02\x02" + - "\u08E7\u08E8\x05t;\x02\u08E8\u09BF\x03\x02\x02\x02\u08E9\u08EB\x07\x8C" + - "\x02\x02\u08EA\u08EC\x05\u02D4\u016B\x02\u08EB\u08EA\x03\x02\x02\x02\u08EB" + - "\u08EC\x03\x02\x02\x02\u08EC\u08ED\x03\x02\x02\x02\u08ED\u08EE\x05\u0550" + - "\u02A9\x02\u08EE\u08EF\x07\u0132\x02\x02\u08EF\u08F0\x05t;\x02\u08F0\u09BF" + - "\x03\x02\x02\x02\u08F1\u08F3\x07\x8C\x02\x02\u08F2\u08F4\x05\u02D4\u016B" + - "\x02\u08F3\u08F2\x03\x02\x02\x02\u08F3\u08F4\x03\x02\x02\x02\u08F4\u08F5" + - "\x03\x02\x02\x02\u08F5\u08F6\x05\u0550\u02A9\x02\u08F6\u08F7\x07\u0146" + - "\x02\x02\u08F7\u08F8\x07\u0152\x02\x02\u08F8\u08F9\x05\u0550\u02A9\x02" + - "\u08F9\u09BF\x03\x02\x02\x02\u08FA\u08FC\x07\x8C\x02\x02\u08FB\u08FD\x05" + - "\u02D4\u016B\x02\u08FC\u08FB\x03\x02\x02\x02\u08FC\u08FD\x03\x02\x02\x02" + - "\u08FD\u08FE\x03\x02\x02\x02\u08FE\u08FF\x05\u0550\u02A9\x02\u08FF\u0900" + - "\x07\x87\x02\x02\u0900\u0901\x07\u01AF\x02\x02\u0901\u0902\x05\xC6d\x02" + - "\u0902\u0903\x07&\x02\x02\u0903\u0905\x07\xDD\x02\x02\u0904\u0906\x05" + - "\u011C\x8F\x02\u0905\u0904\x03\x02\x02\x02\u0905\u0906\x03\x02\x02\x02" + - "\u0906\u09BF\x03\x02\x02\x02\u0907\u0909\x07\x8C\x02\x02\u0908\u090A\x05" + - "\u02D4\u016B\x02\u0909\u0908\x03\x02\x02\x02\u0909\u090A\x03\x02\x02\x02" + - "\u090A\u090B\x03\x02\x02\x02\u090B\u090C\x05\u0550\u02A9\x02\u090C\u090D" + - "\x05|?\x02\u090D\u09BF\x03\x02\x02\x02\u090E\u0910\x07\x8C\x02\x02\u090F" + - "\u0911\x05\u02D4\u016B\x02\u0910\u090F\x03\x02\x02\x02\u0910\u0911\x03" + - "\x02\x02\x02\u0911\u0912\x03\x02\x02\x02\u0912\u0913\x05\u0550\u02A9\x02" + - "\u0913\u0914\x07\xC1\x02\x02\u0914\u0915\x07\xDD\x02\x02\u0915\u09BF\x03" + - "\x02\x02\x02\u0916\u0918\x07\x8C\x02\x02\u0917\u0919\x05\u02D4\u016B\x02" + - "\u0918\u0917\x03\x02\x02\x02\u0918\u0919\x03\x02\x02\x02\u0919\u091A\x03" + - "\x02\x02\x02\u091A\u091B\x05\u0550\u02A9\x02\u091B\u091C\x07\xC1\x02\x02" + - "\u091C\u091D\x07\xDD\x02\x02\u091D\u091E\x07\xDE\x02\x02\u091E\u091F\x07" + - "\u0185\x02\x02\u091F\u09BF\x03\x02\x02\x02\u0920\u0922\x07\xC1\x02\x02" + - "\u0921\u0923\x05\u02D4\u016B\x02\u0922\u0921\x03\x02\x02\x02\u0922\u0923" + - "\x03\x02\x02\x02\u0923\u0924\x03\x02\x02\x02\u0924\u0925\x07\xDE\x02\x02" + - "\u0925\u0926\x07\u0185\x02\x02\u0926\u0928\x05\u0550\u02A9\x02\u0927\u0929" + - "\x05l7\x02\u0928\u0927\x03\x02\x02\x02\u0928\u0929\x03\x02\x02\x02\u0929" + - "\u09BF\x03\x02\x02\x02\u092A\u092C\x07\xC1\x02\x02\u092B\u092D\x05\u02D4" + - "\u016B\x02\u092C\u092B\x03\x02\x02\x02\u092C\u092D\x03\x02\x02\x02\u092D" + - "\u092E\x03\x02\x02\x02\u092E\u0930\x05\u0550\u02A9\x02\u092F\u0931\x05" + - "l7\x02\u0930\u092F\x03\x02\x02\x02\u0930\u0931\x03\x02\x02\x02\u0931\u09BF" + - "\x03\x02\x02\x02\u0932\u0934\x07\x8C\x02\x02\u0933\u0935\x05\u02D4\u016B" + - "\x02\u0934\u0933\x03\x02\x02\x02\u0934\u0935\x03\x02\x02\x02\u0935\u0936" + - "\x03\x02\x02\x02\u0936\u0938\x05\u0550\u02A9\x02\u0937\u0939\x05\u02D6" + - "\u016C\x02\u0938\u0937\x03\x02\x02\x02\u0938\u0939\x03\x02\x02\x02\u0939" + - "\u093A\x03\x02\x02\x02\u093A\u093B\x07\u0161\x02\x02\u093B\u093D\x05\u0454" + - "\u022B\x02\u093C\u093E\x05n8\x02\u093D\u093C\x03\x02\x02\x02\u093D\u093E" + - "\x03\x02\x02\x02\u093E\u0940\x03\x02\x02\x02\u093F\u0941\x05p9\x02\u0940" + - "\u093F\x03\x02\x02\x02\u0940\u0941\x03\x02\x02\x02\u0941\u09BF\x03\x02" + - "\x02\x02\u0942\u0944\x07\x8C\x02\x02\u0943\u0945\x05\u02D4\u016B\x02\u0944" + - "\u0943\x03\x02\x02\x02\u0944\u0945\x03\x02\x02\x02\u0945\u0946\x03\x02" + - "\x02\x02\u0946\u0947\x05\u0550\u02A9\x02\u0947\u0948\x05\u0158\xAD\x02" + - "\u0948\u09BF\x03\x02\x02\x02\u0949\u094A\x07\x87\x02\x02\u094A\u09BF\x05" + - "\xD0i\x02\u094B\u094C\x07\x8C\x02\x02\u094C\u094D\x07/\x02\x02\u094D\u094E" + - "\x05\u0530\u0299\x02\u094E\u094F\x05\u01B8\xDD\x02\u094F\u09BF\x03\x02" + - "\x02\x02\u0950\u0951\x07\u016D\x02\x02\u0951\u0952\x07/\x02\x02\u0952" + - "\u09BF\x05\u0530\u0299\x02\u0953\u0954\x07\xC1\x02\x02\u0954\u0955\x07" + - "/\x02\x02\u0955\u0956\x07\xDE\x02\x02\u0956\u0957\x07\u0185\x02\x02\u0957" + - "\u0959\x05\u0530\u0299\x02\u0958\u095A\x05l7\x02\u0959\u0958\x03\x02\x02" + - "\x02\u0959\u095A\x03\x02\x02\x02\u095A\u09BF\x03\x02\x02\x02\u095B\u095C" + - "\x07\xC1\x02\x02\u095C\u095D\x07/\x02\x02\u095D\u095F\x05\u0530\u0299" + - "\x02\u095E\u0960\x05l7\x02\u095F\u095E\x03\x02\x02\x02\u095F\u0960\x03" + - "\x02\x02\x02\u0960\u09BF\x03\x02\x02\x02\u0961\u0962\x07\u0146\x02\x02" + - "\u0962\u0963\x07\u0174\x02\x02\u0963\u09BF\x07\u010E\x02\x02\u0964\u0965" + - "\x07\xA0\x02\x02\u0965\u0966\x07R\x02\x02\u0966\u09BF\x05\u0530\u0299" + - "\x02\u0967\u0968\x07\u0146\x02\x02\u0968\u0969\x07\u0174\x02\x02\u0969" + - "\u09BF\x07\xA0\x02\x02\u096A\u096B\x07\u0146\x02\x02\u096B\u09BF\x07\u01B0" + - "\x02\x02\u096C\u096D\x07\u0146\x02\x02\u096D\u09BF\x07\u0168\x02\x02\u096E" + - "\u096F\x07\xC3\x02\x02\u096F\u0970\x07\u015E\x02\x02\u0970\u09BF\x05\u0530" + - "\u0299\x02\u0971\u0972\x07\xC3\x02\x02\u0972\u0973\x07\x8D\x02\x02\u0973" + - "\u0974\x07\u015E\x02\x02\u0974\u09BF\x05\u0530\u0299\x02\u0975\u0976\x07" + - "\xC3\x02\x02\u0976\u0977\x07\u0131\x02\x02\u0977\u0978\x07\u015E\x02\x02" + - "\u0978\u09BF\x05\u0530\u0299\x02\u0979\u097A\x07\xC3\x02\x02\u097A\u097B" + - "\x07\u015E\x02\x02\u097B\u09BF\x07 \x02\x02\u097C\u097D\x07\xC3\x02\x02" + - "\u097D\u097E\x07\u015E\x02\x02\u097E\u09BF\x07e\x02\x02\u097F\u0980\x07" + - "\xBC\x02\x02\u0980\u0981\x07\u015E\x02\x02\u0981\u09BF\x05\u0530\u0299" + - "\x02\u0982\u0983\x07\xBC\x02\x02\u0983\u0984\x07\u015E\x02\x02\u0984\u09BF" + - "\x07 \x02\x02\u0985\u0986\x07\xBC\x02\x02\u0986\u0987\x07\u015E\x02\x02" + - "\u0987\u09BF\x07e\x02\x02\u0988\u0989\x07\xC3\x02\x02\u0989\u098A\x07" + - "\u013A\x02\x02\u098A\u09BF\x05\u0530\u0299\x02\u098B\u098C\x07\xC3\x02" + - "\x02\u098C\u098D\x07\x8D\x02\x02\u098D\u098E\x07\u013A\x02\x02\u098E\u09BF" + - "\x05\u0530\u0299\x02\u098F\u0990\x07\xC3\x02\x02\u0990\u0991\x07\u0131" + - "\x02\x02\u0991\u0992\x07\u013A\x02\x02\u0992\u09BF\x05\u0530\u0299\x02" + - "\u0993\u0994\x07\xBC\x02\x02\u0994\u0995\x07\u013A\x02\x02\u0995\u09BF" + - "\x05\u0530\u0299\x02\u0996\u0997\x07\xE6\x02\x02\u0997\u09BF\x05\u052C" + - "\u0297\x02\u0998\u0999\x07\u0106\x02\x02\u0999\u099A\x07\xE6\x02\x02\u099A" + - "\u09BF\x05\u052C\u0297\x02\u099B\u099C\x07\u010C\x02\x02\u099C\u09BF\x05" + - "\u020C\u0107\x02\u099D\u099E\x07O\x02\x02\u099E\u09BF\x07\u010C\x02\x02" + - "\u099F\u09A0\x07\u0113\x02\x02\u09A0\u09A1\x07`\x02\x02\u09A1\u09BF\x05" + - "\u054C\u02A7\x02\u09A2\u09A3\x07\u0146\x02\x02\u09A3\u09A4\x07\u0158\x02" + - "\x02\u09A4\u09BF\x05\u0530\u0299\x02\u09A5\u09A6\x07\u0146\x02\x02\u09A6" + - "\u09BF\x05t;\x02\u09A7\u09A8\x07\u0132\x02\x02\u09A8\u09BF\x05t;\x02\u09A9" + - "\u09AA\x07\u0131\x02\x02\u09AA\u09AB\x07\xDD\x02\x02\u09AB\u09BF\x05r" + - ":\x02\u09AC\u09AD\x07\xC3\x02\x02\u09AD\u09AE\x07\u0197\x02\x02\u09AE" + - "\u09AF\x07\xF4\x02\x02\u09AF\u09BF\x07\u0140\x02\x02\u09B0\u09B1\x07\xBC" + - "\x02\x02\u09B1\u09B2\x07\u0197\x02\x02\u09B2\u09B3\x07\xF4\x02\x02\u09B3" + - "\u09BF\x07\u0140\x02\x02\u09B4\u09B5\x07\xD3\x02\x02\u09B5\u09B6\x07\u0197" + - "\x02\x02\u09B6\u09B7\x07\xF4\x02\x02\u09B7\u09BF\x07\u0140\x02\x02\u09B8" + - "\u09B9\x07\u0106\x02\x02\u09B9\u09BA\x07\xD3\x02\x02\u09BA\u09BB\x07\u0197" + - "\x02\x02\u09BB\u09BC\x07\xF4\x02\x02\u09BC\u09BF\x07\u0140\x02\x02\u09BD" + - "\u09BF\x05\u0158\xAD\x02\u09BE\u0894\x03\x02\x02\x02\u09BE\u0896\x03\x02" + - "\x02\x02\u09BE\u089B\x03\x02\x02\x02\u09BE\u089E\x03\x02\x02\x02\u09BE" + - "\u08A4\x03\x02\x02\x02\u09BE\u08AB\x03\x02\x02\x02\u09BE\u08B4\x03\x02" + - "\x02\x02\u09BE\u08BD\x03\x02\x02\x02\u09BE\u08C5\x03\x02\x02\x02\u09BE" + - "\u08CF\x03\x02\x02\x02\u09BE\u08D8\x03\x02\x02\x02\u09BE\u08E1\x03\x02" + - "\x02\x02\u09BE\u08E9\x03\x02\x02\x02\u09BE\u08F1\x03\x02\x02\x02\u09BE" + - "\u08FA\x03\x02\x02\x02\u09BE\u0907\x03\x02\x02\x02\u09BE\u090E\x03\x02" + - "\x02\x02\u09BE\u0916\x03\x02\x02\x02\u09BE\u0920\x03\x02\x02\x02\u09BE" + - "\u092A\x03\x02\x02\x02\u09BE\u0932\x03\x02\x02\x02\u09BE\u0942\x03\x02" + - "\x02\x02\u09BE\u0949\x03\x02\x02\x02\u09BE\u094B\x03\x02\x02\x02\u09BE" + - "\u0950\x03\x02\x02\x02\u09BE\u0953\x03\x02\x02\x02\u09BE\u095B\x03\x02" + - "\x02\x02\u09BE\u0961\x03\x02\x02\x02\u09BE\u0964\x03\x02\x02\x02\u09BE" + - "\u0967\x03\x02\x02\x02\u09BE\u096A\x03\x02\x02\x02\u09BE\u096C\x03\x02" + - "\x02\x02\u09BE\u096E\x03\x02\x02\x02\u09BE\u0971\x03\x02\x02\x02\u09BE" + - "\u0975\x03\x02\x02\x02\u09BE\u0979\x03\x02\x02\x02\u09BE\u097C\x03\x02" + - "\x02\x02\u09BE\u097F\x03\x02\x02\x02\u09BE\u0982\x03\x02\x02\x02\u09BE" + - "\u0985\x03\x02\x02\x02\u09BE\u0988\x03\x02\x02\x02\u09BE\u098B\x03\x02" + - "\x02\x02\u09BE\u098F\x03\x02\x02\x02\u09BE\u0993\x03\x02\x02\x02\u09BE" + - "\u0996\x03\x02\x02\x02\u09BE\u0998\x03\x02\x02\x02\u09BE\u099B\x03\x02" + - "\x02\x02\u09BE\u099D\x03\x02\x02\x02\u09BE\u099F\x03\x02\x02\x02\u09BE" + - "\u09A2\x03\x02\x02\x02\u09BE\u09A5\x03\x02\x02\x02\u09BE\u09A7\x03\x02" + - "\x02\x02\u09BE\u09A9\x03\x02\x02\x02\u09BE\u09AC\x03\x02\x02\x02\u09BE" + - "\u09B0\x03\x02\x02\x02\u09BE\u09B4\x03\x02\x02\x02\u09BE\u09B8\x03\x02" + - "\x02\x02\u09BE\u09BD\x03\x02\x02\x02\u09BFi\x03\x02\x02\x02\u09C0\u09C1" + - "\x07\u0146\x02\x02\u09C1\u09C2\x077\x02\x02\u09C2\u09C6\x05\u0480\u0241" + - "\x02\u09C3\u09C4\x07\xC1\x02\x02\u09C4\u09C6\x077\x02\x02\u09C5\u09C0" + - "\x03\x02\x02\x02\u09C5\u09C3\x03\x02\x02\x02\u09C6k\x03\x02\x02\x02\u09C7" + - "\u09C8\t\f\x02\x02\u09C8m\x03\x02\x02\x02\u09C9\u09CA\x07-\x02\x02\u09CA" + - "\u09CB\x05\u020C\u0107\x02\u09CBo\x03\x02\x02\x02\u09CC\u09CD\x07f\x02" + - "\x02\u09CD\u09CE\x05\u0480\u0241\x02\u09CEq\x03\x02\x02\x02\u09CF\u09D6" + - "\x07\u0107\x02\x02\u09D0\u09D6\x07s\x02\x02\u09D1\u09D6\x077\x02\x02\u09D2" + - "\u09D3\x07f\x02\x02\u09D3\u09D4\x07\xE4\x02\x02\u09D4\u09D6\x05\u0530" + - "\u0299\x02\u09D5\u09CF\x03\x02\x02\x02\u09D5\u09D0\x03\x02\x02\x02\u09D5" + - "\u09D1\x03\x02\x02\x02\u09D5\u09D2\x03\x02\x02\x02\u09D6s\x03\x02\x02" + - "\x02\u09D7\u09D8\x07\x04\x02\x02\u09D8\u09D9\x05x=\x02\u09D9\u09DA\x07" + - "\x05\x02\x02\u09DAu\x03\x02\x02\x02\u09DB\u09DC\x07k\x02\x02\u09DC\u09DD" + - "\x05t;\x02\u09DDw\x03\x02\x02\x02\u09DE\u09E3\x05z>\x02\u09DF\u09E0\x07" + - "\b\x02\x02\u09E0\u09E2\x05z>\x02\u09E1\u09DF\x03\x02\x02\x02\u09E2\u09E5" + - "\x03\x02\x02\x02\u09E3\u09E1\x03\x02\x02\x02\u09E3\u09E4\x03\x02\x02\x02" + - "\u09E4y\x03\x02\x02\x02\u09E5\u09E3\x03\x02\x02\x02\u09E6\u09EF\x05\u0556" + - "\u02AC\x02\u09E7\u09E8\x07\f\x02\x02\u09E8\u09F0\x05\u01D2\xEA\x02\u09E9" + - "\u09EA\x07\r\x02\x02\u09EA\u09ED\x05\u0556\u02AC\x02\u09EB\u09EC\x07\f" + - "\x02\x02\u09EC\u09EE\x05\u01D2\xEA\x02\u09ED\u09EB\x03\x02\x02\x02\u09ED" + - "\u09EE\x03\x02\x02\x02\u09EE\u09F0\x03\x02\x02\x02\u09EF\u09E7\x03\x02" + - "\x02\x02\u09EF\u09E9\x03\x02\x02\x02\u09EF\u09F0\x03\x02\x02\x02\u09F0" + - "{\x03\x02\x02\x02\u09F1\u09F3\x05~@\x02\u09F2\u09F1\x03\x02\x02\x02\u09F3" + - "\u09F4\x03\x02\x02\x02\u09F4\u09F2\x03\x02\x02\x02\u09F4\u09F5\x03\x02" + - "\x02\x02\u09F5}\x03\x02\x02\x02\u09F6\u09FB\x07\u0133\x02\x02\u09F7\u09F9" + - "\x05\x10\t\x02\u09F8\u09F7\x03\x02\x02\x02\u09F8\u09F9\x03\x02\x02\x02" + - "\u09F9\u09FA\x03\x02\x02\x02\u09FA\u09FC\x05\u0124\x93\x02\u09FB\u09F8" + - "\x03\x02\x02\x02\u09FB\u09FC\x03\x02\x02\x02\u09FC\u0A04\x03\x02\x02\x02" + - "\u09FD\u0A01\x07\u0146\x02\x02\u09FE\u0A02\x05\u0120\x91\x02\u09FF\u0A00" + - "\x07\u01AF\x02\x02\u0A00\u0A02\x05\xC6d\x02\u0A01\u09FE\x03\x02\x02\x02" + - "\u0A01\u09FF\x03\x02\x02\x02\u0A02\u0A04\x03\x02\x02\x02\u0A03\u09F6\x03" + - "\x02\x02\x02\u0A03\u09FD\x03\x02\x02\x02\u0A04\x7F\x03\x02\x02\x02\u0A05" + - "\u0A06\x07@\x02\x02\u0A06\u0A07\x07\u019F\x02\x02\u0A07\u0A08\x07k\x02" + - "\x02\u0A08\u0A09\x07\x04\x02\x02\u0A09\u0A0A\x05\x84C\x02\u0A0A\u0A0B" + - "\x07\x05\x02\x02\u0A0B\u0A20\x03\x02\x02\x02\u0A0C\u0A0D\x07@\x02\x02" + - "\u0A0D\u0A0E\x07\u019F\x02\x02\u0A0E\u0A0F\x07F\x02\x02\u0A0F\u0A10\x07" + - "\x04\x02\x02\u0A10\u0A11\x05\u04F4\u027B\x02\u0A11\u0A12\x07\x05\x02\x02" + - "\u0A12\u0A20\x03\x02\x02\x02\u0A13\u0A14\x07@\x02\x02\u0A14\u0A15\x07" + - "\u019F\x02\x02\u0A15\u0A16\x07B\x02\x02\u0A16\u0A17\x07\x04\x02\x02\u0A17" + - "\u0A18\x05\u04F4\u027B\x02\u0A18\u0A19\x07\x05\x02\x02\u0A19\u0A1A\x07" + - "`\x02\x02\u0A1A\u0A1B\x07\x04\x02\x02\u0A1B\u0A1C\x05\u04F4\u027B\x02" + - "\u0A1C\u0A1D\x07\x05\x02\x02\u0A1D\u0A20\x03\x02\x02\x02\u0A1E\u0A20\x07" + - "7\x02\x02\u0A1F\u0A05\x03\x02\x02\x02\u0A1F\u0A0C\x03\x02\x02\x02\u0A1F" + - "\u0A13\x03\x02\x02\x02\u0A1F\u0A1E\x03\x02\x02\x02\u0A20\x81\x03\x02\x02" + - "\x02\u0A21\u0A22\x05\u0554\u02AB\x02\u0A22\u0A23\x05\u0540\u02A1\x02\u0A23" + - "\x83\x03\x02\x02\x02\u0A24\u0A29\x05\x82B\x02\u0A25\u0A26\x07\b\x02\x02" + - "\u0A26\u0A28\x05\x82B\x02\u0A27\u0A25\x03\x02\x02\x02\u0A28\u0A2B\x03" + - "\x02\x02\x02\u0A29\u0A27\x03\x02\x02\x02\u0A29\u0A2A\x03\x02\x02\x02\u0A2A" + - "\x85\x03\x02\x02\x02\u0A2B\u0A29\x03\x02\x02\x02\u0A2C\u0A2D\x07\x8C\x02" + - "\x02\u0A2D\u0A2E\x07\u0161\x02\x02\u0A2E\u0A2F\x05\u020C\u0107\x02\u0A2F" + - "\u0A30\x05\x88E\x02\u0A30\x87\x03\x02\x02\x02\u0A31\u0A36\x05\x8AF\x02" + - "\u0A32\u0A33\x07\b\x02\x02\u0A33\u0A35\x05\x8AF\x02\u0A34\u0A32\x03\x02" + - "\x02\x02\u0A35\u0A38\x03\x02\x02\x02\u0A36\u0A34\x03\x02\x02\x02\u0A36" + - "\u0A37\x03\x02\x02\x02\u0A37\x89\x03\x02\x02\x02\u0A38\u0A36\x03\x02\x02" + - "\x02\u0A39\u0A3A\x07\x87\x02\x02\u0A3A\u0A3B\x07\x91\x02\x02\u0A3B\u0A3D" + - "\x05\u0444\u0223\x02\u0A3C\u0A3E\x05l7\x02\u0A3D\u0A3C\x03\x02\x02\x02" + - "\u0A3D\u0A3E\x03\x02\x02\x02\u0A3E\u0A58\x03\x02\x02\x02\u0A3F\u0A40\x07" + - "\xC1\x02\x02\u0A40\u0A43\x07\x91\x02\x02\u0A41\u0A42\x07\xDE\x02\x02\u0A42" + - "\u0A44\x07\u0185\x02\x02\u0A43\u0A41\x03\x02\x02\x02\u0A43\u0A44\x03\x02" + - "\x02\x02\u0A44\u0A45\x03\x02\x02\x02\u0A45\u0A47\x05\u0550\u02A9\x02\u0A46" + - "\u0A48\x05l7\x02\u0A47\u0A46\x03\x02\x02\x02\u0A47\u0A48\x03\x02\x02\x02" + - "\u0A48\u0A58\x03\x02\x02\x02\u0A49\u0A4A\x07\x8C\x02\x02\u0A4A\u0A4B\x07" + - "\x91\x02\x02\u0A4B\u0A4D\x05\u0550\u02A9\x02\u0A4C\u0A4E\x05\u02D6\u016C" + - "\x02\u0A4D\u0A4C\x03\x02\x02\x02\u0A4D\u0A4E\x03\x02\x02\x02\u0A4E\u0A4F" + - "\x03\x02\x02\x02\u0A4F\u0A50\x07\u0161\x02\x02\u0A50\u0A52\x05\u0454\u022B" + - "\x02\u0A51\u0A53\x05n8\x02\u0A52\u0A51\x03\x02\x02\x02\u0A52\u0A53\x03" + - "\x02\x02\x02\u0A53\u0A55\x03\x02\x02\x02\u0A54\u0A56\x05l7\x02\u0A55\u0A54" + - "\x03\x02\x02\x02\u0A55\u0A56\x03\x02\x02\x02\u0A56\u0A58\x03\x02\x02\x02" + - "\u0A57\u0A39\x03\x02\x02\x02\u0A57\u0A3F\x03\x02\x02\x02\u0A57\u0A49\x03" + - "\x02\x02\x02\u0A58\x8B\x03\x02\x02\x02\u0A59\u0A5C\x07\x9F\x02\x02\u0A5A" + - "\u0A5D\x05\u03B2\u01DA\x02\u0A5B\u0A5D\x07 \x02\x02\u0A5C\u0A5A\x03\x02" + - "\x02\x02\u0A5C\u0A5B\x03\x02\x02\x02\u0A5D\x8D\x03\x02\x02\x02\u0A5E\u0A60" + - "\x07\xAB\x02\x02\u0A5F\u0A61\x05\x9CO\x02\u0A60\u0A5F\x03\x02\x02\x02" + - "\u0A60\u0A61\x03\x02\x02\x02\u0A61\u0A62\x03\x02\x02\x02\u0A62\u0A64\x05" + - "\u052C\u0297\x02\u0A63\u0A65\x05\xD6l\x02\u0A64\u0A63\x03\x02\x02\x02" + - "\u0A64\u0A65\x03\x02\x02\x02\u0A65\u0A66\x03\x02\x02\x02\u0A66\u0A68\x05" + - "\x90I\x02\u0A67\u0A69\x05\x92J\x02\u0A68\u0A67\x03\x02\x02\x02\u0A68\u0A69" + - "\x03\x02\x02\x02\u0A69\u0A6A\x03\x02\x02\x02\u0A6A\u0A6C\x05\x94K\x02" + - "\u0A6B\u0A6D\x05\x9EP\x02\u0A6C\u0A6B\x03\x02\x02\x02\u0A6C\u0A6D\x03" + - "\x02\x02\x02\u0A6D\u0A6F\x03\x02\x02\x02\u0A6E\u0A70\x05\x10\t\x02\u0A6F" + - "\u0A6E\x03\x02\x02\x02\u0A6F\u0A70\x03\x02\x02\x02\u0A70\u0A71\x03\x02" + - "\x02\x02\u0A71\u0A73\x05\x96L\x02\u0A72\u0A74\x05\u043C\u021F\x02\u0A73" + - "\u0A72\x03\x02\x02\x02\u0A73\u0A74\x03\x02\x02\x02\u0A74\u0A84\x03\x02" + - "\x02\x02\u0A75\u0A76\x07\xAB\x02\x02\u0A76\u0A77\x07\x04\x02\x02\u0A77" + - "\u0A78\x05\u037E\u01C0\x02\u0A78\u0A79\x07\x05\x02\x02\u0A79\u0A7B\x07" + - "`\x02\x02\u0A7A\u0A7C\x05\x92J\x02\u0A7B\u0A7A\x03\x02\x02\x02\u0A7B\u0A7C" + - "\x03\x02\x02\x02\u0A7C\u0A7D\x03\x02\x02\x02\u0A7D\u0A7F\x05\x94K\x02" + - "\u0A7E\u0A80\x05\x10\t\x02\u0A7F\u0A7E\x03\x02\x02\x02\u0A7F\u0A80\x03" + - "\x02\x02\x02\u0A80\u0A81\x03\x02\x02\x02\u0A81\u0A82\x05\x96L\x02\u0A82" + - "\u0A84\x03\x02\x02\x02\u0A83\u0A5E\x03\x02\x02\x02\u0A83\u0A75\x03\x02" + - "\x02\x02\u0A84\x8F\x03\x02\x02\x02\u0A85\u0A86\t\r\x02\x02\u0A86\x91\x03" + - "\x02\x02\x02\u0A87\u0A88\x07\u0122\x02\x02\u0A88\x93\x03\x02\x02\x02\u0A89" + - "\u0A8D\x05\u0542\u02A2\x02\u0A8A\u0A8D\x07\u0150\x02\x02\u0A8B\u0A8D\x07" + - "\u0151\x02\x02\u0A8C\u0A89\x03\x02\x02\x02\u0A8C\u0A8A\x03\x02\x02\x02" + - "\u0A8C\u0A8B\x03\x02\x02\x02\u0A8D\x95\x03\x02\x02\x02\u0A8E\u0A94\x05" + - "\x98M\x02\u0A8F\u0A90\x07\x04\x02\x02\u0A90\u0A91\x05\xA2R\x02\u0A91\u0A92" + - "\x07\x05\x02\x02\u0A92\u0A94\x03\x02\x02\x02\u0A93\u0A8E\x03\x02\x02\x02" + - "\u0A93\u0A8F\x03\x02\x02\x02\u0A94\x97\x03\x02\x02\x02\u0A95\u0A97\x05" + - "\x9AN\x02\u0A96\u0A95\x03\x02\x02\x02\u0A97\u0A9A\x03\x02\x02\x02\u0A98" + - "\u0A96\x03\x02\x02\x02\u0A98\u0A99\x03\x02\x02\x02\u0A99\x99\x03\x02\x02" + - "\x02\u0A9A\u0A98\x03\x02\x02\x02\u0A9B\u0AC3\x07m\x02\x02\u0A9C\u0AC3" + - "\x07r\x02\x02\u0A9D\u0A9F\x07\xB9\x02\x02\u0A9E\u0AA0\x05\u0342\u01A2" + - "\x02\u0A9F\u0A9E\x03\x02\x02\x02\u0A9F\u0AA0\x03\x02\x02\x02\u0AA0\u0AA1" + - "\x03\x02\x02\x02\u0AA1\u0AC3\x05\u0542\u02A2\x02\u0AA2\u0AA4\x07P\x02" + - "\x02\u0AA3\u0AA5\x05\u0342\u01A2\x02\u0AA4\u0AA3\x03\x02\x02\x02\u0AA4" + - "\u0AA5\x03\x02\x02\x02\u0AA5\u0AA6\x03\x02\x02\x02\u0AA6\u0AC3\x05\u0542" + - "\u02A2\x02\u0AA7\u0AC3\x07\xAD\x02\x02\u0AA8\u0AC3\x07\xDA\x02\x02\u0AA9" + - "\u0AAB\x07\u0123\x02\x02\u0AAA\u0AAC\x05\u0342\u01A2\x02\u0AAB\u0AAA\x03" + - "\x02\x02\x02\u0AAB\u0AAC\x03\x02\x02\x02\u0AAC\u0AAD\x03\x02\x02\x02\u0AAD" + - "\u0AC3\x05\u0542\u02A2\x02\u0AAE\u0AB0\x07\xC7\x02\x02\u0AAF\u0AB1\x05" + - "\u0342\u01A2\x02\u0AB0\u0AAF\x03\x02\x02\x02\u0AB0\u0AB1\x03\x02\x02\x02" + - "\u0AB1\u0AB2\x03\x02\x02\x02\u0AB2\u0AC3\x05\u0542\u02A2\x02\u0AB3\u0AB4" + - "\x07\xD3\x02\x02\u0AB4\u0AB5\x07\u0123\x02\x02\u0AB5\u0AC3\x05\xD8m\x02" + - "\u0AB6\u0AB7\x07\xD3\x02\x02\u0AB7\u0AB8\x07\u0123\x02\x02\u0AB8\u0AC3" + - "\x07\v\x02\x02\u0AB9\u0ABA\x07\xD3\x02\x02\u0ABA\u0ABB\x07O\x02\x02\u0ABB" + - "\u0ABC\x07P\x02\x02\u0ABC\u0AC3\x05\xD8m\x02\u0ABD\u0ABE\x07\xD3\x02\x02" + - "\u0ABE\u0ABF\x07P\x02\x02\u0ABF\u0AC3\x05\xD8m\x02\u0AC0\u0AC1\x07\xC4" + - "\x02\x02\u0AC1\u0AC3\x05\u0542\u02A2\x02\u0AC2\u0A9B\x03\x02\x02\x02\u0AC2" + - "\u0A9C\x03\x02\x02\x02\u0AC2\u0A9D\x03\x02\x02\x02\u0AC2\u0AA2\x03\x02" + - "\x02\x02\u0AC2\u0AA7\x03\x02\x02\x02\u0AC2\u0AA8\x03\x02\x02\x02\u0AC2" + - "\u0AA9\x03\x02\x02\x02\u0AC2\u0AAE\x03\x02\x02\x02\u0AC2\u0AB3\x03\x02" + - "\x02\x02\u0AC2\u0AB6\x03\x02\x02\x02\u0AC2\u0AB9\x03\x02\x02\x02\u0AC2" + - "\u0ABD\x03\x02\x02\x02\u0AC2\u0AC0\x03\x02\x02\x02\u0AC3\x9B\x03\x02\x02" + - "\x02\u0AC4\u0AC5\x07m\x02\x02\u0AC5\x9D\x03\x02\x02\x02\u0AC6\u0AC8\x05" + - "\xA0Q\x02\u0AC7\u0AC6\x03\x02\x02\x02\u0AC7\u0AC8\x03\x02\x02\x02\u0AC8" + - "\u0AC9\x03\x02\x02\x02\u0AC9\u0ACA\x07\xBA\x02\x02\u0ACA\u0ACB\x05\u0542" + - "\u02A2\x02\u0ACB\x9F\x03\x02\x02\x02\u0ACC\u0ACD\x07f\x02\x02\u0ACD\xA1" + - "\x03\x02\x02\x02\u0ACE\u0AD3\x05\xA4S\x02\u0ACF\u0AD0\x07\b\x02\x02\u0AD0" + - "\u0AD2\x05\xA4S\x02\u0AD1\u0ACF\x03\x02\x02\x02\u0AD2\u0AD5\x03\x02\x02" + - "\x02\u0AD3\u0AD1\x03\x02\x02\x02\u0AD3\u0AD4\x03\x02\x02\x02\u0AD4\xA3" + - "\x03\x02\x02\x02\u0AD5\u0AD3\x03\x02\x02\x02\u0AD6\u0AD8\x05\u0556\u02AC" + - "\x02\u0AD7\u0AD9\x05\xA6T\x02\u0AD8\u0AD7\x03\x02\x02\x02\u0AD8\u0AD9" + - "\x03\x02\x02\x02\u0AD9\xA5\x03\x02\x02\x02\u0ADA\u0AE2\x05B\"\x02\u0ADB" + - "\u0AE2\x05\u0124\x93\x02\u0ADC\u0AE2\x07\v\x02\x02\u0ADD\u0ADE\x07\x04" + - "\x02\x02\u0ADE\u0ADF\x05\xA8U\x02\u0ADF\u0AE0\x07\x05\x02\x02\u0AE0\u0AE2" + - "\x03\x02\x02\x02\u0AE1\u0ADA\x03\x02\x02\x02\u0AE1\u0ADB\x03\x02\x02\x02" + - "\u0AE1\u0ADC\x03\x02\x02\x02\u0AE1\u0ADD\x03\x02\x02\x02\u0AE2\xA7\x03" + - "\x02\x02\x02\u0AE3\u0AE8\x05\xAAV\x02\u0AE4\u0AE5\x07\b\x02\x02\u0AE5" + - "\u0AE7\x05\xAAV\x02\u0AE6\u0AE4\x03\x02\x02\x02\u0AE7\u0AEA\x03\x02\x02" + - "\x02\u0AE8\u0AE6\x03\x02\x02\x02\u0AE8\u0AE9\x03\x02\x02\x02\u0AE9\xA9" + - "\x03\x02\x02\x02\u0AEA\u0AE8\x03\x02\x02\x02\u0AEB\u0AEC\x05B\"\x02\u0AEC" + - "\xAB\x03\x02\x02\x02\u0AED\u0AEF\x070\x02\x02\u0AEE\u0AF0\x05\xAEX\x02" + - "\u0AEF\u0AEE\x03\x02\x02\x02\u0AEF\u0AF0\x03\x02\x02\x02\u0AF0\u0AF1\x03" + - "\x02\x02\x02\u0AF1\u0AF5\x07^\x02\x02\u0AF2\u0AF3\x07\xDE\x02\x02\u0AF3" + - "\u0AF4\x07O\x02\x02\u0AF4\u0AF6\x07\u0185\x02\x02\u0AF5\u0AF2\x03\x02" + - "\x02\x02\u0AF5\u0AF6\x03\x02\x02\x02\u0AF6\u0AF7\x03\x02\x02\x02\u0AF7" + - "\u0B39\x05\u052C\u0297\x02\u0AF8\u0AFA\x07\x04\x02\x02\u0AF9\u0AFB\x05" + - "\xB0Y\x02\u0AFA\u0AF9\x03\x02\x02\x02\u0AFA\u0AFB\x03\x02\x02\x02\u0AFB" + - "\u0AFC\x03\x02\x02\x02\u0AFC\u0AFE\x07\x05\x02\x02\u0AFD\u0AFF\x05\xEE" + - "x\x02\u0AFE\u0AFD\x03\x02\x02\x02\u0AFE\u0AFF\x03\x02\x02\x02\u0AFF\u0B01" + - "\x03\x02\x02\x02\u0B00\u0B02\x05\xF0y\x02\u0B01\u0B00\x03\x02\x02\x02" + - "\u0B01\u0B02\x03\x02\x02\x02\u0B02\u0B04\x03\x02\x02\x02\u0B03\u0B05\x05" + - "\xF8}\x02\u0B04\u0B03\x03\x02\x02\x02\u0B04\u0B05\x03\x02\x02\x02\u0B05" + - "\u0B07\x03\x02\x02\x02\u0B06\u0B08\x05\xFA~\x02\u0B07\u0B06\x03\x02\x02" + - "\x02\u0B07\u0B08\x03\x02\x02\x02\u0B08\u0B0A\x03\x02\x02\x02\u0B09\u0B0B" + - "\x05\xFC\x7F\x02\u0B0A\u0B09\x03\x02\x02\x02\u0B0A\u0B0B\x03\x02\x02\x02" + - "\u0B0B\u0B0D\x03\x02\x02\x02\u0B0C\u0B0E\x05\xFE\x80\x02\u0B0D\u0B0C\x03" + - "\x02\x02\x02\u0B0D\u0B0E\x03\x02\x02\x02\u0B0E\u0B3A\x03\x02\x02\x02\u0B0F" + - "\u0B10\x07\u010C\x02\x02\u0B10\u0B12\x05\u020C\u0107\x02\u0B11\u0B13\x05" + - "\xB2Z\x02\u0B12\u0B11\x03\x02\x02\x02\u0B12\u0B13\x03\x02\x02\x02\u0B13" + - "\u0B15\x03\x02\x02\x02\u0B14\u0B16\x05\xF0y\x02\u0B15\u0B14\x03\x02\x02" + - "\x02\u0B15\u0B16\x03\x02\x02\x02\u0B16\u0B18\x03\x02\x02\x02\u0B17\u0B19" + - "\x05\xF8}\x02\u0B18\u0B17\x03\x02\x02\x02\u0B18\u0B19\x03\x02\x02\x02" + - "\u0B19\u0B1B\x03\x02\x02\x02\u0B1A\u0B1C\x05\xFA~\x02\u0B1B\u0B1A\x03" + - "\x02\x02\x02\u0B1B\u0B1C\x03\x02\x02\x02\u0B1C\u0B1E\x03\x02\x02\x02\u0B1D" + - "\u0B1F\x05\xFC\x7F\x02\u0B1E\u0B1D\x03\x02\x02\x02\u0B1E\u0B1F\x03\x02" + - "\x02\x02\u0B1F\u0B21\x03\x02\x02\x02\u0B20\u0B22\x05\xFE\x80\x02\u0B21" + - "\u0B20\x03\x02\x02\x02\u0B21\u0B22\x03\x02\x02\x02\u0B22\u0B3A\x03\x02" + - "\x02\x02\u0B23\u0B24\x07\u0116\x02\x02\u0B24\u0B25\x07\u010C\x02\x02\u0B25" + - "\u0B27\x05\u052C\u0297\x02\u0B26\u0B28\x05\xB2Z\x02\u0B27\u0B26\x03\x02" + - "\x02\x02\u0B27\u0B28\x03\x02\x02\x02\u0B28\u0B29\x03\x02\x02\x02\u0B29" + - "\u0B2B\x05\x80A\x02\u0B2A\u0B2C\x05\xF0y\x02\u0B2B\u0B2A\x03\x02\x02\x02" + - "\u0B2B\u0B2C\x03\x02\x02\x02\u0B2C\u0B2E\x03\x02\x02\x02\u0B2D\u0B2F\x05" + - "\xF8}\x02\u0B2E\u0B2D\x03\x02\x02\x02\u0B2E\u0B2F\x03\x02\x02\x02\u0B2F" + - "\u0B31\x03\x02\x02"; + "b2\x02\u0873\u089B\x03\x02\x02\x02\u0874\u0875\x07\x8C\x02\x02\u0875\u0876" + + "\x07\u0105\x02\x02\u0876\u0879\x07\u017A\x02\x02\u0877\u0878\x07\xDE\x02" + + "\x02\u0878\u087A\x07\u018E\x02\x02\u0879\u0877\x03\x02\x02\x02\u0879\u087A" + + "\x03\x02\x02\x02\u087A\u087B\x03\x02\x02\x02\u087B\u087C\x05\u053C\u029F" + + "\x02\u087C\u087D\x05b2\x02\u087D\u089B\x03\x02\x02\x02\u087E\u087F\x07" + + "\x8C\x02\x02\u087F\u0880\x07\u0105\x02\x02\u0880\u0881\x07\u017A\x02\x02" + + "\u0881\u0882\x07 \x02\x02\u0882\u0883\x07F\x02\x02\u0883\u0884\x07\u0161" + + "\x02\x02\u0884\u0888\x05\u0540\u02A1\x02\u0885\u0886\x07\u011B\x02\x02" + + "\u0886\u0887\x07\x95\x02\x02\u0887\u0889\x05\u0560\u02B1\x02\u0888\u0885" + + "\x03\x02\x02\x02\u0888\u0889\x03\x02\x02\x02\u0889\u088A\x03\x02\x02\x02" + + "\u088A\u088B\x07\u014F\x02\x02\u088B\u088C\x07\u0161\x02\x02\u088C\u088E" + + "\x05\u0540\u02A1\x02\u088D\u088F\x05\u03B0\u01D9\x02\u088E\u088D\x03\x02" + + "\x02\x02\u088E\u088F\x03\x02\x02\x02\u088F\u089B\x03\x02\x02\x02\u0890" + + "\u0891\x07\x8C\x02\x02\u0891\u0892\x07A\x02\x02\u0892\u0895\x07^\x02\x02" + + "\u0893\u0894\x07\xDE\x02\x02\u0894\u0896\x07\u018E\x02\x02\u0895\u0893" + + "\x03\x02\x02\x02\u0895\u0896\x03\x02\x02\x02\u0896\u0897\x03\x02\x02\x02" + + "\u0897\u0898\x05\u0436\u021C\x02\u0898\u0899\x05b2\x02\u0899\u089B\x03" + + "\x02\x02\x02\u089A\u082A\x03\x02\x02\x02\u089A\u0835\x03\x02\x02\x02\u089A" + + "\u0846\x03\x02\x02\x02\u089A\u0851\x03\x02\x02\x02\u089A\u0862\x03\x02" + + "\x02\x02\u089A\u086B\x03\x02\x02\x02\u089A\u0874\x03\x02\x02\x02\u089A" + + "\u087E\x03\x02\x02\x02\u089A\u0890\x03\x02\x02\x02\u089Ba\x03\x02\x02" + + "\x02\u089C\u08A1\x05h5\x02\u089D\u089E\x07\b\x02\x02\u089E\u08A0\x05h" + + "5\x02\u089F\u089D\x03\x02\x02\x02\u08A0\u08A3\x03\x02\x02\x02\u08A1\u089F" + + "\x03\x02\x02\x02\u08A1\u08A2\x03\x02\x02\x02\u08A2c\x03\x02\x02\x02\u08A3" + + "\u08A1\x03\x02\x02\x02\u08A4\u08A5\x07\u01B5\x02\x02\u08A5\u08A6\x07\u011F" + + "\x02\x02\u08A6\u08A7\x05\u053C\u029F\x02\u08A7\u08A8\x05\x80A\x02\u08A8" + + "\u08AD\x03\x02\x02\x02\u08A9\u08AA\x07\u01B6\x02\x02\u08AA\u08AB\x07\u011F" + + "\x02\x02\u08AB\u08AD\x05\u053C\u029F\x02\u08AC\u08A4\x03\x02\x02\x02\u08AC" + + "\u08A9\x03\x02\x02\x02\u08ADe\x03\x02\x02\x02\u08AE\u08AF\x07\u01B5\x02" + + "\x02\u08AF\u08B0\x07\u011F\x02\x02\u08B0\u08B1\x05\u053C\u029F\x02\u08B1" + + "g\x03\x02\x02\x02\u08B2\u08B3\x07\x87\x02\x02\u08B3\u09DD\x05\xBE`\x02" + + "\u08B4\u08B5\x07\x87\x02\x02\u08B5\u08B6\x07\xDE\x02\x02\u08B6\u08B7\x07" + + "O\x02\x02\u08B7\u08B8\x07\u018E\x02\x02\u08B8\u09DD\x05\xBE`\x02\u08B9" + + "\u08BA\x07\x87\x02\x02\u08BA\u08BB\x07.\x02\x02\u08BB\u09DD\x05\xBE`\x02" + + "\u08BC\u08BD\x07\x87\x02\x02\u08BD\u08BE\x07.\x02\x02\u08BE\u08BF\x07" + + "\xDE\x02\x02\u08BF\u08C0\x07O\x02\x02\u08C0\u08C1\x07\u018E\x02\x02\u08C1" + + "\u09DD\x05\xBE`\x02\u08C2\u08C4\x07\x8C\x02\x02\u08C3\u08C5\x05\u02E2" + + "\u0172\x02\u08C4\u08C3\x03\x02\x02\x02\u08C4\u08C5\x03\x02\x02\x02\u08C5" + + "\u08C6\x03\x02\x02\x02\u08C6\u08C7\x05\u0562\u02B2\x02\u08C7\u08C8\x05" + + "j6\x02\u08C8\u09DD\x03\x02\x02\x02\u08C9\u08CB\x07\x8C\x02\x02\u08CA\u08CC" + + "\x05\u02E2\u0172\x02\u08CB\u08CA\x03\x02\x02\x02\u08CB\u08CC\x03\x02\x02" + + "\x02\u08CC\u08CD\x03\x02\x02\x02\u08CD\u08CE\x05\u0562\u02B2\x02\u08CE" + + "\u08CF\x07\xC1\x02\x02\u08CF\u08D0\x07O\x02\x02\u08D0\u08D1\x07P\x02\x02" + + "\u08D1\u09DD\x03\x02\x02\x02\u08D2\u08D4\x07\x8C\x02\x02\u08D3\u08D5\x05" + + "\u02E2\u0172\x02\u08D4\u08D3\x03\x02\x02\x02\u08D4\u08D5\x03\x02\x02\x02" + + "\u08D5\u08D6\x03\x02\x02\x02\u08D6\u08D7\x05\u0562\u02B2\x02\u08D7\u08D8" + + "\x07\u014F\x02\x02\u08D8\u08D9\x07O\x02\x02\u08D9\u08DA\x07P\x02\x02\u08DA" + + "\u09DD\x03\x02\x02\x02\u08DB\u08DD\x07\x8C\x02\x02\u08DC\u08DE\x05\u02E2" + + "\u0172\x02\u08DD\u08DC\x03\x02\x02\x02\u08DD\u08DE\x03\x02\x02\x02\u08DE" + + "\u08DF\x03\x02\x02\x02\u08DF\u08E0\x05\u0562\u02B2\x02\u08E0\u08E1\x07" + + "\xC1\x02\x02\u08E1\u08E2\x07\u01B7\x02\x02\u08E2\u09DD\x03\x02\x02\x02" + + "\u08E3\u08E5\x07\x8C\x02\x02\u08E4\u08E6\x05\u02E2\u0172\x02\u08E5\u08E4" + + "\x03\x02\x02\x02\u08E5\u08E6\x03\x02\x02\x02\u08E6\u08E7\x03\x02\x02\x02" + + "\u08E7\u08E8\x05\u0562\u02B2\x02\u08E8\u08E9\x07\xC1\x02\x02\u08E9\u08EA" + + "\x07\u01B7\x02\x02\u08EA\u08EB\x07\xDE\x02\x02\u08EB\u08EC\x07\u018E\x02" + + "\x02\u08EC\u09DD\x03\x02\x02\x02\u08ED\u08EF\x07\x8C\x02\x02\u08EE\u08F0" + + "\x05\u02E2\u0172\x02\u08EF\u08EE\x03\x02\x02\x02\u08EF\u08F0\x03\x02\x02" + + "\x02\u08F0\u08F1\x03\x02\x02\x02\u08F1\u08F2\x05\u0562\u02B2\x02\u08F2" + + "\u08F3\x07\u014F\x02\x02\u08F3\u08F4\x07\u0158\x02\x02\u08F4\u08F5\x05" + + "\u0558\u02AD\x02\u08F5\u09DD\x03\x02\x02\x02\u08F6\u08F8\x07\x8C\x02\x02" + + "\u08F7\u08F9\x05\u02E2\u0172\x02\u08F8\u08F7\x03\x02\x02\x02\u08F8\u08F9" + + "\x03\x02\x02\x02\u08F9\u08FA\x03\x02\x02\x02\u08FA\u08FB\x05\u0550\u02A9" + + "\x02\u08FB\u08FC\x07\u014F\x02\x02\u08FC\u08FD\x07\u0158\x02\x02\u08FD" + + "\u08FE\x05\u0558\u02AD\x02\u08FE\u09DD\x03\x02\x02\x02\u08FF\u0901\x07" + + "\x8C\x02\x02\u0900\u0902\x05\u02E2\u0172\x02\u0901\u0900\x03\x02\x02\x02" + + "\u0901\u0902\x03\x02\x02\x02\u0902\u0903\x03\x02\x02\x02\u0903\u0904\x05" + + "\u0562\u02B2\x02\u0904\u0905\x07\u014F\x02\x02\u0905\u0906\x05t;\x02\u0906" + + "\u09DD\x03\x02\x02\x02\u0907\u0909\x07\x8C\x02\x02\u0908\u090A\x05\u02E2" + + "\u0172\x02\u0909\u0908\x03\x02\x02\x02\u0909\u090A\x03\x02\x02\x02\u090A" + + "\u090B\x03\x02\x02\x02\u090B\u090C\x05\u0562\u02B2\x02\u090C\u090D\x07" + + "\u013B\x02\x02\u090D\u090E\x05t;\x02\u090E\u09DD\x03\x02\x02\x02\u090F" + + "\u0911\x07\x8C\x02\x02\u0910\u0912\x05\u02E2\u0172\x02\u0911\u0910\x03" + + "\x02\x02\x02\u0911\u0912\x03\x02\x02\x02\u0912\u0913\x03\x02\x02\x02\u0913" + + "\u0914\x05\u0562\u02B2\x02\u0914\u0915\x07\u014F\x02\x02\u0915\u0916\x07" + + "\u015B\x02\x02\u0916\u0917\x05\u0562\u02B2\x02\u0917\u09DD\x03\x02\x02" + + "\x02\u0918\u091A\x07\x8C\x02\x02\u0919\u091B\x05\u02E2\u0172\x02\u091A" + + "\u0919\x03\x02\x02\x02\u091A\u091B\x03\x02\x02\x02\u091B\u091C\x03\x02" + + "\x02\x02\u091C\u091D\x05\u0562\u02B2\x02\u091D\u091E\x07\x87\x02\x02\u091E" + + "\u091F\x07\u01B8\x02\x02\u091F\u0920\x05\xC8e\x02\u0920\u0921\x07&\x02" + + "\x02\u0921\u0923\x07\xDD\x02\x02\u0922\u0924\x05\u0120\x91\x02\u0923\u0922" + + "\x03\x02\x02\x02\u0923\u0924\x03\x02\x02\x02\u0924\u09DD\x03\x02\x02\x02" + + "\u0925\u0927\x07\x8C\x02\x02\u0926\u0928\x05\u02E2\u0172\x02\u0927\u0926" + + "\x03\x02\x02\x02\u0927\u0928\x03\x02\x02\x02\u0928\u0929\x03\x02\x02\x02" + + "\u0929\u092A\x05\u0562\u02B2\x02\u092A\u092B\x05|?\x02\u092B\u09DD\x03" + + "\x02\x02\x02\u092C\u092E\x07\x8C\x02\x02\u092D\u092F\x05\u02E2\u0172\x02" + + "\u092E\u092D\x03\x02\x02\x02\u092E\u092F\x03\x02\x02\x02\u092F\u0930\x03" + + "\x02\x02\x02\u0930\u0931\x05\u0562\u02B2\x02\u0931\u0932\x07\xC1\x02\x02" + + "\u0932\u0933\x07\xDD\x02\x02\u0933\u09DD\x03\x02\x02\x02\u0934\u0936\x07" + + "\x8C\x02\x02\u0935\u0937\x05\u02E2\u0172\x02\u0936\u0935\x03\x02\x02\x02" + + "\u0936\u0937\x03\x02\x02\x02\u0937\u0938\x03\x02\x02\x02\u0938\u0939\x05" + + "\u0562\u02B2\x02\u0939\u093A\x07\xC1\x02\x02\u093A\u093B\x07\xDD\x02\x02" + + "\u093B\u093C\x07\xDE\x02\x02\u093C\u093D\x07\u018E\x02\x02\u093D\u09DD" + + "\x03\x02\x02\x02\u093E\u0940\x07\xC1\x02\x02\u093F\u0941\x05\u02E2\u0172" + + "\x02\u0940\u093F\x03\x02\x02\x02\u0940\u0941\x03\x02\x02\x02\u0941\u0942" + + "\x03\x02\x02\x02\u0942\u0943\x07\xDE\x02\x02\u0943\u0944\x07\u018E\x02" + + "\x02\u0944\u0946\x05\u0562\u02B2\x02\u0945\u0947\x05l7\x02\u0946\u0945" + + "\x03\x02\x02\x02\u0946\u0947\x03\x02\x02\x02\u0947\u09DD\x03\x02\x02\x02" + + "\u0948\u094A\x07\xC1\x02\x02\u0949\u094B\x05\u02E2\u0172\x02\u094A\u0949" + + "\x03\x02\x02\x02\u094A\u094B\x03\x02\x02\x02\u094B\u094C\x03\x02\x02\x02" + + "\u094C\u094E\x05\u0562\u02B2\x02\u094D\u094F\x05l7\x02\u094E\u094D\x03" + + "\x02\x02\x02\u094E\u094F\x03\x02\x02\x02\u094F\u09DD\x03\x02\x02\x02\u0950" + + "\u0952\x07\x8C\x02\x02\u0951\u0953\x05\u02E2\u0172\x02\u0952\u0951\x03" + + "\x02\x02\x02\u0952\u0953\x03\x02\x02\x02\u0953\u0954\x03\x02\x02\x02\u0954" + + "\u0956\x05\u0562\u02B2\x02\u0955\u0957\x05\u02E4\u0173\x02\u0956\u0955" + + "\x03\x02\x02\x02\u0956\u0957\x03\x02\x02\x02\u0957\u0958\x03\x02\x02\x02" + + "\u0958\u0959\x07\u016A\x02\x02\u0959\u095B\x05\u0462\u0232\x02\u095A\u095C" + + "\x05n8\x02\u095B\u095A\x03\x02\x02\x02\u095B\u095C\x03\x02\x02\x02\u095C" + + "\u095E\x03\x02\x02\x02\u095D\u095F\x05p9\x02\u095E\u095D\x03\x02\x02\x02" + + "\u095E\u095F\x03\x02\x02\x02\u095F\u09DD\x03\x02\x02\x02\u0960\u0962\x07" + + "\x8C\x02\x02\u0961\u0963\x05\u02E2\u0172\x02\u0962\u0961\x03\x02\x02\x02" + + "\u0962\u0963\x03\x02\x02\x02\u0963\u0964\x03\x02\x02\x02\u0964\u0965\x05" + + "\u0562\u02B2\x02\u0965\u0966\x05\u015C\xAF\x02\u0966\u09DD\x03\x02\x02" + + "\x02\u0967\u0968\x07\x87\x02\x02\u0968\u09DD\x05\xD4k\x02\u0969\u096A" + + "\x07\x8C\x02\x02\u096A\u096B\x07/\x02\x02\u096B\u096C\x05\u0540\u02A1" + + "\x02\u096C\u096D\x05\u01C0\xE1\x02\u096D\u09DD\x03\x02\x02\x02\u096E\u096F" + + "\x07\u0176\x02\x02\u096F\u0970\x07/\x02\x02\u0970\u09DD\x05\u0540\u02A1" + + "\x02\u0971\u0972\x07\xC1\x02\x02\u0972\u0973\x07/\x02\x02\u0973\u0974" + + "\x07\xDE\x02\x02\u0974\u0975\x07\u018E\x02\x02\u0975\u0977\x05\u0540\u02A1" + + "\x02\u0976\u0978\x05l7\x02\u0977\u0976\x03\x02\x02\x02\u0977\u0978\x03" + + "\x02\x02\x02\u0978\u09DD\x03\x02\x02\x02\u0979\u097A\x07\xC1\x02\x02\u097A" + + "\u097B\x07/\x02\x02\u097B\u097D\x05\u0540\u02A1\x02\u097C\u097E\x05l7" + + "\x02\u097D\u097C\x03\x02\x02\x02\u097D\u097E\x03\x02\x02\x02\u097E\u09DD" + + "\x03\x02\x02\x02\u097F\u0980\x07\u014F\x02\x02\u0980\u0981\x07\u017D\x02" + + "\x02\u0981\u09DD\x07\u0117\x02\x02\u0982\u0983\x07\xA0\x02\x02\u0983\u0984" + + "\x07R\x02\x02\u0984\u09DD\x05\u0540\u02A1\x02\u0985\u0986\x07\u014F\x02" + + "\x02\u0986\u0987\x07\u017D\x02\x02\u0987\u09DD\x07\xA0\x02\x02\u0988\u0989" + + "\x07\u014F\x02\x02\u0989\u09DD\x07\u01B9\x02\x02\u098A\u098B\x07\u014F" + + "\x02\x02\u098B\u09DD\x07\u0171\x02\x02\u098C\u098D\x07\xC3\x02\x02\u098D" + + "\u098E\x07\u0167\x02\x02\u098E\u09DD\x05\u0540\u02A1\x02\u098F\u0990\x07" + + "\xC3\x02\x02\u0990\u0991\x07\x8D\x02\x02\u0991\u0992\x07\u0167\x02\x02" + + "\u0992\u09DD\x05\u0540\u02A1\x02\u0993\u0994\x07\xC3\x02\x02\u0994\u0995" + + "\x07\u013A\x02\x02\u0995\u0996\x07\u0167\x02\x02\u0996\u09DD\x05\u0540" + + "\u02A1\x02\u0997\u0998\x07\xC3\x02\x02\u0998\u0999\x07\u0167\x02\x02\u0999" + + "\u09DD\x07 \x02\x02\u099A\u099B\x07\xC3\x02\x02\u099B\u099C\x07\u0167" + + "\x02\x02\u099C\u09DD\x07e\x02\x02\u099D\u099E\x07\xBC\x02\x02\u099E\u099F" + + "\x07\u0167\x02\x02\u099F\u09DD\x05\u0540\u02A1\x02\u09A0\u09A1\x07\xBC" + + "\x02\x02\u09A1\u09A2\x07\u0167\x02\x02\u09A2\u09DD\x07 \x02\x02\u09A3" + + "\u09A4\x07\xBC\x02\x02\u09A4\u09A5\x07\u0167\x02\x02\u09A5\u09DD\x07e" + + "\x02\x02\u09A6\u09A7\x07\xC3\x02\x02\u09A7\u09A8\x07\u0143\x02\x02\u09A8" + + "\u09DD\x05\u0540\u02A1\x02\u09A9\u09AA\x07\xC3\x02\x02\u09AA\u09AB\x07" + + "\x8D\x02\x02\u09AB\u09AC\x07\u0143\x02\x02\u09AC\u09DD\x05\u0540\u02A1" + + "\x02\u09AD\u09AE\x07\xC3\x02\x02\u09AE\u09AF\x07\u013A\x02\x02\u09AF\u09B0" + + "\x07\u0143\x02\x02\u09B0\u09DD\x05\u0540\u02A1\x02\u09B1\u09B2\x07\xBC" + + "\x02\x02\u09B2\u09B3\x07\u0143\x02\x02\u09B3\u09DD\x05\u0540\u02A1\x02" + + "\u09B4\u09B5\x07\xE6\x02\x02\u09B5\u09DD\x05\u053C\u029F\x02\u09B6\u09B7" + + "\x07\u010F\x02\x02\u09B7\u09B8\x07\xE6\x02\x02\u09B8\u09DD\x05\u053C\u029F" + + "\x02\u09B9\u09BA\x07\u0115\x02\x02\u09BA\u09DD\x05\u0214\u010B\x02\u09BB" + + "\u09BC\x07O\x02\x02\u09BC\u09DD\x07\u0115\x02\x02\u09BD\u09BE\x07\u011C" + + "\x02\x02\u09BE\u09BF\x07`\x02\x02\u09BF\u09DD\x05\u055E\u02B0\x02\u09C0" + + "\u09C1\x07\u014F\x02\x02\u09C1\u09C2\x07\u0161\x02\x02\u09C2\u09DD\x05" + + "\u0540\u02A1\x02\u09C3\u09C4\x07\u014F\x02\x02\u09C4\u09DD\x05t;\x02\u09C5" + + "\u09C6\x07\u013B\x02\x02\u09C6\u09DD\x05t;\x02\u09C7\u09C8\x07\u013A\x02" + + "\x02\u09C8\u09C9\x07\xDD\x02\x02\u09C9\u09DD\x05r:\x02\u09CA\u09CB\x07" + + "\xC3\x02\x02\u09CB\u09CC\x07\u01A0\x02\x02\u09CC\u09CD\x07\xFD\x02\x02" + + "\u09CD\u09DD\x07\u0149\x02\x02\u09CE\u09CF\x07\xBC\x02\x02\u09CF\u09D0" + + "\x07\u01A0\x02\x02\u09D0\u09D1\x07\xFD\x02\x02\u09D1\u09DD\x07\u0149\x02" + + "\x02\u09D2\u09D3\x07\xD3\x02\x02\u09D3\u09D4\x07\u01A0\x02\x02\u09D4\u09D5" + + "\x07\xFD\x02\x02\u09D5\u09DD\x07\u0149\x02\x02\u09D6\u09D7\x07\u010F\x02" + + "\x02\u09D7\u09D8\x07\xD3\x02\x02\u09D8\u09D9\x07\u01A0\x02\x02\u09D9\u09DA" + + "\x07\xFD\x02\x02\u09DA\u09DD\x07\u0149\x02\x02\u09DB\u09DD\x05\u015C\xAF" + + "\x02\u09DC\u08B2\x03\x02\x02\x02\u09DC\u08B4\x03\x02\x02\x02\u09DC\u08B9" + + "\x03\x02\x02\x02\u09DC\u08BC\x03\x02\x02\x02\u09DC\u08C2\x03\x02\x02\x02" + + "\u09DC\u08C9\x03\x02\x02\x02\u09DC\u08D2\x03\x02\x02\x02\u09DC\u08DB\x03" + + "\x02\x02\x02\u09DC\u08E3\x03\x02\x02\x02\u09DC\u08ED\x03\x02\x02\x02\u09DC" + + "\u08F6\x03\x02\x02\x02\u09DC\u08FF\x03\x02\x02\x02\u09DC\u0907\x03\x02" + + "\x02\x02\u09DC\u090F\x03\x02\x02\x02\u09DC\u0918\x03\x02\x02\x02\u09DC" + + "\u0925\x03\x02\x02\x02\u09DC\u092C\x03\x02\x02\x02\u09DC\u0934\x03\x02" + + "\x02\x02\u09DC\u093E\x03\x02\x02\x02\u09DC\u0948\x03\x02\x02\x02\u09DC" + + "\u0950\x03\x02\x02\x02\u09DC\u0960\x03\x02\x02\x02\u09DC\u0967\x03\x02" + + "\x02\x02\u09DC\u0969\x03\x02\x02\x02\u09DC\u096E\x03\x02\x02\x02\u09DC" + + "\u0971\x03\x02\x02\x02\u09DC\u0979\x03\x02\x02\x02\u09DC\u097F\x03\x02" + + "\x02\x02\u09DC\u0982\x03\x02\x02\x02\u09DC\u0985\x03\x02\x02\x02\u09DC" + + "\u0988\x03\x02\x02\x02\u09DC\u098A\x03\x02\x02\x02\u09DC\u098C\x03\x02" + + "\x02\x02\u09DC\u098F\x03\x02\x02\x02\u09DC\u0993\x03\x02\x02\x02\u09DC" + + "\u0997\x03\x02\x02\x02\u09DC\u099A\x03\x02\x02\x02\u09DC\u099D\x03\x02" + + "\x02\x02\u09DC\u09A0\x03\x02\x02\x02\u09DC\u09A3\x03\x02\x02\x02\u09DC" + + "\u09A6\x03\x02\x02\x02\u09DC\u09A9\x03\x02\x02\x02\u09DC\u09AD\x03\x02" + + "\x02\x02\u09DC\u09B1\x03\x02\x02\x02\u09DC\u09B4\x03\x02\x02\x02\u09DC" + + "\u09B6\x03\x02\x02\x02\u09DC\u09B9\x03\x02\x02\x02\u09DC\u09BB\x03\x02" + + "\x02\x02\u09DC\u09BD\x03\x02\x02\x02\u09DC\u09C0\x03\x02\x02\x02\u09DC" + + "\u09C3\x03\x02\x02\x02\u09DC\u09C5\x03\x02\x02\x02\u09DC\u09C7\x03\x02" + + "\x02\x02\u09DC\u09CA\x03\x02\x02\x02\u09DC\u09CE\x03\x02\x02\x02\u09DC" + + "\u09D2\x03\x02\x02\x02\u09DC\u09D6\x03\x02\x02\x02\u09DC\u09DB\x03\x02" + + "\x02\x02\u09DDi\x03\x02\x02\x02\u09DE\u09DF\x07\u014F\x02\x02\u09DF\u09E0" + + "\x077\x02\x02\u09E0\u09E4\x05\u048E\u0248\x02\u09E1\u09E2\x07\xC1\x02" + + "\x02\u09E2\u09E4\x077\x02\x02\u09E3\u09DE\x03\x02\x02\x02\u09E3\u09E1" + + "\x03\x02\x02\x02\u09E4k\x03\x02\x02\x02\u09E5\u09E6\t\x11\x02\x02\u09E6" + + "m\x03\x02\x02\x02\u09E7\u09E8\x07-\x02\x02\u09E8\u09E9\x05\u0214\u010B" + + "\x02\u09E9o\x03\x02\x02\x02\u09EA\u09EB\x07f\x02\x02\u09EB\u09EC\x05\u048E" + + "\u0248\x02\u09ECq\x03\x02\x02\x02\u09ED\u09F4\x07\u0110\x02\x02\u09EE" + + "\u09F4\x07s\x02\x02\u09EF\u09F4\x077\x02\x02\u09F0\u09F1\x07f\x02\x02" + + "\u09F1\u09F2\x07\xE4\x02\x02\u09F2\u09F4\x05\u0540\u02A1\x02\u09F3\u09ED" + + "\x03\x02\x02\x02\u09F3\u09EE\x03\x02\x02\x02\u09F3\u09EF\x03\x02\x02\x02" + + "\u09F3\u09F0\x03\x02\x02\x02\u09F4s\x03\x02\x02\x02\u09F5\u09F6\x07\x04" + + "\x02\x02\u09F6\u09F7\x05x=\x02\u09F7\u09F8\x07\x05\x02\x02\u09F8u\x03" + + "\x02\x02\x02\u09F9\u09FA\x07k\x02\x02\u09FA\u09FB\x05t;\x02\u09FBw\x03" + + "\x02\x02\x02\u09FC\u0A01\x05z>\x02\u09FD\u09FE\x07\b\x02\x02\u09FE\u0A00" + + "\x05z>\x02\u09FF\u09FD\x03\x02\x02\x02\u0A00\u0A03\x03\x02\x02\x02\u0A01" + + "\u09FF\x03\x02\x02\x02\u0A01\u0A02\x03\x02\x02\x02\u0A02y\x03\x02\x02" + + "\x02\u0A03\u0A01\x03\x02\x02\x02\u0A04\u0A0D\x05\u0570\u02B9\x02\u0A05" + + "\u0A06\x07\f\x02\x02\u0A06\u0A0E\x05\u01DA\xEE\x02\u0A07\u0A08\x07\r\x02" + + "\x02\u0A08\u0A0B\x05\u0570\u02B9\x02\u0A09\u0A0A\x07\f\x02\x02\u0A0A\u0A0C" + + "\x05\u01DA\xEE\x02\u0A0B\u0A09\x03\x02\x02\x02\u0A0B\u0A0C\x03\x02\x02" + + "\x02\u0A0C\u0A0E\x03\x02\x02\x02\u0A0D\u0A05\x03\x02\x02\x02\u0A0D\u0A07" + + "\x03\x02\x02\x02\u0A0D\u0A0E\x03\x02\x02\x02\u0A0E{\x03\x02\x02\x02\u0A0F" + + "\u0A11\x05~@\x02\u0A10\u0A0F\x03\x02\x02\x02\u0A11\u0A12\x03\x02\x02\x02" + + "\u0A12\u0A10\x03\x02\x02\x02\u0A12\u0A13\x03\x02\x02\x02\u0A13}\x03\x02" + + "\x02\x02\u0A14\u0A19\x07\u013C\x02\x02\u0A15\u0A17\x05\x10\t\x02\u0A16" + + "\u0A15\x03\x02\x02\x02\u0A16\u0A17\x03\x02\x02\x02\u0A17\u0A18\x03\x02" + + "\x02\x02\u0A18\u0A1A\x05\u0128\x95\x02\u0A19\u0A16\x03\x02\x02\x02\u0A19" + + "\u0A1A\x03\x02\x02\x02\u0A1A\u0A22\x03\x02\x02\x02\u0A1B\u0A1F\x07\u014F" + + "\x02\x02\u0A1C\u0A20\x05\u0124\x93\x02\u0A1D\u0A1E\x07\u01B8\x02\x02\u0A1E" + + "\u0A20\x05\xC8e\x02\u0A1F\u0A1C\x03\x02\x02\x02\u0A1F\u0A1D\x03\x02\x02" + + "\x02\u0A20\u0A22\x03\x02\x02\x02\u0A21\u0A14\x03\x02\x02\x02\u0A21\u0A1B" + + "\x03\x02\x02\x02\u0A22\x7F\x03\x02\x02\x02\u0A23\u0A24\x07@\x02\x02\u0A24" + + "\u0A25\x07\u01A8\x02\x02\u0A25\u0A26\x07k\x02\x02\u0A26\u0A27\x07\x04" + + "\x02\x02\u0A27\u0A28\x05\x84C\x02\u0A28\u0A29\x07\x05\x02\x02\u0A29\u0A3E" + + "\x03\x02\x02\x02\u0A2A\u0A2B\x07@\x02\x02\u0A2B\u0A2C\x07\u01A8\x02\x02" + + "\u0A2C\u0A2D\x07F\x02\x02\u0A2D\u0A2E\x07\x04\x02\x02\u0A2E\u0A2F\x05" + + "\u0502\u0282\x02\u0A2F\u0A30\x07\x05\x02\x02\u0A30\u0A3E\x03\x02\x02\x02" + + "\u0A31\u0A32\x07@\x02\x02\u0A32\u0A33\x07\u01A8\x02\x02\u0A33\u0A34\x07" + + "B\x02\x02\u0A34\u0A35\x07\x04\x02\x02\u0A35\u0A36\x05\u0502\u0282\x02" + + "\u0A36\u0A37\x07\x05\x02\x02\u0A37\u0A38\x07`\x02\x02\u0A38\u0A39\x07" + + "\x04\x02\x02\u0A39\u0A3A\x05\u0502\u0282\x02\u0A3A\u0A3B\x07\x05\x02\x02" + + "\u0A3B\u0A3E\x03\x02\x02\x02\u0A3C\u0A3E\x077\x02\x02\u0A3D\u0A23\x03" + + "\x02\x02\x02\u0A3D\u0A2A\x03\x02\x02\x02\u0A3D\u0A31\x03\x02\x02\x02\u0A3D" + + "\u0A3C\x03\x02\x02\x02\u0A3E\x81\x03\x02\x02\x02\u0A3F\u0A40\x05\u056E" + + "\u02B8\x02\u0A40\u0A41\x05\u0550\u02A9\x02\u0A41\x83\x03\x02\x02\x02\u0A42" + + "\u0A47\x05\x82B\x02\u0A43\u0A44\x07\b\x02\x02\u0A44\u0A46\x05\x82B\x02" + + "\u0A45\u0A43\x03\x02\x02\x02\u0A46\u0A49\x03\x02\x02\x02\u0A47\u0A45\x03" + + "\x02\x02\x02\u0A47\u0A48\x03\x02\x02\x02\u0A48\x85\x03\x02\x02\x02\u0A49" + + "\u0A47\x03\x02\x02\x02\u0A4A\u0A4B\x07\x8C\x02\x02\u0A4B\u0A4C\x07\u016A" + + "\x02\x02\u0A4C\u0A4D\x05\u0214\u010B\x02\u0A4D\u0A4E\x05\x88E\x02\u0A4E" + + "\x87\x03\x02\x02\x02\u0A4F\u0A54\x05\x8AF\x02\u0A50\u0A51\x07\b\x02\x02" + + "\u0A51\u0A53\x05\x8AF\x02\u0A52\u0A50\x03\x02\x02\x02\u0A53\u0A56\x03" + + "\x02\x02\x02\u0A54\u0A52\x03\x02\x02\x02\u0A54\u0A55\x03\x02\x02\x02\u0A55" + + "\x89\x03\x02\x02\x02\u0A56\u0A54\x03\x02\x02\x02\u0A57\u0A58\x07\x87\x02" + + "\x02\u0A58\u0A59\x07\x91\x02\x02\u0A59\u0A5B\x05\u0452\u022A\x02\u0A5A" + + "\u0A5C\x05l7\x02\u0A5B\u0A5A\x03\x02\x02\x02\u0A5B\u0A5C\x03\x02\x02\x02" + + "\u0A5C\u0A76\x03\x02\x02\x02\u0A5D\u0A5E\x07\xC1\x02\x02\u0A5E\u0A61\x07" + + "\x91\x02\x02\u0A5F\u0A60\x07\xDE\x02\x02\u0A60\u0A62\x07\u018E\x02\x02" + + "\u0A61\u0A5F\x03\x02\x02\x02\u0A61\u0A62\x03\x02\x02\x02\u0A62\u0A63\x03" + + "\x02\x02\x02\u0A63\u0A65\x05\u0562\u02B2\x02\u0A64\u0A66\x05l7\x02\u0A65" + + "\u0A64\x03\x02\x02\x02\u0A65\u0A66\x03\x02\x02\x02\u0A66\u0A76\x03\x02" + + "\x02\x02\u0A67\u0A68\x07\x8C\x02\x02\u0A68\u0A69\x07\x91\x02\x02\u0A69" + + "\u0A6B\x05\u0562\u02B2\x02\u0A6A\u0A6C\x05\u02E4\u0173\x02\u0A6B\u0A6A" + + "\x03\x02\x02\x02\u0A6B\u0A6C\x03\x02\x02\x02\u0A6C\u0A6D\x03\x02\x02\x02" + + "\u0A6D\u0A6E\x07\u016A\x02\x02\u0A6E\u0A70\x05\u0462\u0232\x02\u0A6F\u0A71" + + "\x05n8\x02\u0A70\u0A6F\x03\x02\x02\x02\u0A70\u0A71\x03\x02\x02\x02\u0A71" + + "\u0A73\x03\x02\x02\x02\u0A72\u0A74\x05l7\x02\u0A73\u0A72\x03\x02\x02\x02" + + "\u0A73\u0A74\x03\x02\x02\x02\u0A74\u0A76\x03\x02\x02\x02\u0A75\u0A57\x03" + + "\x02\x02\x02\u0A75\u0A5D\x03\x02\x02\x02\u0A75\u0A67\x03\x02\x02\x02\u0A76" + + "\x8B\x03\x02\x02\x02\u0A77\u0A7A\x07\x9F\x02\x02\u0A78\u0A7B\x05\u03C0" + + "\u01E1\x02\u0A79\u0A7B\x07 \x02\x02\u0A7A\u0A78\x03\x02\x02\x02\u0A7A" + + "\u0A79\x03\x02\x02\x02\u0A7B\x8D\x03\x02\x02\x02\u0A7C\u0A7E\x07\xAB\x02" + + "\x02\u0A7D\u0A7F\x05\x9CO\x02\u0A7E\u0A7D\x03\x02\x02\x02\u0A7E\u0A7F" + + "\x03\x02\x02\x02\u0A7F\u0A80\x03\x02\x02\x02\u0A80\u0A82\x05\u053C\u029F" + + "\x02\u0A81\u0A83\x05\xDAn\x02\u0A82\u0A81\x03\x02\x02\x02\u0A82\u0A83" + + "\x03\x02\x02\x02\u0A83\u0A84\x03\x02\x02\x02\u0A84\u0A86\x05\x90I\x02" + + "\u0A85\u0A87\x05\x92J\x02\u0A86\u0A85\x03\x02\x02\x02\u0A86\u0A87\x03" + + "\x02\x02\x02\u0A87\u0A88\x03\x02\x02\x02\u0A88\u0A8A\x05\x94K\x02\u0A89" + + "\u0A8B\x05\x9EP\x02\u0A8A\u0A89\x03\x02\x02\x02\u0A8A\u0A8B\x03\x02\x02" + + "\x02\u0A8B\u0A8D\x03\x02\x02\x02\u0A8C\u0A8E\x05\x10\t\x02\u0A8D\u0A8C" + + "\x03\x02\x02\x02\u0A8D\u0A8E\x03\x02\x02\x02\u0A8E\u0A8F\x03\x02\x02\x02" + + "\u0A8F\u0A91\x05\x96L\x02\u0A90\u0A92\x05\u044A\u0226\x02\u0A91\u0A90" + + "\x03\x02\x02\x02\u0A91\u0A92\x03\x02\x02\x02\u0A92\u0AA2\x03\x02\x02\x02" + + "\u0A93\u0A94\x07\xAB\x02\x02\u0A94\u0A95\x07\x04\x02\x02\u0A95\u0A96\x05" + + "\u038C\u01C7\x02\u0A96\u0A97\x07\x05\x02\x02\u0A97\u0A99\x07`\x02\x02" + + "\u0A98\u0A9A\x05\x92J\x02\u0A99\u0A98\x03\x02\x02\x02\u0A99\u0A9A\x03" + + "\x02\x02\x02\u0A9A\u0A9B\x03\x02\x02\x02\u0A9B\u0A9D\x05\x94K\x02\u0A9C" + + "\u0A9E\x05\x10\t\x02\u0A9D\u0A9C\x03\x02\x02\x02\u0A9D\u0A9E\x03\x02\x02" + + "\x02\u0A9E\u0A9F\x03\x02\x02\x02\u0A9F\u0AA0\x05\x96L\x02\u0AA0\u0AA2" + + "\x03\x02\x02\x02\u0AA1\u0A7C\x03\x02\x02\x02\u0AA1\u0A93\x03\x02\x02\x02" + + "\u0AA2\x8F\x03\x02\x02\x02\u0AA3\u0AA4\t\x12\x02\x02\u0AA4\x91\x03\x02" + + "\x02\x02\u0AA5\u0AA6\x07\u012B\x02\x02\u0AA6\x93\x03\x02\x02\x02\u0AA7" + + "\u0AAB\x05\u0552\u02AA\x02\u0AA8\u0AAB\x07\u0159\x02\x02\u0AA9\u0AAB\x07" + + "\u015A\x02\x02\u0AAA\u0AA7\x03\x02\x02\x02\u0AAA\u0AA8\x03\x02\x02\x02" + + "\u0AAA\u0AA9\x03\x02\x02\x02\u0AAB\x95\x03\x02\x02\x02\u0AAC\u0AB2\x05" + + "\x98M\x02\u0AAD\u0AAE\x07\x04\x02\x02\u0AAE\u0AAF\x05\xA2R\x02\u0AAF\u0AB0" + + "\x07\x05\x02\x02\u0AB0\u0AB2\x03\x02\x02\x02\u0AB1\u0AAC\x03\x02\x02\x02" + + "\u0AB1\u0AAD\x03\x02\x02\x02\u0AB2\x97\x03\x02\x02\x02\u0AB3\u0AB5\x05" + + "\x9AN\x02\u0AB4\u0AB3\x03\x02\x02\x02\u0AB5\u0AB8\x03\x02\x02\x02\u0AB6" + + "\u0AB4\x03\x02\x02\x02\u0AB6\u0AB7\x03\x02\x02\x02\u0AB7\x99\x03\x02\x02" + + "\x02\u0AB8\u0AB6\x03\x02\x02\x02\u0AB9\u0AE1\x07m\x02\x02\u0ABA\u0AE1" + + "\x07r\x02\x02\u0ABB\u0ABD\x07\xB9\x02\x02\u0ABC\u0ABE\x05\u0350\u01A9" + + "\x02\u0ABD\u0ABC\x03\x02\x02\x02\u0ABD\u0ABE\x03\x02\x02\x02\u0ABE\u0ABF" + + "\x03\x02\x02\x02\u0ABF\u0AE1\x05\u0552\u02AA\x02\u0AC0\u0AC2\x07P\x02" + + "\x02\u0AC1\u0AC3\x05\u0350\u01A9\x02\u0AC2\u0AC1\x03\x02\x02\x02\u0AC2" + + "\u0AC3\x03\x02\x02\x02\u0AC3\u0AC4\x03\x02\x02\x02\u0AC4\u0AE1\x05\u0552" + + "\u02AA\x02\u0AC5\u0AE1\x07\xAD\x02\x02\u0AC6\u0AE1\x07\xDA\x02\x02\u0AC7" + + "\u0AC9\x07\u012C\x02\x02\u0AC8\u0ACA\x05\u0350\u01A9\x02\u0AC9\u0AC8\x03" + + "\x02\x02\x02\u0AC9\u0ACA\x03\x02\x02\x02\u0ACA\u0ACB\x03\x02\x02\x02\u0ACB" + + "\u0AE1\x05\u0552\u02AA\x02\u0ACC\u0ACE\x07\xC7\x02\x02\u0ACD\u0ACF\x05" + + "\u0350\u01A9\x02\u0ACE\u0ACD\x03\x02\x02\x02\u0ACE\u0ACF\x03\x02\x02\x02" + + "\u0ACF\u0AD0\x03\x02\x02\x02\u0AD0\u0AE1\x05\u0552\u02AA\x02\u0AD1\u0AD2" + + "\x07\xD3\x02\x02\u0AD2\u0AD3\x07\u012C\x02\x02\u0AD3\u0AE1\x05\xDCo\x02" + + "\u0AD4\u0AD5\x07\xD3\x02\x02\u0AD5\u0AD6\x07\u012C\x02\x02\u0AD6\u0AE1" + + "\x07\v\x02\x02\u0AD7\u0AD8\x07\xD3\x02\x02\u0AD8\u0AD9\x07O\x02\x02\u0AD9" + + "\u0ADA\x07P\x02\x02\u0ADA\u0AE1\x05\xDCo\x02\u0ADB\u0ADC\x07\xD3\x02\x02" + + "\u0ADC\u0ADD\x07P\x02\x02\u0ADD\u0AE1\x05\xDCo\x02\u0ADE\u0ADF\x07\xC4" + + "\x02\x02\u0ADF\u0AE1\x05\u0552\u02AA\x02\u0AE0\u0AB9\x03\x02\x02\x02\u0AE0" + + "\u0ABA\x03\x02\x02\x02\u0AE0\u0ABB\x03\x02\x02\x02\u0AE0\u0AC0\x03\x02" + + "\x02\x02\u0AE0\u0AC5\x03\x02\x02\x02\u0AE0\u0AC6\x03\x02\x02\x02\u0AE0" + + "\u0AC7\x03\x02\x02\x02\u0AE0\u0ACC\x03\x02\x02\x02\u0AE0\u0AD1\x03\x02" + + "\x02\x02\u0AE0\u0AD4\x03\x02\x02\x02\u0AE0\u0AD7\x03\x02\x02\x02\u0AE0" + + "\u0ADB\x03\x02\x02\x02\u0AE0\u0ADE\x03\x02\x02\x02\u0AE1\x9B\x03\x02\x02" + + "\x02\u0AE2\u0AE3\x07m\x02\x02\u0AE3\x9D\x03\x02\x02\x02\u0AE4\u0AE6\x05" + + "\xA0Q\x02\u0AE5\u0AE4\x03\x02\x02\x02\u0AE5\u0AE6\x03\x02\x02\x02\u0AE6" + + "\u0AE7\x03\x02\x02\x02\u0AE7\u0AE8\x07\xBA\x02\x02\u0AE8\u0AE9\x05\u0552" + + "\u02AA\x02\u0AE9\x9F\x03\x02\x02\x02\u0AEA\u0AEB\x07f\x02\x02\u0AEB\xA1" + + "\x03\x02\x02\x02\u0AEC\u0AF1\x05\xA4S\x02\u0AED\u0AEE\x07\b\x02\x02\u0AEE" + + "\u0AF0\x05\xA4S\x02\u0AEF\u0AED\x03\x02\x02\x02\u0AF0\u0AF3\x03\x02\x02" + + "\x02\u0AF1\u0AEF\x03\x02\x02\x02\u0AF1\u0AF2\x03\x02\x02\x02\u0AF2\xA3" + + "\x03\x02\x02\x02\u0AF3\u0AF1\x03\x02\x02\x02\u0AF4\u0AF6\x05\u0570\u02B9" + + "\x02\u0AF5\u0AF7\x05\xA6T\x02\u0AF6\u0AF5\x03\x02\x02\x02\u0AF6\u0AF7" + + "\x03\x02\x02\x02\u0AF7\xA5\x03\x02\x02\x02\u0AF8\u0B00\x05B\"\x02\u0AF9" + + "\u0B00\x05\u0128\x95\x02\u0AFA\u0B00\x07\v\x02\x02\u0AFB\u0AFC\x07\x04" + + "\x02\x02\u0AFC\u0AFD\x05\xA8U\x02\u0AFD\u0AFE\x07\x05\x02\x02\u0AFE\u0B00" + + "\x03\x02\x02\x02\u0AFF\u0AF8\x03\x02\x02\x02\u0AFF\u0AF9\x03\x02\x02\x02" + + "\u0AFF\u0AFA\x03\x02\x02\x02\u0AFF\u0AFB\x03\x02\x02\x02\u0B00\xA7\x03" + + "\x02\x02\x02\u0B01\u0B06\x05\xAAV\x02\u0B02\u0B03\x07\b\x02\x02\u0B03" + + "\u0B05\x05\xAAV\x02\u0B04\u0B02\x03\x02\x02\x02\u0B05\u0B08\x03\x02\x02" + + "\x02\u0B06\u0B04\x03\x02\x02\x02\u0B06\u0B07\x03\x02\x02\x02\u0B07\xA9" + + "\x03\x02\x02\x02\u0B08\u0B06\x03\x02\x02\x02\u0B09\u0B0A\x05B\"\x02\u0B0A" + + "\xAB\x03\x02\x02\x02\u0B0B\u0B0D\x070\x02\x02\u0B0C\u0B0E\x05\xAEX\x02" + + "\u0B0D\u0B0C\x03\x02\x02\x02\u0B0D\u0B0E\x03\x02\x02\x02\u0B0E\u0B0F\x03" + + "\x02\x02\x02\u0B0F\u0B13\x07^\x02\x02\u0B10\u0B11\x07\xDE\x02\x02\u0B11" + + "\u0B12\x07O\x02\x02\u0B12\u0B14\x07\u018E\x02"; private static readonly _serializedATNSegment8: string = - "\x02\u0B30\u0B32\x05\xFA~\x02\u0B31\u0B30\x03\x02\x02\x02\u0B31\u0B32" + - "\x03\x02\x02\x02\u0B32\u0B34\x03\x02\x02\x02\u0B33\u0B35\x05\xFC\x7F\x02" + - "\u0B34\u0B33\x03\x02\x02\x02\u0B34\u0B35\x03\x02\x02\x02\u0B35\u0B37\x03" + - "\x02\x02\x02\u0B36\u0B38\x05\xFE\x80\x02\u0B37\u0B36\x03\x02\x02\x02\u0B37" + - "\u0B38\x03\x02\x02\x02\u0B38\u0B3A\x03\x02\x02\x02\u0B39\u0AF8\x03\x02" + - "\x02\x02\u0B39\u0B0F\x03\x02\x02\x02\u0B39\u0B23\x03\x02\x02\x02\u0B3A" + - "\xAD\x03\x02\x02\x02\u0B3B\u0B43\x07\u015B\x02\x02\u0B3C\u0B43\x07\u0159" + - "\x02\x02\u0B3D\u0B3E\x07\xF7\x02\x02\u0B3E\u0B43\t\x0E\x02\x02\u0B3F\u0B40" + - "\x07\xD7\x02\x02\u0B40\u0B43\t\x0E\x02\x02\u0B41\u0B43\x07\u0168\x02\x02" + - "\u0B42\u0B3B\x03\x02\x02\x02\u0B42\u0B3C\x03\x02\x02\x02\u0B42\u0B3D\x03" + - "\x02\x02\x02\u0B42\u0B3F\x03\x02\x02\x02\u0B42\u0B41\x03\x02\x02\x02\u0B43" + - "\xAF\x03\x02\x02\x02\u0B44\u0B45\x05\xB4[\x02\u0B45\xB1\x03\x02\x02\x02" + - "\u0B46\u0B47\x07\x04\x02\x02\u0B47\u0B48\x05\xB6\\\x02\u0B48\u0B49\x07" + - "\x05\x02\x02\u0B49\xB3\x03\x02\x02\x02\u0B4A\u0B4F\x05\xB8]\x02\u0B4B" + - "\u0B4C\x07\b\x02\x02\u0B4C\u0B4E\x05\xB8]\x02\u0B4D\u0B4B\x03\x02\x02" + - "\x02\u0B4E\u0B51\x03\x02\x02\x02\u0B4F\u0B4D\x03\x02\x02\x02\u0B4F\u0B50" + - "\x03\x02\x02\x02\u0B50\xB5\x03\x02\x02\x02\u0B51\u0B4F\x03\x02\x02\x02" + - "\u0B52\u0B57\x05\xBA^\x02\u0B53\u0B54\x07\b\x02\x02\u0B54\u0B56\x05\xBA" + - "^\x02\u0B55\u0B53\x03\x02\x02\x02\u0B56\u0B59\x03\x02\x02\x02\u0B57\u0B55" + - "\x03\x02\x02\x02\u0B57\u0B58\x03\x02\x02\x02\u0B58\xB7\x03\x02\x02\x02" + - "\u0B59\u0B57\x03\x02\x02\x02\u0B5A\u0B5E\x05\xBC_\x02\u0B5B\u0B5E\x05" + - "\xCAf\x02\u0B5C\u0B5E\x05\xD0i\x02\u0B5D\u0B5A\x03\x02\x02\x02\u0B5D\u0B5B" + - "\x03\x02\x02\x02\u0B5D\u0B5C\x03\x02\x02\x02\u0B5E\xB9\x03\x02\x02\x02" + - "\u0B5F\u0B62\x05\xBE`\x02\u0B60\u0B62\x05\xD0i\x02\u0B61\u0B5F\x03\x02" + - "\x02\x02\u0B61\u0B60\x03\x02\x02\x02\u0B62\xBB\x03\x02\x02\x02\u0B63\u0B64" + - "\x05\u0550\u02A9\x02\u0B64\u0B66\x05\u0454\u022B\x02\u0B65\u0B67\x05\u0154" + - "\xAB\x02\u0B66\u0B65\x03\x02\x02\x02\u0B66\u0B67\x03\x02\x02\x02\u0B67" + - "\u0B68\x03\x02\x02\x02\u0B68\u0B69\x05\xC0a\x02\u0B69\xBD\x03\x02\x02" + - "\x02\u0B6A\u0B6D\x05\u0550\u02A9\x02\u0B6B\u0B6C\x07k\x02\x02\u0B6C\u0B6E" + - "\x07\u0111\x02\x02\u0B6D\u0B6B\x03\x02\x02\x02\u0B6D\u0B6E\x03\x02\x02" + - "\x02\u0B6E\u0B6F\x03\x02\x02\x02\u0B6F\u0B70\x05\xC0a\x02\u0B70\xBF\x03" + - "\x02\x02\x02\u0B71\u0B73\x05\xC2b\x02\u0B72\u0B71\x03\x02\x02\x02\u0B73" + - "\u0B76\x03\x02\x02\x02\u0B74\u0B72\x03\x02\x02\x02\u0B74\u0B75\x03\x02" + - "\x02\x02\u0B75\xC1\x03\x02\x02\x02\u0B76\u0B74\x03\x02\x02\x02\u0B77\u0B78" + - "\x07/\x02\x02\u0B78\u0B79\x05\u0530\u0299\x02\u0B79\u0B7A\x05\xC4c\x02" + - "\u0B7A\u0B80\x03\x02\x02\x02\u0B7B\u0B80\x05\xC4c\x02\u0B7C\u0B80\x05" + - "\xC8e\x02\u0B7D\u0B7E\x07-\x02\x02\u0B7E\u0B80\x05\u020C\u0107\x02\u0B7F" + - "\u0B77\x03\x02\x02\x02\u0B7F\u0B7B\x03\x02\x02\x02\u0B7F\u0B7C\x03\x02" + - "\x02\x02\u0B7F\u0B7D\x03\x02\x02\x02\u0B80\xC3\x03\x02\x02\x02\u0B81\u0B82" + - "\x07O\x02\x02\u0B82\u0BB6\x07P\x02\x02\u0B83\u0BB6\x07P\x02\x02\u0B84" + - "\u0B86\x07d\x02\x02\u0B85\u0B87\x05\u0298\u014D\x02\u0B86\u0B85\x03\x02" + - "\x02\x02\u0B86\u0B87\x03\x02\x02\x02\u0B87\u0B89\x03\x02\x02\x02\u0B88" + - "\u0B8A\x05\u0100\x81\x02\u0B89\u0B88\x03\x02\x02\x02\u0B89\u0B8A\x03\x02" + - "\x02\x02\u0B8A\u0BB6\x03\x02\x02\x02\u0B8B\u0B8C\x07W\x02\x02\u0B8C\u0B8E" + - "\x07\xEE\x02\x02\u0B8D\u0B8F\x05\u0298\u014D\x02\u0B8E\u0B8D\x03\x02\x02" + - "\x02\u0B8E\u0B8F\x03\x02\x02\x02\u0B8F\u0B91\x03\x02\x02\x02\u0B90\u0B92" + - "\x05\u0100\x81\x02\u0B91\u0B90\x03\x02\x02\x02\u0B91\u0B92\x03\x02\x02" + - "\x02\u0B92\u0BB6\x03\x02\x02\x02\u0B93\u0B94\x07,\x02\x02\u0B94\u0B95" + - "\x07\x04\x02\x02\u0B95\u0B96\x05\u0480\u0241\x02\u0B96\u0B98\x07\x05\x02" + - "\x02\u0B97\u0B99\x05\xD4k\x02\u0B98\u0B97\x03\x02\x02\x02\u0B98\u0B99" + - "\x03\x02\x02\x02\u0B99\u0BB6\x03\x02\x02\x02\u0B9A\u0B9B\x077\x02\x02" + - "\u0B9B\u0BB6\x05\u04A8\u0255\x02\u0B9C\u0B9D\x07\u01AF\x02\x02\u0B9D\u0B9E" + - "\x05\xC6d\x02\u0B9E\u0BA8\x07&\x02\x02\u0B9F\u0BA1\x07\xDD\x02\x02\u0BA0" + - "\u0BA2\x05\u011C\x8F\x02\u0BA1\u0BA0\x03\x02\x02\x02\u0BA1\u0BA2\x03\x02" + - "\x02\x02\u0BA2\u0BA9\x03\x02\x02\x02\u0BA3\u0BA4\x07\x04\x02\x02\u0BA4" + - "\u0BA5\x05\u0480\u0241\x02\u0BA5\u0BA6\x07\x05\x02\x02\u0BA6\u0BA7\x07" + - "\u01B1\x02\x02\u0BA7\u0BA9\x03\x02\x02\x02\u0BA8\u0B9F\x03\x02\x02\x02" + - "\u0BA8\u0BA3\x03\x02\x02\x02\u0BA9\u0BB6\x03\x02\x02\x02\u0BAA\u0BAB\x07" + - "X\x02\x02\u0BAB\u0BAD\x05\u052C\u0297\x02\u0BAC\u0BAE\x05\xD6l\x02\u0BAD" + - "\u0BAC\x03\x02\x02\x02\u0BAD\u0BAE\x03\x02\x02\x02\u0BAE\u0BB0\x03\x02" + - "\x02\x02\u0BAF\u0BB1\x05\xDEp\x02\u0BB0\u0BAF\x03\x02\x02\x02\u0BB0\u0BB1" + - "\x03\x02\x02\x02\u0BB1\u0BB3\x03\x02\x02\x02\u0BB2\u0BB4\x05\xE6t\x02" + - "\u0BB3\u0BB2\x03\x02\x02\x02\u0BB3\u0BB4\x03\x02\x02\x02\u0BB4\u0BB6\x03" + - "\x02\x02\x02\u0BB5\u0B81\x03\x02\x02\x02\u0BB5\u0B83\x03\x02\x02\x02\u0BB5" + - "\u0B84\x03\x02\x02\x02\u0BB5\u0B8B\x03\x02\x02\x02\u0BB5\u0B93\x03\x02" + - "\x02\x02\u0BB5\u0B9A\x03\x02\x02\x02\u0BB5\u0B9C\x03\x02\x02\x02\u0BB5" + - "\u0BAA\x03\x02\x02\x02\u0BB6\xC5\x03\x02\x02\x02\u0BB7\u0BBB\x07\x8D\x02" + - "\x02\u0BB8\u0BB9\x07\x95\x02\x02\u0BB9\u0BBB\x077\x02\x02\u0BBA\u0BB7" + - "\x03\x02\x02\x02\u0BBA\u0BB8\x03\x02\x02\x02\u0BBB\xC7\x03\x02\x02\x02" + - "\u0BBC\u0BC2\x078\x02\x02\u0BBD\u0BBE\x07O\x02\x02\u0BBE\u0BC2\x078\x02" + - "\x02\u0BBF\u0BC0\x07G\x02\x02\u0BC0\u0BC2\t\n\x02\x02\u0BC1\u0BBC\x03" + - "\x02\x02\x02\u0BC1\u0BBD\x03\x02\x02\x02\u0BC1\u0BBF\x03\x02\x02\x02\u0BC2" + - "\xC9\x03\x02\x02\x02\u0BC3\u0BC4\x07z\x02\x02\u0BC4\u0BC5\x05\u052C\u0297" + - "\x02\u0BC5\u0BC6\x05\xCCg\x02\u0BC6\xCB\x03\x02\x02\x02\u0BC7\u0BC8\t" + - "\x0F\x02\x02\u0BC8\u0BCA\x05\xCEh\x02\u0BC9\u0BC7\x03\x02\x02\x02\u0BCA" + - "\u0BCD\x03\x02\x02\x02\u0BCB\u0BC9\x03\x02\x02\x02\u0BCB\u0BCC\x03\x02" + - "\x02\x02\u0BCC\xCD\x03\x02\x02\x02\u0BCD\u0BCB\x03\x02\x02\x02\u0BCE\u0BCF" + - "\t\x10\x02\x02\u0BCF\xCF\x03\x02\x02\x02\u0BD0\u0BD1\x07/\x02\x02\u0BD1" + - "\u0BD2\x05\u0530\u0299\x02\u0BD2\u0BD3\x05\xD2j\x02\u0BD3\u0BD6\x03\x02" + - "\x02\x02\u0BD4\u0BD6\x05\xD2j\x02\u0BD5\u0BD0\x03\x02\x02\x02\u0BD5\u0BD4" + - "\x03\x02\x02\x02\u0BD6\xD1\x03\x02\x02\x02\u0BD7\u0BD8\x07,\x02\x02\u0BD8" + - "\u0BD9\x07\x04\x02\x02\u0BD9\u0BDA\x05\u0480\u0241\x02\u0BDA\u0BDB\x07" + - "\x05\x02\x02\u0BDB\u0BDC\x05\u01B8\xDD\x02\u0BDC\u0C2E\x03\x02\x02\x02" + - "\u0BDD\u0BEF\x07d\x02\x02\u0BDE\u0BDF\x07\x04\x02\x02\u0BDF\u0BE0\x05" + - "\xD8m\x02\u0BE0\u0BE2\x07\x05\x02\x02\u0BE1\u0BE3\x05\xDCo\x02\u0BE2\u0BE1" + - "\x03\x02\x02\x02\u0BE2\u0BE3\x03\x02\x02\x02\u0BE3\u0BE5\x03\x02\x02\x02" + - "\u0BE4\u0BE6\x05\u0298\u014D\x02\u0BE5\u0BE4\x03\x02\x02\x02\u0BE5\u0BE6" + - "\x03\x02\x02\x02\u0BE6\u0BE8\x03\x02\x02\x02\u0BE7\u0BE9\x05\u0100\x81" + - "\x02\u0BE8\u0BE7\x03\x02\x02\x02\u0BE8\u0BE9\x03\x02\x02\x02\u0BE9\u0BEA" + - "\x03\x02\x02\x02\u0BEA\u0BEB\x05\u01B8\xDD\x02\u0BEB\u0BF0\x03\x02\x02" + - "\x02\u0BEC\u0BED\x05\u0102\x82\x02\u0BED\u0BEE\x05\u01B8\xDD\x02\u0BEE" + - "\u0BF0\x03\x02\x02\x02\u0BEF\u0BDE\x03\x02\x02\x02\u0BEF\u0BEC\x03\x02" + - "\x02\x02\u0BF0\u0C2E\x03\x02\x02\x02\u0BF1\u0BF2\x07W\x02\x02\u0BF2\u0C04" + - "\x07\xEE\x02\x02\u0BF3\u0BF4\x07\x04\x02\x02\u0BF4\u0BF5\x05\xD8m\x02" + - "\u0BF5\u0BF7\x07\x05\x02\x02\u0BF6\u0BF8\x05\xDCo\x02\u0BF7\u0BF6\x03" + - "\x02\x02\x02\u0BF7\u0BF8\x03\x02\x02\x02\u0BF8\u0BFA\x03\x02\x02\x02\u0BF9" + - "\u0BFB\x05\u0298\u014D\x02\u0BFA\u0BF9\x03\x02\x02\x02\u0BFA\u0BFB\x03" + - "\x02\x02\x02\u0BFB\u0BFD\x03\x02\x02\x02\u0BFC\u0BFE\x05\u0100\x81\x02" + - "\u0BFD\u0BFC\x03\x02\x02\x02\u0BFD\u0BFE\x03\x02\x02\x02\u0BFE\u0BFF\x03" + - "\x02\x02\x02\u0BFF\u0C00\x05\u01B8\xDD\x02\u0C00\u0C05\x03\x02\x02\x02" + - "\u0C01\u0C02\x05\u0102\x82\x02\u0C02\u0C03\x05\u01B8\xDD\x02\u0C03\u0C05" + - "\x03\x02\x02\x02\u0C04\u0BF3\x03\x02\x02\x02\u0C04\u0C01\x03\x02\x02\x02" + - "\u0C05\u0C2E\x03\x02\x02\x02\u0C06\u0C08\x07\xC9\x02\x02\u0C07\u0C09\x05" + - "\u0254\u012B\x02\u0C08\u0C07\x03\x02\x02\x02\u0C08\u0C09\x03\x02\x02\x02" + - "\u0C09\u0C0A\x03\x02\x02\x02\u0C0A\u0C0B\x07\x04\x02\x02\u0C0B\u0C0C\x05" + - "\xE0q\x02\u0C0C\u0C0E\x07\x05\x02\x02\u0C0D\u0C0F\x05\xDCo\x02\u0C0E\u0C0D" + - "\x03\x02\x02\x02\u0C0E\u0C0F\x03\x02\x02\x02\u0C0F\u0C11\x03\x02\x02\x02" + - "\u0C10\u0C12\x05\u0298\u014D\x02\u0C11\u0C10\x03\x02\x02\x02\u0C11\u0C12" + - "\x03\x02\x02\x02\u0C12\u0C14\x03\x02\x02\x02\u0C13\u0C15\x05\u0100\x81" + - "\x02\u0C14\u0C13\x03\x02\x02\x02\u0C14\u0C15\x03\x02\x02\x02\u0C15\u0C17" + - "\x03\x02\x02\x02\u0C16\u0C18\x05\xE4s\x02\u0C17\u0C16\x03\x02\x02\x02" + - "\u0C17\u0C18\x03\x02\x02\x02\u0C18\u0C19\x03\x02\x02\x02\u0C19\u0C1A\x05" + - "\u01B8\xDD\x02\u0C1A\u0C2E\x03\x02\x02\x02\u0C1B\u0C1C\x07A\x02\x02\u0C1C" + - "\u0C1D\x07\xEE\x02\x02\u0C1D\u0C1E\x07\x04\x02\x02\u0C1E\u0C1F\x05\xD8" + - "m\x02\u0C1F\u0C20\x07\x05\x02\x02\u0C20\u0C21\x07X\x02\x02\u0C21\u0C23" + - "\x05\u052C\u0297\x02\u0C22\u0C24\x05\xD6l\x02\u0C23\u0C22\x03\x02\x02" + - "\x02\u0C23\u0C24\x03\x02\x02\x02\u0C24\u0C26\x03\x02\x02\x02\u0C25\u0C27" + - "\x05\xDEp\x02\u0C26\u0C25\x03\x02\x02\x02\u0C26\u0C27\x03\x02\x02\x02" + - "\u0C27\u0C29\x03\x02\x02\x02\u0C28\u0C2A\x05\xE6t\x02\u0C29\u0C28\x03" + - "\x02\x02\x02\u0C29\u0C2A\x03\x02\x02\x02\u0C2A\u0C2B\x03\x02\x02\x02\u0C2B" + - "\u0C2C\x05\u01B8\xDD\x02\u0C2C\u0C2E\x03\x02\x02\x02\u0C2D\u0BD7\x03\x02" + - "\x02\x02\u0C2D\u0BDD\x03\x02\x02\x02\u0C2D\u0BF1\x03\x02\x02\x02\u0C2D" + - "\u0C06\x03\x02\x02\x02\u0C2D\u0C1B\x03\x02\x02\x02\u0C2E\xD3\x03\x02\x02" + - "\x02\u0C2F\u0C30\x07\u0106\x02\x02\u0C30\u0C31\x07\xE6\x02\x02\u0C31\xD5" + - "\x03\x02\x02\x02\u0C32\u0C33\x07\x04\x02\x02\u0C33\u0C34\x05\xD8m\x02" + - "\u0C34\u0C35\x07\x05\x02\x02\u0C35\xD7\x03\x02\x02\x02\u0C36\u0C3B\x05" + - "\xDAn\x02\u0C37\u0C38\x07\b\x02\x02\u0C38\u0C3A\x05\xDAn\x02\u0C39\u0C37" + - "\x03\x02\x02\x02\u0C3A\u0C3D\x03\x02\x02\x02\u0C3B\u0C39\x03\x02\x02\x02" + - "\u0C3B\u0C3C\x03\x02\x02\x02\u0C3C\xD9\x03\x02\x02\x02\u0C3D\u0C3B\x03" + - "\x02\x02\x02\u0C3E\u0C3F\x05\u0550\u02A9\x02\u0C3F\xDB\x03\x02\x02\x02" + - "\u0C40\u0C41\x07\u01B2\x02\x02\u0C41\u0C42\x07\x04\x02\x02\u0C42\u0C43" + - "\x05\xD8m\x02\u0C43\u0C44\x07\x05\x02\x02\u0C44\xDD\x03\x02\x02\x02\u0C45" + - "\u0C46\x07\xFB\x02\x02\u0C46\u0C47\t\x11\x02\x02\u0C47\xDF\x03\x02\x02" + - "\x02\u0C48\u0C4D\x05\xE2r\x02\u0C49\u0C4A\x07\b\x02\x02\u0C4A\u0C4C\x05" + - "\xE2r\x02\u0C4B\u0C49\x03\x02\x02\x02\u0C4C\u0C4F\x03\x02\x02\x02\u0C4D" + - "\u0C4B\x03\x02\x02\x02\u0C4D\u0C4E\x03\x02\x02\x02\u0C4E\xE1\x03\x02\x02" + - "\x02\u0C4F\u0C4D\x03\x02\x02\x02\u0C50\u0C51\x05\u025A\u012E\x02\u0C51" + - "\u0C58\x07k\x02\x02\u0C52\u0C59\x05\u02AC\u0157\x02\u0C53\u0C54\x07\u010F" + - "\x02\x02\u0C54\u0C55\x07\x04\x02\x02\u0C55\u0C56\x05\u02AC\u0157\x02\u0C56" + - "\u0C57\x07\x05\x02\x02\u0C57\u0C59\x03\x02\x02\x02\u0C58\u0C52\x03\x02" + - "\x02\x02\u0C58\u0C53\x03\x02\x02\x02\u0C59\xE3\x03\x02\x02\x02\u0C5A\u0C5B" + - "\x07i\x02\x02\u0C5B\u0C5C\x07\x04\x02\x02\u0C5C\u0C5D\x05\u0480\u0241" + - "\x02\u0C5D\u0C5E\x07\x05\x02\x02\u0C5E\xE5\x03\x02\x02\x02\u0C5F\u0C68" + - "\x05\xE8u\x02\u0C60\u0C68\x05\xEAv\x02\u0C61\u0C62\x05\xE8u\x02\u0C62" + - "\u0C63\x05\xEAv\x02\u0C63\u0C68\x03\x02\x02\x02\u0C64\u0C65\x05\xEAv\x02" + - "\u0C65\u0C66\x05\xE8u\x02\u0C66\u0C68\x03\x02\x02\x02\u0C67\u0C5F\x03" + - "\x02\x02\x02\u0C67\u0C60\x03\x02\x02\x02\u0C67\u0C61\x03\x02\x02\x02\u0C67" + - "\u0C64\x03\x02\x02\x02\u0C68\xE7\x03\x02\x02\x02\u0C69\u0C6A\x07R\x02" + - "\x02\u0C6A\u0C6B\x07\u016A\x02\x02\u0C6B\u0C6C\x05\xECw\x02\u0C6C\xE9" + - "\x03\x02\x02\x02\u0C6D\u0C6E\x07R\x02\x02\u0C6E\u0C6F\x07\xB8\x02\x02" + - "\u0C6F\u0C70\x05\xECw\x02\u0C70\xEB\x03\x02\x02\x02\u0C71\u0C72\x07\u0106" + - "\x02\x02\u0C72\u0C78\x07\x86\x02\x02\u0C73\u0C78\x07\u0134\x02\x02\u0C74" + - "\u0C78\x07\x98\x02\x02\u0C75\u0C76\x07\u0146\x02\x02\u0C76\u0C78\t\x12" + - "\x02\x02\u0C77\u0C71\x03\x02\x02\x02\u0C77\u0C73\x03\x02\x02\x02\u0C77" + - "\u0C74\x03\x02\x02\x02\u0C77\u0C75\x03\x02\x02\x02\u0C78\xED\x03\x02\x02" + - "\x02\u0C79\u0C7A\x07\xE7\x02\x02\u0C7A\u0C7B\x07\x04\x02\x02\u0C7B\u0C7C" + - "\x05\u052A\u0296\x02\u0C7C\u0C7D\x07\x05\x02\x02\u0C7D\xEF\x03\x02\x02" + - "\x02\u0C7E\u0C7F\x05\xF2z\x02\u0C7F\xF1\x03\x02\x02\x02\u0C80\u0C81\x07" + - "\u0116\x02\x02\u0C81\u0C82\x07\x95\x02\x02\u0C82\u0C83\x05\u0550\u02A9" + - "\x02\u0C83\u0C84\x07\x04\x02\x02\u0C84\u0C85\x05\xF4{\x02\u0C85\u0C86" + - "\x07\x05\x02\x02\u0C86\xF3\x03\x02\x02\x02\u0C87\u0C8C\x05\xF6|\x02\u0C88" + - "\u0C89\x07\b\x02\x02\u0C89\u0C8B\x05\xF6|\x02\u0C8A\u0C88\x03\x02\x02" + - "\x02\u0C8B\u0C8E\x03\x02\x02\x02\u0C8C\u0C8A\x03\x02\x02\x02\u0C8C\u0C8D" + - "\x03\x02\x02\x02\u0C8D\xF5\x03\x02\x02\x02\u0C8E\u0C8C\x03\x02\x02\x02" + - "\u0C8F\u0C91\x05\u0550\u02A9\x02\u0C90\u0C92\x05\u0260\u0131\x02\u0C91" + - "\u0C90\x03\x02\x02\x02\u0C91\u0C92\x03\x02\x02\x02\u0C92\u0C94\x03\x02" + - "\x02\x02\u0C93\u0C95\x05\u0262\u0132\x02\u0C94\u0C93\x03\x02\x02\x02\u0C94" + - "\u0C95\x03\x02\x02\x02\u0C95\u0CA7\x03\x02\x02\x02\u0C96\u0C98\x05\u04B2" + - "\u025A\x02\u0C97\u0C99\x05\u0260\u0131\x02\u0C98\u0C97\x03\x02\x02\x02" + - "\u0C98\u0C99\x03\x02\x02\x02\u0C99\u0C9B\x03\x02\x02\x02\u0C9A\u0C9C\x05" + - "\u0262\u0132\x02\u0C9B\u0C9A\x03\x02\x02\x02\u0C9B\u0C9C\x03\x02\x02\x02" + - "\u0C9C\u0CA7\x03\x02\x02\x02\u0C9D\u0C9E\x07\x04\x02\x02\u0C9E\u0C9F\x05" + - "\u0480\u0241\x02\u0C9F\u0CA1\x07\x05\x02\x02\u0CA0\u0CA2\x05\u0260\u0131" + - "\x02\u0CA1\u0CA0\x03\x02\x02\x02\u0CA1\u0CA2\x03\x02\x02\x02\u0CA2\u0CA4" + - "\x03\x02\x02\x02\u0CA3\u0CA5\x05\u0262\u0132\x02\u0CA4\u0CA3\x03\x02\x02" + - "\x02\u0CA4\u0CA5\x03\x02\x02\x02\u0CA5\u0CA7\x03\x02\x02\x02\u0CA6\u0C8F" + - "\x03\x02\x02\x02\u0CA6\u0C96\x03\x02\x02\x02\u0CA6\u0C9D\x03\x02\x02\x02" + - "\u0CA7\xF7\x03\x02\x02\x02\u0CA8\u0CA9\x07f\x02\x02\u0CA9\u0CAA\x05\u0530" + - "\u0299\x02\u0CAA\xF9\x03\x02\x02\x02\u0CAB\u0CAC\x07k\x02\x02\u0CAC\u0CB0" + - "\x05t;\x02\u0CAD\u0CAE\x07\u0174\x02\x02\u0CAE\u0CB0\x07\u010E\x02\x02" + - "\u0CAF\u0CAB\x03\x02\x02\x02\u0CAF\u0CAD\x03\x02\x02\x02\u0CB0\xFB\x03" + - "\x02\x02\x02\u0CB1\u0CB2\x07R\x02\x02\u0CB2\u0CB8\x07\xA3\x02\x02\u0CB3" + - "\u0CB9\x07\xC1\x02\x02\u0CB4\u0CB5\x07\xB8\x02\x02\u0CB5\u0CB9\x07\u0139" + - "\x02\x02\u0CB6\u0CB7\x07\u011D\x02\x02\u0CB7\u0CB9\x07\u0139\x02\x02\u0CB8" + - "\u0CB3\x03\x02\x02\x02\u0CB8\u0CB4\x03\x02\x02\x02\u0CB8\u0CB6\x03\x02" + - "\x02\x02\u0CB9\xFD\x03\x02\x02\x02\u0CBA\u0CBB\x07\u0158\x02\x02\u0CBB" + - "\u0CBC\x05\u0530\u0299\x02\u0CBC\xFF\x03\x02\x02\x02\u0CBD\u0CBE\x07f" + - "\x02\x02\u0CBE\u0CBF\x07\xE4\x02\x02\u0CBF\u0CC0\x07\u0158\x02\x02\u0CC0" + - "\u0CC1\x05\u0530\u0299\x02\u0CC1\u0101\x03\x02\x02\x02\u0CC2\u0CC3\x07" + - "f\x02\x02\u0CC3\u0CC4\x07\xE4\x02\x02\u0CC4\u0CC5\x05\u0530\u0299\x02" + - "\u0CC5\u0103\x03\x02\x02\x02\u0CC6\u0CC7\x070\x02\x02\u0CC7\u0CCB\x07" + - "\u014F\x02\x02\u0CC8\u0CC9\x07\xDE\x02\x02\u0CC9\u0CCA\x07O\x02\x02\u0CCA" + - "\u0CCC\x07\u0185\x02\x02\u0CCB\u0CC8\x03\x02\x02\x02\u0CCB\u0CCC\x03\x02" + - "\x02\x02\u0CCC\u0CCD\x03\x02\x02\x02\u0CCD\u0CCF\x05\u020C\u0107\x02\u0CCE" + - "\u0CD0\x05\u0366\u01B4\x02\u0CCF\u0CCE\x03\x02\x02\x02\u0CCF\u0CD0\x03" + - "\x02\x02\x02\u0CD0\u0CD1\x03\x02\x02\x02\u0CD1\u0CD2\x07R\x02\x02\u0CD2" + - "\u0CD3\x05\u04F4\u027B\x02\u0CD3\u0CD4\x07B\x02\x02\u0CD4\u0CD5\x05\u041A" + - "\u020E\x02\u0CD5\u0105\x03\x02\x02\x02\u0CD6\u0CD7\x07\x8C\x02\x02\u0CD7" + - "\u0CDA\x07\u014F\x02\x02\u0CD8\u0CD9\x07\xDE\x02\x02\u0CD9\u0CDB\x07\u0185" + - "\x02\x02\u0CDA\u0CD8\x03\x02\x02\x02\u0CDA\u0CDB\x03\x02\x02\x02\u0CDB" + - "\u0CDC\x03\x02\x02\x02\u0CDC\u0CDD\x05\u020C\u0107\x02\u0CDD\u0CDE\x07" + - "\u0146\x02\x02\u0CDE\u0CDF\x07\u014F\x02\x02\u0CDF\u0CE0\x05\u0548\u02A5" + - "\x02\u0CE0\u0107\x03\x02\x02\x02\u0CE1\u0CE3\x070\x02\x02\u0CE2\u0CE4" + - "\x05\xAEX\x02\u0CE3\u0CE2\x03\x02\x02\x02\u0CE3\u0CE4\x03\x02\x02\x02" + - "\u0CE4\u0CE5\x03\x02\x02\x02\u0CE5\u0CE9\x07^\x02\x02\u0CE6\u0CE7\x07" + - "\xDE\x02\x02\u0CE7\u0CE8\x07O\x02\x02\u0CE8\u0CEA\x07\u0185\x02\x02\u0CE9" + - "\u0CE6\x03\x02\x02\x02\u0CE9\u0CEA\x03\x02\x02\x02\u0CEA\u0CEB\x03\x02" + - "\x02\x02\u0CEB\u0CEC\x05\u010A\x86\x02\u0CEC\u0CED\x07&\x02\x02\u0CED" + - "\u0CEF\x05\u03B8\u01DD\x02\u0CEE\u0CF0\x05\u010C\x87\x02\u0CEF\u0CEE\x03" + - "\x02\x02\x02\u0CEF\u0CF0\x03\x02\x02\x02\u0CF0\u0109\x03\x02\x02\x02\u0CF1" + - "\u0CF3\x05\u052C\u0297\x02\u0CF2\u0CF4\x05\xD6l\x02\u0CF3\u0CF2\x03\x02" + - "\x02\x02\u0CF3\u0CF4\x03\x02\x02\x02\u0CF4\u0CF6\x03\x02\x02\x02\u0CF5" + - "\u0CF7\x05\xF8}\x02\u0CF6\u0CF5\x03\x02\x02\x02\u0CF6\u0CF7\x03\x02\x02" + - "\x02\u0CF7\u0CF9\x03\x02\x02\x02\u0CF8\u0CFA\x05\xFA~\x02\u0CF9\u0CF8" + - "\x03\x02\x02\x02\u0CF9\u0CFA\x03\x02\x02\x02\u0CFA\u0CFC\x03\x02\x02\x02" + - "\u0CFB\u0CFD\x05\xFC\x7F\x02\u0CFC\u0CFB\x03\x02\x02\x02\u0CFC\u0CFD\x03" + - "\x02\x02\x02\u0CFD\u0CFF\x03\x02\x02\x02\u0CFE\u0D00\x05\xFE\x80\x02\u0CFF" + - "\u0CFE\x03\x02\x02\x02\u0CFF\u0D00\x03\x02\x02\x02\u0D00\u010B\x03\x02" + - "\x02\x02\u0D01\u0D05\x07k\x02\x02\u0D02\u0D06\x07\xB0\x02\x02\u0D03\u0D04" + - "\x07\u0106\x02\x02\u0D04\u0D06\x07\xB0\x02\x02\u0D05\u0D02\x03\x02\x02" + - "\x02\u0D05\u0D03\x03\x02\x02\x02\u0D06\u010D\x03\x02\x02\x02\u0D07\u0D09" + - "\x070\x02\x02\u0D08\u0D0A\x05\u0112\x8A\x02\u0D09\u0D08\x03\x02\x02\x02" + - "\u0D09\u0D0A\x03\x02\x02\x02\u0D0A\u0D0B\x03\x02\x02\x02\u0D0B\u0D0C\x07" + - "\xFC\x02\x02\u0D0C\u0D10\x07\u0171\x02\x02\u0D0D\u0D0E\x07\xDE\x02\x02" + - "\u0D0E\u0D0F\x07O\x02\x02\u0D0F\u0D11\x07\u0185\x02\x02\u0D10\u0D0D\x03" + - "\x02\x02\x02\u0D10\u0D11\x03\x02\x02\x02\u0D11\u0D12\x03\x02\x02\x02\u0D12" + - "\u0D13\x05\u0110\x89\x02\u0D13\u0D14\x07&\x02\x02\u0D14\u0D16\x05\u03B8" + - "\u01DD\x02\u0D15\u0D17\x05\u010C\x87\x02\u0D16\u0D15\x03\x02\x02\x02\u0D16" + - "\u0D17\x03\x02\x02\x02\u0D17\u010F\x03\x02\x02\x02\u0D18\u0D1A\x05\u052C" + - "\u0297\x02\u0D19\u0D1B\x05\xD6l\x02\u0D1A\u0D19\x03\x02\x02\x02\u0D1A" + - "\u0D1B\x03\x02\x02\x02\u0D1B\u0D1D\x03\x02\x02\x02\u0D1C\u0D1E\x05\xF8" + - "}\x02\u0D1D\u0D1C\x03\x02\x02\x02\u0D1D\u0D1E\x03\x02\x02\x02\u0D1E\u0D20" + - "\x03\x02\x02\x02\u0D1F\u0D21\x05v<\x02\u0D20\u0D1F\x03\x02\x02\x02\u0D20" + - "\u0D21\x03\x02\x02\x02\u0D21\u0D23\x03\x02\x02\x02\u0D22\u0D24\x05\xFE" + - "\x80\x02\u0D23\u0D22\x03\x02\x02\x02\u0D23\u0D24\x03\x02\x02\x02\u0D24" + - "\u0111\x03\x02\x02\x02\u0D25\u0D26\x07\u0168\x02\x02\u0D26\u0113\x03\x02" + - "\x02\x02\u0D27\u0D28\x07\u012A\x02\x02\u0D28\u0D29\x07\xFC\x02\x02\u0D29" + - "\u0D2B\x07\u0171\x02\x02\u0D2A\u0D2C\x05\u0250\u0129\x02\u0D2B\u0D2A\x03" + - "\x02\x02\x02\u0D2B\u0D2C\x03\x02\x02\x02\u0D2C\u0D2D\x03\x02\x02\x02\u0D2D" + - "\u0D2F\x05\u052C\u0297\x02\u0D2E\u0D30\x05\u010C\x87\x02\u0D2F\u0D2E\x03" + - "\x02\x02\x02\u0D2F\u0D30\x03\x02\x02\x02\u0D30\u0115\x03\x02\x02\x02\u0D31" + - "\u0D33\x070\x02\x02\u0D32\u0D34\x05\xAEX\x02\u0D33\u0D32\x03\x02\x02\x02" + - "\u0D33\u0D34\x03\x02\x02\x02\u0D34\u0D35\x03\x02\x02\x02\u0D35\u0D39\x07" + - "\u0141\x02\x02\u0D36\u0D37\x07\xDE\x02\x02\u0D37\u0D38\x07O\x02\x02\u0D38" + - "\u0D3A\x07\u0185\x02\x02\u0D39\u0D36\x03\x02\x02\x02\u0D39\u0D3A\x03\x02" + - "\x02\x02\u0D3A\u0D3B\x03\x02\x02\x02\u0D3B\u0D3D\x05\u052C\u0297\x02\u0D3C" + - "\u0D3E\x05\u011A\x8E\x02\u0D3D\u0D3C\x03\x02\x02\x02\u0D3D\u0D3E\x03\x02" + - "\x02\x02\u0D3E\u0117\x03\x02\x02\x02\u0D3F\u0D40\x07\x8C\x02\x02\u0D40" + - "\u0D43\x07\u0141\x02\x02\u0D41\u0D42\x07\xDE\x02\x02\u0D42\u0D44\x07\u0185" + - "\x02\x02\u0D43\u0D41\x03\x02\x02\x02\u0D43\u0D44\x03\x02\x02\x02\u0D44" + - "\u0D45\x03\x02\x02\x02\u0D45\u0D46\x05\u052C\u0297\x02\u0D46\u0D47\x05" + - "\u011E\x90\x02\u0D47\u0119\x03\x02\x02\x02\u0D48\u0D49\x05\u011E\x90\x02" + - "\u0D49\u011B\x03\x02\x02\x02\u0D4A\u0D4B\x07\x04\x02\x02\u0D4B\u0D4C\x05" + - "\u011E\x90\x02\u0D4C\u0D4D\x07\x05\x02\x02\u0D4D\u011D\x03\x02\x02\x02" + - "\u0D4E\u0D50\x05\u0120\x91\x02\u0D4F\u0D4E\x03\x02\x02\x02\u0D50\u0D51" + - "\x03\x02\x02\x02\u0D51\u0D4F\x03\x02\x02\x02\u0D51\u0D52\x03\x02\x02\x02" + - "\u0D52\u011F\x03\x02\x02\x02\u0D53\u0D54\x07&\x02\x02\u0D54\u0D76\x05" + - "\u0458\u022D\x02\u0D55\u0D56\x07\x96\x02\x02\u0D56\u0D76\x05\u0124\x93" + - "\x02\u0D57\u0D76\x07\xAF\x02\x02\u0D58\u0D5A\x07\xE3\x02\x02\u0D59\u0D5B" + - "\x05\u0122\x92\x02\u0D5A\u0D59\x03\x02\x02\x02\u0D5A\u0D5B\x03\x02\x02" + - "\x02\u0D5B\u0D5C\x03\x02\x02\x02\u0D5C\u0D76\x05\u0124\x93\x02\u0D5D\u0D5E" + - "\x07\xFD\x02\x02\u0D5E\u0D76\x05\u0124\x93\x02\u0D5F\u0D60\x07\xFF\x02" + - "\x02\u0D60\u0D76\x05\u0124\x93\x02\u0D61\u0D62\x07\u0106\x02\x02\u0D62" + - "\u0D76\t\x13\x02\x02\u0D63\u0D64\x07\u0112\x02\x02\u0D64\u0D65\x07\x95" + - "\x02\x02\u0D65\u0D76\x05\u020C\u0107\x02\u0D66\u0D67\x07\u0141\x02\x02" + - "\u0D67\u0D68\x07\u0103\x02\x02\u0D68\u0D76\x05\u020C\u0107\x02\u0D69\u0D6B" + - "\x07\u014D\x02\x02\u0D6A\u0D6C\x05\x10\t\x02\u0D6B\u0D6A\x03\x02\x02\x02" + - "\u0D6B\u0D6C\x03\x02\x02\x02\u0D6C\u0D6D\x03\x02\x02\x02\u0D6D\u0D76\x05" + - "\u0124\x93\x02\u0D6E\u0D70\x07\u0133\x02\x02\u0D6F\u0D71\x05\x10\t\x02" + - "\u0D70\u0D6F\x03\x02\x02\x02\u0D70\u0D71\x03\x02\x02\x02\u0D71\u0D73\x03" + - "\x02\x02\x02\u0D72\u0D74\x05\u0124\x93\x02\u0D73\u0D72\x03\x02\x02\x02" + - "\u0D73\u0D74\x03\x02\x02\x02\u0D74\u0D76\x03\x02\x02\x02\u0D75\u0D53\x03" + - "\x02\x02\x02\u0D75\u0D55\x03\x02\x02\x02\u0D75\u0D57\x03\x02\x02\x02\u0D75" + - "\u0D58\x03\x02\x02\x02\u0D75\u0D5D\x03\x02\x02\x02\u0D75\u0D5F\x03\x02" + - "\x02\x02\u0D75\u0D61\x03\x02\x02\x02\u0D75\u0D63\x03\x02\x02\x02\u0D75" + - "\u0D66\x03\x02\x02\x02\u0D75\u0D69\x03\x02\x02\x02\u0D75\u0D6E\x03\x02" + - "\x02\x02\u0D76\u0121\x03\x02\x02\x02\u0D77\u0D78\x07\x95\x02\x02\u0D78" + - "\u0123\x03\x02\x02\x02\u0D79\u0D80\x05\u053E\u02A0\x02\u0D7A\u0D7B\x07" + - "\x0E\x02\x02\u0D7B\u0D80\x05\u053E\u02A0\x02\u0D7C\u0D7D\x07\x0F\x02\x02" + - "\u0D7D\u0D80\x05\u053E\u02A0\x02\u0D7E\u0D80\x05\u0548\u02A5\x02\u0D7F" + - "\u0D79\x03\x02\x02\x02\u0D7F\u0D7A\x03\x02\x02\x02\u0D7F\u0D7C\x03\x02" + - "\x02\x02\u0D7F\u0D7E\x03\x02\x02\x02\u0D80\u0125\x03\x02\x02\x02\u0D81" + - "\u0D86\x05\u0124\x93\x02\u0D82\u0D83\x07\b\x02\x02\u0D83\u0D85\x05\u0124" + - "\x93\x02\u0D84\u0D82\x03\x02\x02\x02\u0D85\u0D88\x03\x02\x02\x02\u0D86" + - "\u0D84\x03\x02\x02\x02\u0D86\u0D87\x03\x02\x02\x02\u0D87\u0127\x03\x02" + - "\x02\x02\u0D88\u0D86\x03\x02\x02\x02\u0D89\u0D8B\x070\x02\x02\u0D8A\u0D8C" + - "\x05\u026A\u0136\x02\u0D8B\u0D8A\x03\x02\x02\x02\u0D8B\u0D8C\x03\x02\x02" + - "\x02\u0D8C\u0D8E\x03\x02\x02\x02\u0D8D\u0D8F\x05\u012A\x96\x02\u0D8E\u0D8D" + - "\x03\x02\x02\x02\u0D8E\u0D8F\x03\x02\x02\x02\u0D8F\u0D91\x03\x02\x02\x02" + - "\u0D90\u0D92\x05\u0134\x9B\x02\u0D91\u0D90\x03\x02\x02\x02\u0D91\u0D92" + - "\x03\x02\x02\x02\u0D92\u0D93\x03\x02\x02\x02\u0D93\u0D94\x07\xF0\x02\x02" + - "\u0D94\u0D9D\x05\u0530\u0299\x02\u0D95\u0D96\x07\xD9\x02\x02\u0D96\u0D98" + - "\x05\u012C\x97\x02\u0D97\u0D99\x05\u012E\x98\x02\u0D98\u0D97\x03\x02\x02" + - "\x02\u0D98\u0D99\x03\x02\x02\x02\u0D99\u0D9B\x03\x02\x02\x02\u0D9A\u0D9C" + - "\x05\u0132\x9A\x02\u0D9B\u0D9A\x03\x02\x02\x02\u0D9B\u0D9C\x03\x02\x02" + - "\x02\u0D9C\u0D9E\x03\x02\x02\x02\u0D9D\u0D95\x03\x02\x02\x02\u0D9D\u0D9E" + - "\x03\x02\x02\x02\u0D9E\u0129\x03\x02\x02\x02\u0D9F\u0DA0\x07\u0160\x02" + - "\x02\u0DA0\u012B\x03\x02\x02\x02\u0DA1\u0DA3\x05\u0530\u0299\x02\u0DA2" + - "\u0DA4\x05\u020E\u0108\x02\u0DA3\u0DA2\x03\x02\x02\x02\u0DA3\u0DA4\x03" + - "\x02\x02\x02\u0DA4\u012D\x03\x02\x02\x02\u0DA5\u0DA6\x07\xE8\x02\x02\u0DA6" + - "\u0DA7\x05\u012C\x97\x02\u0DA7\u012F\x03\x02\x02\x02\u0DA8\u0DA9\x07\u016E" + - "\x02\x02\u0DA9\u0DAD\x05\u012C\x97\x02\u0DAA\u0DAB\x07\u0106\x02\x02\u0DAB" + - "\u0DAD\x07\u016E\x02\x02\u0DAC\u0DA8\x03\x02\x02\x02\u0DAC\u0DAA\x03\x02" + - "\x02\x02\u0DAD\u0131\x03\x02\x02\x02\u0DAE\u0DAF\x05\u0130\x99\x02\u0DAF" + - "\u0133\x03\x02\x02\x02\u0DB0\u0DB1\x07\u0120\x02\x02\u0DB1\u0135\x03\x02" + - "\x02\x02\u0DB2\u0DB3\x070\x02\x02\u0DB3\u0DB4\x07\u0158\x02\x02\u0DB4" + - "\u0DB6\x05\u0530\u0299\x02\u0DB5\u0DB7\x05\u0138\x9D\x02\u0DB6\u0DB5\x03" + - "\x02\x02\x02\u0DB6\u0DB7\x03\x02\x02\x02\u0DB7\u0DB8\x03\x02\x02\x02\u0DB8" + - "\u0DB9\x07\xF8\x02\x02\u0DB9\u0DBB\x05\u0542\u02A2\x02\u0DBA\u0DBC\x05" + - "v<\x02\u0DBB\u0DBA\x03\x02\x02\x02\u0DBB\u0DBC\x03\x02\x02\x02\u0DBC\u0137" + - "\x03\x02\x02\x02\u0DBD\u0DBE\x07\u0113\x02\x02\u0DBE\u0DBF\x05\u054C\u02A7" + - "\x02\u0DBF\u0139\x03\x02\x02\x02\u0DC0\u0DC1\x07\xC1\x02\x02\u0DC1\u0DC4" + - "\x07\u0158\x02\x02\u0DC2\u0DC3\x07\xDE\x02\x02\u0DC3\u0DC5\x07\u0185\x02" + - "\x02\u0DC4\u0DC2\x03\x02\x02\x02\u0DC4\u0DC5\x03\x02\x02\x02\u0DC5\u0DC6" + - "\x03\x02\x02\x02\u0DC6\u0DC7\x05\u0530\u0299\x02\u0DC7\u013B\x03\x02\x02" + - "\x02\u0DC8\u0DC9\x070\x02\x02\u0DC9\u0DCD\x07\xCE\x02\x02\u0DCA\u0DCB" + - "\x07\xDE\x02\x02\u0DCB\u0DCC\x07O\x02\x02\u0DCC\u0DCE\x07\u0185\x02\x02" + - "\u0DCD\u0DCA\x03\x02\x02\x02\u0DCD\u0DCE\x03\x02\x02\x02\u0DCE\u0DCF\x03" + - "\x02\x02\x02\u0DCF\u0DD1\x05\u0530\u0299\x02\u0DD0\u0DD2\x05\x10\t\x02" + - "\u0DD1\u0DD0\x03\x02\x02\x02\u0DD1\u0DD2\x03\x02\x02\x02\u0DD2\u0DD3\x03" + - "\x02\x02\x02\u0DD3\u0DD4\x05\u013E\xA0\x02\u0DD4\u013D\x03\x02\x02\x02" + - "\u0DD5\u0DD7\x05\u0140\xA1\x02\u0DD6\u0DD5\x03\x02\x02\x02\u0DD7\u0DDA" + - "\x03\x02\x02\x02\u0DD8\u0DD6\x03\x02\x02\x02\u0DD8\u0DD9\x03\x02\x02\x02" + - "\u0DD9\u013F\x03\x02\x02\x02\u0DDA\u0DD8\x03\x02\x02\x02\u0DDB\u0DDC\x07" + - "\u013C\x02\x02\u0DDC\u0DE3\x05\u0530\u0299\x02\u0DDD\u0DDE\x07\u0170\x02" + - "\x02\u0DDE\u0DE3\x05H%\x02\u0DDF\u0DE0\x07B\x02\x02\u0DE0\u0DE3\x05H%" + - "\x02\u0DE1\u0DE3\x07\x98\x02\x02\u0DE2\u0DDB\x03\x02\x02\x02\u0DE2\u0DDD" + - "\x03\x02\x02\x02\u0DE2"; + "\x02\u0B13\u0B10\x03\x02\x02\x02\u0B13\u0B14\x03\x02\x02\x02\u0B14\u0B15" + + "\x03\x02\x02\x02\u0B15\u0B57\x05\u053A\u029E\x02\u0B16\u0B18\x07\x04\x02" + + "\x02\u0B17\u0B19\x05\xB0Y\x02\u0B18\u0B17\x03\x02\x02\x02\u0B18\u0B19" + + "\x03\x02\x02\x02\u0B19\u0B1A\x03\x02\x02\x02\u0B1A\u0B1C\x07\x05\x02\x02" + + "\u0B1B\u0B1D\x05\xF2z\x02\u0B1C\u0B1B\x03\x02\x02\x02\u0B1C\u0B1D\x03" + + "\x02\x02\x02\u0B1D\u0B1F\x03\x02\x02\x02\u0B1E\u0B20\x05\xF4{\x02\u0B1F" + + "\u0B1E\x03\x02\x02\x02\u0B1F\u0B20\x03\x02\x02\x02\u0B20\u0B22\x03\x02" + + "\x02\x02\u0B21\u0B23\x05\xFC\x7F\x02\u0B22\u0B21\x03\x02\x02\x02\u0B22" + + "\u0B23\x03\x02\x02\x02\u0B23\u0B25\x03\x02\x02\x02\u0B24\u0B26\x05\xFE" + + "\x80\x02\u0B25\u0B24\x03\x02\x02\x02\u0B25\u0B26\x03\x02\x02\x02\u0B26" + + "\u0B28\x03\x02\x02\x02\u0B27\u0B29\x05\u0100\x81\x02\u0B28\u0B27\x03\x02" + + "\x02\x02\u0B28\u0B29\x03\x02\x02\x02\u0B29\u0B2B\x03\x02\x02\x02\u0B2A" + + "\u0B2C\x05\u0102\x82\x02\u0B2B\u0B2A\x03\x02\x02\x02\u0B2B\u0B2C\x03\x02" + + "\x02\x02\u0B2C\u0B58\x03\x02\x02\x02\u0B2D\u0B2E\x07\u0115\x02\x02\u0B2E" + + "\u0B30\x05\u0214\u010B\x02\u0B2F\u0B31\x05\xB4[\x02\u0B30\u0B2F\x03\x02" + + "\x02\x02\u0B30\u0B31\x03\x02\x02\x02\u0B31\u0B33\x03\x02\x02\x02\u0B32" + + "\u0B34\x05\xF4{\x02\u0B33\u0B32\x03\x02\x02\x02\u0B33\u0B34\x03\x02\x02" + + "\x02\u0B34\u0B36\x03\x02\x02\x02\u0B35\u0B37\x05\xFC\x7F\x02\u0B36\u0B35" + + "\x03\x02\x02\x02\u0B36\u0B37\x03\x02\x02\x02\u0B37\u0B39\x03\x02\x02\x02" + + "\u0B38\u0B3A\x05\xFE\x80\x02\u0B39\u0B38\x03\x02\x02\x02\u0B39\u0B3A\x03" + + "\x02\x02\x02\u0B3A\u0B3C\x03\x02\x02\x02\u0B3B\u0B3D\x05\u0100\x81\x02" + + "\u0B3C\u0B3B\x03\x02\x02\x02\u0B3C\u0B3D\x03\x02\x02\x02\u0B3D\u0B3F\x03" + + "\x02\x02\x02\u0B3E\u0B40\x05\u0102\x82\x02\u0B3F\u0B3E\x03\x02\x02\x02" + + "\u0B3F\u0B40\x03\x02\x02\x02\u0B40\u0B58\x03\x02\x02\x02\u0B41\u0B42\x07" + + "\u011F\x02\x02\u0B42\u0B43\x07\u0115\x02\x02\u0B43\u0B45\x05\u053C\u029F" + + "\x02\u0B44\u0B46\x05\xB4[\x02\u0B45\u0B44\x03\x02\x02\x02\u0B45\u0B46" + + "\x03\x02\x02\x02\u0B46\u0B47\x03\x02\x02\x02\u0B47\u0B49\x05\x80A\x02" + + "\u0B48\u0B4A\x05\xF4{\x02\u0B49\u0B48\x03\x02\x02\x02\u0B49\u0B4A\x03" + + "\x02\x02\x02\u0B4A\u0B4C\x03\x02\x02\x02\u0B4B\u0B4D\x05\xFC\x7F\x02\u0B4C" + + "\u0B4B\x03\x02\x02\x02\u0B4C\u0B4D\x03\x02\x02\x02\u0B4D\u0B4F\x03\x02" + + "\x02\x02\u0B4E\u0B50\x05\xFE\x80\x02\u0B4F\u0B4E\x03\x02\x02\x02\u0B4F" + + "\u0B50\x03\x02\x02\x02\u0B50\u0B52\x03\x02\x02\x02\u0B51\u0B53\x05\u0100" + + "\x81\x02\u0B52\u0B51\x03\x02\x02\x02\u0B52\u0B53\x03\x02\x02\x02\u0B53" + + "\u0B55\x03\x02\x02\x02\u0B54\u0B56\x05\u0102\x82\x02\u0B55\u0B54\x03\x02" + + "\x02\x02\u0B55\u0B56\x03\x02\x02\x02\u0B56\u0B58\x03\x02\x02\x02\u0B57" + + "\u0B16\x03\x02\x02\x02\u0B57\u0B2D\x03\x02\x02\x02\u0B57\u0B41\x03\x02" + + "\x02\x02\u0B58\xAD\x03\x02\x02\x02\u0B59\u0B61\x07\u0164\x02\x02\u0B5A" + + "\u0B61\x07\u0162\x02\x02\u0B5B\u0B5C\x07\u0100\x02\x02\u0B5C\u0B61\t\x13" + + "\x02\x02\u0B5D\u0B5E\x07\xD7\x02\x02\u0B5E\u0B61\t\x13\x02\x02\u0B5F\u0B61" + + "\x07\u0171\x02\x02\u0B60\u0B59\x03\x02\x02\x02\u0B60\u0B5A\x03\x02\x02" + + "\x02\u0B60\u0B5B\x03\x02\x02\x02\u0B60\u0B5D\x03\x02\x02\x02\u0B60\u0B5F" + + "\x03\x02\x02\x02\u0B61\xAF\x03\x02\x02\x02\u0B62\u0B63\x05\xB6\\\x02\u0B63" + + "\xB1\x03\x02\x02\x02\u0B64\u0B65\x05\xB6\\\x02\u0B65\xB3\x03\x02\x02\x02" + + "\u0B66\u0B67\x07\x04\x02\x02\u0B67\u0B68\x05\xB8]\x02\u0B68\u0B69\x07" + + "\x05\x02\x02\u0B69\xB5\x03\x02\x02\x02\u0B6A\u0B6F\x05\xBA^\x02\u0B6B" + + "\u0B6C\x07\b\x02\x02\u0B6C\u0B6E\x05\xBA^\x02\u0B6D\u0B6B\x03\x02\x02" + + "\x02\u0B6E\u0B71\x03\x02\x02\x02\u0B6F\u0B6D\x03\x02\x02\x02\u0B6F\u0B70" + + "\x03\x02\x02\x02\u0B70\xB7\x03\x02\x02\x02\u0B71\u0B6F\x03\x02\x02\x02" + + "\u0B72\u0B77\x05\xBC_\x02\u0B73\u0B74\x07\b\x02\x02\u0B74\u0B76\x05\xBC" + + "_\x02\u0B75\u0B73\x03\x02\x02\x02\u0B76\u0B79\x03\x02\x02\x02\u0B77\u0B75" + + "\x03\x02\x02\x02\u0B77\u0B78\x03\x02\x02\x02\u0B78\xB9\x03\x02\x02\x02" + + "\u0B79\u0B77\x03\x02\x02\x02\u0B7A\u0B7E\x05\xBE`\x02\u0B7B\u0B7E\x05" + + "\xCEh\x02\u0B7C\u0B7E\x05\xD4k\x02\u0B7D\u0B7A\x03\x02\x02\x02\u0B7D\u0B7B" + + "\x03\x02\x02\x02\u0B7D\u0B7C\x03\x02\x02\x02\u0B7E\xBB\x03\x02\x02\x02" + + "\u0B7F\u0B82\x05\xC0a\x02\u0B80\u0B82\x05\xD4k\x02\u0B81\u0B7F\x03\x02" + + "\x02\x02\u0B81\u0B80\x03\x02\x02\x02\u0B82\xBD\x03\x02\x02\x02\u0B83\u0B84" + + "\x05\u0562\u02B2\x02\u0B84\u0B86\x05\u0462\u0232\x02\u0B85\u0B87\x05\u0158" + + "\xAD\x02\u0B86\u0B85\x03\x02\x02\x02\u0B86\u0B87\x03\x02\x02\x02\u0B87" + + "\u0B8A\x03\x02\x02\x02\u0B88\u0B89\x07-\x02\x02\u0B89\u0B8B\x05\u0214" + + "\u010B\x02\u0B8A\u0B88\x03\x02\x02\x02\u0B8A\u0B8B\x03\x02\x02\x02\u0B8B" + + "\u0B8C\x03\x02\x02\x02\u0B8C\u0B8D\x05\xC2b\x02\u0B8D\xBF\x03\x02\x02" + + "\x02\u0B8E\u0B91\x05\u0562\u02B2\x02\u0B8F\u0B90\x07k\x02\x02\u0B90\u0B92" + + "\x07\u011A\x02\x02\u0B91\u0B8F\x03\x02\x02\x02\u0B91\u0B92\x03\x02\x02" + + "\x02\u0B92\u0B93\x03\x02\x02\x02\u0B93\u0B94\x05\xC2b\x02\u0B94\xC1\x03" + + "\x02\x02\x02\u0B95\u0B97\x05\xC4c\x02\u0B96\u0B95\x03\x02\x02\x02\u0B97" + + "\u0B9A\x03\x02\x02\x02\u0B98\u0B96\x03\x02\x02\x02\u0B98\u0B99\x03\x02" + + "\x02\x02\u0B99\xC3\x03\x02\x02\x02\u0B9A\u0B98\x03\x02\x02\x02\u0B9B\u0B9C" + + "\x07/\x02\x02\u0B9C\u0B9E\x05\u0540\u02A1\x02\u0B9D\u0B9B\x03\x02\x02" + + "\x02\u0B9D\u0B9E\x03\x02\x02\x02\u0B9E\u0B9F\x03\x02\x02\x02\u0B9F\u0BA1" + + "\x05\xC6d\x02\u0BA0\u0BA2\x05\xCAf\x02\u0BA1\u0BA0\x03\x02\x02\x02\u0BA1" + + "\u0BA2\x03\x02\x02\x02\u0BA2\u0BA4\x03\x02\x02\x02\u0BA3\u0BA5\x05\xCC" + + "g\x02\u0BA4\u0BA3\x03\x02\x02\x02\u0BA4\u0BA5\x03\x02\x02\x02\u0BA5\u0BAE" + + "\x03\x02\x02\x02\u0BA6\u0BA8\x05\xC6d\x02\u0BA7\u0BA9\x05\xCAf\x02\u0BA8" + + "\u0BA7\x03\x02\x02\x02\u0BA8\u0BA9\x03\x02\x02\x02\u0BA9\u0BAB\x03\x02" + + "\x02\x02\u0BAA\u0BAC\x05\xCCg\x02\u0BAB\u0BAA\x03\x02\x02\x02\u0BAB\u0BAC" + + "\x03\x02\x02\x02\u0BAC\u0BAE\x03\x02\x02\x02\u0BAD\u0B9D\x03\x02\x02\x02" + + "\u0BAD\u0BA6\x03\x02\x02\x02\u0BAE\xC5\x03\x02\x02\x02\u0BAF\u0BB0\x07" + + "O\x02\x02\u0BB0\u0BE4\x07P\x02\x02\u0BB1\u0BE4\x07P\x02\x02\u0BB2\u0BB4" + + "\x07d\x02\x02\u0BB3\u0BB5\x05\u02A6\u0154\x02\u0BB4\u0BB3\x03\x02\x02" + + "\x02\u0BB4\u0BB5\x03\x02\x02\x02\u0BB5\u0BB7\x03\x02\x02\x02\u0BB6\u0BB8" + + "\x05\u0104\x83\x02\u0BB7\u0BB6\x03\x02\x02\x02\u0BB7\u0BB8\x03\x02\x02" + + "\x02\u0BB8\u0BE4\x03\x02\x02\x02\u0BB9\u0BBA\x07W\x02\x02\u0BBA\u0BBC" + + "\x07\xF7\x02\x02\u0BBB\u0BBD\x05\u02A6\u0154\x02\u0BBC\u0BBB\x03\x02\x02" + + "\x02\u0BBC\u0BBD\x03\x02\x02\x02\u0BBD\u0BBF\x03\x02\x02\x02\u0BBE\u0BC0" + + "\x05\u0104\x83\x02\u0BBF\u0BBE\x03\x02\x02\x02\u0BBF\u0BC0\x03\x02\x02" + + "\x02\u0BC0\u0BE4\x03\x02\x02\x02\u0BC1\u0BC2\x07,\x02\x02\u0BC2\u0BC3" + + "\x07\x04\x02\x02\u0BC3\u0BC4\x05\u048E\u0248\x02\u0BC4\u0BC6\x07\x05\x02" + + "\x02\u0BC5\u0BC7\x05\xD8m\x02\u0BC6\u0BC5\x03\x02\x02\x02\u0BC6\u0BC7" + + "\x03\x02\x02\x02\u0BC7\u0BE4\x03\x02\x02\x02\u0BC8\u0BC9\x077\x02\x02" + + "\u0BC9\u0BE4\x05\u04B6\u025C\x02\u0BCA\u0BCB\x07\u01B8\x02\x02\u0BCB\u0BCC" + + "\x05\xC8e\x02\u0BCC\u0BD6\x07&\x02\x02\u0BCD\u0BCF\x07\xDD\x02\x02\u0BCE" + + "\u0BD0\x05\u0120\x91\x02\u0BCF\u0BCE\x03\x02\x02\x02\u0BCF\u0BD0\x03\x02" + + "\x02\x02\u0BD0\u0BD7\x03\x02\x02\x02\u0BD1\u0BD2\x07\x04\x02\x02\u0BD2" + + "\u0BD3\x05\u048E\u0248\x02\u0BD3\u0BD4\x07\x05\x02\x02\u0BD4\u0BD5\x07" + + "\u01BA\x02\x02\u0BD5\u0BD7\x03\x02\x02\x02\u0BD6\u0BCD\x03\x02\x02\x02" + + "\u0BD6\u0BD1\x03\x02\x02\x02\u0BD7\u0BE4\x03\x02\x02\x02\u0BD8\u0BD9\x07" + + "X\x02\x02\u0BD9\u0BDB\x05\u053C\u029F\x02\u0BDA\u0BDC\x05\xDAn\x02\u0BDB" + + "\u0BDA\x03\x02\x02\x02\u0BDB\u0BDC\x03\x02\x02\x02\u0BDC\u0BDE\x03\x02" + + "\x02\x02\u0BDD\u0BDF\x05\xE2r\x02\u0BDE\u0BDD\x03\x02\x02\x02\u0BDE\u0BDF" + + "\x03\x02\x02\x02\u0BDF\u0BE1\x03\x02\x02\x02\u0BE0\u0BE2\x05\xEAv\x02" + + "\u0BE1\u0BE0\x03\x02\x02\x02\u0BE1\u0BE2\x03\x02\x02\x02\u0BE2\u0BE4\x03" + + "\x02\x02\x02\u0BE3\u0BAF\x03\x02\x02\x02\u0BE3\u0BB1\x03\x02\x02\x02\u0BE3" + + "\u0BB2\x03\x02\x02\x02\u0BE3\u0BB9\x03\x02\x02\x02\u0BE3\u0BC1\x03\x02" + + "\x02\x02\u0BE3\u0BC8\x03\x02\x02\x02\u0BE3\u0BCA\x03\x02\x02\x02\u0BE3" + + "\u0BD8\x03\x02\x02\x02\u0BE4\xC7\x03\x02\x02\x02\u0BE5\u0BE9\x07\x8D\x02" + + "\x02\u0BE6\u0BE7\x07\x95\x02\x02\u0BE7\u0BE9\x077\x02\x02\u0BE8\u0BE5" + + "\x03\x02\x02\x02\u0BE8\u0BE6\x03\x02\x02\x02\u0BE9\xC9\x03\x02\x02\x02" + + "\u0BEA\u0BEE\x078\x02\x02\u0BEB\u0BEC\x07O\x02\x02\u0BEC\u0BEE\x078\x02" + + "\x02\u0BED\u0BEA\x03\x02\x02\x02\u0BED\u0BEB\x03\x02\x02\x02\u0BEE\xCB" + + "\x03\x02\x02\x02\u0BEF\u0BF0\x07G\x02\x02\u0BF0\u0BF1\t\x0F\x02\x02\u0BF1" + + "\xCD\x03\x02\x02\x02\u0BF2\u0BF3\x07z\x02\x02\u0BF3\u0BF4\x05\u053C\u029F" + + "\x02\u0BF4\u0BF5\x05\xD0i\x02\u0BF5\xCF\x03\x02\x02\x02\u0BF6\u0BF7\t" + + "\x14\x02\x02\u0BF7\u0BF9\x05\xD2j\x02\u0BF8\u0BF6\x03\x02\x02\x02\u0BF9" + + "\u0BFC\x03\x02\x02\x02\u0BFA\u0BF8\x03\x02\x02\x02\u0BFA\u0BFB\x03\x02" + + "\x02\x02\u0BFB\xD1\x03\x02\x02\x02\u0BFC\u0BFA\x03\x02\x02\x02\u0BFD\u0BFE" + + "\t\x15\x02\x02\u0BFE\xD3\x03\x02\x02\x02\u0BFF\u0C00\x07/\x02\x02\u0C00" + + "\u0C01\x05\u0540\u02A1\x02\u0C01\u0C02\x05\xD6l\x02\u0C02\u0C05\x03\x02" + + "\x02\x02\u0C03\u0C05\x05\xD6l\x02\u0C04\u0BFF\x03\x02\x02\x02\u0C04\u0C03" + + "\x03\x02\x02\x02\u0C05\xD5\x03\x02\x02\x02\u0C06\u0C07\x07,\x02\x02\u0C07" + + "\u0C08\x07\x04\x02\x02\u0C08\u0C09\x05\u048E\u0248\x02\u0C09\u0C0A\x07" + + "\x05\x02\x02\u0C0A\u0C0B\x05\u01C0\xE1\x02\u0C0B\u0C5D\x03\x02\x02\x02" + + "\u0C0C\u0C1E\x07d\x02\x02\u0C0D\u0C0E\x07\x04\x02\x02\u0C0E\u0C0F\x05" + + "\xDCo\x02\u0C0F\u0C11\x07\x05\x02\x02\u0C10\u0C12\x05\xE0q\x02\u0C11\u0C10" + + "\x03\x02\x02\x02\u0C11\u0C12\x03\x02\x02\x02\u0C12\u0C14\x03\x02\x02\x02" + + "\u0C13\u0C15\x05\u02A6\u0154\x02\u0C14\u0C13\x03\x02\x02\x02\u0C14\u0C15" + + "\x03\x02\x02\x02\u0C15\u0C17\x03\x02\x02\x02\u0C16\u0C18\x05\u0104\x83" + + "\x02\u0C17\u0C16\x03\x02\x02\x02\u0C17\u0C18\x03\x02\x02\x02\u0C18\u0C19" + + "\x03\x02\x02\x02\u0C19\u0C1A\x05\u01C0\xE1\x02\u0C1A\u0C1F\x03\x02\x02" + + "\x02\u0C1B\u0C1C\x05\u0106\x84\x02\u0C1C\u0C1D\x05\u01C0\xE1\x02\u0C1D" + + "\u0C1F\x03\x02\x02\x02\u0C1E\u0C0D\x03\x02\x02\x02\u0C1E\u0C1B\x03\x02" + + "\x02\x02\u0C1F\u0C5D\x03\x02\x02\x02\u0C20\u0C21\x07W\x02\x02\u0C21\u0C33" + + "\x07\xF7\x02\x02\u0C22\u0C23\x07\x04\x02\x02\u0C23\u0C24\x05\xDCo\x02" + + "\u0C24\u0C26\x07\x05\x02\x02\u0C25\u0C27\x05\xE0q\x02\u0C26\u0C25\x03" + + "\x02\x02\x02\u0C26\u0C27\x03\x02\x02\x02\u0C27\u0C29\x03\x02\x02\x02\u0C28" + + "\u0C2A\x05\u02A6\u0154\x02\u0C29\u0C28\x03\x02\x02\x02\u0C29\u0C2A\x03" + + "\x02\x02\x02\u0C2A\u0C2C\x03\x02\x02\x02\u0C2B\u0C2D\x05\u0104\x83\x02" + + "\u0C2C\u0C2B\x03\x02\x02\x02\u0C2C\u0C2D\x03\x02\x02\x02\u0C2D\u0C2E\x03" + + "\x02\x02\x02\u0C2E\u0C2F\x05\u01C0\xE1\x02\u0C2F\u0C34\x03\x02\x02\x02" + + "\u0C30\u0C31\x05\u0106\x84\x02\u0C31\u0C32\x05\u01C0\xE1\x02\u0C32\u0C34" + + "\x03\x02\x02\x02\u0C33\u0C22\x03\x02\x02\x02\u0C33\u0C30\x03\x02\x02\x02" + + "\u0C34\u0C5D\x03\x02\x02\x02\u0C35\u0C37\x07\xC9\x02\x02\u0C36\u0C38\x05" + + "\u0260\u0131\x02\u0C37\u0C36\x03\x02\x02\x02\u0C37\u0C38\x03\x02\x02\x02" + + "\u0C38\u0C39\x03\x02\x02\x02\u0C39\u0C3A\x07\x04\x02\x02\u0C3A\u0C3B\x05" + + "\xE4s\x02\u0C3B\u0C3D\x07\x05\x02\x02\u0C3C\u0C3E\x05\xE0q\x02\u0C3D\u0C3C" + + "\x03\x02\x02\x02\u0C3D\u0C3E\x03\x02\x02\x02\u0C3E\u0C40\x03\x02\x02\x02" + + "\u0C3F\u0C41\x05\u02A6\u0154\x02\u0C40\u0C3F\x03\x02\x02\x02\u0C40\u0C41" + + "\x03\x02\x02\x02\u0C41\u0C43\x03\x02\x02\x02\u0C42\u0C44\x05\u0104\x83" + + "\x02\u0C43\u0C42\x03\x02\x02\x02\u0C43\u0C44\x03\x02\x02\x02\u0C44\u0C46" + + "\x03\x02\x02\x02\u0C45\u0C47\x05\xE8u\x02\u0C46\u0C45\x03\x02\x02\x02" + + "\u0C46\u0C47\x03\x02\x02\x02\u0C47\u0C48\x03\x02\x02\x02\u0C48\u0C49\x05" + + "\u01C0\xE1\x02\u0C49\u0C5D\x03\x02\x02\x02\u0C4A\u0C4B\x07A\x02\x02\u0C4B" + + "\u0C4C\x07\xF7\x02\x02\u0C4C\u0C4D\x07\x04\x02\x02\u0C4D\u0C4E\x05\xDC" + + "o\x02\u0C4E\u0C4F\x07\x05\x02\x02\u0C4F\u0C50\x07X\x02\x02\u0C50\u0C52" + + "\x05\u053C\u029F\x02\u0C51\u0C53\x05\xDAn\x02\u0C52\u0C51\x03\x02\x02" + + "\x02\u0C52\u0C53\x03\x02\x02\x02\u0C53\u0C55\x03\x02\x02\x02\u0C54\u0C56" + + "\x05\xE2r\x02\u0C55\u0C54\x03\x02\x02\x02\u0C55\u0C56\x03\x02\x02\x02" + + "\u0C56\u0C58\x03\x02\x02\x02\u0C57\u0C59\x05\xEAv\x02\u0C58\u0C57\x03" + + "\x02\x02\x02\u0C58\u0C59\x03\x02\x02\x02\u0C59\u0C5A\x03\x02\x02\x02\u0C5A" + + "\u0C5B\x05\u01C0\xE1\x02\u0C5B\u0C5D\x03\x02\x02\x02\u0C5C\u0C06\x03\x02" + + "\x02\x02\u0C5C\u0C0C\x03\x02\x02\x02\u0C5C\u0C20\x03\x02\x02\x02\u0C5C" + + "\u0C35\x03\x02\x02\x02\u0C5C\u0C4A\x03\x02\x02\x02\u0C5D\xD7\x03\x02\x02" + + "\x02\u0C5E\u0C5F\x07\u010F\x02\x02\u0C5F\u0C60\x07\xE6\x02\x02\u0C60\xD9" + + "\x03\x02\x02\x02\u0C61\u0C62\x07\x04\x02\x02\u0C62\u0C63\x05\xDCo\x02" + + "\u0C63\u0C64\x07\x05\x02\x02\u0C64\xDB\x03\x02\x02\x02\u0C65\u0C6A\x05" + + "\xDEp\x02\u0C66\u0C67\x07\b\x02\x02\u0C67\u0C69\x05\xDEp\x02\u0C68\u0C66" + + "\x03\x02\x02\x02\u0C69\u0C6C\x03\x02\x02\x02\u0C6A\u0C68\x03\x02\x02\x02" + + "\u0C6A\u0C6B\x03\x02\x02\x02\u0C6B\xDD\x03\x02\x02\x02\u0C6C\u0C6A\x03" + + "\x02\x02\x02\u0C6D\u0C6E\x05\u0562\u02B2\x02\u0C6E\xDF\x03\x02\x02\x02" + + "\u0C6F\u0C70\x07\u01BB\x02\x02\u0C70\u0C71\x07\x04\x02\x02\u0C71\u0C72" + + "\x05\xDCo\x02\u0C72\u0C73\x07\x05\x02\x02\u0C73\xE1\x03\x02\x02\x02\u0C74" + + "\u0C75\x07\u0104\x02\x02\u0C75\u0C76\t\x16\x02\x02\u0C76\xE3\x03\x02\x02" + + "\x02\u0C77\u0C7C\x05\xE6t\x02\u0C78\u0C79\x07\b\x02\x02\u0C79\u0C7B\x05" + + "\xE6t\x02\u0C7A\u0C78\x03\x02\x02\x02\u0C7B\u0C7E\x03\x02\x02\x02\u0C7C" + + "\u0C7A\x03\x02\x02\x02\u0C7C\u0C7D\x03\x02\x02\x02\u0C7D\xE5\x03\x02\x02" + + "\x02\u0C7E\u0C7C\x03\x02\x02\x02\u0C7F\u0C80\x05\u0266\u0134\x02\u0C80" + + "\u0C87\x07k\x02\x02\u0C81\u0C88\x05\u02BA\u015E\x02\u0C82\u0C83\x07\u0118" + + "\x02\x02\u0C83\u0C84\x07\x04\x02\x02\u0C84\u0C85\x05\u02BA\u015E\x02\u0C85" + + "\u0C86\x07\x05\x02\x02\u0C86\u0C88\x03\x02\x02\x02\u0C87\u0C81\x03\x02" + + "\x02\x02\u0C87\u0C82\x03\x02\x02\x02\u0C88\xE7\x03\x02\x02\x02\u0C89\u0C8A" + + "\x07i\x02\x02\u0C8A\u0C8B\x07\x04\x02\x02\u0C8B\u0C8C\x05\u048E\u0248" + + "\x02\u0C8C\u0C8D\x07\x05\x02\x02\u0C8D\xE9\x03\x02\x02\x02\u0C8E\u0C97" + + "\x05\xECw\x02\u0C8F\u0C97\x05\xEEx\x02\u0C90\u0C91\x05\xECw\x02\u0C91" + + "\u0C92\x05\xEEx\x02\u0C92\u0C97\x03\x02\x02\x02\u0C93\u0C94\x05\xEEx\x02" + + "\u0C94\u0C95\x05\xECw\x02\u0C95\u0C97\x03\x02\x02\x02\u0C96\u0C8E\x03" + + "\x02\x02\x02\u0C96\u0C8F\x03\x02\x02\x02\u0C96\u0C90\x03\x02\x02\x02\u0C96" + + "\u0C93\x03\x02\x02\x02\u0C97\xEB\x03\x02\x02\x02\u0C98\u0C99\x07R\x02" + + "\x02\u0C99\u0C9A\x07\u0173\x02\x02\u0C9A\u0C9B\x05\xF0y\x02\u0C9B\xED" + + "\x03\x02\x02\x02\u0C9C\u0C9D\x07R\x02\x02\u0C9D\u0C9E\x07\xB8\x02\x02" + + "\u0C9E\u0C9F\x05\xF0y\x02\u0C9F\xEF\x03\x02\x02\x02\u0CA0\u0CA1\x07\u010F" + + "\x02\x02\u0CA1\u0CA7\x07\x86\x02\x02\u0CA2\u0CA7\x07\u013D\x02\x02\u0CA3" + + "\u0CA7\x07\x98\x02\x02\u0CA4\u0CA5\x07\u014F\x02\x02\u0CA5\u0CA7\t\x17" + + "\x02\x02\u0CA6\u0CA0\x03\x02\x02\x02\u0CA6\u0CA2\x03\x02\x02\x02\u0CA6" + + "\u0CA3\x03\x02\x02\x02\u0CA6\u0CA4\x03\x02\x02\x02\u0CA7\xF1\x03\x02\x02" + + "\x02\u0CA8\u0CA9\x07\xF0\x02\x02\u0CA9\u0CAA\x07\x04\x02\x02\u0CAA\u0CAB" + + "\x05\u0538\u029D\x02\u0CAB\u0CAC\x07\x05\x02\x02\u0CAC\xF3\x03\x02\x02" + + "\x02\u0CAD\u0CAE\x05\xF6|\x02\u0CAE\xF5\x03\x02\x02\x02\u0CAF\u0CB0\x07" + + "\u011F\x02\x02\u0CB0\u0CB1\x07\x95\x02\x02\u0CB1\u0CB2\x05\u0562\u02B2" + + "\x02\u0CB2\u0CB3\x07\x04\x02\x02\u0CB3\u0CB4\x05\xF8}\x02\u0CB4\u0CB5" + + "\x07\x05\x02\x02\u0CB5\xF7\x03\x02\x02\x02\u0CB6\u0CBB\x05\xFA~\x02\u0CB7" + + "\u0CB8\x07\b\x02\x02\u0CB8\u0CBA\x05\xFA~\x02\u0CB9\u0CB7\x03\x02\x02" + + "\x02\u0CBA\u0CBD\x03\x02\x02\x02\u0CBB\u0CB9\x03\x02\x02\x02\u0CBB\u0CBC" + + "\x03\x02\x02\x02\u0CBC\xF9\x03\x02\x02\x02\u0CBD\u0CBB\x03\x02\x02\x02" + + "\u0CBE\u0CC0\x05\u0562\u02B2\x02\u0CBF\u0CC1\x05\u026C\u0137\x02\u0CC0" + + "\u0CBF\x03\x02\x02\x02\u0CC0\u0CC1\x03\x02\x02\x02\u0CC1\u0CC3\x03\x02" + + "\x02\x02\u0CC2\u0CC4\x05\u026E\u0138\x02\u0CC3\u0CC2\x03\x02\x02\x02\u0CC3" + + "\u0CC4\x03\x02\x02\x02\u0CC4\u0CD6\x03\x02\x02\x02\u0CC5\u0CC7\x05\u04C0" + + "\u0261\x02\u0CC6\u0CC8\x05\u026C\u0137\x02\u0CC7\u0CC6\x03\x02\x02\x02" + + "\u0CC7\u0CC8\x03\x02\x02\x02\u0CC8\u0CCA\x03\x02\x02\x02\u0CC9\u0CCB\x05" + + "\u026E\u0138\x02\u0CCA\u0CC9\x03\x02\x02\x02\u0CCA\u0CCB\x03\x02\x02\x02" + + "\u0CCB\u0CD6\x03\x02\x02\x02\u0CCC\u0CCD\x07\x04\x02\x02\u0CCD\u0CCE\x05" + + "\u048E\u0248\x02\u0CCE\u0CD0\x07\x05\x02\x02\u0CCF\u0CD1\x05\u026C\u0137" + + "\x02\u0CD0\u0CCF\x03\x02\x02\x02\u0CD0\u0CD1\x03\x02\x02\x02\u0CD1\u0CD3" + + "\x03\x02\x02\x02\u0CD2\u0CD4\x05\u026E\u0138\x02\u0CD3\u0CD2\x03\x02\x02" + + "\x02\u0CD3\u0CD4\x03\x02\x02\x02\u0CD4\u0CD6\x03\x02\x02\x02\u0CD5\u0CBE" + + "\x03\x02\x02\x02\u0CD5\u0CC5\x03\x02\x02\x02\u0CD5\u0CCC\x03\x02\x02\x02" + + "\u0CD6\xFB\x03\x02\x02\x02\u0CD7\u0CD8\x07f\x02\x02\u0CD8\u0CD9\x05\u0540" + + "\u02A1\x02\u0CD9\xFD\x03\x02\x02\x02\u0CDA\u0CDB\x07k\x02\x02\u0CDB\u0CE1" + + "\x05t;\x02\u0CDC\u0CDD\x07\u017D\x02\x02\u0CDD\u0CE1\x07\u0117\x02\x02" + + "\u0CDE\u0CDF\x07k\x02\x02\u0CDF\u0CE1\x07\u0117\x02\x02\u0CE0\u0CDA\x03" + + "\x02\x02\x02\u0CE0\u0CDC\x03\x02\x02\x02\u0CE0\u0CDE\x03\x02\x02\x02\u0CE1" + + "\xFF\x03\x02\x02\x02\u0CE2\u0CE3\x07R\x02\x02\u0CE3\u0CE9\x07\xA3\x02" + + "\x02\u0CE4\u0CEA\x07\xC1\x02\x02\u0CE5\u0CE6\x07\xB8\x02\x02\u0CE6\u0CEA" + + "\x07\u0142\x02\x02\u0CE7\u0CE8\x07\u0126\x02\x02\u0CE8\u0CEA\x07\u0142" + + "\x02\x02\u0CE9\u0CE4\x03\x02\x02\x02\u0CE9\u0CE5\x03\x02\x02\x02\u0CE9" + + "\u0CE7\x03\x02\x02\x02\u0CEA\u0101\x03\x02\x02\x02\u0CEB\u0CEC\x07\u0161" + + "\x02\x02\u0CEC\u0CED\x05\u0540\u02A1\x02\u0CED\u0103\x03\x02\x02\x02\u0CEE" + + "\u0CEF\x07f\x02\x02\u0CEF\u0CF0\x07\xE4\x02\x02\u0CF0\u0CF1\x07\u0161" + + "\x02\x02\u0CF1\u0CF2\x05\u0540\u02A1\x02\u0CF2\u0105\x03\x02\x02\x02\u0CF3" + + "\u0CF4\x07f\x02\x02\u0CF4\u0CF5\x07\xE4\x02\x02\u0CF5\u0CF6\x05\u0540" + + "\u02A1\x02\u0CF6\u0107\x03\x02\x02\x02\u0CF7\u0CF8\x070\x02\x02\u0CF8" + + "\u0CFC\x07\u0158\x02\x02\u0CF9\u0CFA\x07\xDE\x02\x02\u0CFA\u0CFB\x07O" + + "\x02\x02\u0CFB\u0CFD\x07\u018E\x02\x02\u0CFC\u0CF9\x03\x02\x02\x02\u0CFC" + + "\u0CFD\x03\x02\x02\x02\u0CFD\u0CFE\x03\x02\x02\x02\u0CFE\u0D00\x05\u0214" + + "\u010B\x02\u0CFF\u0D01\x05\u0374\u01BB\x02\u0D00\u0CFF\x03\x02\x02\x02" + + "\u0D00\u0D01\x03\x02\x02\x02\u0D01\u0D02\x03\x02\x02\x02\u0D02\u0D03\x07" + + "R\x02\x02\u0D03\u0D04\x05\u0502\u0282\x02\u0D04\u0D05\x07B\x02\x02\u0D05" + + "\u0D06\x05\u0428\u0215\x02\u0D06\u0109\x03\x02\x02\x02\u0D07\u0D08\x07" + + "\x8C\x02\x02\u0D08\u0D0B\x07\u0158\x02\x02\u0D09\u0D0A\x07\xDE\x02\x02" + + "\u0D0A\u0D0C\x07\u018E\x02\x02\u0D0B\u0D09\x03\x02\x02\x02\u0D0B\u0D0C" + + "\x03\x02\x02\x02\u0D0C\u0D0D\x03\x02\x02\x02\u0D0D\u0D0E\x05\u0214\u010B" + + "\x02\u0D0E\u0D0F\x07\u014F\x02\x02\u0D0F\u0D10\x07\u0158\x02\x02\u0D10" + + "\u0D11\x05\u0558\u02AD\x02\u0D11\u010B\x03\x02\x02\x02\u0D12\u0D14\x07" + + "0\x02\x02\u0D13\u0D15\x05\xAEX\x02\u0D14\u0D13\x03\x02\x02\x02\u0D14\u0D15" + + "\x03\x02\x02\x02\u0D15\u0D16\x03\x02\x02\x02\u0D16\u0D1A\x07^\x02\x02" + + "\u0D17\u0D18\x07\xDE\x02\x02\u0D18\u0D19\x07O\x02\x02\u0D19\u0D1B\x07" + + "\u018E\x02\x02\u0D1A\u0D17\x03\x02\x02\x02\u0D1A\u0D1B\x03\x02\x02\x02" + + "\u0D1B\u0D1C\x03\x02\x02\x02\u0D1C\u0D1D\x05\u010E\x88\x02\u0D1D\u0D1E" + + "\x07&\x02\x02\u0D1E\u0D20\x05\u03C6\u01E4\x02\u0D1F\u0D21\x05\u0110\x89" + + "\x02\u0D20\u0D1F\x03\x02\x02\x02\u0D20\u0D21\x03\x02\x02\x02\u0D21\u010D" + + "\x03\x02\x02\x02\u0D22\u0D24\x05\u053C\u029F\x02\u0D23\u0D25\x05\xDAn" + + "\x02\u0D24\u0D23\x03\x02\x02\x02\u0D24\u0D25\x03\x02\x02\x02\u0D25\u0D27" + + "\x03\x02\x02\x02\u0D26\u0D28\x05\xFC\x7F\x02\u0D27\u0D26\x03\x02\x02\x02" + + "\u0D27\u0D28\x03\x02\x02\x02\u0D28\u0D2A\x03\x02\x02\x02\u0D29\u0D2B\x05" + + "\xFE\x80\x02\u0D2A\u0D29\x03\x02\x02\x02\u0D2A\u0D2B\x03\x02\x02\x02\u0D2B" + + "\u0D2D\x03\x02\x02\x02\u0D2C\u0D2E\x05\u0100\x81\x02\u0D2D\u0D2C\x03\x02" + + "\x02\x02\u0D2D\u0D2E\x03\x02\x02\x02\u0D2E\u0D30\x03\x02\x02\x02\u0D2F" + + "\u0D31\x05\u0102\x82\x02\u0D30\u0D2F\x03\x02\x02\x02\u0D30\u0D31\x03\x02" + + "\x02\x02\u0D31\u010F\x03\x02\x02\x02\u0D32\u0D36\x07k\x02\x02\u0D33\u0D37" + + "\x07\xB0\x02\x02\u0D34\u0D35\x07\u010F\x02\x02\u0D35\u0D37\x07\xB0\x02" + + "\x02\u0D36\u0D33\x03\x02\x02\x02\u0D36\u0D34\x03\x02\x02\x02\u0D37\u0111" + + "\x03\x02\x02\x02\u0D38\u0D3A\x070\x02\x02\u0D39\u0D3B\x05\u0116\x8C\x02" + + "\u0D3A\u0D39\x03\x02\x02\x02\u0D3A\u0D3B\x03\x02\x02\x02\u0D3B\u0D3C\x03" + + "\x02\x02\x02\u0D3C\u0D3D\x07\u0105\x02\x02\u0D3D\u0D41\x07\u017A\x02\x02" + + "\u0D3E\u0D3F\x07\xDE\x02\x02\u0D3F\u0D40\x07O\x02\x02\u0D40\u0D42\x07" + + "\u018E\x02\x02\u0D41\u0D3E\x03\x02\x02\x02\u0D41\u0D42\x03\x02\x02\x02" + + "\u0D42\u0D43\x03\x02\x02\x02\u0D43\u0D44\x05\u0114\x8B\x02\u0D44\u0D45" + + "\x07&\x02\x02\u0D45\u0D47\x05\u03C6\u01E4\x02\u0D46\u0D48\x05\u0110\x89" + + "\x02\u0D47\u0D46\x03\x02\x02\x02\u0D47\u0D48\x03\x02\x02\x02\u0D48\u0113" + + "\x03\x02\x02\x02\u0D49\u0D4B\x05\u053C\u029F\x02\u0D4A\u0D4C\x05\xDAn" + + "\x02\u0D4B\u0D4A\x03\x02\x02\x02\u0D4B\u0D4C\x03\x02\x02\x02\u0D4C\u0D4E" + + "\x03\x02\x02\x02\u0D4D\u0D4F\x05\xFC\x7F\x02\u0D4E\u0D4D\x03\x02\x02\x02" + + "\u0D4E\u0D4F\x03\x02\x02\x02\u0D4F\u0D51\x03\x02\x02\x02\u0D50\u0D52\x05" + + "v<\x02\u0D51\u0D50\x03\x02\x02\x02\u0D51\u0D52\x03\x02\x02\x02\u0D52\u0D54" + + "\x03\x02\x02\x02\u0D53\u0D55\x05\u0102\x82\x02\u0D54\u0D53\x03\x02\x02" + + "\x02\u0D54\u0D55\x03\x02\x02\x02\u0D55\u0115\x03\x02\x02\x02\u0D56\u0D57" + + "\x07\u0171\x02\x02\u0D57\u0117\x03\x02\x02\x02\u0D58\u0D59\x07\u0133\x02" + + "\x02\u0D59\u0D5A\x07\u0105\x02\x02\u0D5A\u0D5C\x07\u017A\x02\x02\u0D5B" + + "\u0D5D\x05\u025C\u012F\x02\u0D5C\u0D5B\x03\x02\x02\x02\u0D5C\u0D5D\x03" + + "\x02\x02\x02\u0D5D\u0D5E\x03\x02\x02\x02\u0D5E\u0D60\x05\u053C\u029F\x02" + + "\u0D5F\u0D61\x05\u0110\x89\x02\u0D60\u0D5F\x03\x02\x02\x02\u0D60\u0D61" + + "\x03\x02\x02\x02\u0D61\u0119\x03\x02\x02\x02\u0D62\u0D64\x070\x02\x02" + + "\u0D63\u0D65\x05\xAEX\x02\u0D64\u0D63\x03\x02\x02\x02\u0D64\u0D65\x03" + + "\x02\x02\x02\u0D65\u0D66\x03\x02\x02\x02\u0D66\u0D6A\x07\u014A\x02\x02" + + "\u0D67\u0D68\x07\xDE\x02\x02\u0D68\u0D69\x07O\x02\x02\u0D69\u0D6B\x07" + + "\u018E\x02\x02\u0D6A\u0D67\x03\x02\x02\x02\u0D6A\u0D6B\x03\x02\x02\x02" + + "\u0D6B\u0D6C\x03\x02\x02\x02\u0D6C\u0D6E\x05\u053C\u029F\x02\u0D6D\u0D6F" + + "\x05\u011E\x90\x02\u0D6E\u0D6D\x03\x02\x02\x02\u0D6E\u0D6F\x03\x02\x02" + + "\x02\u0D6F\u011B\x03\x02\x02\x02\u0D70\u0D71\x07\x8C\x02\x02\u0D71\u0D74" + + "\x07\u014A\x02\x02\u0D72\u0D73\x07\xDE\x02\x02\u0D73\u0D75\x07\u018E\x02" + + "\x02\u0D74\u0D72\x03\x02\x02\x02\u0D74\u0D75\x03\x02\x02\x02\u0D75\u0D76" + + "\x03\x02\x02\x02\u0D76\u0D77\x05\u053C\u029F\x02\u0D77\u0D78\x05\u0122" + + "\x92\x02\u0D78\u011D\x03\x02\x02\x02\u0D79\u0D7A\x05\u0122\x92\x02\u0D7A" + + "\u011F\x03\x02\x02\x02\u0D7B\u0D7C\x07\x04\x02\x02\u0D7C\u0D7D\x05\u0122" + + "\x92\x02\u0D7D\u0D7E\x07\x05\x02\x02\u0D7E\u0121\x03\x02\x02\x02\u0D7F" + + "\u0D81\x05\u0124\x93\x02\u0D80\u0D7F\x03\x02\x02\x02\u0D81\u0D82\x03\x02" + + "\x02\x02\u0D82\u0D80\x03\x02\x02\x02\u0D82\u0D83\x03\x02\x02\x02\u0D83" + + "\u0123\x03\x02\x02\x02\u0D84\u0D85\x07&\x02\x02\u0D85\u0DA7\x05\u0466" + + "\u0234\x02\u0D86\u0D87\x07\x96\x02\x02\u0D87\u0DA7\x05\u0128\x95\x02\u0D88" + + "\u0DA7\x07\xAF\x02\x02\u0D89\u0D8B\x07\xE3\x02\x02\u0D8A\u0D8C\x05\u0126" + + "\x94\x02\u0D8B\u0D8A\x03\x02\x02\x02\u0D8B\u0D8C\x03\x02\x02\x02\u0D8C" + + "\u0D8D\x03\x02\x02\x02\u0D8D\u0DA7\x05\u0128\x95\x02\u0D8E\u0D8F\x07\u0106" + + "\x02\x02\u0D8F\u0DA7\x05\u0128\x95\x02\u0D90\u0D91\x07\u0108\x02\x02\u0D91" + + "\u0DA7\x05\u0128\x95\x02\u0D92\u0D93\x07\u010F\x02\x02\u0D93\u0DA7\t\x18" + + "\x02\x02\u0D94\u0D95\x07\u011B\x02\x02\u0D95\u0D96\x07\x95\x02\x02\u0D96" + + "\u0DA7\x05\u0214\u010B\x02\u0D97\u0D98\x07\u014A\x02\x02\u0D98\u0D99\x07" + + "\u010C\x02\x02\u0D99\u0DA7\x05\u0214\u010B\x02\u0D9A\u0D9C\x07\u0156\x02" + + "\x02\u0D9B\u0D9D\x05\x10\t\x02\u0D9C\u0D9B\x03\x02\x02\x02\u0D9C\u0D9D" + + "\x03\x02\x02\x02\u0D9D\u0D9E\x03\x02\x02\x02\u0D9E\u0DA7\x05\u0128\x95" + + "\x02\u0D9F\u0DA1\x07\u013C\x02\x02\u0DA0\u0DA2\x05\x10\t\x02\u0DA1\u0DA0" + + "\x03\x02\x02\x02\u0DA1\u0DA2\x03\x02\x02\x02\u0DA2\u0DA4\x03\x02\x02\x02" + + "\u0DA3\u0DA5\x05\u0128\x95\x02\u0DA4\u0DA3\x03\x02\x02\x02\u0DA4\u0DA5" + + "\x03\x02\x02\x02\u0DA5\u0DA7\x03\x02\x02\x02\u0DA6\u0D84\x03\x02\x02\x02" + + "\u0DA6\u0D86\x03\x02\x02\x02\u0DA6\u0D88\x03\x02\x02\x02\u0DA6\u0D89\x03" + + "\x02\x02\x02\u0DA6\u0D8E\x03\x02\x02\x02\u0DA6\u0D90\x03\x02\x02\x02\u0DA6" + + "\u0D92\x03\x02\x02\x02\u0DA6\u0D94\x03\x02\x02\x02\u0DA6\u0D97\x03\x02" + + "\x02\x02\u0DA6\u0D9A\x03\x02\x02\x02\u0DA6\u0D9F\x03\x02\x02\x02\u0DA7" + + "\u0125\x03\x02\x02\x02\u0DA8\u0DA9\x07\x95\x02\x02\u0DA9\u0127\x03\x02" + + "\x02\x02\u0DAA\u0DB1\x05\u054E\u02A8\x02\u0DAB\u0DAC\x07\x0E\x02\x02\u0DAC" + + "\u0DB1\x05\u054E\u02A8\x02\u0DAD\u0DAE\x07\x0F\x02\x02\u0DAE\u0DB1\x05" + + "\u054E\u02A8\x02\u0DAF\u0DB1\x05\u0558\u02AD\x02\u0DB0\u0DAA\x03\x02\x02" + + "\x02\u0DB0\u0DAB\x03\x02\x02\x02\u0DB0\u0DAD\x03\x02\x02\x02\u0DB0\u0DAF" + + "\x03\x02\x02\x02\u0DB1\u0129\x03\x02\x02\x02\u0DB2\u0DB7\x05\u0128\x95" + + "\x02\u0DB3\u0DB4\x07\b\x02\x02\u0DB4\u0DB6\x05\u0128\x95\x02\u0DB5\u0DB3" + + "\x03\x02\x02\x02\u0DB6\u0DB9\x03\x02\x02\x02\u0DB7\u0DB5\x03\x02\x02\x02" + + "\u0DB7\u0DB8\x03\x02\x02\x02\u0DB8\u012B\x03\x02\x02\x02\u0DB9\u0DB7\x03" + + "\x02\x02\x02\u0DBA\u0DBC\x070\x02\x02\u0DBB\u0DBD\x05\u0278\u013D\x02" + + "\u0DBC\u0DBB\x03\x02\x02\x02\u0DBC\u0DBD\x03\x02\x02\x02\u0DBD\u0DBF\x03" + + "\x02\x02\x02\u0DBE\u0DC0\x05\u012E\x98\x02\u0DBF"; private static readonly _serializedATNSegment9: string = - "\u0DDF\x03\x02\x02\x02\u0DE2\u0DE1\x03\x02\x02\x02\u0DE3\u0141\x03\x02" + - "\x02\x02\u0DE4\u0DE5\x07\x8C\x02\x02\u0DE5\u0DE6\x07\xCE\x02\x02\u0DE6" + - "\u0DE7\x05\u0530\u0299\x02\u0DE7\u0DE8\x07\u016A\x02\x02\u0DE8\u0DE9\x05" + - "\u0144\xA3\x02\u0DE9\u0143\x03\x02\x02\x02\u0DEA\u0DEC\x05\u0146\xA4\x02" + - "\u0DEB\u0DEA\x03\x02\x02\x02\u0DEC\u0DEF\x03\x02\x02\x02\u0DED\u0DEB\x03" + - "\x02\x02\x02\u0DED\u0DEE\x03\x02\x02\x02\u0DEE\u0145\x03\x02\x02\x02\u0DEF" + - "\u0DED\x03\x02\x02\x02\u0DF0\u0DF1\x07`\x02\x02\u0DF1\u0DF2\x05H%\x02" + - "\u0DF2\u0147\x03\x02\x02\x02\u0DF3\u0DF4\x07\x8C\x02\x02\u0DF4\u0DF5\x07" + - "\xCE\x02\x02\u0DF5\u0DF6\x05\u0530\u0299\x02\u0DF6\u0DF7\x05(\x15\x02" + - "\u0DF7\u0DF8\x05\u0204\u0103\x02\u0DF8\u0DF9\x05\u0530\u0299\x02\u0DF9" + - "\u0E5C\x03\x02\x02\x02\u0DFA\u0DFB\x07\x8C\x02\x02\u0DFB\u0DFC\x07\xCE" + - "\x02\x02\u0DFC\u0DFD\x05\u0530\u0299\x02\u0DFD\u0DFE\x05(\x15\x02\u0DFE" + - "\u0DFF\x05\u0202\u0102\x02\u0DFF\u0E00\x05\u020C\u0107\x02\u0E00\u0E5C" + - "\x03\x02\x02\x02\u0E01\u0E02\x07\x8C\x02\x02\u0E02\u0E03\x07\xCE\x02\x02" + - "\u0E03\u0E04\x05\u0530\u0299\x02\u0E04\u0E05\x05(\x15\x02\u0E05\u0E06" + - "\x07\x8A\x02\x02\u0E06\u0E07\x05\u028A\u0146\x02\u0E07\u0E5C\x03\x02\x02" + - "\x02\u0E08\u0E09\x07\x8C\x02\x02\u0E09\u0E0A\x07\xCE\x02\x02\u0E0A\u0E0B" + - "\x05\u0530\u0299\x02\u0E0B\u0E0C\x05(\x15\x02\u0E0C\u0E0D\x07+\x02\x02" + - "\u0E0D\u0E0E\x07\x04\x02\x02\u0E0E\u0E0F\x05\u0454\u022B\x02\u0E0F\u0E10" + - "\x07&\x02\x02\u0E10\u0E11\x05\u0454\u022B\x02\u0E11\u0E12\x07\x05\x02" + - "\x02\u0E12\u0E5C\x03\x02\x02\x02\u0E13\u0E14\x07\x8C\x02\x02\u0E14\u0E15" + - "\x07\xCE\x02\x02\u0E15\u0E16\x05\u0530\u0299\x02\u0E16\u0E17\x05(\x15" + - "\x02\u0E17\u0E18\x07\xBF\x02\x02\u0E18\u0E19\x05\u0454\u022B\x02\u0E19" + - "\u0E5C\x03\x02\x02\x02\u0E1A\u0E1B\x07\x8C\x02\x02\u0E1B\u0E1C\x07\xCE" + - "\x02\x02\u0E1C\u0E1D\x05\u0530\u0299\x02\u0E1D\u0E1E\x05(\x15\x02\u0E1E" + - "\u0E1F\x07\xD5\x02\x02\u0E1F\u0E20\x05\u0272\u013A\x02\u0E20\u0E5C\x03" + - "\x02\x02\x02\u0E21\u0E22\x07\x8C\x02\x02\u0E22\u0E23\x07\xCE\x02\x02\u0E23" + - "\u0E24\x05\u0530\u0299\x02\u0E24\u0E25\x05(\x15\x02\u0E25\u0E26\x07\u010F" + - "\x02\x02\u0E26\u0E27\x05\u02B0\u0159\x02\u0E27\u0E5C\x03\x02\x02\x02\u0E28" + - "\u0E29\x07\x8C\x02\x02\u0E29\u0E2A\x07\xCE\x02\x02\u0E2A\u0E2B\x05\u0530" + - "\u0299\x02\u0E2B\u0E2C\x05(\x15\x02\u0E2C\u0E2D\x07\u010F\x02\x02\u0E2D" + - "\u0E2E\x07\x9E\x02\x02\u0E2E\u0E2F\x05\u020C\u0107\x02\u0E2F\u0E30\x07" + - "f\x02\x02\u0E30\u0E31\x05\u0530\u0299\x02\u0E31\u0E5C\x03\x02\x02\x02" + - "\u0E32\u0E33\x07\x8C\x02\x02\u0E33\u0E34\x07\xCE\x02\x02\u0E34\u0E35\x05" + - "\u0530\u0299\x02\u0E35\u0E36\x05(\x15\x02\u0E36\u0E37\x07\u010F\x02\x02" + - "\u0E37\u0E38\x07\xD0\x02\x02\u0E38\u0E39\x05\u020C\u0107\x02\u0E39\u0E3A" + - "\x07f\x02\x02\u0E3A\u0E3B\x05\u0530\u0299\x02\u0E3B\u0E5C\x03\x02\x02" + - "\x02\u0E3C\u0E3D\x07\x8C\x02\x02\u0E3D\u0E3E\x07\xCE\x02\x02\u0E3E\u0E3F" + - "\x05\u0530\u0299\x02\u0E3F\u0E40\x05(\x15\x02\u0E40\u0E41\x07\u0121\x02" + - "\x02\u0E41\u0E42\x05\u0272\u013A\x02\u0E42\u0E5C\x03\x02\x02\x02\u0E43" + - "\u0E44\x07\x8C\x02\x02\u0E44\u0E45\x07\xCE\x02\x02\u0E45\u0E46\x05\u0530" + - "\u0299\x02\u0E46\u0E47\x05(\x15\x02\u0E47\u0E48\x07\u01B3\x02\x02\u0E48" + - "\u0E49\x05\u0272\u013A\x02\u0E49\u0E5C\x03\x02\x02\x02\u0E4A\u0E4B\x07" + - "\x8C\x02\x02\u0E4B\u0E4C\x07\xCE\x02\x02\u0E4C\u0E4D\x05\u0530\u0299\x02" + - "\u0E4D\u0E4E\x05(\x15\x02\u0E4E\u0E4F\x07\u01B4\x02\x02\u0E4F\u0E50\x07" + - "@\x02\x02\u0E50\u0E51\x05\u0454\u022B\x02\u0E51\u0E52\x07\xF0\x02\x02" + - "\u0E52\u0E53\x05\u0530\u0299\x02\u0E53\u0E5C\x03\x02\x02\x02\u0E54\u0E55" + - "\x07\x8C\x02\x02\u0E55\u0E56\x07\xCE\x02\x02\u0E56\u0E57\x05\u0530\u0299" + - "\x02\u0E57\u0E58\x05(\x15\x02\u0E58\u0E59\x07\u0161\x02\x02\u0E59\u0E5A" + - "\x05\u0454\u022B\x02\u0E5A\u0E5C\x03\x02\x02\x02\u0E5B\u0DF3\x03\x02\x02" + - "\x02\u0E5B\u0DFA\x03\x02\x02\x02\u0E5B\u0E01\x03\x02\x02\x02\u0E5B\u0E08" + - "\x03\x02\x02\x02\u0E5B\u0E13\x03\x02\x02\x02\u0E5B\u0E1A\x03\x02\x02\x02" + - "\u0E5B\u0E21\x03\x02\x02\x02\u0E5B\u0E28\x03\x02\x02\x02\u0E5B\u0E32\x03" + - "\x02\x02\x02\u0E5B\u0E3C\x03\x02\x02\x02\u0E5B\u0E43\x03\x02\x02\x02\u0E5B" + - "\u0E4A\x03\x02\x02\x02\u0E5B\u0E54\x03\x02\x02\x02\u0E5C\u0149\x03\x02" + - "\x02\x02\u0E5D\u0E5E\x070\x02\x02\u0E5E\u0E5F\x07A\x02\x02\u0E5F\u0E60" + - "\x07\xB0\x02\x02\u0E60\u0E61\x07\u0176\x02\x02\u0E61\u0E63\x05\u0530\u0299" + - "\x02\u0E62\u0E64\x05\u0150\xA9\x02\u0E63\u0E62\x03\x02\x02\x02\u0E63\u0E64" + - "\x03\x02\x02\x02\u0E64\u0E66\x03\x02\x02\x02\u0E65\u0E67\x05\u0154\xAB" + - "\x02\u0E66\u0E65\x03\x02\x02\x02\u0E66\u0E67\x03\x02\x02\x02\u0E67\u014B" + - "\x03\x02\x02\x02\u0E68\u0E69\x07\xD9\x02\x02\u0E69\u0E71\x05\u012C\x97" + - "\x02\u0E6A\u0E6B\x07\u0106\x02\x02\u0E6B\u0E71\x07\xD9\x02\x02\u0E6C\u0E6D" + - "\x07\u016E\x02\x02\u0E6D\u0E71\x05\u012C\x97\x02\u0E6E\u0E6F\x07\u0106" + - "\x02\x02\u0E6F\u0E71\x07\u016E\x02\x02\u0E70\u0E68\x03\x02\x02\x02\u0E70" + - "\u0E6A\x03\x02\x02\x02\u0E70\u0E6C\x03\x02\x02\x02\u0E70\u0E6E\x03\x02" + - "\x02\x02\u0E71\u014D\x03\x02\x02\x02\u0E72\u0E74\x05\u014C\xA7\x02\u0E73" + - "\u0E72\x03\x02\x02\x02\u0E74\u0E75\x03\x02\x02\x02\u0E75\u0E73\x03\x02" + - "\x02\x02\u0E75\u0E76\x03\x02\x02\x02\u0E76\u014F\x03\x02\x02\x02\u0E77" + - "\u0E78\x05\u014E\xA8\x02\u0E78\u0151\x03\x02\x02\x02\u0E79\u0E7A\x07\x8C" + - "\x02\x02\u0E7A\u0E7B\x07A\x02\x02\u0E7B\u0E7C\x07\xB0\x02\x02\u0E7C\u0E7D" + - "\x07\u0176\x02\x02\u0E7D\u0E7F\x05\u0530\u0299\x02\u0E7E\u0E80\x05\u0150" + - "\xA9\x02\u0E7F\u0E7E\x03\x02\x02\x02\u0E7F\u0E80\x03\x02\x02\x02\u0E80" + - "\u0E81\x03\x02\x02\x02\u0E81\u0E82\x05\u0158\xAD\x02\u0E82\u0E8B\x03\x02" + - "\x02\x02\u0E83\u0E84\x07\x8C\x02\x02\u0E84\u0E85\x07A\x02\x02\u0E85\u0E86" + - "\x07\xB0\x02\x02\u0E86\u0E87\x07\u0176\x02\x02\u0E87\u0E88\x05\u0530\u0299" + - "\x02\u0E88\u0E89\x05\u014E\xA8\x02\u0E89\u0E8B\x03\x02\x02\x02\u0E8A\u0E79" + - "\x03\x02\x02\x02\u0E8A\u0E83\x03\x02\x02\x02\u0E8B\u0153\x03\x02\x02\x02" + - "\u0E8C\u0E8D\x07\u0111\x02\x02\u0E8D\u0E8E\x07\x04\x02\x02\u0E8E\u0E8F" + - "\x05\u0156\xAC\x02\u0E8F\u0E90\x07\x05\x02\x02\u0E90\u0155\x03\x02\x02" + - "\x02\u0E91\u0E96\x05\u015E\xB0\x02\u0E92\u0E93\x07\b\x02\x02\u0E93\u0E95" + - "\x05\u015E\xB0\x02\u0E94\u0E92\x03\x02\x02\x02\u0E95\u0E98\x03\x02\x02" + - "\x02\u0E96\u0E94\x03\x02\x02\x02\u0E96\u0E97\x03\x02\x02\x02\u0E97\u0157" + - "\x03\x02\x02\x02\u0E98\u0E96\x03\x02\x02\x02\u0E99\u0E9A\x07\u0111\x02" + - "\x02\u0E9A\u0E9B\x07\x04\x02\x02\u0E9B\u0E9C\x05\u015A\xAE\x02\u0E9C\u0E9D" + - "\x07\x05\x02\x02\u0E9D\u0159\x03\x02\x02\x02\u0E9E\u0EA3\x05\u015C\xAF" + - "\x02\u0E9F\u0EA0\x07\b\x02\x02\u0EA0\u0EA2\x05\u015C\xAF\x02\u0EA1\u0E9F" + - "\x03\x02\x02\x02\u0EA2\u0EA5\x03\x02\x02\x02\u0EA3\u0EA1\x03\x02\x02\x02" + - "\u0EA3\u0EA4\x03\x02\x02\x02\u0EA4\u015B\x03\x02\x02\x02\u0EA5\u0EA3\x03" + - "\x02\x02\x02\u0EA6\u0EAE\x05\u015E\xB0\x02\u0EA7\u0EA8\x07\u0146\x02\x02" + - "\u0EA8\u0EAE\x05\u015E\xB0\x02\u0EA9\u0EAA\x07\x87\x02\x02\u0EAA\u0EAE" + - "\x05\u015E\xB0\x02\u0EAB\u0EAC\x07\xC1\x02\x02\u0EAC\u0EAE\x05\u0160\xB1" + - "\x02\u0EAD\u0EA6\x03\x02\x02\x02\u0EAD\u0EA7\x03\x02\x02\x02\u0EAD\u0EA9" + - "\x03\x02\x02\x02\u0EAD\u0EAB\x03\x02\x02\x02\u0EAE\u015D\x03\x02\x02\x02" + - "\u0EAF\u0EB0\x05\u0160\xB1\x02\u0EB0\u0EB1\x05\u0162\xB2\x02\u0EB1\u015F" + - "\x03\x02\x02\x02\u0EB2\u0EB3\x05\u0556\u02AC\x02\u0EB3\u0161\x03\x02\x02" + - "\x02\u0EB4\u0EB5\x05\u0542\u02A2\x02\u0EB5\u0163\x03\x02\x02\x02\u0EB6" + - "\u0EB7\x070\x02\x02\u0EB7\u0EB8\x07\u0144\x02\x02\u0EB8\u0EBA\x05\u0530" + - "\u0299\x02\u0EB9\u0EBB\x05\u0166\xB4\x02\u0EBA\u0EB9\x03\x02\x02\x02\u0EBA" + - "\u0EBB\x03\x02\x02\x02\u0EBB\u0EBD\x03\x02\x02\x02\u0EBC\u0EBE\x05\u016A" + - "\xB6\x02\u0EBD\u0EBC\x03\x02\x02\x02\u0EBD\u0EBE\x03\x02\x02\x02\u0EBE" + - "\u0EBF\x03\x02\x02\x02\u0EBF\u0EC0\x07A\x02\x02\u0EC0\u0EC1\x07\xB0\x02" + - "\x02\u0EC1\u0EC2\x07\u0176\x02\x02\u0EC2\u0EC4\x05\u0530\u0299\x02\u0EC3" + - "\u0EC5\x05\u0154\xAB\x02\u0EC4\u0EC3\x03\x02\x02\x02\u0EC4\u0EC5\x03\x02" + - "\x02\x02\u0EC5\u0EDA\x03\x02\x02\x02\u0EC6\u0EC7\x070\x02\x02\u0EC7\u0EC8" + - "\x07\u0144\x02\x02\u0EC8\u0EC9\x07\xDE\x02\x02\u0EC9\u0ECA\x07O\x02\x02" + - "\u0ECA\u0ECB\x07\u0185\x02\x02\u0ECB\u0ECD\x05\u0530\u0299\x02\u0ECC\u0ECE" + - "\x05\u0166\xB4\x02\u0ECD\u0ECC\x03\x02\x02\x02\u0ECD\u0ECE\x03\x02\x02" + - "\x02\u0ECE\u0ED0\x03\x02\x02\x02\u0ECF\u0ED1\x05\u016A\xB6\x02\u0ED0\u0ECF" + - "\x03\x02\x02\x02\u0ED0\u0ED1\x03\x02\x02\x02\u0ED1\u0ED2\x03\x02\x02\x02" + - "\u0ED2\u0ED3\x07A\x02\x02\u0ED3\u0ED4\x07\xB0\x02\x02\u0ED4\u0ED5\x07" + - "\u0176\x02\x02\u0ED5\u0ED7\x05\u0530\u0299\x02\u0ED6\u0ED8\x05\u0154\xAB" + - "\x02\u0ED7\u0ED6\x03\x02\x02\x02\u0ED7\u0ED8\x03\x02\x02\x02\u0ED8\u0EDA" + - "\x03\x02\x02\x02\u0ED9\u0EB6\x03\x02\x02\x02\u0ED9\u0EC6\x03\x02\x02\x02" + - "\u0EDA\u0165\x03\x02\x02\x02\u0EDB\u0EDC\x07\u0161\x02\x02\u0EDC\u0EDD" + - "\x05\u0542\u02A2\x02\u0EDD\u0167\x03\x02\x02\x02\u0EDE\u0EE1\x07\u0170" + - "\x02\x02\u0EDF\u0EE2\x05\u0542\u02A2\x02\u0EE0\u0EE2\x07P\x02\x02\u0EE1" + - "\u0EDF\x03\x02\x02\x02\u0EE1\u0EE0\x03\x02\x02\x02\u0EE2\u0169\x03\x02" + - "\x02\x02\u0EE3\u0EE4\x05\u0168\xB5\x02\u0EE4\u016B\x03\x02\x02\x02\u0EE5" + - "\u0EE6\x07\x8C\x02\x02\u0EE6\u0EE7\x07\u0144\x02\x02\u0EE7\u0EED\x05\u0530" + - "\u0299\x02\u0EE8\u0EEE\x05\u0158\xAD\x02\u0EE9\u0EEB\x05\u0168\xB5\x02" + - "\u0EEA\u0EEC\x05\u0158\xAD\x02\u0EEB\u0EEA\x03\x02\x02\x02\u0EEB\u0EEC" + - "\x03\x02\x02\x02\u0EEC\u0EEE\x03\x02\x02\x02\u0EED\u0EE8\x03\x02\x02\x02" + - "\u0EED\u0EE9\x03\x02\x02\x02\u0EEE\u016D\x03\x02\x02\x02\u0EEF\u0EF0\x07" + - "0\x02\x02\u0EF0\u0EF1\x07A\x02\x02\u0EF1\u0EF2\x07^\x02\x02\u0EF2\u0EF3" + - "\x05\u052C\u0297\x02\u0EF3\u0EF5\x07\x04\x02\x02\u0EF4\u0EF6\x05\xB0Y" + - "\x02\u0EF5\u0EF4\x03\x02\x02\x02\u0EF5\u0EF6\x03\x02\x02\x02\u0EF6\u0EF7" + - "\x03\x02\x02\x02\u0EF7\u0EF9\x07\x05\x02\x02\u0EF8\u0EFA\x05\xEEx\x02" + - "\u0EF9\u0EF8\x03\x02\x02\x02\u0EF9\u0EFA\x03\x02\x02\x02\u0EFA\u0EFB\x03" + - "\x02\x02\x02\u0EFB\u0EFC\x07\u0144\x02\x02\u0EFC\u0EFE\x05\u0530\u0299" + - "\x02\u0EFD\u0EFF\x05\u0154\xAB\x02\u0EFE\u0EFD\x03\x02\x02\x02\u0EFE\u0EFF" + - "\x03\x02\x02\x02\u0EFF\u0F38\x03\x02\x02\x02\u0F00\u0F01\x070\x02\x02" + - "\u0F01\u0F02\x07A\x02\x02\u0F02\u0F03\x07^\x02\x02\u0F03\u0F04\x07\xDE" + - "\x02\x02\u0F04\u0F05\x07O\x02\x02\u0F05\u0F06\x07\u0185\x02\x02\u0F06" + - "\u0F07\x05\u052C\u0297\x02\u0F07\u0F09\x07\x04\x02\x02\u0F08\u0F0A\x05" + - "\xB0Y\x02\u0F09\u0F08\x03\x02\x02\x02\u0F09\u0F0A\x03\x02\x02\x02\u0F0A" + - "\u0F0B\x03\x02\x02\x02\u0F0B\u0F0D\x07\x05\x02\x02\u0F0C\u0F0E\x05\xEE" + - "x\x02\u0F0D\u0F0C\x03\x02\x02\x02\u0F0D\u0F0E\x03\x02\x02\x02\u0F0E\u0F0F" + - "\x03\x02\x02\x02\u0F0F\u0F10\x07\u0144\x02\x02\u0F10\u0F12\x05\u0530\u0299" + - "\x02\u0F11\u0F13\x05\u0154\xAB\x02\u0F12\u0F11\x03\x02\x02\x02\u0F12\u0F13" + - "\x03\x02\x02\x02\u0F13\u0F38\x03\x02\x02\x02\u0F14\u0F15\x070\x02\x02" + - "\u0F15\u0F16\x07A\x02\x02\u0F16\u0F17\x07^\x02\x02\u0F17\u0F18\x05\u052C" + - "\u0297\x02\u0F18\u0F19\x07\u0116\x02\x02\u0F19\u0F1A\x07\u010C\x02\x02" + - "\u0F1A\u0F1C\x05\u052C\u0297\x02\u0F1B\u0F1D\x05\xB2Z\x02\u0F1C\u0F1B" + - "\x03\x02\x02\x02\u0F1C\u0F1D\x03\x02\x02\x02\u0F1D\u0F1E\x03\x02\x02\x02" + - "\u0F1E\u0F1F\x05\x80A\x02\u0F1F\u0F20\x07\u0144\x02\x02\u0F20\u0F22\x05" + - "\u0530\u0299\x02\u0F21\u0F23\x05\u0154\xAB\x02\u0F22\u0F21\x03\x02\x02" + - "\x02\u0F22\u0F23\x03\x02\x02\x02\u0F23\u0F38\x03\x02\x02\x02\u0F24\u0F25" + - "\x070\x02\x02\u0F25\u0F26\x07A\x02\x02\u0F26\u0F27\x07^\x02\x02\u0F27" + - "\u0F28\x07\xDE\x02\x02\u0F28\u0F29\x07O\x02\x02\u0F29\u0F2A\x07\u0185" + - "\x02\x02\u0F2A\u0F2B\x05\u052C\u0297\x02\u0F2B\u0F2C\x07\u0116\x02\x02" + - "\u0F2C\u0F2D\x07\u010C\x02\x02\u0F2D\u0F2F\x05\u052C\u0297\x02\u0F2E\u0F30" + - "\x05\xB2Z\x02\u0F2F\u0F2E\x03\x02\x02\x02\u0F2F\u0F30\x03\x02\x02\x02" + - "\u0F30\u0F31\x03\x02\x02\x02\u0F31\u0F32\x05\x80A\x02\u0F32\u0F33\x07" + - "\u0144\x02\x02\u0F33\u0F35\x05\u0530\u0299\x02\u0F34\u0F36\x05\u0154\xAB" + - "\x02\u0F35\u0F34\x03\x02\x02\x02\u0F35\u0F36\x03\x02\x02\x02\u0F36\u0F38" + - "\x03\x02\x02\x02\u0F37\u0EEF\x03\x02\x02\x02\u0F37\u0F00\x03\x02\x02\x02" + - "\u0F37\u0F14\x03\x02\x02\x02\u0F37\u0F24\x03\x02\x02\x02\u0F38\u016F\x03" + - "\x02\x02\x02\u0F39\u0F3A\x07\u01B5\x02\x02\u0F3A\u0F3B\x07A\x02\x02\u0F3B" + - "\u0F3C\x07\u013C\x02\x02\u0F3C\u0F3E\x05\u0530\u0299\x02\u0F3D\u0F3F\x05" + - "\u0174\xBB\x02\u0F3E\u0F3D\x03\x02\x02\x02\u0F3E\u0F3F\x03\x02\x02\x02" + - "\u0F3F\u0F40\x03\x02\x02\x02\u0F40\u0F41\x07B\x02\x02\u0F41\u0F42\x07" + - "\u0144\x02\x02\u0F42\u0F43\x05\u0530\u0299\x02\u0F43\u0F44\x07I\x02\x02" + - "\u0F44\u0F46\x05\u0530\u0299\x02\u0F45\u0F47\x05\u0154\xAB\x02\u0F46\u0F45" + - "\x03\x02\x02\x02\u0F46\u0F47\x03\x02\x02\x02\u0F47\u0171\x03\x02\x02\x02" + - "\u0F48\u0F49\x07L\x02\x02\u0F49\u0F4C\x07`\x02\x02\u0F4A\u0F4C\x07=\x02" + - "\x02\u0F4B\u0F48\x03\x02\x02\x02\u0F4B\u0F4A\x03\x02\x02\x02\u0F4C\u0173" + - "\x03\x02\x02\x02\u0F4D\u0F4E\x05\u0172\xBA\x02\u0F4E\u0F4F\x07\x04\x02" + - "\x02\u0F4F\u0F50\x05\u042A\u0216\x02\u0F50\u0F51\x07\x05\x02\x02\u0F51" + - "\u0175\x03\x02\x02\x02\u0F52\u0F53\x070\x02\x02\u0F53\u0F54\x07e\x02\x02" + - "\u0F54\u0F55\x07\xFA\x02\x02\u0F55\u0F56\x07@\x02\x02\u0F56\u0F57\x05" + - "\u0178\xBD\x02\u0F57\u0F58\x07\u0144\x02\x02\u0F58\u0F5A\x05\u0530\u0299" + - "\x02\u0F59\u0F5B\x05\u0154\xAB\x02\u0F5A\u0F59\x03\x02\x02\x02\u0F5A\u0F5B" + - "\x03\x02\x02\x02\u0F5B\u0F6A\x03\x02\x02\x02\u0F5C\u0F5D\x070\x02\x02" + - "\u0F5D\u0F5E\x07e\x02\x02\u0F5E\u0F5F\x07\xFA\x02\x02\u0F5F\u0F60\x07" + - "\xDE\x02\x02\u0F60\u0F61\x07O\x02\x02\u0F61\u0F62\x07\u0185\x02\x02\u0F62" + - "\u0F63\x07@\x02\x02\u0F63\u0F64\x05\u0178\xBD\x02\u0F64\u0F65\x07\u0144" + - "\x02\x02\u0F65\u0F67\x05\u0530\u0299\x02\u0F66\u0F68\x05\u0154\xAB\x02" + - "\u0F67\u0F66\x03\x02\x02\x02\u0F67\u0F68\x03\x02\x02\x02\u0F68\u0F6A\x03" + - "\x02\x02\x02\u0F69\u0F52\x03\x02\x02\x02\u0F69\u0F5C\x03\x02\x02\x02\u0F6A" + - "\u0177\x03\x02\x02\x02\u0F6B\u0F6E\x05\u054C\u02A7\x02\u0F6C\u0F6E\x07" + - "e\x02\x02\u0F6D\u0F6B\x03\x02\x02\x02\u0F6D\u0F6C\x03\x02\x02\x02\u0F6E" + - "\u0179\x03\x02\x02\x02\u0F6F\u0F70\x07\xC1\x02\x02\u0F70\u0F71\x07e\x02" + - "\x02\u0F71\u0F72\x07\xFA\x02\x02\u0F72\u0F73\x07@\x02\x02\u0F73\u0F74" + - "\x05\u0178\xBD\x02\u0F74\u0F75\x07\u0144\x02\x02\u0F75\u0F76\x05\u0530" + - "\u0299\x02\u0F76\u0F82\x03\x02\x02\x02\u0F77\u0F78\x07\xC1\x02\x02\u0F78" + - "\u0F79\x07e\x02\x02\u0F79\u0F7A\x07\xFA\x02\x02\u0F7A\u0F7B\x07\xDE\x02" + - "\x02\u0F7B\u0F7C\x07\u0185\x02\x02\u0F7C\u0F7D\x07@\x02\x02\u0F7D\u0F7E" + - "\x05\u0178\xBD\x02\u0F7E\u0F7F\x07\u0144\x02\x02\u0F7F\u0F80\x05\u0530" + - "\u0299\x02\u0F80\u0F82\x03\x02\x02\x02\u0F81\u0F6F\x03\x02\x02\x02\u0F81" + - "\u0F77\x03\x02\x02\x02\u0F82\u017B\x03\x02\x02\x02\u0F83\u0F84\x07\x8C" + - "\x02\x02\u0F84\u0F85\x07e\x02\x02\u0F85\u0F86\x07\xFA\x02\x02\u0F86\u0F87" + - "\x07@\x02\x02\u0F87\u0F88\x05\u0178\xBD\x02\u0F88\u0F89\x07\u0144\x02" + - "\x02\u0F89\u0F8A\x05\u0530\u0299\x02\u0F8A\u0F8B\x05\u0158\xAD\x02\u0F8B" + - "\u017D\x03\x02\x02\x02\u0F8C\u0F8D\x070\x02\x02\u0F8D\u0F8E\x07\u01B6" + - "\x02\x02\u0F8E\u0F8F\x05\u0530\u0299\x02\u0F8F\u0F90\x07R\x02\x02\u0F90" + - "\u0F92\x05\u052C\u0297\x02\u0F91\u0F93\x05\u018A\xC6\x02\u0F92\u0F91\x03" + - "\x02\x02\x02\u0F92\u0F93\x03\x02\x02\x02\u0F93\u0F95\x03\x02\x02\x02\u0F94" + - "\u0F96\x05\u018C\xC7\x02\u0F95\u0F94\x03\x02\x02\x02\u0F95\u0F96\x03\x02" + - "\x02\x02\u0F96\u0F98\x03\x02\x02\x02\u0F97\u0F99\x05\u0186\xC4\x02\u0F98" + - "\u0F97\x03\x02\x02\x02\u0F98\u0F99\x03\x02\x02\x02\u0F99\u0F9B\x03\x02" + - "\x02\x02\u0F9A\u0F9C\x05\u0182\xC2\x02\u0F9B\u0F9A\x03\x02\x02\x02\u0F9B" + - "\u0F9C\x03\x02\x02\x02\u0F9C\u0F9E\x03\x02\x02\x02\u0F9D\u0F9F\x05\u0184" + - "\xC3\x02\u0F9E\u0F9D\x03\x02\x02\x02\u0F9E\u0F9F\x03\x02\x02\x02\u0F9F" + - "\u017F\x03\x02\x02\x02\u0FA0\u0FA1\x07\x8C\x02\x02\u0FA1\u0FA2\x07\u01B6" + - "\x02\x02\u0FA2\u0FA3\x05\u0530\u0299\x02\u0FA3\u0FA4\x07R\x02\x02\u0FA4" + - "\u0FA6\x05\u052C\u0297\x02\u0FA5\u0FA7\x05\u0188\xC5\x02\u0FA6\u0FA5\x03" + - "\x02\x02\x02\u0FA6\u0FA7\x03\x02\x02\x02\u0FA7\u0FA9\x03\x02\x02\x02\u0FA8" + - "\u0FAA\x05\u0182\xC2\x02\u0FA9\u0FA8\x03\x02\x02\x02\u0FA9\u0FAA\x03\x02" + - "\x02\x02\u0FAA\u0FAC\x03\x02\x02\x02\u0FAB\u0FAD\x05\u0184\xC3\x02\u0FAC" + - "\u0FAB\x03\x02\x02\x02\u0FAC\u0FAD\x03\x02\x02\x02\u0FAD\u0181\x03\x02" + - "\x02\x02\u0FAE\u0FAF\x07f\x02\x02\u0FAF\u0FB0\x07\x04\x02\x02\u0FB0\u0FB1" + - "\x05\u0480\u0241\x02\u0FB1\u0FB2\x07\x05\x02\x02\u0FB2\u0183\x03\x02\x02" + - "\x02\u0FB3\u0FB4\x07k\x02\x02\u0FB4\u0FB5\x07,\x02\x02\u0FB5\u0FB6\x07" + - "\x04\x02\x02\u0FB6\u0FB7\x05\u0480\u0241\x02\u0FB7\u0FB8\x07\x05\x02\x02" + - "\u0FB8\u0185\x03\x02\x02\x02\u0FB9\u0FBA\x07`\x02\x02\u0FBA\u0FBB\x05" + - "\u054E\u02A8\x02\u0FBB\u0187\x03\x02\x02\x02\u0FBC\u0FBD\x07`\x02\x02" + - "\u0FBD\u0FBE\x05\u054E\u02A8\x02\u0FBE\u0189\x03\x02\x02\x02\u0FBF\u0FC0" + - "\x07&\x02\x02\u0FC0\u0FC1\x05\u0558\u02AD\x02\u0FC1\u018B\x03\x02\x02" + - "\x02\u0FC2\u0FC3\x07@\x02\x02\u0FC3\u0FC4\x05\u018E\xC8\x02\u0FC4\u018D" + - "\x03\x02\x02\x02\u0FC5\u0FC6\t\x14\x02\x02\u0FC6\u018F\x03\x02\x02\x02" + - "\u0FC7\u0FC8\x070\x02\x02\u0FC8\u0FC9\x07\x85\x02\x02\u0FC9\u0FCA\x07" + - "\u01B7\x02\x02\u0FCA\u0FCB\x05\u0530\u0299\x02\u0FCB\u0FCC\x07\u0161\x02" + - "\x02\u0FCC\u0FCD\x05\u0192\xCA\x02\u0FCD\u0FCE\x07\xD9\x02\x02\u0FCE\u0FCF" + - "\x05\u012C\x97\x02\u0FCF\u0191\x03\x02\x02\x02\u0FD0\u0FD1\t\x15\x02\x02" + - "\u0FD1\u0193\x03\x02\x02\x02\u0FD2\u0FD3\x070\x02\x02\u0FD3\u0FD4\x07" + - "\u015E\x02\x02\u0FD4\u0FD5\x05\u0530\u0299\x02\u0FD5\u0FD6\x05\u0196\xCC" + - "\x02\u0FD6\u0FD7\x05\u0198\xCD\x02\u0FD7\u0FD8\x07R\x02\x02\u0FD8\u0FDA" + - "\x05\u052C\u0297\x02\u0FD9\u0FDB\x05\u019C\xCF\x02\u0FDA\u0FD9\x03\x02" + - "\x02\x02\u0FDA\u0FDB\x03\x02\x02\x02\u0FDB\u0FDD\x03\x02\x02\x02\u0FDC" + - "\u0FDE\x05\u01A8\xD5\x02\u0FDD\u0FDC\x03\x02\x02\x02\u0FDD\u0FDE\x03\x02" + - "\x02\x02\u0FDE\u0FE0\x03\x02\x02\x02\u0FDF\u0FE1\x05\u01AE\xD8\x02\u0FE0" + - "\u0FDF\x03\x02\x02\x02\u0FE0\u0FE1\x03\x02\x02\x02\u0FE1\u0FE2\x03\x02" + - "\x02\x02\u0FE2\u0FE3\x07\xCC\x02\x02\u0FE3\u0FE4\x05\u01B0\xD9\x02\u0FE4" + - "\u0FE5\x05\u0536\u029C\x02\u0FE5\u0FE6\x07\x04\x02\x02\u0FE6\u0FE7\x05" + - "\u01B2\xDA\x02\u0FE7\u0FE8\x07\x05\x02\x02\u0FE8\u1003\x03\x02\x02\x02" + - "\u0FE9\u0FEA\x070\x02\x02\u0FEA\u0FEB\x07/\x02\x02\u0FEB\u0FEC\x07\u015E" + - "\x02\x02\u0FEC\u0FED\x05\u0530\u0299\x02\u0FED\u0FEE\x07\x89\x02\x02\u0FEE" + - "\u0FEF\x05\u0198\xCD\x02\u0FEF\u0FF0\x07R\x02\x02\u0FF0\u0FF2\x05\u052C" + - "\u0297\x02\u0FF1\u0FF3\x05\u01B6\xDC\x02\u0FF2\u0FF1\x03\x02\x02\x02\u0FF2" + - "\u0FF3\x03\x02\x02\x02\u0FF3\u0FF4\x03\x02\x02\x02\u0FF4\u0FF5\x05\u01B8" + - "\xDD\x02\u0FF5\u0FF6\x07@\x02\x02\u0FF6\u0FF7\x07\xC2\x02\x02\u0FF7\u0FF9" + - "\x07\u0197\x02\x02\u0FF8\u0FFA\x05\u01AE\xD8\x02\u0FF9\u0FF8\x03\x02\x02" + - "\x02\u0FF9\u0FFA\x03\x02\x02\x02\u0FFA\u0FFB\x03\x02\x02\x02\u0FFB\u0FFC" + - "\x07\xCC\x02\x02\u0FFC\u0FFD\x05\u01B0\xD9\x02\u0FFD\u0FFE\x05\u0536\u029C" + - "\x02\u0FFE\u0FFF\x07\x04\x02\x02\u0FFF\u1000\x05\u01B2\xDA\x02\u1000\u1001" + - "\x07\x05\x02\x02\u1001\u1003\x03\x02\x02\x02\u1002\u0FD2\x03\x02\x02\x02" + - "\u1002\u0FE9\x03\x02\x02\x02\u1003\u0195\x03\x02\x02\x02\u1004\u1009\x07" + - "\x93\x02\x02\u1005\u1009\x07\x89\x02\x02\u1006\u1007\x07\xEB\x02\x02\u1007" + - "\u1009\x07\u010C\x02\x02\u1008\u1004\x03\x02\x02\x02\u1008\u1005\x03\x02" + - "\x02\x02\u1008\u1006\x03\x02\x02\x02\u1009\u0197\x03\x02\x02\x02\u100A" + - "\u100F\x05\u019A\xCE\x02\u100B\u100C\x07T\x02\x02\u100C\u100E\x05\u019A" + - "\xCE\x02\u100D\u100B\x03\x02\x02\x02\u100E\u1011\x03\x02\x02\x02\u100F" + - "\u100D\x03\x02\x02\x02\u100F\u1010\x03\x02\x02\x02\u1010\u0199\x03\x02" + - "\x02\x02\u1011\u100F\x03\x02\x02\x02\u1012\u101A\x07\xEA\x02\x02\u1013" + - "\u101A\x07\xB8\x02\x02\u1014\u101A\x07\u016A\x02\x02\u1015\u1016\x07\u016A" + - "\x02\x02\u1016\u1017\x07\u010C\x02\x02\u1017\u101A\x05\xD8m\x02\u1018" + - "\u101A\x07\u015F\x02\x02\u1019\u1012\x03\x02\x02\x02\u1019\u1013\x03\x02" + - "\x02\x02\u1019\u1014\x03\x02\x02\x02\u1019\u1015\x03\x02\x02\x02\u1019" + - "\u1018\x03\x02\x02\x02\u101A\u019B\x03\x02\x02\x02\u101B\u101C\x07\u01B8" + - "\x02\x02\u101C\u101D\x05\u019E\xD0\x02\u101D\u019D\x03\x02\x02\x02\u101E" + - "\u1020\x05\u01A0\xD1\x02\u101F\u101E\x03\x02\x02\x02\u1020\u1021\x03\x02" + - "\x02\x02\u1021\u101F\x03\x02\x02\x02\u1021\u1022\x03\x02\x02\x02\u1022" + - "\u019F\x03\x02\x02\x02\u1023\u1024\x05\u01A2\xD2\x02\u1024\u1026\x05\u01A4" + - "\xD3\x02\u1025\u1027\x05\u0342\u01A2\x02\u1026\u1025\x03\x02\x02\x02\u1026" + - "\u1027\x03\x02\x02\x02\u1027\u1028\x03\x02\x02\x02\u1028\u1029\x05\u01A6" + - "\xD4\x02\u1029\u01A1\x03\x02\x02\x02\u102A\u102B\t\x16\x02\x02\u102B\u01A3" + - "\x03\x02\x02\x02\u102C\u102D\t\x17\x02\x02\u102D\u01A5\x03\x02\x02\x02" + - "\u102E\u102F\x05\u0550\u02A9\x02\u102F\u01A7\x03\x02\x02\x02\u1030\u1032" + - "\x07@\x02\x02\u1031\u1033\x05\u01AA\xD6\x02\u1032\u1031\x03\x02\x02\x02" + - "\u1032\u1033\x03\x02\x02\x02\u1033\u1034\x03\x02\x02\x02\u1034\u1035\x05" + - "\u01AC\xD7\x02\u1035\u01A9\x03\x02\x02\x02\u1036\u1037\x07\xC2\x02\x02" + - "\u1037\u01AB\x03\x02\x02\x02\u1038\u1039\t\x18\x02\x02\u1039\u01AD\x03" + - "\x02\x02\x02\u103A\u103B\x07h\x02\x02\u103B\u103C\x07\x04\x02\x02\u103C" + - "\u103D\x05\u0480\u0241\x02\u103D\u103E\x07\x05\x02\x02\u103E\u01AF\x03" + - "\x02\x02\x02\u103F\u1040\t\x19\x02\x02\u1040\u01B1\x03\x02\x02\x02\u1041" + - "\u1044\x05\u01B4\xDB\x02\u1042\u1044\x03\x02\x02\x02\u1043\u1041\x03\x02" + - "\x02\x02\u1043\u1042\x03\x02\x02\x02\u1044\u1049\x03\x02\x02\x02\u1045" + - "\u1046\x07\b\x02\x02\u1046\u1048\x05\u01B4\xDB\x02\u1047\u1045\x03\x02" + - "\x02\x02\u1048\u104B\x03\x02\x02\x02\u1049\u1047\x03\x02\x02\x02\u1049" + - "\u104A\x03\x02\x02\x02\u104A\u01B3\x03\x02\x02\x02\u104B\u1049\x03\x02" + - "\x02\x02\u104C\u1051\x05\u0540\u02A1\x02\u104D\u1051\x05\u053E\u02A0\x02" + - "\u104E\u1051\x05\u0542\u02A2\x02\u104F\u1051\x05\u0556\u02AC\x02\u1050" + - "\u104C\x03\x02\x02\x02\u1050\u104D\x03\x02\x02\x02\u1050\u104E\x03\x02" + - "\x02\x02\u1050\u104F\x03\x02\x02\x02\u1051\u01B5\x03\x02\x02\x02\u1052" + - "\u1053\x07B\x02\x02\u1053\u1054\x05\u052C\u0297\x02\u1054\u01B7\x03\x02" + - "\x02\x02\u1055\u1057\x05\u01BA\xDE\x02\u1056\u1055\x03\x02\x02\x02\u1057" + - "\u105A\x03\x02\x02\x02\u1058\u1056\x03\x02\x02\x02\u1058\u1059\x03\x02" + - "\x02\x02\u1059\u01B9\x03\x02\x02\x02\u105A\u1058\x03\x02\x02\x02\u105B" + - "\u105C\x07O\x02\x02\u105C\u1067\x078\x02\x02\u105D\u1067\x078\x02\x02" + - "\u105E\u105F\x07G\x02\x02\u105F\u1067\x07\xDF\x02\x02\u1060\u1061\x07" + - "G\x02\x02\u1061\u1067\x07\xB6\x02\x02\u1062\u1063\x07O\x02\x02\u1063\u1067" + - "\x07\u016C\x02\x02\u1064\u1065\x07\u0106\x02\x02\u1065\u1067\x07\xE6\x02" + - "\x02\u1066\u105B\x03\x02\x02\x02\u1066\u105D\x03\x02\x02\x02\u1066\u105E" + - "\x03\x02\x02\x02\u1066\u1060\x03\x02\x02\x02\u1066\u1062\x03\x02\x02\x02" + - "\u1066\u1064\x03\x02\x02\x02\u1067\u01BB\x03\x02\x02\x02\u1068\u1069\x07" + - "0\x02\x02\u1069\u106A\x07\xC8\x02\x02\u106A\u106B\x07\u015E\x02\x02\u106B" + - "\u106C\x05\u0530\u0299\x02\u106C\u106D\x07R\x02\x02\u106D\u106E\x05\u0556" + - "\u02AC\x02\u106E\u106F\x07\xCC\x02\x02\u106F\u1070\x05\u01B0\xD9\x02\u1070" + - "\u1071\x05\u0536\u029C\x02\u1071\u1072\x07\x04\x02\x02\u1072\u1073\x07" + - "\x05\x02\x02\u1073\u1083\x03\x02\x02\x02\u1074\u1075\x070\x02\x02\u1075" + - "\u1076\x07\xC8\x02\x02\u1076\u1077\x07\u015E\x02\x02\u1077\u1078\x05\u0530" + - "\u0299\x02\u1078\u1079\x07R\x02\x02\u1079\u107A\x05\u0556\u02AC\x02\u107A" + - "\u107B\x07h\x02\x02\u107B\u107C\x05\u01BE\xE0\x02\u107C\u107D\x07\xCC" + - "\x02\x02\u107D\u107E\x05\u01B0\xD9\x02\u107E\u107F\x05\u0536\u029C\x02" + - "\u107F\u1080\x07\x04\x02\x02\u1080\u1081\x07\x05\x02\x02\u1081\u1083\x03" + - "\x02\x02\x02\u1082\u1068\x03\x02\x02\x02\u1082\u1074\x03\x02\x02\x02\u1083" + - "\u01BD\x03\x02\x02\x02\u1084\u1089\x05\u01C0\xE1\x02\u1085\u1086\x07#" + - "\x02\x02\u1086\u1088\x05\u01C0\xE1\x02\u1087\u1085\x03\x02\x02\x02\u1088" + - "\u108B\x03\x02\x02\x02\u1089\u1087\x03\x02\x02\x02\u1089\u108A\x03\x02" + - "\x02\x02\u108A\u01BF\x03\x02\x02\x02\u108B\u1089\x03\x02\x02\x02\u108C" + - "\u108D\x05\u0550\u02A9\x02\u108D\u108E\x07F\x02\x02\u108E\u108F\x07\x04" + - "\x02\x02\u108F\u1090\x05\u01C2\xE2\x02\u1090\u1091\x07\x05\x02\x02\u1091" + - "\u01C1\x03\x02\x02\x02\u1092\u1097\x05\u0542\u02A2\x02\u1093\u1094\x07" + - "\b\x02\x02\u1094\u1096\x05\u0542\u02A2\x02\u1095\u1093\x03\x02\x02\x02" + - "\u1096\u1099\x03\x02\x02\x02\u1097\u1095\x03\x02\x02\x02\u1097\u1098\x03" + - "\x02\x02\x02\u1098\u01C3\x03\x02\x02\x02\u1099\u1097\x03\x02\x02\x02\u109A" + - "\u109B\x07\x8C\x02\x02\u109B\u109C\x07\xC8\x02\x02\u109C\u109D\x07\u015E" + - "\x02\x02\u109D\u109E\x05\u0530\u0299\x02\u109E\u109F\x05\u01C6\xE4\x02" + - "\u109F\u01C5\x03\x02\x02\x02\u10A0\u10A7\x07\xC3\x02\x02\u10A1\u10A2\x07" + - "\xC3\x02\x02\u10A2\u10A7\x07\u0131\x02\x02\u10A3\u10A4\x07\xC3\x02\x02" + - "\u10A4\u10A7\x07\x8D\x02\x02\u10A5\u10A7\x07\xBC\x02\x02\u10A6\u10A0\x03" + - "\x02\x02\x02\u10A6\u10A1\x03\x02\x02\x02\u10A6\u10A3\x03\x02\x02\x02\u10A6" + - "\u10A5\x03\x02\x02\x02\u10A7\u01C7\x03\x02\x02\x02\u10A8\u10A9\x070\x02" + - "\x02\u10A9\u10AA\x07\x8E\x02\x02\u10AA\u10AB\x05\u020C\u0107\x02\u10AB" + - "\u10AC\x07,\x02\x02\u10AC\u10AD\x07\x04\x02\x02\u10AD\u10AE\x05\u0480" + - "\u0241\x02\u10AE\u10AF\x07\x05\x02\x02\u10AF\u10B0\x05\u01B8\xDD\x02\u10B0" + - "\u01C9\x03\x02\x02\x02\u10B1\u10B3\x070\x02\x02\u10B2\u10B4\x05\u026A" + - "\u0136\x02\u10B3\u10B2\x03\x02\x02\x02\u10B3\u10B4\x03\x02\x02\x02\u10B4" + - "\u10B5\x03\x02\x02\x02\u10B5\u10B6\x07\x8A\x02\x02\u10B6\u10B7\x05\u0536" + - "\u029C\x02\u10B7\u10B8\x05\u0286\u0144\x02\u10B8\u10B9\x05\u01CC\xE7\x02" + - "\u10B9\u1124\x03\x02\x02\x02\u10BA\u10BC\x070\x02\x02\u10BB\u10BD\x05" + - "\u026A\u0136\x02\u10BC\u10BB\x03\x02\x02\x02\u10BC\u10BD\x03\x02\x02\x02" + - "\u10BD\u10BE\x03\x02\x02\x02\u10BE\u10BF\x07"; + "\u0DBE\x03\x02\x02\x02\u0DBF\u0DC0\x03\x02\x02\x02\u0DC0\u0DC2\x03\x02" + + "\x02\x02\u0DC1\u0DC3\x05\u0138\x9D\x02\u0DC2\u0DC1\x03\x02\x02\x02\u0DC2" + + "\u0DC3\x03\x02\x02\x02\u0DC3\u0DC4\x03\x02\x02\x02\u0DC4\u0DC5\x07\xF9" + + "\x02\x02\u0DC5\u0DCE\x05\u0540\u02A1\x02\u0DC6\u0DC7\x07\xD9\x02\x02\u0DC7" + + "\u0DC9\x05\u0130\x99\x02\u0DC8\u0DCA\x05\u0132\x9A\x02\u0DC9\u0DC8\x03" + + "\x02\x02\x02\u0DC9\u0DCA\x03\x02\x02\x02\u0DCA\u0DCC\x03\x02\x02\x02\u0DCB" + + "\u0DCD\x05\u0136\x9C\x02\u0DCC\u0DCB\x03\x02\x02\x02\u0DCC\u0DCD\x03\x02" + + "\x02\x02\u0DCD\u0DCF\x03\x02\x02\x02\u0DCE\u0DC6\x03\x02\x02\x02\u0DCE" + + "\u0DCF\x03\x02\x02\x02\u0DCF\u012D\x03\x02\x02\x02\u0DD0\u0DD1\x07\u0169" + + "\x02\x02\u0DD1\u012F\x03\x02\x02\x02\u0DD2\u0DD4\x05\u0540\u02A1\x02\u0DD3" + + "\u0DD5\x05\u0216\u010C\x02\u0DD4\u0DD3\x03\x02\x02\x02\u0DD4\u0DD5\x03" + + "\x02\x02\x02\u0DD5\u0131\x03\x02\x02\x02\u0DD6\u0DD7\x07\xF1\x02\x02\u0DD7" + + "\u0DD8\x05\u0130\x99\x02\u0DD8\u0133\x03\x02\x02\x02\u0DD9\u0DDA\x07\u0177" + + "\x02\x02\u0DDA\u0DDE\x05\u0130\x99\x02\u0DDB\u0DDC\x07\u010F\x02\x02\u0DDC" + + "\u0DDE\x07\u0177\x02\x02\u0DDD\u0DD9\x03\x02\x02\x02\u0DDD\u0DDB\x03\x02" + + "\x02\x02\u0DDE\u0135\x03\x02\x02\x02\u0DDF\u0DE0\x05\u0134\x9B\x02\u0DE0" + + "\u0137\x03\x02\x02\x02\u0DE1\u0DE2\x07\u0129\x02\x02\u0DE2\u0139\x03\x02" + + "\x02\x02\u0DE3\u0DE4\x070\x02\x02\u0DE4\u0DE5\x07\u0161\x02\x02\u0DE5" + + "\u0DE7\x05\u0540\u02A1\x02\u0DE6\u0DE8\x05\u013C\x9F\x02\u0DE7\u0DE6\x03" + + "\x02\x02\x02\u0DE7\u0DE8\x03\x02\x02\x02\u0DE8\u0DE9\x03\x02\x02\x02\u0DE9" + + "\u0DEA\x07\u0101\x02\x02\u0DEA\u0DEC\x05\u0552\u02AA\x02\u0DEB\u0DED\x05" + + "v<\x02\u0DEC\u0DEB\x03\x02\x02\x02\u0DEC\u0DED\x03\x02\x02\x02\u0DED\u013B" + + "\x03\x02\x02\x02\u0DEE\u0DEF\x07\u011C\x02\x02\u0DEF\u0DF0\x05\u055E\u02B0" + + "\x02\u0DF0\u013D\x03\x02\x02\x02\u0DF1\u0DF2\x07\xC1\x02\x02\u0DF2\u0DF5" + + "\x07\u0161\x02\x02\u0DF3\u0DF4\x07\xDE\x02\x02\u0DF4\u0DF6\x07\u018E\x02" + + "\x02\u0DF5\u0DF3\x03\x02\x02\x02\u0DF5\u0DF6\x03\x02\x02\x02\u0DF6\u0DF7" + + "\x03\x02\x02\x02\u0DF7\u0DF8\x05\u0540\u02A1\x02\u0DF8\u013F\x03\x02\x02" + + "\x02\u0DF9\u0DFA\x070\x02\x02\u0DFA\u0DFE\x07\xCE\x02\x02\u0DFB\u0DFC" + + "\x07\xDE\x02\x02\u0DFC\u0DFD\x07O\x02\x02\u0DFD\u0DFF\x07\u018E\x02\x02" + + "\u0DFE\u0DFB\x03\x02\x02\x02\u0DFE\u0DFF\x03\x02\x02\x02\u0DFF\u0E00\x03" + + "\x02\x02\x02\u0E00\u0E02\x05\u0540\u02A1\x02\u0E01\u0E03\x05\x10\t\x02" + + "\u0E02\u0E01\x03\x02\x02\x02\u0E02\u0E03\x03\x02\x02\x02\u0E03\u0E04\x03" + + "\x02\x02\x02\u0E04\u0E05\x05\u0142\xA2\x02\u0E05\u0141\x03\x02\x02\x02" + + "\u0E06\u0E08\x05\u0144\xA3\x02\u0E07\u0E06\x03\x02\x02\x02\u0E08\u0E0B" + + "\x03\x02\x02\x02\u0E09\u0E07\x03\x02\x02\x02\u0E09\u0E0A\x03\x02\x02\x02" + + "\u0E0A\u0143\x03\x02\x02\x02\u0E0B\u0E09\x03\x02\x02\x02\u0E0C\u0E0D\x07" + + "\u0145\x02\x02\u0E0D\u0E14\x05\u0540\u02A1\x02\u0E0E\u0E0F\x07\u0179\x02" + + "\x02\u0E0F\u0E14\x05H%\x02\u0E10\u0E11\x07B\x02\x02\u0E11\u0E14\x05H%" + + "\x02\u0E12\u0E14\x07\x98\x02\x02\u0E13\u0E0C\x03\x02\x02\x02\u0E13\u0E0E" + + "\x03\x02\x02\x02\u0E13\u0E10\x03\x02\x02\x02\u0E13\u0E12\x03\x02\x02\x02" + + "\u0E14\u0145\x03\x02\x02\x02\u0E15\u0E16\x07\x8C\x02\x02\u0E16\u0E17\x07" + + "\xCE\x02\x02\u0E17\u0E18\x05\u0540\u02A1\x02\u0E18\u0E19\x07\u0173\x02" + + "\x02\u0E19\u0E1A\x05\u0148\xA5\x02\u0E1A\u0147\x03\x02\x02\x02\u0E1B\u0E1D" + + "\x05\u014A\xA6\x02\u0E1C\u0E1B\x03\x02\x02\x02\u0E1D\u0E20\x03\x02\x02" + + "\x02\u0E1E\u0E1C\x03\x02\x02\x02\u0E1E\u0E1F\x03\x02\x02\x02\u0E1F\u0149" + + "\x03\x02\x02\x02\u0E20\u0E1E\x03\x02\x02\x02\u0E21\u0E22\x07`\x02\x02" + + "\u0E22\u0E23\x05H%\x02\u0E23\u014B\x03\x02\x02\x02\u0E24\u0E25\x07\x8C" + + "\x02\x02\u0E25\u0E26\x07\xCE\x02\x02\u0E26\u0E27\x05\u0540\u02A1\x02\u0E27" + + "\u0E28\x05(\x15\x02\u0E28\u0E29\x05\u020C\u0107\x02\u0E29\u0E2A\x05\u0540" + + "\u02A1\x02\u0E2A\u0E8D\x03\x02\x02\x02\u0E2B\u0E2C\x07\x8C\x02\x02\u0E2C" + + "\u0E2D\x07\xCE\x02\x02\u0E2D\u0E2E\x05\u0540\u02A1\x02\u0E2E\u0E2F\x05" + + "(\x15\x02\u0E2F\u0E30\x05\u020A\u0106\x02\u0E30\u0E31\x05\u0214\u010B" + + "\x02\u0E31\u0E8D\x03\x02\x02\x02\u0E32\u0E33\x07\x8C\x02\x02\u0E33\u0E34" + + "\x07\xCE\x02\x02\u0E34\u0E35\x05\u0540\u02A1\x02\u0E35\u0E36\x05(\x15" + + "\x02\u0E36\u0E37\x07\x8A\x02\x02\u0E37\u0E38\x05\u0298\u014D\x02\u0E38" + + "\u0E8D\x03\x02\x02\x02\u0E39\u0E3A\x07\x8C\x02\x02\u0E3A\u0E3B\x07\xCE" + + "\x02\x02\u0E3B\u0E3C\x05\u0540\u02A1\x02\u0E3C\u0E3D\x05(\x15\x02\u0E3D" + + "\u0E3E\x07+\x02\x02\u0E3E\u0E3F\x07\x04\x02\x02\u0E3F\u0E40\x05\u0462" + + "\u0232\x02\u0E40\u0E41\x07&\x02\x02\u0E41\u0E42\x05\u0462\u0232\x02\u0E42" + + "\u0E43\x07\x05\x02\x02\u0E43\u0E8D\x03\x02\x02\x02\u0E44\u0E45\x07\x8C" + + "\x02\x02\u0E45\u0E46\x07\xCE\x02\x02\u0E46\u0E47\x05\u0540\u02A1\x02\u0E47" + + "\u0E48\x05(\x15\x02\u0E48\u0E49\x07\xBF\x02\x02\u0E49\u0E4A\x05\u0462" + + "\u0232\x02\u0E4A\u0E8D\x03\x02\x02\x02\u0E4B\u0E4C\x07\x8C\x02\x02\u0E4C" + + "\u0E4D\x07\xCE\x02\x02\u0E4D\u0E4E\x05\u0540\u02A1\x02\u0E4E\u0E4F\x05" + + "(\x15\x02\u0E4F\u0E50\x07\xD5\x02\x02\u0E50\u0E51\x05\u0280\u0141\x02" + + "\u0E51\u0E8D\x03\x02\x02\x02\u0E52\u0E53\x07\x8C\x02\x02\u0E53\u0E54\x07" + + "\xCE\x02\x02\u0E54\u0E55\x05\u0540\u02A1\x02\u0E55\u0E56\x05(\x15\x02" + + "\u0E56\u0E57\x07\u0118\x02\x02\u0E57\u0E58\x05\u02BE\u0160\x02\u0E58\u0E8D" + + "\x03\x02\x02\x02\u0E59\u0E5A\x07\x8C\x02\x02\u0E5A\u0E5B\x07\xCE\x02\x02" + + "\u0E5B\u0E5C\x05\u0540\u02A1\x02\u0E5C\u0E5D\x05(\x15\x02\u0E5D\u0E5E" + + "\x07\u0118\x02\x02\u0E5E\u0E5F\x07\x9E\x02\x02\u0E5F\u0E60\x05\u0214\u010B" + + "\x02\u0E60\u0E61\x07f\x02\x02\u0E61\u0E62\x05\u0540\u02A1\x02\u0E62\u0E8D" + + "\x03\x02\x02\x02\u0E63\u0E64\x07\x8C\x02\x02\u0E64\u0E65\x07\xCE\x02\x02" + + "\u0E65\u0E66\x05\u0540\u02A1\x02\u0E66\u0E67\x05(\x15\x02\u0E67\u0E68" + + "\x07\u0118\x02\x02\u0E68\u0E69\x07\xD0\x02\x02\u0E69\u0E6A\x05\u0214\u010B" + + "\x02\u0E6A\u0E6B\x07f\x02\x02\u0E6B\u0E6C\x05\u0540\u02A1\x02\u0E6C\u0E8D" + + "\x03\x02\x02\x02\u0E6D\u0E6E\x07\x8C\x02\x02\u0E6E\u0E6F\x07\xCE\x02\x02" + + "\u0E6F\u0E70\x05\u0540\u02A1\x02\u0E70\u0E71\x05(\x15\x02\u0E71\u0E72" + + "\x07\u012A\x02\x02\u0E72\u0E73\x05\u0280\u0141\x02\u0E73\u0E8D\x03\x02" + + "\x02\x02\u0E74\u0E75\x07\x8C\x02\x02\u0E75\u0E76\x07\xCE\x02\x02\u0E76" + + "\u0E77\x05\u0540\u02A1\x02\u0E77\u0E78\x05(\x15\x02\u0E78\u0E79\x07\u01BC" + + "\x02\x02\u0E79\u0E7A\x05\u0280\u0141\x02\u0E7A\u0E8D\x03\x02\x02\x02\u0E7B" + + "\u0E7C\x07\x8C\x02\x02\u0E7C\u0E7D\x07\xCE\x02\x02\u0E7D\u0E7E\x05\u0540" + + "\u02A1\x02\u0E7E\u0E7F\x05(\x15\x02\u0E7F\u0E80\x07\u01BD\x02\x02\u0E80" + + "\u0E81\x07@\x02\x02\u0E81\u0E82\x05\u0462\u0232\x02\u0E82\u0E83\x07\xF9" + + "\x02\x02\u0E83\u0E84\x05\u0540\u02A1\x02\u0E84\u0E8D\x03\x02\x02\x02\u0E85" + + "\u0E86\x07\x8C\x02\x02\u0E86\u0E87\x07\xCE\x02\x02\u0E87\u0E88\x05\u0540" + + "\u02A1\x02\u0E88\u0E89\x05(\x15\x02\u0E89\u0E8A\x07\u016A\x02\x02\u0E8A" + + "\u0E8B\x05\u0462\u0232\x02\u0E8B\u0E8D\x03\x02\x02\x02\u0E8C\u0E24\x03" + + "\x02\x02\x02\u0E8C\u0E2B\x03\x02\x02\x02\u0E8C\u0E32\x03\x02\x02\x02\u0E8C" + + "\u0E39\x03\x02\x02\x02\u0E8C\u0E44\x03\x02\x02\x02\u0E8C\u0E4B\x03\x02" + + "\x02\x02\u0E8C\u0E52\x03\x02\x02\x02\u0E8C\u0E59\x03\x02\x02\x02\u0E8C" + + "\u0E63\x03\x02\x02\x02\u0E8C\u0E6D\x03\x02\x02\x02\u0E8C\u0E74\x03\x02" + + "\x02\x02\u0E8C\u0E7B\x03\x02\x02\x02\u0E8C\u0E85\x03\x02\x02\x02\u0E8D" + + "\u014D\x03\x02\x02\x02\u0E8E\u0E8F\x070\x02\x02\u0E8F\u0E90\x07A\x02\x02" + + "\u0E90\u0E91\x07\xB0\x02\x02\u0E91\u0E92\x07\u017F\x02\x02\u0E92\u0E94" + + "\x05\u0540\u02A1\x02\u0E93\u0E95\x05\u0154\xAB\x02\u0E94\u0E93\x03\x02" + + "\x02\x02\u0E94\u0E95\x03\x02\x02\x02\u0E95\u0E97\x03\x02\x02\x02\u0E96" + + "\u0E98\x05\u0158\xAD\x02\u0E97\u0E96\x03\x02\x02\x02\u0E97\u0E98\x03\x02" + + "\x02\x02\u0E98\u014F\x03\x02\x02\x02\u0E99\u0E9A\x07\xD9\x02\x02\u0E9A" + + "\u0EA2\x05\u0130\x99\x02\u0E9B\u0E9C\x07\u010F\x02\x02\u0E9C\u0EA2\x07" + + "\xD9\x02\x02\u0E9D\u0E9E\x07\u0177\x02\x02\u0E9E\u0EA2\x05\u0130\x99\x02" + + "\u0E9F\u0EA0\x07\u010F\x02\x02\u0EA0\u0EA2\x07\u0177\x02\x02\u0EA1\u0E99" + + "\x03\x02\x02\x02\u0EA1\u0E9B\x03\x02\x02\x02\u0EA1\u0E9D\x03\x02\x02\x02" + + "\u0EA1\u0E9F\x03\x02\x02\x02\u0EA2\u0151\x03\x02\x02\x02\u0EA3\u0EA5\x05" + + "\u0150\xA9\x02\u0EA4\u0EA3\x03\x02\x02\x02\u0EA5\u0EA6\x03\x02\x02\x02" + + "\u0EA6\u0EA4\x03\x02\x02\x02\u0EA6\u0EA7\x03\x02\x02\x02\u0EA7\u0153\x03" + + "\x02\x02\x02\u0EA8\u0EA9\x05\u0152\xAA\x02\u0EA9\u0155\x03\x02\x02\x02" + + "\u0EAA\u0EAB\x07\x8C\x02\x02\u0EAB\u0EAC\x07A\x02\x02\u0EAC\u0EAD\x07" + + "\xB0\x02\x02\u0EAD\u0EAE\x07\u017F\x02\x02\u0EAE\u0EB0\x05\u0540\u02A1" + + "\x02\u0EAF\u0EB1\x05\u0154\xAB\x02\u0EB0\u0EAF\x03\x02\x02\x02\u0EB0\u0EB1" + + "\x03\x02\x02\x02\u0EB1\u0EB2\x03\x02\x02\x02\u0EB2\u0EB3\x05\u015C\xAF" + + "\x02\u0EB3\u0EBC\x03\x02\x02\x02\u0EB4\u0EB5\x07\x8C\x02\x02\u0EB5\u0EB6" + + "\x07A\x02\x02\u0EB6\u0EB7\x07\xB0\x02\x02\u0EB7\u0EB8\x07\u017F\x02\x02" + + "\u0EB8\u0EB9\x05\u0540\u02A1\x02\u0EB9\u0EBA\x05\u0152\xAA\x02\u0EBA\u0EBC" + + "\x03\x02\x02\x02\u0EBB\u0EAA\x03\x02\x02\x02\u0EBB\u0EB4\x03\x02\x02\x02" + + "\u0EBC\u0157\x03\x02\x02\x02\u0EBD\u0EBE\x07\u011A\x02\x02\u0EBE\u0EBF" + + "\x07\x04\x02\x02\u0EBF\u0EC0\x05\u015A\xAE\x02\u0EC0\u0EC1\x07\x05\x02" + + "\x02\u0EC1\u0159\x03\x02\x02\x02\u0EC2\u0EC7\x05\u0162\xB2\x02\u0EC3\u0EC4" + + "\x07\b\x02\x02\u0EC4\u0EC6\x05\u0162\xB2\x02\u0EC5\u0EC3\x03\x02\x02\x02" + + "\u0EC6\u0EC9\x03\x02\x02\x02\u0EC7\u0EC5\x03\x02\x02\x02\u0EC7\u0EC8\x03" + + "\x02\x02\x02\u0EC8\u015B\x03\x02\x02\x02\u0EC9\u0EC7\x03\x02\x02\x02\u0ECA" + + "\u0ECB\x07\u011A\x02\x02\u0ECB\u0ECC\x07\x04\x02\x02\u0ECC\u0ECD\x05\u015E" + + "\xB0\x02\u0ECD\u0ECE\x07\x05\x02\x02\u0ECE\u015D\x03\x02\x02\x02\u0ECF" + + "\u0ED4\x05\u0160\xB1\x02\u0ED0\u0ED1\x07\b\x02\x02\u0ED1\u0ED3\x05\u0160" + + "\xB1\x02\u0ED2\u0ED0\x03\x02\x02\x02\u0ED3\u0ED6\x03\x02\x02\x02\u0ED4" + + "\u0ED2\x03\x02\x02\x02\u0ED4\u0ED5\x03\x02\x02\x02\u0ED5\u015F\x03\x02" + + "\x02\x02\u0ED6\u0ED4\x03\x02\x02\x02\u0ED7\u0EDF\x05\u0162\xB2\x02\u0ED8" + + "\u0ED9\x07\u014F\x02\x02\u0ED9\u0EDF\x05\u0162\xB2\x02\u0EDA\u0EDB\x07" + + "\x87\x02\x02\u0EDB\u0EDF\x05\u0162\xB2\x02\u0EDC\u0EDD\x07\xC1\x02\x02" + + "\u0EDD\u0EDF\x05\u0162\xB2\x02\u0EDE\u0ED7\x03\x02\x02\x02\u0EDE\u0ED8" + + "\x03\x02\x02\x02\u0EDE\u0EDA\x03\x02\x02\x02\u0EDE\u0EDC\x03\x02\x02\x02" + + "\u0EDF\u0161\x03\x02\x02\x02\u0EE0\u0EE1\x05\u0164\xB3\x02\u0EE1\u0EE2" + + "\x05\u0166\xB4\x02\u0EE2\u0163\x03\x02\x02\x02\u0EE3\u0EE4\x05\u0570\u02B9" + + "\x02\u0EE4\u0165\x03\x02\x02\x02\u0EE5\u0EE6\x05\u0552\u02AA\x02\u0EE6" + + "\u0167\x03\x02\x02\x02\u0EE7\u0EE8\x070\x02\x02\u0EE8\u0EE9\x07\u014D" + + "\x02\x02\u0EE9\u0EEB\x05\u0540\u02A1\x02\u0EEA\u0EEC\x05\u016A\xB6\x02" + + "\u0EEB\u0EEA\x03\x02\x02\x02\u0EEB\u0EEC\x03\x02\x02\x02\u0EEC\u0EEE\x03" + + "\x02\x02\x02\u0EED\u0EEF\x05\u016E\xB8\x02\u0EEE\u0EED\x03\x02\x02\x02" + + "\u0EEE\u0EEF\x03\x02\x02\x02\u0EEF\u0EF0\x03\x02\x02\x02\u0EF0\u0EF1\x07" + + "A\x02\x02\u0EF1\u0EF2\x07\xB0\x02\x02\u0EF2\u0EF3\x07\u017F\x02\x02\u0EF3" + + "\u0EF5\x05\u0540\u02A1\x02\u0EF4\u0EF6\x05\u0158\xAD\x02\u0EF5\u0EF4\x03" + + "\x02\x02\x02\u0EF5\u0EF6\x03\x02\x02\x02\u0EF6\u0F0B\x03\x02\x02\x02\u0EF7" + + "\u0EF8\x070\x02\x02\u0EF8\u0EF9\x07\u014D\x02\x02\u0EF9\u0EFA\x07\xDE" + + "\x02\x02\u0EFA\u0EFB\x07O\x02\x02\u0EFB\u0EFC\x07\u018E\x02\x02\u0EFC" + + "\u0EFE\x05\u0540\u02A1\x02\u0EFD\u0EFF\x05\u016A\xB6\x02\u0EFE\u0EFD\x03" + + "\x02\x02\x02\u0EFE\u0EFF\x03\x02\x02\x02\u0EFF\u0F01\x03\x02\x02\x02\u0F00" + + "\u0F02\x05\u016E\xB8\x02\u0F01\u0F00\x03\x02\x02\x02\u0F01\u0F02\x03\x02" + + "\x02\x02\u0F02\u0F03\x03\x02\x02\x02\u0F03\u0F04\x07A\x02\x02\u0F04\u0F05" + + "\x07\xB0\x02\x02\u0F05\u0F06\x07\u017F\x02\x02\u0F06\u0F08\x05\u0540\u02A1" + + "\x02\u0F07\u0F09\x05\u0158\xAD\x02\u0F08\u0F07\x03\x02\x02\x02\u0F08\u0F09" + + "\x03\x02\x02\x02\u0F09\u0F0B\x03\x02\x02\x02\u0F0A\u0EE7\x03\x02\x02\x02" + + "\u0F0A\u0EF7\x03\x02\x02\x02\u0F0B\u0169\x03\x02\x02\x02\u0F0C\u0F0D\x07" + + "\u016A\x02\x02\u0F0D\u0F0E\x05\u0552\u02AA\x02\u0F0E\u016B\x03\x02\x02" + + "\x02\u0F0F\u0F12\x07\u0179\x02\x02\u0F10\u0F13\x05\u0552\u02AA\x02\u0F11" + + "\u0F13\x07P\x02\x02\u0F12\u0F10\x03\x02\x02\x02\u0F12\u0F11\x03\x02\x02" + + "\x02\u0F13\u016D\x03\x02\x02\x02\u0F14\u0F15\x05\u016C\xB7\x02\u0F15\u016F" + + "\x03\x02\x02\x02\u0F16\u0F17\x07\x8C\x02\x02\u0F17\u0F18\x07\u014D\x02" + + "\x02\u0F18\u0F1E\x05\u0540\u02A1\x02\u0F19\u0F1F\x05\u015C\xAF\x02\u0F1A" + + "\u0F1C\x05\u016C\xB7\x02\u0F1B\u0F1D\x05\u015C\xAF\x02\u0F1C\u0F1B\x03" + + "\x02\x02\x02\u0F1C\u0F1D\x03\x02\x02\x02\u0F1D\u0F1F\x03\x02\x02\x02\u0F1E" + + "\u0F19\x03\x02\x02\x02\u0F1E\u0F1A\x03\x02\x02\x02\u0F1F\u0171\x03\x02" + + "\x02\x02\u0F20\u0F21\x070\x02\x02\u0F21\u0F22\x07A\x02\x02\u0F22\u0F23" + + "\x07^\x02\x02\u0F23\u0F24\x05\u053C\u029F\x02\u0F24\u0F26\x07\x04\x02" + + "\x02\u0F25\u0F27\x05\xB2Z\x02\u0F26\u0F25\x03\x02\x02\x02\u0F26\u0F27" + + "\x03\x02\x02\x02\u0F27\u0F28\x03\x02\x02\x02\u0F28\u0F2A\x07\x05\x02\x02" + + "\u0F29\u0F2B\x05\xF2z\x02\u0F2A\u0F29\x03\x02\x02\x02\u0F2A\u0F2B\x03" + + "\x02\x02\x02\u0F2B\u0F2C\x03\x02\x02\x02\u0F2C\u0F2D\x07\u014D\x02\x02" + + "\u0F2D\u0F2F\x05\u0540\u02A1\x02\u0F2E\u0F30\x05\u0158\xAD\x02\u0F2F\u0F2E" + + "\x03\x02\x02\x02\u0F2F\u0F30\x03\x02\x02\x02\u0F30\u0F69\x03\x02\x02\x02" + + "\u0F31\u0F32\x070\x02\x02\u0F32\u0F33\x07A\x02\x02\u0F33\u0F34\x07^\x02" + + "\x02\u0F34\u0F35\x07\xDE\x02\x02\u0F35\u0F36\x07O\x02\x02\u0F36\u0F37" + + "\x07\u018E\x02\x02\u0F37\u0F38\x05\u053C\u029F\x02\u0F38\u0F3A\x07\x04" + + "\x02\x02\u0F39\u0F3B\x05\xB2Z\x02\u0F3A\u0F39\x03\x02\x02\x02\u0F3A\u0F3B" + + "\x03\x02\x02\x02\u0F3B\u0F3C\x03\x02\x02\x02\u0F3C\u0F3E\x07\x05\x02\x02" + + "\u0F3D\u0F3F\x05\xF2z\x02\u0F3E\u0F3D\x03\x02\x02\x02\u0F3E\u0F3F\x03" + + "\x02\x02\x02\u0F3F\u0F40\x03\x02\x02\x02\u0F40\u0F41\x07\u014D\x02\x02" + + "\u0F41\u0F43\x05\u0540\u02A1\x02\u0F42\u0F44\x05\u0158\xAD\x02\u0F43\u0F42" + + "\x03\x02\x02\x02\u0F43\u0F44\x03\x02\x02\x02\u0F44\u0F69\x03\x02\x02\x02" + + "\u0F45\u0F46\x070\x02\x02\u0F46\u0F47\x07A\x02\x02\u0F47\u0F48\x07^\x02" + + "\x02\u0F48\u0F49\x05\u053C\u029F\x02\u0F49\u0F4A\x07\u011F\x02\x02\u0F4A" + + "\u0F4B\x07\u0115\x02\x02\u0F4B\u0F4D\x05\u053C\u029F\x02\u0F4C\u0F4E\x05" + + "\xB4[\x02\u0F4D\u0F4C\x03\x02\x02\x02\u0F4D\u0F4E\x03\x02\x02\x02\u0F4E" + + "\u0F4F\x03\x02\x02\x02\u0F4F\u0F50\x05\x80A\x02\u0F50\u0F51\x07\u014D" + + "\x02\x02\u0F51\u0F53\x05\u0540\u02A1\x02\u0F52\u0F54\x05\u0158\xAD\x02" + + "\u0F53\u0F52\x03\x02\x02\x02\u0F53\u0F54\x03\x02\x02\x02\u0F54\u0F69\x03" + + "\x02\x02\x02\u0F55\u0F56\x070\x02\x02\u0F56\u0F57\x07A\x02\x02\u0F57\u0F58" + + "\x07^\x02\x02\u0F58\u0F59\x07\xDE\x02\x02\u0F59\u0F5A\x07O\x02\x02\u0F5A" + + "\u0F5B\x07\u018E\x02\x02\u0F5B\u0F5C\x05\u053C\u029F\x02\u0F5C\u0F5D\x07" + + "\u011F\x02\x02\u0F5D\u0F5E\x07\u0115\x02\x02\u0F5E\u0F60\x05\u053C\u029F" + + "\x02\u0F5F\u0F61\x05\xB4[\x02\u0F60\u0F5F\x03\x02\x02\x02\u0F60\u0F61" + + "\x03\x02\x02\x02\u0F61\u0F62\x03\x02\x02\x02\u0F62\u0F63\x05\x80A\x02" + + "\u0F63\u0F64\x07\u014D\x02\x02\u0F64\u0F66\x05\u0540\u02A1\x02\u0F65\u0F67" + + "\x05\u0158\xAD\x02\u0F66\u0F65\x03\x02\x02\x02\u0F66\u0F67\x03\x02\x02" + + "\x02\u0F67\u0F69\x03\x02\x02\x02\u0F68\u0F20\x03\x02\x02\x02\u0F68\u0F31" + + "\x03\x02\x02\x02\u0F68\u0F45\x03\x02\x02\x02\u0F68\u0F55\x03\x02\x02\x02" + + "\u0F69\u0173\x03\x02\x02\x02\u0F6A\u0F6B\x07\u01BE\x02\x02\u0F6B\u0F6C" + + "\x07A\x02\x02\u0F6C\u0F6D\x07\u0145\x02\x02\u0F6D\u0F6F\x05\u0540\u02A1" + + "\x02\u0F6E\u0F70\x05\u0178\xBD\x02\u0F6F\u0F6E\x03\x02\x02\x02\u0F6F\u0F70" + + "\x03\x02\x02\x02\u0F70\u0F71\x03\x02\x02\x02\u0F71\u0F72\x07B\x02\x02" + + "\u0F72\u0F73\x07\u014D\x02\x02\u0F73\u0F74\x05\u0540\u02A1\x02\u0F74\u0F75" + + "\x07I\x02\x02\u0F75\u0F77\x05\u0540\u02A1\x02\u0F76\u0F78\x05\u0158\xAD" + + "\x02\u0F77\u0F76\x03\x02\x02\x02\u0F77\u0F78\x03\x02\x02\x02\u0F78\u0175" + + "\x03\x02\x02\x02\u0F79\u0F7A\x07L\x02\x02\u0F7A\u0F7D\x07`\x02\x02\u0F7B" + + "\u0F7D\x07=\x02\x02\u0F7C\u0F79\x03\x02\x02\x02\u0F7C\u0F7B\x03\x02\x02" + + "\x02\u0F7D\u0177\x03\x02\x02\x02\u0F7E\u0F7F\x05\u0176\xBC\x02\u0F7F\u0F80" + + "\x07\x04\x02\x02\u0F80\u0F81\x05\u0438\u021D\x02\u0F81\u0F82\x07\x05\x02" + + "\x02\u0F82\u0179\x03\x02\x02\x02\u0F83\u0F84\x070\x02\x02\u0F84\u0F85" + + "\x07e\x02\x02\u0F85\u0F86\x07\u0103\x02\x02\u0F86\u0F87\x07@\x02\x02\u0F87" + + "\u0F88\x05\u017C\xBF\x02\u0F88\u0F89\x07\u014D\x02\x02\u0F89\u0F8B\x05" + + "\u0540\u02A1\x02\u0F8A\u0F8C\x05\u0158\xAD\x02\u0F8B\u0F8A\x03\x02\x02" + + "\x02\u0F8B\u0F8C\x03\x02\x02\x02\u0F8C\u0F9B\x03\x02\x02\x02\u0F8D\u0F8E" + + "\x070\x02\x02\u0F8E\u0F8F\x07e\x02\x02\u0F8F\u0F90\x07\u0103\x02\x02\u0F90" + + "\u0F91\x07\xDE\x02\x02\u0F91\u0F92\x07O\x02\x02\u0F92\u0F93\x07\u018E" + + "\x02\x02\u0F93\u0F94\x07@\x02\x02\u0F94\u0F95\x05\u017C\xBF\x02\u0F95" + + "\u0F96\x07\u014D\x02\x02\u0F96\u0F98\x05\u0540\u02A1\x02\u0F97\u0F99\x05" + + "\u0158\xAD\x02\u0F98\u0F97\x03\x02\x02\x02\u0F98\u0F99\x03\x02\x02\x02" + + "\u0F99\u0F9B\x03\x02\x02\x02\u0F9A\u0F83\x03\x02\x02\x02\u0F9A\u0F8D\x03" + + "\x02\x02\x02\u0F9B\u017B\x03\x02\x02\x02\u0F9C\u0F9F\x05\u055E\u02B0\x02" + + "\u0F9D\u0F9F\x07e\x02\x02\u0F9E\u0F9C\x03\x02\x02\x02\u0F9E\u0F9D\x03" + + "\x02\x02\x02\u0F9F\u017D\x03\x02\x02\x02\u0FA0\u0FA1\x07\xC1\x02\x02\u0FA1" + + "\u0FA2\x07e\x02\x02\u0FA2\u0FA3\x07\u0103\x02\x02\u0FA3\u0FA4\x07@\x02" + + "\x02\u0FA4\u0FA5\x05\u017C\xBF\x02\u0FA5\u0FA6\x07\u014D\x02\x02\u0FA6" + + "\u0FA7\x05\u0540\u02A1\x02\u0FA7\u0FB3\x03\x02\x02\x02\u0FA8\u0FA9\x07" + + "\xC1\x02\x02\u0FA9\u0FAA\x07e\x02\x02\u0FAA\u0FAB\x07\u0103\x02\x02\u0FAB" + + "\u0FAC\x07\xDE\x02\x02\u0FAC\u0FAD\x07\u018E\x02\x02\u0FAD\u0FAE\x07@" + + "\x02\x02\u0FAE\u0FAF\x05\u017C\xBF\x02\u0FAF\u0FB0\x07\u014D\x02\x02\u0FB0" + + "\u0FB1\x05\u0540\u02A1\x02\u0FB1\u0FB3\x03\x02\x02\x02\u0FB2\u0FA0\x03" + + "\x02\x02\x02\u0FB2\u0FA8\x03\x02\x02\x02\u0FB3\u017F\x03\x02\x02\x02\u0FB4" + + "\u0FB5\x07\x8C\x02\x02\u0FB5\u0FB6\x07e\x02\x02\u0FB6\u0FB7\x07\u0103" + + "\x02\x02\u0FB7\u0FB8\x07@\x02\x02\u0FB8\u0FB9\x05\u017C\xBF\x02\u0FB9" + + "\u0FBA\x07\u014D\x02\x02\u0FBA\u0FBB\x05\u0540\u02A1\x02\u0FBB\u0FBC\x05" + + "\u015C\xAF\x02\u0FBC\u0181\x03\x02\x02\x02\u0FBD\u0FBE\x070\x02\x02\u0FBE" + + "\u0FBF\x07\u01BF\x02\x02\u0FBF\u0FC0\x05\u0540\u02A1\x02\u0FC0\u0FC1\x07" + + "R\x02\x02\u0FC1\u0FC3\x05\u053C\u029F\x02\u0FC2\u0FC4\x05\u018E\xC8\x02" + + "\u0FC3\u0FC2\x03\x02\x02\x02\u0FC3\u0FC4\x03\x02\x02\x02\u0FC4\u0FC6\x03" + + "\x02\x02\x02\u0FC5\u0FC7\x05\u0190\xC9\x02\u0FC6\u0FC5\x03\x02\x02\x02" + + "\u0FC6\u0FC7\x03\x02\x02\x02\u0FC7\u0FC9\x03\x02\x02\x02\u0FC8\u0FCA\x05" + + "\u018A\xC6\x02\u0FC9\u0FC8\x03\x02\x02\x02\u0FC9\u0FCA\x03\x02\x02\x02" + + "\u0FCA\u0FCC\x03\x02\x02\x02\u0FCB\u0FCD\x05\u0186\xC4\x02\u0FCC\u0FCB" + + "\x03\x02\x02\x02\u0FCC\u0FCD\x03\x02\x02\x02\u0FCD\u0FCF\x03\x02\x02\x02" + + "\u0FCE\u0FD0\x05\u0188\xC5\x02\u0FCF\u0FCE\x03\x02\x02\x02\u0FCF\u0FD0" + + "\x03\x02\x02\x02\u0FD0\u0183\x03\x02\x02\x02\u0FD1\u0FD2\x07\x8C\x02\x02" + + "\u0FD2\u0FD3\x07\u01BF\x02\x02\u0FD3\u0FD4\x05\u0540\u02A1\x02\u0FD4\u0FD5" + + "\x07R\x02\x02\u0FD5\u0FD7\x05\u053C\u029F\x02\u0FD6\u0FD8\x05\u018C\xC7" + + "\x02\u0FD7\u0FD6\x03\x02\x02\x02\u0FD7\u0FD8\x03\x02\x02\x02\u0FD8\u0FDA" + + "\x03\x02\x02\x02\u0FD9\u0FDB\x05\u0186\xC4\x02\u0FDA\u0FD9\x03\x02\x02" + + "\x02\u0FDA\u0FDB\x03\x02\x02\x02\u0FDB\u0FDD\x03\x02\x02\x02\u0FDC\u0FDE" + + "\x05\u0188\xC5\x02\u0FDD\u0FDC\x03\x02\x02\x02\u0FDD\u0FDE\x03\x02\x02" + + "\x02\u0FDE\u0185\x03\x02\x02\x02\u0FDF\u0FE0\x07f\x02\x02\u0FE0\u0FE1" + + "\x07\x04\x02\x02\u0FE1\u0FE2\x05\u048E\u0248\x02\u0FE2\u0FE3\x07\x05\x02" + + "\x02\u0FE3\u0187\x03\x02\x02\x02\u0FE4\u0FE5\x07k\x02\x02\u0FE5\u0FE6" + + "\x07,\x02\x02\u0FE6\u0FE7\x07\x04\x02\x02\u0FE7\u0FE8\x05\u048E\u0248" + + "\x02\u0FE8\u0FE9\x07\x05\x02\x02\u0FE9\u0189\x03\x02\x02\x02\u0FEA\u0FEB" + + "\x07`\x02\x02\u0FEB\u0FEC\x05\u0560\u02B1\x02\u0FEC\u018B\x03\x02\x02" + + "\x02\u0FED\u0FEE\x07`\x02\x02\u0FEE\u0FEF\x05\u0560\u02B1\x02\u0FEF\u018D" + + "\x03\x02\x02\x02\u0FF0\u0FF1\x07&\x02\x02\u0FF1\u0FF2\x05\u0572\u02BA" + + "\x02\u0FF2\u018F\x03\x02\x02\x02\u0FF3\u0FF4\x07@\x02\x02\u0FF4\u0FF5" + + "\x05\u0192\xCA\x02\u0FF5\u0191\x03\x02\x02\x02\u0FF6\u0FF7\t\x19\x02\x02" + + "\u0FF7\u0193\x03\x02\x02\x02\u0FF8\u0FF9\x070\x02\x02\u0FF9\u0FFA\x07" + + "\x85\x02\x02\u0FFA\u0FFB\x07\u01C0\x02\x02\u0FFB\u0FFC\x05\u0540\u02A1" + + "\x02\u0FFC\u0FFD\x07\u016A\x02\x02\u0FFD\u0FFE\x05\u0196\xCC\x02\u0FFE" + + "\u0FFF\x07\xD9\x02\x02\u0FFF\u1000\x05\u0130\x99\x02\u1000\u0195\x03\x02" + + "\x02\x02\u1001\u1002\t\x1A\x02\x02\u1002\u0197\x03\x02\x02\x02\u1003\u1004" + + "\x070\x02\x02\u1004\u1005\x07\u0167\x02\x02\u1005\u1006\x05\u0540\u02A1" + + "\x02\u1006\u1007\x05\u019A\xCE\x02\u1007\u1008\x05\u01A0\xD1\x02\u1008" + + "\u1009\x07R\x02\x02\u1009\u100B\x05\u053C\u029F\x02\u100A\u100C\x05\u01A4" + + "\xD3\x02\u100B\u100A\x03\x02\x02\x02\u100B\u100C\x03\x02\x02\x02\u100C" + + "\u100E\x03\x02\x02\x02\u100D\u100F\x05\u01B0\xD9\x02\u100E\u100D\x03\x02" + + "\x02\x02\u100E\u100F\x03\x02\x02\x02\u100F\u1011\x03\x02\x02\x02\u1010" + + "\u1012\x05\u01B6\xDC\x02\u1011\u1010\x03\x02\x02\x02\u1011\u1012\x03\x02" + + "\x02\x02\u1012\u1013\x03\x02\x02\x02\u1013\u1014\x07\xCC\x02\x02\u1014" + + "\u1015\x05\u01B8\xDD\x02\u1015\u1016\x05\u0546\u02A4\x02\u1016\u1017\x07" + + "\x04\x02\x02\u1017\u1018\x05\u01BA\xDE\x02\u1018\u1019\x07\x05\x02\x02" + + "\u1019\u1036\x03\x02\x02\x02\u101A\u101C\x070\x02\x02\u101B\u101D\x07" + + "/\x02\x02\u101C\u101B\x03\x02\x02\x02\u101C\u101D\x03\x02\x02\x02\u101D" + + "\u101E\x03\x02\x02\x02\u101E\u101F\x07\u0167\x02\x02\u101F\u1020\x05\u0540" + + "\u02A1\x02\u1020\u1021\x05\u019A\xCE\x02\u1021\u1022\x05\u01A0\xD1\x02" + + "\u1022\u1023\x07R\x02\x02\u1023\u1025\x05\u053C\u029F\x02\u1024\u1026" + + "\x05\u01BE\xE0\x02\u1025\u1024\x03\x02\x02\x02\u1025\u1026\x03\x02\x02" + + "\x02\u1026\u1027\x03\x02\x02\x02\u1027\u1029\x05\u01C0\xE1\x02\u1028\u102A" + + "\x05\u019C\xCF\x02\u1029\u1028\x03\x02\x02\x02\u1029\u102A\x03\x02\x02" + + "\x02\u102A\u102C\x03\x02\x02\x02\u102B\u102D\x05\u01B6\xDC\x02\u102C\u102B" + + "\x03\x02\x02\x02\u102C\u102D\x03\x02\x02\x02\u102D\u102E\x03\x02\x02\x02" + + "\u102E\u102F\x07\xCC\x02\x02\u102F\u1030\x05\u01B8\xDD\x02\u1030\u1031" + + "\x05\u0546\u02A4\x02\u1031\u1032\x07\x04\x02\x02\u1032\u1033\x05\u01BA" + + "\xDE\x02\u1033\u1034\x07\x05\x02\x02\u1034\u1036\x03\x02\x02\x02\u1035" + + "\u1003\x03\x02\x02\x02\u1035\u101A\x03\x02\x02\x02\u1036\u0199\x03\x02" + + "\x02\x02\u1037\u103C\x07\x93\x02\x02\u1038\u103C\x07\x89\x02\x02\u1039" + + "\u103A\x07\xF4\x02\x02\u103A\u103C\x07\u0115\x02\x02\u103B\u1037\x03\x02" + + "\x02\x02\u103B\u1038\x03\x02\x02\x02\u103B\u1039\x03\x02\x02\x02\u103C" + + "\u019B\x03\x02\x02\x02\u103D\u103F\x07@\x02\x02\u103E\u1040\x07\xC2\x02" + + "\x02\u103F\u103E\x03\x02\x02\x02\u103F\u1040\x03\x02\x02\x02\u1040\u1041" + + "\x03\x02\x02\x02\u1041\u1042\x05\u019E\xD0\x02\u1042\u019D\x03\x02\x02" + + "\x02\u1043\u1044\t\x1B\x02\x02\u1044\u019F\x03\x02\x02\x02\u1045\u104A" + + "\x05\u01A2\xD2\x02\u1046\u1047\x07T\x02\x02\u1047\u1049\x05\u01A2\xD2" + + "\x02\u1048\u1046\x03\x02\x02\x02\u1049\u104C\x03\x02\x02\x02\u104A\u1048" + + "\x03\x02\x02\x02\u104A\u104B\x03\x02\x02\x02\u104B\u01A1\x03\x02\x02\x02" + + "\u104C\u104A\x03\x02\x02\x02\u104D\u1055\x07\xF3\x02\x02\u104E\u1055\x07" + + "\xB8\x02\x02\u104F\u1055\x07\u0173\x02\x02\u1050\u1051\x07\u0173\x02\x02" + + "\u1051\u1052\x07\u0115\x02\x02\u1052\u1055\x05\xDCo\x02\u1053\u1055\x07" + + "\u0168\x02\x02\u1054\u104D\x03\x02\x02\x02\u1054\u104E\x03\x02\x02\x02" + + "\u1054\u104F\x03\x02\x02\x02\u1054\u1050\x03\x02\x02\x02\u1054\u1053\x03" + + "\x02\x02\x02\u1055\u01A3\x03\x02\x02\x02\u1056\u1057\x07\u01C1\x02\x02" + + "\u1057\u1058\x05\u01A6\xD4\x02\u1058\u01A5\x03\x02\x02\x02\u1059\u105B" + + "\x05\u01A8\xD5\x02\u105A\u1059\x03\x02\x02\x02\u105B\u105C\x03\x02\x02" + + "\x02\u105C\u105A\x03\x02\x02\x02\u105C\u105D\x03\x02\x02\x02\u105D\u01A7" + + "\x03\x02\x02\x02\u105E\u105F\x05\u01AA\xD6\x02\u105F\u1061\x05\u01AC\xD7" + + "\x02\u1060\u1062\x05\u0350\u01A9\x02\u1061\u1060\x03\x02\x02\x02\u1061" + + "\u1062\x03\x02\x02\x02\u1062\u1063\x03\x02\x02\x02\u1063\u1064\x05\u01AE" + + "\xD8\x02\u1064\u01A9\x03\x02\x02\x02\u1065\u1066\t\x1C\x02\x02\u1066\u01AB" + + "\x03\x02\x02\x02\u1067\u1068\t\x1D\x02\x02\u1068\u01AD\x03\x02\x02\x02" + + "\u1069\u106A\x05\u0562\u02B2\x02\u106A\u01AF\x03\x02\x02\x02\u106B\u106D" + + "\x07@\x02\x02\u106C\u106E\x05\u01B2\xDA\x02\u106D\u106C\x03\x02\x02\x02" + + "\u106D\u106E\x03\x02\x02\x02\u106E\u106F\x03\x02\x02\x02\u106F\u1070\x05" + + "\u01B4\xDB\x02\u1070\u01B1\x03\x02\x02\x02\u1071\u1072\x07\xC2\x02\x02" + + "\u1072\u01B3\x03\x02\x02\x02\u1073\u1074\t\x1B\x02\x02\u1074\u01B5\x03" + + "\x02\x02\x02\u1075\u1076\x07h\x02\x02\u1076\u1077\x07\x04\x02\x02\u1077" + + "\u1078\x05\u048E\u0248\x02\u1078\u1079\x07\x05\x02\x02\u1079\u01B7\x03" + + "\x02\x02\x02\u107A\u107B\t\x1E\x02\x02\u107B\u01B9\x03\x02\x02\x02\u107C" + + "\u107F\x05\u01BC\xDF\x02\u107D\u107F\x03\x02\x02\x02\u107E\u107C\x03\x02" + + "\x02\x02\u107E\u107D\x03\x02\x02\x02\u107F\u1084\x03\x02\x02\x02\u1080" + + "\u1081\x07\b\x02\x02\u1081\u1083\x05\u01BC\xDF\x02\u1082\u1080\x03\x02" + + "\x02\x02\u1083\u1086\x03\x02\x02\x02\u1084\u1082\x03\x02\x02\x02\u1084" + + "\u1085\x03\x02\x02\x02\u1085\u01BB\x03\x02\x02\x02\u1086\u1084\x03\x02" + + "\x02\x02\u1087\u108C\x05\u0550\u02A9\x02\u1088\u108C\x05\u054E\u02A8\x02" + + "\u1089\u108C\x05\u0552\u02AA\x02\u108A\u108C\x05\u0570\u02B9\x02\u108B" + + "\u1087\x03\x02\x02\x02\u108B\u1088\x03\x02\x02\x02\u108B\u1089\x03\x02" + + "\x02\x02\u108B\u108A\x03\x02\x02\x02\u108C\u01BD\x03\x02\x02\x02\u108D" + + "\u108E\x07B\x02\x02\u108E\u108F\x05\u053C\u029F\x02\u108F\u01BF\x03\x02" + + "\x02\x02\u1090\u1092\x05\u01C2\xE2\x02\u1091\u1090\x03\x02\x02\x02\u1092" + + "\u1095\x03\x02\x02\x02\u1093\u1091\x03\x02\x02\x02\u1093\u1094\x03\x02" + + "\x02\x02\u1094\u01C1\x03\x02\x02\x02\u1095\u1093\x03\x02\x02\x02\u1096" + + "\u1097\x07"; private static readonly _serializedATNSegment10: string = - "\x8A\x02\x02\u10BF\u10C0\x05\u0536\u029C\x02\u10C0\u10C1\x05\u01D4\xEB" + - "\x02\u10C1\u1124\x03\x02\x02\x02\u10C2\u10C3\x070\x02\x02\u10C3\u10C4" + - "\x07\u010F\x02\x02\u10C4\u10C5\x05\u02AC\u0157\x02\u10C5\u10C6\x05\u01CC" + - "\xE7\x02\u10C6\u1124\x03\x02\x02\x02\u10C7\u10C8\x070\x02\x02\u10C8\u10C9" + - "\x07\u0161\x02\x02\u10C9\u10CA\x05\u020C\u0107\x02\u10CA\u10CB\x05\u01CC" + - "\xE7\x02\u10CB\u1124\x03\x02\x02\x02\u10CC\u10CD\x070\x02\x02\u10CD\u10CE" + - "\x07\u0161\x02\x02\u10CE\u1124\x05\u020C\u0107\x02\u10CF\u10D0\x070\x02" + - "\x02\u10D0\u10D1\x07\u0161\x02\x02\u10D1\u10D2\x05\u020C\u0107\x02\u10D2" + - "\u10D3\x07&\x02\x02\u10D3\u10D5\x07\x04\x02\x02\u10D4\u10D6\x05\u0440" + - "\u0221\x02\u10D5\u10D4\x03\x02\x02\x02\u10D5\u10D6\x03\x02\x02\x02\u10D6" + - "\u10D7\x03\x02\x02\x02\u10D7\u10D8\x07\x05\x02\x02\u10D8\u1124\x03\x02" + - "\x02\x02\u10D9\u10DA\x070\x02\x02\u10DA\u10DB\x07\u0161\x02\x02\u10DB" + - "\u10DC\x05\u020C\u0107\x02\u10DC\u10DD\x07&\x02\x02\u10DD\u10DE\x07\xC6" + - "\x02\x02\u10DE\u10E0\x07\x04\x02\x02\u10DF\u10E1\x05\u01DA\xEE\x02\u10E0" + - "\u10DF\x03\x02\x02\x02\u10E0\u10E1\x03\x02\x02\x02\u10E1\u10E2\x03\x02" + - "\x02\x02\u10E2\u10E3\x07\x05\x02\x02\u10E3\u1124\x03\x02\x02\x02\u10E4" + - "\u10E5\x070\x02\x02\u10E5\u10E6\x07\u0161\x02\x02\u10E6\u10E7\x05\u020C" + - "\u0107\x02\u10E7\u10E8\x07&\x02\x02\u10E8\u10E9\x07\u0124\x02\x02\u10E9" + - "\u10EA\x05\u01CC\xE7\x02\u10EA\u1124\x03\x02\x02\x02\u10EB\u10EC\x070" + - "\x02\x02\u10EC\u10ED\x07\u015C\x02\x02\u10ED\u10EE\x07\u013E\x02\x02\u10EE" + - "\u10EF\x07\u0114\x02\x02\u10EF\u10F0\x05\u020C\u0107\x02\u10F0\u10F1\x05" + - "\u01CC\xE7\x02\u10F1\u1124\x03\x02\x02\x02\u10F2\u10F3\x070\x02\x02\u10F3" + - "\u10F4\x07\u015C\x02\x02\u10F4\u10F5\x07\u013E\x02\x02\u10F5\u10F6\x07" + - "\xBB\x02\x02\u10F6\u10F7\x05\u020C\u0107\x02\u10F7\u10F8\x05\u01CC\xE7" + - "\x02\u10F8\u1124\x03\x02\x02\x02\u10F9\u10FA\x070\x02\x02\u10FA\u10FB" + - "\x07\u015C\x02\x02\u10FB\u10FC\x07\u013E\x02\x02\u10FC\u10FD\x07\u015A" + - "\x02\x02\u10FD\u10FE\x05\u020C\u0107\x02\u10FE\u10FF\x05\u01CC\xE7\x02" + - "\u10FF\u1124\x03\x02\x02\x02\u1100\u1101\x070\x02\x02\u1101\u1102\x07" + - "\u015C\x02\x02\u1102\u1103\x07\u013E\x02\x02\u1103\u1104\x07\xA5\x02\x02" + - "\u1104\u1105\x05\u020C\u0107\x02\u1105\u1106\x05\u01CC\xE7\x02\u1106\u1124" + - "\x03\x02\x02\x02\u1107\u1108\x070\x02\x02\u1108\u1109\x07n\x02\x02\u1109" + - "\u110A\x05\u020C\u0107\x02\u110A\u110B\x05\u01CC\xE7\x02\u110B\u1124\x03" + - "\x02\x02\x02\u110C\u110D\x070\x02\x02\u110D\u110E\x07n\x02\x02\u110E\u110F" + - "\x07\xDE\x02\x02\u110F\u1110\x07O\x02\x02\u1110\u1111\x07\u0185\x02\x02" + - "\u1111\u1112\x05\u020C\u0107\x02\u1112\u1113\x05\u01CC\xE7\x02\u1113\u1124" + - "\x03\x02\x02\x02\u1114\u1115\x070\x02\x02\u1115\u1116\x07n\x02\x02\u1116" + - "\u1117\x05\u020C\u0107\x02\u1117\u1118\x07B\x02\x02\u1118\u1119\x05\u020C" + - "\u0107\x02\u1119\u1124\x03\x02\x02\x02\u111A\u111B\x070\x02\x02\u111B" + - "\u111C\x07n\x02\x02\u111C\u111D\x07\xDE\x02\x02\u111D\u111E\x07O\x02\x02" + - "\u111E\u111F\x07\u0185\x02\x02\u111F\u1120\x05\u020C\u0107\x02\u1120\u1121" + - "\x07B\x02\x02\u1121\u1122\x05\u020C\u0107\x02\u1122\u1124\x03\x02\x02" + - "\x02\u1123\u10B1\x03\x02\x02\x02\u1123\u10BA\x03\x02\x02\x02\u1123\u10C2" + - "\x03\x02\x02\x02\u1123\u10C7\x03\x02\x02\x02\u1123\u10CC\x03\x02\x02\x02" + - "\u1123\u10CF\x03\x02\x02\x02\u1123\u10D9\x03\x02\x02\x02\u1123\u10E4\x03" + - "\x02\x02\x02\u1123\u10EB\x03\x02\x02\x02\u1123\u10F2\x03\x02\x02\x02\u1123" + - "\u10F9\x03\x02\x02\x02\u1123\u1100\x03\x02\x02\x02\u1123\u1107\x03\x02" + - "\x02\x02\u1123\u110C\x03\x02\x02\x02\u1123\u1114\x03\x02\x02\x02\u1123" + - "\u111A\x03\x02\x02\x02\u1124\u01CB\x03\x02\x02\x02\u1125\u1126\x07\x04" + - "\x02\x02\u1126\u1127\x05\u01CE\xE8\x02\u1127\u1128\x07\x05\x02\x02\u1128" + - "\u01CD\x03\x02\x02\x02\u1129\u112E\x05\u01D0\xE9\x02\u112A\u112B\x07\b" + - "\x02\x02\u112B\u112D\x05\u01D0\xE9\x02\u112C\u112A\x03\x02\x02\x02\u112D" + - "\u1130\x03\x02\x02\x02\u112E\u112C\x03\x02\x02\x02\u112E\u112F\x03\x02" + - "\x02\x02\u112F\u01CF\x03\x02\x02\x02\u1130\u112E\x03\x02\x02\x02\u1131" + - "\u1134\x05\u0556\u02AC\x02\u1132\u1133\x07\f\x02\x02\u1133\u1135\x05\u01D2" + - "\xEA\x02\u1134\u1132\x03\x02\x02\x02\u1134\u1135\x03\x02\x02\x02\u1135" + - "\u01D1\x03\x02\x02\x02\u1136\u113D\x05\u0280\u0141\x02\u1137\u113D\x05" + - "\u0562\u02B2\x02\u1138\u113D\x05\u04F0\u0279\x02\u1139\u113D\x05\u0124" + - "\x93\x02\u113A\u113D\x05\u0542\u02A2\x02\u113B\u113D\x07\u0190\x02\x02" + - "\u113C\u1136\x03\x02\x02\x02\u113C\u1137\x03\x02\x02\x02\u113C\u1138\x03" + - "\x02\x02\x02\u113C\u1139\x03\x02\x02\x02\u113C\u113A\x03\x02\x02\x02\u113C" + - "\u113B\x03\x02\x02\x02\u113D\u01D3\x03\x02\x02\x02\u113E\u113F\x07\x04" + - "\x02\x02\u113F\u1140\x05\u01D6\xEC\x02\u1140\u1141\x07\x05\x02\x02\u1141" + - "\u01D5\x03\x02\x02\x02\u1142\u1147\x05\u01D8\xED\x02\u1143\u1144\x07\b" + - "\x02\x02\u1144\u1146\x05\u01D8\xED\x02\u1145\u1143\x03\x02\x02\x02\u1146" + - "\u1149\x03\x02\x02\x02\u1147\u1145\x03\x02\x02\x02\u1147\u1148\x03\x02" + - "\x02\x02\u1148\u01D7\x03\x02\x02\x02\u1149\u1147\x03\x02\x02\x02\u114A" + - "\u114B\x05\u0558\u02AD\x02\u114B\u114C\x07\f\x02\x02\u114C\u114D\x05\u01D2" + - "\xEA\x02\u114D\u01D9\x03\x02\x02\x02\u114E\u114F\x05\u01DC\xEF\x02\u114F" + - "\u01DB\x03\x02\x02\x02\u1150\u1155\x05\u0542\u02A2\x02\u1151\u1152\x07" + - "\b\x02\x02\u1152\u1154\x05\u0542\u02A2\x02\u1153\u1151\x03\x02\x02\x02" + - "\u1154\u1157\x03\x02\x02\x02\u1155\u1153\x03\x02\x02\x02\u1155\u1156\x03" + - "\x02\x02\x02\u1156\u01DD\x03\x02\x02\x02\u1157\u1155\x03\x02\x02\x02\u1158" + - "\u1159\x07\x8C\x02\x02\u1159\u115A\x07\u0161\x02\x02\u115A\u115B\x05\u020C" + - "\u0107\x02\u115B\u115C\x07\x87\x02\x02\u115C\u115E\x07\u01BB\x02\x02\u115D" + - "\u115F\x05\u01E0\xF1\x02\u115E\u115D\x03\x02\x02\x02\u115E\u115F\x03\x02" + - "\x02\x02\u115F\u1160\x03\x02\x02\x02\u1160\u1161\x05\u0542\u02A2\x02\u1161" + - "\u1184\x03\x02\x02\x02\u1162\u1163\x07\x8C\x02\x02\u1163\u1164\x07\u0161" + - "\x02\x02\u1164\u1165\x05\u020C\u0107\x02\u1165\u1166\x07\x87\x02\x02\u1166" + - "\u1168\x07\u01BB\x02\x02\u1167\u1169\x05\u01E0\xF1\x02\u1168\u1167\x03" + - "\x02\x02\x02\u1168\u1169\x03\x02\x02\x02\u1169\u116A\x03\x02\x02\x02\u116A" + - "\u116B\x05\u0542\u02A2\x02\u116B\u116C\x07\x93\x02\x02\u116C\u116D\x05" + - "\u0542\u02A2\x02\u116D\u1184\x03\x02\x02\x02\u116E\u116F\x07\x8C\x02\x02" + - "\u116F\u1170\x07\u0161\x02\x02\u1170\u1171\x05\u020C\u0107\x02\u1171\u1172" + - "\x07\x87\x02\x02\u1172\u1174\x07\u01BB\x02\x02\u1173\u1175\x05\u01E0\xF1" + - "\x02\u1174\u1173\x03\x02\x02\x02\u1174\u1175\x03\x02\x02\x02\u1175\u1176" + - "\x03\x02\x02\x02\u1176\u1177\x05\u0542\u02A2\x02\u1177\u1178\x07\x89\x02" + - "\x02\u1178\u1179\x05\u0542\u02A2\x02\u1179\u1184\x03\x02\x02\x02\u117A" + - "\u117B\x07\x8C\x02\x02\u117B\u117C\x07\u0161\x02\x02\u117C\u117D\x05\u020C" + - "\u0107\x02\u117D\u117E\x07\u012E\x02\x02\u117E\u117F\x07\u01BB\x02\x02" + - "\u117F\u1180\x05\u0542\u02A2\x02\u1180\u1181\x07`\x02\x02\u1181\u1182" + - "\x05\u0542\u02A2\x02\u1182\u1184\x03\x02\x02\x02\u1183\u1158\x03\x02\x02" + - "\x02\u1183\u1162\x03\x02\x02\x02\u1183\u116E\x03\x02\x02\x02\u1183\u117A" + - "\x03\x02\x02\x02\u1184\u01DF\x03\x02\x02\x02\u1185\u1186\x07\xDE\x02\x02" + - "\u1186\u1187\x07O\x02\x02\u1187\u1188\x07\u0185\x02\x02\u1188\u01E1\x03" + - "\x02\x02\x02\u1189\u118A\x070\x02\x02\u118A\u118B\x07\u010F\x02\x02\u118B" + - "\u118C\x07\x9E\x02\x02\u118C\u118E\x05\u020C\u0107\x02\u118D\u118F\x05" + - "\u01E8\xF5\x02\u118E\u118D\x03\x02\x02\x02\u118E\u118F\x03\x02\x02\x02" + - "\u118F\u1190\x03\x02\x02\x02\u1190\u1191\x07@\x02\x02\u1191\u1192\x07" + - "\u0161\x02\x02\u1192\u1193\x05\u0454\u022B\x02\u1193\u1194\x07f\x02\x02" + - "\u1194\u1196\x05\u0530\u0299\x02\u1195\u1197\x05\u01EA\xF6\x02\u1196\u1195" + - "\x03\x02\x02\x02\u1196\u1197\x03\x02\x02\x02\u1197\u1198\x03\x02\x02\x02" + - "\u1198\u1199\x07&\x02\x02\u1199\u119A\x05\u01E4\xF3\x02\u119A\u01E3\x03" + - "\x02\x02\x02\u119B\u11A0\x05\u01E6\xF4\x02\u119C\u119D\x07\b\x02\x02\u119D" + - "\u119F\x05\u01E6\xF4\x02\u119E\u119C\x03\x02\x02\x02\u119F\u11A2\x03\x02" + - "\x02\x02\u11A0\u119E\x03\x02\x02\x02\u11A0\u11A1\x03\x02\x02\x02\u11A1" + - "\u01E5\x03\x02\x02\x02\u11A2\u11A0\x03\x02\x02\x02\u11A3\u11A4\x07\u010F" + - "\x02\x02\u11A4\u11A5\x05\u0540\u02A1\x02\u11A5\u11A7\x05\u02AC\u0157\x02" + - "\u11A6\u11A8\x05\u01EC\xF7\x02\u11A7\u11A6\x03\x02\x02\x02\u11A7\u11A8" + - "\x03\x02\x02\x02\u11A8\u11AA\x03\x02\x02\x02\u11A9\u11AB\x05\u01EE\xF8" + - "\x02\u11AA\u11A9\x03\x02\x02\x02\u11AA\u11AB\x03\x02\x02\x02\u11AB\u11C3" + - "\x03\x02\x02\x02\u11AC\u11AD\x07\u010F\x02\x02\u11AD\u11AE\x05\u0540\u02A1" + - "\x02\u11AE\u11B0\x05\u02B0\u0159\x02\u11AF\u11B1\x05\u01EC\xF7\x02\u11B0" + - "\u11AF\x03\x02\x02\x02\u11B0\u11B1\x03\x02\x02\x02\u11B1\u11B3\x03\x02" + - "\x02\x02\u11B2\u11B4\x05\u01EE\xF8\x02\u11B3\u11B2\x03\x02\x02\x02\u11B3" + - "\u11B4\x03\x02\x02\x02\u11B4\u11C3\x03\x02\x02\x02\u11B5\u11B6\x07\xD5" + - "\x02\x02\u11B6\u11B7\x05\u0540\u02A1\x02\u11B7\u11B8\x05\u0272\u013A\x02" + - "\u11B8\u11C3\x03\x02\x02\x02\u11B9\u11BA\x07\xD5\x02\x02\u11BA\u11BB\x05" + - "\u0540\u02A1\x02\u11BB\u11BC\x07\x04\x02\x02\u11BC\u11BD\x05\u04FA\u027E" + - "\x02\u11BD\u11BE\x07\x05\x02\x02\u11BE\u11BF\x05\u0272\u013A\x02\u11BF" + - "\u11C3\x03\x02\x02\x02\u11C0\u11C1\x07\u0152\x02\x02\u11C1\u11C3\x05\u0454" + - "\u022B\x02\u11C2\u11A3\x03\x02\x02\x02\u11C2\u11AC\x03\x02\x02\x02\u11C2" + - "\u11B5\x03\x02\x02\x02\u11C2\u11B9\x03\x02\x02\x02\u11C2\u11C0\x03\x02" + - "\x02\x02\u11C3\u01E7\x03\x02\x02\x02\u11C4\u11C5\x077\x02\x02\u11C5\u01E9" + - "\x03\x02\x02\x02\u11C6\u11C7\x07\xD0\x02\x02\u11C7\u11C8\x05\u020C\u0107" + - "\x02\u11C8\u01EB\x03\x02\x02\x02\u11C9\u11CA\x07@\x02\x02\u11CA\u11D0" + - "\x07\u013E\x02\x02\u11CB\u11CC\x07@\x02\x02\u11CC\u11CD\x07U\x02\x02\u11CD" + - "\u11CE\x07\x95\x02\x02\u11CE\u11D0\x05\u020C\u0107\x02\u11CF\u11C9\x03" + - "\x02\x02\x02\u11CF\u11CB\x03\x02\x02\x02\u11D0\u01ED\x03\x02\x02\x02\u11D1" + - "\u11D2\x07\u0127\x02\x02\u11D2\u01EF\x03\x02\x02\x02\u11D3\u11D4\x070" + - "\x02\x02\u11D4\u11D5\x07\u010F\x02\x02\u11D5\u11D6\x07\xD0\x02\x02\u11D6" + - "\u11D7\x05\u020C\u0107\x02\u11D7\u11D8\x07f\x02\x02\u11D8\u11D9\x05\u0530" + - "\u0299\x02\u11D9\u01F1\x03\x02\x02\x02\u11DA\u11DB\x07\x8C\x02\x02\u11DB" + - "\u11DC\x07\u010F\x02\x02\u11DC\u11DD\x07\xD0\x02\x02\u11DD\u11DE\x05\u020C" + - "\u0107\x02\u11DE\u11DF\x07f\x02\x02\u11DF\u11E0\x05\u0530\u0299\x02\u11E0" + - "\u11E1\x07\x87\x02\x02\u11E1\u11E2\x05\u01E4\xF3\x02\u11E2\u11ED\x03\x02" + - "\x02\x02\u11E3\u11E4\x07\x8C\x02\x02\u11E4\u11E5\x07\u010F\x02\x02\u11E5" + - "\u11E6\x07\xD0\x02\x02\u11E6\u11E7\x05\u020C\u0107\x02\u11E7\u11E8\x07" + - "f\x02\x02\u11E8\u11E9\x05\u0530\u0299\x02\u11E9\u11EA\x07\xC1\x02\x02" + - "\u11EA\u11EB\x05\u01F4\xFB\x02\u11EB\u11ED\x03\x02\x02\x02\u11EC\u11DA" + - "\x03\x02\x02\x02\u11EC\u11E3\x03\x02\x02\x02\u11ED\u01F3\x03\x02\x02\x02" + - "\u11EE\u11F3\x05\u01F6\xFC\x02\u11EF\u11F0\x07\b\x02\x02\u11F0\u11F2\x05" + - "\u01F6\xFC\x02\u11F1\u11EF\x03\x02\x02\x02\u11F2\u11F5\x03\x02\x02\x02" + - "\u11F3\u11F1\x03\x02\x02\x02\u11F3\u11F4\x03\x02\x02\x02\u11F4\u01F5\x03" + - "\x02\x02\x02\u11F5\u11F3\x03\x02\x02\x02\u11F6\u11F7\x07\u010F\x02\x02" + - "\u11F7\u11F8\x05\u0540\u02A1\x02\u11F8\u11F9\x07\x04\x02\x02\u11F9\u11FA" + - "\x05\u04FA\u027E\x02\u11FA\u11FB\x07\x05\x02\x02\u11FB\u1203\x03\x02\x02" + - "\x02\u11FC\u11FD\x07\xD5\x02\x02\u11FD\u11FE\x05\u0540\u02A1\x02\u11FE" + - "\u11FF\x07\x04\x02\x02\u11FF\u1200\x05\u04FA\u027E\x02\u1200\u1201\x07" + - "\x05\x02\x02\u1201\u1203\x03\x02\x02\x02\u1202\u11F6\x03\x02\x02\x02\u1202" + - "\u11FC\x03\x02\x02\x02\u1203\u01F7\x03\x02\x02\x02\u1204\u1205\x07\xC1" + - "\x02\x02\u1205\u1206\x07\u010F\x02\x02\u1206\u1207\x07\x9E\x02\x02\u1207" + - "\u1208\x05\u020C\u0107\x02\u1208\u1209\x07f\x02\x02\u1209\u120B\x05\u0530" + - "\u0299\x02\u120A\u120C\x05l7\x02\u120B\u120A\x03\x02\x02\x02\u120B\u120C" + - "\x03\x02\x02\x02\u120C\u1219\x03\x02\x02\x02\u120D\u120E\x07\xC1\x02\x02" + - "\u120E\u120F\x07\u010F\x02\x02\u120F\u1210\x07\x9E\x02\x02\u1210\u1211" + - "\x07\xDE\x02\x02\u1211\u1212\x07\u0185\x02\x02\u1212\u1213\x05\u020C\u0107" + - "\x02\u1213\u1214\x07f\x02\x02\u1214\u1216\x05\u0530\u0299\x02\u1215\u1217" + - "\x05l7\x02\u1216\u1215\x03\x02\x02\x02\u1216\u1217\x03\x02\x02\x02\u1217" + - "\u1219\x03\x02\x02\x02\u1218\u1204\x03\x02\x02\x02\u1218\u120D\x03\x02" + - "\x02\x02\u1219\u01F9\x03\x02\x02\x02\u121A\u121B\x07\xC1\x02\x02\u121B" + - "\u121C\x07\u010F\x02\x02\u121C\u121D\x07\xD0\x02\x02\u121D\u121E\x05\u020C" + - "\u0107\x02\u121E\u121F\x07f\x02\x02\u121F\u1221\x05\u0530\u0299\x02\u1220" + - "\u1222\x05l7\x02\u1221\u1220\x03\x02\x02\x02\u1221\u1222\x03\x02\x02\x02" + - "\u1222\u122F\x03\x02\x02\x02\u1223\u1224\x07\xC1\x02\x02\u1224\u1225\x07" + - "\u010F\x02\x02\u1225\u1226\x07\xD0\x02\x02\u1226\u1227\x07\xDE\x02\x02" + - "\u1227\u1228\x07\u0185\x02\x02\u1228\u1229\x05\u020C\u0107\x02\u1229\u122A" + - "\x07f\x02\x02\u122A\u122C\x05\u0530\u0299\x02\u122B\u122D\x05l7\x02\u122C" + - "\u122B\x03\x02\x02\x02\u122C\u122D\x03\x02\x02\x02\u122D\u122F\x03\x02" + - "\x02\x02\u122E\u121A\x03\x02\x02\x02\u122E\u1223\x03\x02\x02\x02\u122F" + - "\u01FB\x03\x02\x02\x02\u1230\u1231\x07\xC1\x02\x02\u1231\u1232\x07\u0112" + - "\x02\x02\u1232\u1233\x07\x95\x02\x02\u1233\u1235\x05\u054E\u02A8\x02\u1234" + - "\u1236\x05l7\x02\u1235\u1234\x03\x02\x02\x02\u1235\u1236\x03\x02\x02\x02" + - "\u1236\u01FD\x03\x02\x02\x02\u1237\u1238\x07\u0126\x02\x02\u1238\u1239" + - "\x07\u0112\x02\x02\u1239\u123A\x07\x95\x02\x02\u123A\u123B\x05\u054E\u02A8" + - "\x02\u123B\u123C\x07`\x02\x02\u123C\u123D\x05\u054C\u02A7\x02\u123D\u01FF" + - "\x03\x02\x02\x02\u123E\u123F\x07\xC1\x02\x02\u123F\u1240\x05\u0202\u0102" + - "\x02\u1240\u1241\x07\xDE\x02\x02\u1241\u1242\x07\u0185\x02\x02\u1242\u1244" + - "\x05\u020A\u0106\x02\u1243\u1245\x05l7\x02\u1244\u1243\x03\x02\x02\x02" + - "\u1244\u1245\x03\x02\x02\x02\u1245\u1299\x03\x02\x02\x02\u1246\u1247\x07" + - "\xC1\x02\x02\u1247\u1248\x05\u0202\u0102\x02\u1248\u124A\x05\u020A\u0106" + - "\x02\u1249\u124B\x05l7\x02\u124A\u1249\x03\x02\x02\x02\u124A\u124B\x03" + - "\x02\x02\x02\u124B\u1299\x03\x02\x02\x02\u124C\u124D\x07\xC1\x02\x02\u124D" + - "\u124E\x05\u0206\u0104\x02\u124E\u124F\x07\xDE\x02\x02\u124F\u1250\x07" + - "\u0185\x02\x02\u1250\u1252\x05\u052E\u0298\x02\u1251\u1253\x05l7\x02\u1252" + - "\u1251\x03\x02\x02\x02\u1252\u1253\x03\x02\x02\x02\u1253\u1299\x03\x02" + - "\x02\x02\u1254\u1255\x07\xC1\x02\x02\u1255\u1256\x05\u0206\u0104\x02\u1256" + - "\u1258\x05\u052E\u0298\x02\u1257\u1259\x05l7\x02\u1258\u1257\x03\x02\x02" + - "\x02\u1258\u1259\x03\x02\x02\x02\u1259\u1299\x03\x02\x02\x02\u125A\u125B" + - "\x07\xC1\x02\x02\u125B\u125C\x05\u0208\u0105\x02\u125C\u125D\x05\u0530" + - "\u0299\x02\u125D\u125E\x07R\x02\x02\u125E\u1260\x05\u020C\u0107\x02\u125F" + - "\u1261\x05l7\x02\u1260\u125F\x03\x02\x02\x02\u1260\u1261\x03\x02\x02\x02" + - "\u1261\u1299\x03\x02\x02\x02\u1262\u1263\x07\xC1\x02\x02\u1263\u1264\x05" + - "\u0208\u0105\x02\u1264\u1265\x07\xDE\x02\x02\u1265\u1266\x07\u0185\x02" + - "\x02\u1266\u1267\x05\u0530\u0299\x02\u1267\u1268\x07R\x02\x02\u1268\u126A" + - "\x05\u020C\u0107\x02\u1269\u126B\x05l7\x02\u126A\u1269\x03\x02\x02\x02" + - "\u126A\u126B\x03\x02\x02\x02\u126B\u1299\x03\x02\x02\x02\u126C\u126D\x07" + - "\xC1\x02\x02\u126D\u126E\x07\u0161\x02\x02\u126E\u1270\x05\u0210\u0109" + - "\x02\u126F\u1271\x05l7\x02\u1270\u126F\x03\x02\x02\x02\u1270\u1271\x03" + - "\x02\x02\x02\u1271\u1299\x03\x02\x02\x02\u1272\u1273\x07\xC1\x02\x02\u1273" + - "\u1274\x07\u0161\x02\x02\u1274\u1275\x07\xDE\x02\x02\u1275\u1276\x07\u0185" + - "\x02\x02\u1276\u1278\x05\u0210\u0109\x02\u1277\u1279\x05l7\x02\u1278\u1277" + - "\x03\x02\x02\x02\u1278\u1279\x03\x02\x02\x02\u1279\u1299\x03\x02\x02\x02" + - "\u127A\u127B\x07\xC1\x02\x02\u127B\u127C\x07\xBF\x02\x02\u127C\u127E\x05" + - "\u0210\u0109\x02\u127D\u127F\x05l7\x02\u127E\u127D\x03\x02\x02\x02\u127E" + - "\u127F\x03\x02\x02\x02\u127F\u1299\x03\x02\x02\x02\u1280\u1281\x07\xC1" + - "\x02\x02\u1281\u1282\x07\xBF\x02\x02\u1282\u1283\x07\xDE\x02\x02\u1283" + - "\u1284\x07\u0185\x02\x02\u1284\u1286\x05\u0210\u0109\x02\u1285\u1287\x05" + - "l7\x02\u1286\u1285\x03\x02\x02\x02\u1286\u1287\x03\x02\x02\x02\u1287\u1299" + - "\x03\x02\x02\x02\u1288\u1289\x07\xC1\x02\x02\u1289\u128A\x07\xE4\x02\x02" + - "\u128A\u128B\x07o\x02\x02\u128B\u128D\x05\u020A\u0106\x02\u128C\u128E" + - "\x05l7\x02\u128D\u128C\x03\x02\x02\x02\u128D\u128E\x03\x02\x02\x02\u128E" + - "\u1299\x03\x02\x02\x02\u128F\u1290\x07\xC1\x02\x02\u1290\u1291\x07\xE4" + - "\x02\x02\u1291\u1292\x07o\x02\x02\u1292\u1293\x07\xDE\x02\x02\u1293\u1294" + - "\x07\u0185\x02\x02\u1294\u1296\x05\u020A\u0106\x02\u1295\u1297\x05l7\x02" + - "\u1296\u1295\x03\x02\x02\x02\u1296\u1297\x03\x02\x02\x02\u1297\u1299\x03" + - "\x02\x02\x02\u1298\u123E\x03\x02\x02\x02\u1298\u1246\x03\x02\x02\x02\u1298" + - "\u124C\x03\x02\x02\x02\u1298\u1254\x03\x02\x02\x02\u1298\u125A\x03\x02" + - "\x02\x02\u1298\u1262\x03\x02\x02\x02\u1298\u126C\x03\x02\x02\x02\u1298" + - "\u1272\x03\x02\x02\x02\u1298\u127A\x03\x02\x02\x02\u1298\u1280\x03\x02" + - "\x02\x02\u1298\u1288\x03\x02\x02\x02\u1298\u128F\x03\x02\x02\x02\u1299" + - "\u0201\x03\x02\x02\x02\u129A\u12B2\x07^\x02\x02\u129B\u12B2\x07\u0141" + - "\x02\x02\u129C\u12B2\x07\u0171\x02\x02\u129D\u129E\x07\xFC\x02\x02\u129E" + - "\u12B2\x07\u0171\x02\x02\u129F\u12B2\x07\xE4\x02\x02\u12A0\u12A1\x07A" + - "\x02\x02\u12A1\u12B2\x07^\x02\x02\u12A2\u12B2\x07n\x02\x02\u12A3\u12B2" + - "\x07\xAA\x02\x02\u12A4\u12B2\x07\u014F\x02\x02\u12A5\u12A6\x07\u015C\x02" + - "\x02\u12A6\u12A7\x07\u013E\x02\x02\u12A7\u12B2\x07\u0114\x02\x02\u12A8" + - "\u12A9\x07\u015C\x02\x02\u12A9\u12AA\x07\u013E\x02\x02\u12AA\u12B2\x07" + - "\xBB\x02\x02\u12AB\u12AC\x07\u015C\x02\x02\u12AC\u12AD\x07\u013E\x02\x02" + - "\u12AD\u12B2\x07\u015A\x02\x02\u12AE\u12AF\x07\u015C\x02\x02\u12AF\u12B0" + - "\x07\u013E\x02\x02\u12B0\u12B2\x07\xA5\x02\x02\u12B1\u129A\x03\x02\x02" + - "\x02\u12B1\u129B\x03\x02\x02\x02\u12B1\u129C\x03\x02\x02\x02\u12B1\u129D" + - "\x03\x02\x02\x02\u12B1\u129F\x03\x02\x02\x02\u12B1\u12A0\x03\x02\x02\x02" + - "\u12B1\u12A2\x03\x02\x02\x02\u12B1\u12A3\x03\x02\x02\x02\u12B1\u12A4\x03" + - "\x02\x02\x02\u12B1\u12A5\x03\x02\x02\x02\u12B1\u12A8\x03\x02\x02\x02\u12B1" + - "\u12AB\x03\x02\x02\x02\u12B1\u12AE\x03\x02\x02\x02\u12B2\u0203\x03\x02" + - "\x02\x02\u12B3\u12B9\x05\u0206\u0104\x02\u12B4\u12B9\x07\xB1\x02\x02\u12B5" + - "\u12B9\x07\u0137\x02\x02\u12B6\u12B9\x07\u01BC\x02\x02\u12B7\u12B9\x07" + - "\u0158\x02\x02\u12B8\u12B3\x03\x02\x02\x02\u12B8\u12B4\x03\x02\x02\x02" + - "\u12B8\u12B5\x03\x02\x02\x02\u12B8\u12B6\x03\x02\x02\x02\u12B8\u12B7\x03" + - "\x02\x02\x02\u12B9\u0205\x03\x02\x02\x02\u12BA\u12BB\x07\x85\x02\x02\u12BB" + - "\u12CA\x07\u01B7\x02\x02\u12BC\u12BD\x07\xC8\x02\x02\u12BD\u12CA\x07\u015E" + - "\x02\x02\u12BE\u12CA\x07\xCE\x02\x02\u12BF\u12C0\x07A\x02\x02\u12C0\u12C1" + - "\x07\xB0\x02\x02\u12C1\u12CA\x07\u0176\x02\x02\u12C2\u12C4\x05\u0134\x9B" + - "\x02\u12C3\u12C2\x03\x02\x02\x02\u12C3\u12C4\x03\x02\x02\x02\u12C4\u12C5" + - "\x03\x02\x02\x02\u12C5\u12CA\x07\xF0\x02\x02\u12C6\u12CA\x07\u01BD\x02" + - "\x02\u12C7\u12CA\x07\u013C\x02\x02\u12C8\u12CA\x07\u0144\x02\x02\u12C9" + - "\u12BA\x03\x02\x02\x02\u12C9\u12BC\x03\x02\x02\x02\u12C9\u12BE\x03\x02" + - "\x02\x02\u12C9\u12BF\x03\x02\x02\x02\u12C9\u12C3\x03\x02\x02\x02\u12C9" + - "\u12C6\x03\x02\x02\x02\u12C9\u12C7\x03\x02\x02\x02\u12C9\u12C8\x03\x02" + - "\x02\x02\u12CA\u0207\x03\x02\x02\x02\u12CB\u12CC\t\x1A\x02\x02\u12CC\u0209" + - "\x03\x02\x02\x02\u12CD\u12D2\x05\u020C\u0107\x02\u12CE\u12CF\x07\b\x02" + - "\x02\u12CF\u12D1\x05\u020C\u0107\x02\u12D0\u12CE\x03\x02\x02\x02\u12D1" + - "\u12D4\x03\x02\x02\x02\u12D2\u12D0\x03\x02\x02\x02\u12D2\u12D3\x03\x02" + - "\x02\x02\u12D3\u020B\x03\x02\x02\x02\u12D4\u12D2\x03\x02\x02\x02\u12D5" + - "\u12D7\x05\u0550\u02A9\x02\u12D6\u12D8\x05\u020E\u0108\x02\u12D7\u12D6" + - "\x03\x02\x02\x02\u12D7\u12D8\x03\x02\x02\x02\u12D8\u020D\x03\x02\x02\x02" + - "\u12D9\u12DA\x07\r\x02\x02\u12DA\u12DC\x05\u0532\u029A\x02\u12DB\u12D9" + - "\x03\x02\x02\x02\u12DC\u12DD\x03\x02\x02\x02\u12DD\u12DB\x03\x02\x02\x02" + - "\u12DD\u12DE\x03\x02\x02\x02\u12DE\u020F\x03\x02\x02\x02\u12DF\u12E4\x05" + - "\u0454\u022B\x02\u12E0\u12E1\x07\b\x02\x02\u12E1\u12E3\x05\u0454\u022B" + - "\x02\u12E2\u12E0\x03\x02\x02\x02\u12E3\u12E6\x03\x02\x02\x02\u12E4\u12E2" + - "\x03\x02\x02\x02\u12E4\u12E5\x03\x02\x02\x02\u12E5\u0211\x03\x02\x02\x02" + - "\u12E6\u12E4\x03\x02\x02\x02\u12E7\u12E9\x07\u015F\x02\x02\u12E8\u12EA" + - "\x05\u03D6\u01EC\x02\u12E9\u12E8\x03\x02\x02\x02\u12E9\u12EA\x03\x02\x02" + - "\x02\u12EA\u12EB\x03\x02\x02\x02\u12EB\u12ED\x05\u042A\u0216\x02\u12EC" + - "\u12EE\x05\u0214\u010B\x02\u12ED\u12EC\x03\x02\x02\x02\u12ED\u12EE\x03" + - "\x02\x02\x02\u12EE\u12F0\x03\x02\x02\x02\u12EF\u12F1\x05l7\x02\u12F0\u12EF" + - "\x03\x02\x02\x02\u12F0\u12F1\x03\x02\x02\x02\u12F1\u0213\x03\x02\x02\x02" + - "\u12F2\u12F3\x07\xA9\x02\x02\u12F3\u12F7\x07\xDD\x02\x02\u12F4\u12F5\x07" + - "\u0133\x02\x02\u12F5\u12F7\x07\xDD\x02\x02\u12F6\u12F2\x03\x02\x02\x02" + - "\u12F6\u12F4\x03\x02\x02\x02\u12F7\u0215\x03\x02\x02\x02\u12F8\u12F9\x07" + - "\xA1\x02\x02\u12F9\u12FA\x07R\x02\x02\u12FA\u12FB\x05\u0202\u0102\x02" + - "\u12FB\u12FC\x05\u020C\u0107\x02\u12FC\u12FD\x07v\x02\x02\u12FD\u12FE" + - "\x05\u0218\u010D\x02\u12FE\u138C\x03\x02\x02\x02\u12FF\u1300\x07\xA1\x02" + - "\x02\u1300\u1301\x07R\x02\x02\u1301\u1302\x07.\x02\x02\u1302\u1303\x05" + - "\u020C\u0107\x02\u1303\u1304\x07v\x02\x02\u1304\u1305\x05\u0218\u010D" + - "\x02\u1305\u138C\x03\x02\x02\x02\u1306\u1307\x07\xA1\x02\x02\u1307\u1308" + - "\x07R\x02\x02\u1308\u1309\x05\u0204\u0103\x02\u1309\u130A\x05\u0530\u0299" + - "\x02\u130A\u130B\x07v\x02\x02\u130B\u130C\x05\u0218\u010D\x02\u130C\u138C" + - "\x03\x02\x02\x02\u130D\u130E\x07\xA1\x02\x02\u130E\u130F\x07R\x02\x02" + - "\u130F\u1310\x07\u0161\x02\x02\u1310\u1311\x05\u0454\u022B\x02\u1311\u1312" + - "\x07v\x02\x02\u1312\u1313\x05\u0218\u010D\x02\u1313\u138C\x03\x02\x02" + - "\x02\u1314\u1315\x07\xA1\x02\x02\u1315\u1316\x07R\x02\x02\u1316\u1317" + - "\x07\xBF\x02\x02\u1317\u1318\x05\u0454\u022B\x02\u1318\u1319\x07v\x02" + - "\x02\u1319\u131A\x05\u0218\u010D\x02\u131A\u138C\x03\x02\x02\x02\u131B" + - "\u131C\x07\xA1\x02\x02\u131C\u131D\x07R\x02\x02\u131D\u131E\x07\x8A\x02" + - "\x02\u131E\u131F\x05\u028A\u0146\x02\u131F\u1320\x07v\x02\x02\u1320\u1321" + - "\x05\u0218\u010D\x02\u1321\u138C\x03\x02\x02\x02\u1322\u1323\x07\xA1\x02" + - "\x02\u1323\u1324\x07R\x02\x02\u1324\u1325\x07\xD5\x02\x02\u1325\u1326" + - "\x05\u0272\u013A\x02\u1326\u1327\x07v\x02\x02\u1327\u1328\x05\u0218\u010D" + - "\x02\u1328\u138C\x03\x02\x02\x02\u1329\u132A\x07\xA1\x02\x02\u132A\u132B" + - "\x07R\x02\x02\u132B\u132C\x07\u010F\x02\x02\u132C\u132D\x05\u02B0\u0159" + - "\x02\u132D\u132E\x07v\x02\x02\u132E\u132F\x05\u0218\u010D\x02\u132F\u138C" + - "\x03\x02\x02\x02\u1330\u1331\x07\xA1\x02\x02\u1331\u1332\x07R\x02\x02" + - "\u1332\u1333\x07/\x02\x02\u1333\u1334\x05\u0530\u0299\x02\u1334\u1335" + - "\x07R\x02\x02\u1335\u1336\x05\u020C\u0107\x02\u1336\u1337\x07v\x02\x02" + - "\u1337\u1338\x05\u0218\u010D\x02\u1338\u138C\x03\x02\x02\x02\u1339\u133A" + - "\x07\xA1\x02\x02\u133A\u133B\x07R\x02\x02\u133B\u133C\x07/\x02\x02\u133C" + - "\u133D\x05\u0530\u0299\x02\u133D\u133E\x07R\x02\x02\u133E\u133F\x07\xBF" + - "\x02\x02\u133F\u1340\x05\u020C\u0107\x02\u1340\u1341\x07v\x02\x02\u1341" + - "\u1342\x05\u0218\u010D\x02\u1342\u138C\x03\x02\x02\x02\u1343\u1344\x07" + - "\xA1\x02\x02\u1344\u1345\x07R\x02\x02\u1345\u1346\x05\u0208\u0105\x02" + - "\u1346\u1347\x05\u0530\u0299\x02\u1347\u1348\x07R\x02\x02\u1348\u1349" + - "\x05\u020C\u0107\x02\u1349\u134A\x07v\x02\x02\u134A\u134B\x05\u0218\u010D" + - "\x02\u134B\u138C\x03\x02\x02\x02\u134C\u134D\x07\xA1\x02\x02\u134D\u134E" + - "\x07R\x02\x02\u134E\u134F\x07\u0121\x02\x02\u134F\u1350\x05\u0272\u013A" + - "\x02\u1350\u1351\x07v\x02\x02\u1351\u1352\x05\u0218\u010D\x02\u1352\u138C" + - "\x03\x02\x02\x02\u1353\u1354\x07\xA1\x02\x02\u1354\u1355\x07R\x02\x02" + - "\u1355\u1356\x07\u01B3\x02\x02\u1356\u1357\x05\u0272\u013A\x02\u1357\u1358" + - "\x07v\x02\x02\u1358\u1359\x05\u0218\u010D\x02\u1359\u138C\x03\x02\x02" + - "\x02\u135A\u135B\x07\xA1\x02\x02\u135B\u135C\x07R\x02\x02\u135C\u135D" + - "\x07\u01B4\x02\x02\u135D\u135E\x07@\x02\x02\u135E\u135F\x05\u0454\u022B" + - "\x02\u135F\u1360\x07\xF0\x02\x02\u1360\u1361\x05\u0530\u0299\x02\u1361" + - "\u1362\x07v\x02\x02\u1362\u1363\x05\u0218\u010D\x02\u1363\u138C\x03\x02" + - "\x02\x02\u1364\u1365\x07\xA1\x02\x02\u1365\u1366\x07R\x02\x02\u1366\u1367" + - "\x07\u010F\x02\x02\u1367\u1368\x07\x9E\x02\x02\u1368\u1369\x05\u020C\u0107" + - "\x02\u1369\u136A\x07f\x02\x02\u136A\u136B\x05\u0530\u0299\x02\u136B\u136C" + - "\x07v\x02\x02\u136C\u136D\x05\u0218\u010D\x02\u136D\u138C\x03\x02\x02" + - "\x02\u136E\u136F\x07\xA1\x02\x02\u136F\u1370\x07R\x02\x02\u1370\u1371" + - "\x07\u010F\x02\x02\u1371\u1372\x07\xD0\x02\x02\u1372\u1373\x05\u020C\u0107" + - "\x02\u1373\u1374\x07f\x02\x02\u1374\u1375\x05\u0530\u0299\x02\u1375\u1376" + - "\x07v\x02\x02\u1376\u1377\x05\u0218\u010D\x02\u1377\u138C\x03\x02\x02" + - "\x02\u1378\u1379\x07\xA1\x02\x02\u1379\u137A\x07R\x02\x02\u137A\u137B" + - "\x07\xF1\x02\x02\u137B\u137C\x07\u010B\x02\x02\u137C\u137D\x05\u0124\x93" + - "\x02\u137D\u137E\x07v\x02\x02\u137E\u137F\x05\u0218\u010D\x02\u137F\u138C" + - "\x03\x02\x02\x02\u1380\u1381\x07\xA1\x02\x02\u1381\u1382\x07R\x02\x02" + - "\u1382\u1383\x07+\x02\x02\u1383\u1384\x07\x04\x02\x02\u1384\u1385\x05" + - "\u0454\u022B\x02\u1385\u1386\x07&\x02\x02\u1386\u1387\x05\u0454\u022B" + - "\x02\u1387\u1388\x07\x05\x02\x02\u1388\u1389\x07v\x02\x02\u1389\u138A" + - "\x05\u0218\u010D\x02\u138A\u138C\x03\x02\x02\x02\u138B\u12F8\x03\x02\x02" + - "\x02\u138B\u12FF\x03\x02\x02\x02\u138B\u1306\x03\x02\x02\x02\u138B\u130D" + - "\x03\x02\x02\x02\u138B\u1314\x03\x02\x02\x02\u138B\u131B\x03\x02\x02\x02" + - "\u138B\u1322\x03\x02\x02\x02\u138B\u1329\x03\x02\x02"; + "O\x02\x02\u1097\u10A2\x078\x02\x02\u1098\u10A2\x078\x02\x02\u1099\u109A" + + "\x07G\x02\x02\u109A\u10A2\x07\xDF\x02\x02\u109B\u109C\x07G\x02\x02\u109C" + + "\u10A2\x07\xB6\x02\x02\u109D\u109E\x07O\x02\x02\u109E\u10A2\x07\u0175" + + "\x02\x02\u109F\u10A0\x07\u010F\x02\x02\u10A0\u10A2\x07\xE6\x02\x02\u10A1" + + "\u1096\x03\x02\x02\x02\u10A1\u1098\x03\x02\x02\x02\u10A1\u1099\x03\x02" + + "\x02\x02\u10A1\u109B\x03\x02\x02\x02\u10A1\u109D\x03\x02\x02\x02\u10A1" + + "\u109F\x03\x02\x02\x02\u10A2\u01C3\x03\x02\x02\x02\u10A3\u10A4\x070\x02" + + "\x02\u10A4\u10A5\x07\xC8\x02\x02\u10A5\u10A6\x07\u0167\x02\x02\u10A6\u10A7" + + "\x05\u0540\u02A1\x02\u10A7\u10A8\x07R\x02\x02\u10A8\u10A9\x05\u0570\u02B9" + + "\x02\u10A9\u10AA\x07\xCC\x02\x02\u10AA\u10AB\x05\u01B8\xDD\x02\u10AB\u10AC" + + "\x05\u0546\u02A4\x02\u10AC\u10AD\x07\x04\x02\x02\u10AD\u10AE\x07\x05\x02" + + "\x02\u10AE\u10BE\x03\x02\x02\x02\u10AF\u10B0\x070\x02\x02\u10B0\u10B1" + + "\x07\xC8\x02\x02\u10B1\u10B2\x07\u0167\x02\x02\u10B2\u10B3\x05\u0540\u02A1" + + "\x02\u10B3\u10B4\x07R\x02\x02\u10B4\u10B5\x05\u0570\u02B9\x02\u10B5\u10B6" + + "\x07h\x02\x02\u10B6\u10B7\x05\u01C6\xE4\x02\u10B7\u10B8\x07\xCC\x02\x02" + + "\u10B8\u10B9\x05\u01B8\xDD\x02\u10B9\u10BA\x05\u0546\u02A4\x02\u10BA\u10BB" + + "\x07\x04\x02\x02\u10BB\u10BC\x07\x05\x02\x02\u10BC\u10BE\x03\x02\x02\x02" + + "\u10BD\u10A3\x03\x02\x02\x02\u10BD\u10AF\x03\x02\x02\x02\u10BE\u01C5\x03" + + "\x02\x02\x02\u10BF\u10C4\x05\u01C8\xE5\x02\u10C0\u10C1\x07#\x02\x02\u10C1" + + "\u10C3\x05\u01C8\xE5\x02\u10C2\u10C0\x03\x02\x02\x02\u10C3\u10C6\x03\x02" + + "\x02\x02\u10C4\u10C2\x03\x02\x02\x02\u10C4\u10C5\x03\x02\x02\x02\u10C5" + + "\u01C7\x03\x02\x02\x02\u10C6\u10C4\x03\x02\x02\x02\u10C7\u10C8\x05\u0562" + + "\u02B2\x02\u10C8\u10C9\x07F\x02\x02\u10C9\u10CA\x07\x04\x02\x02\u10CA" + + "\u10CB\x05\u01CA\xE6\x02\u10CB\u10CC\x07\x05\x02\x02\u10CC\u01C9\x03\x02" + + "\x02\x02\u10CD\u10D2\x05\u0552\u02AA\x02\u10CE\u10CF\x07\b\x02\x02\u10CF" + + "\u10D1\x05\u0552\u02AA\x02\u10D0\u10CE\x03\x02\x02\x02\u10D1\u10D4\x03" + + "\x02\x02\x02\u10D2\u10D0\x03\x02\x02\x02\u10D2\u10D3\x03\x02\x02\x02\u10D3" + + "\u01CB\x03\x02\x02\x02\u10D4\u10D2\x03\x02\x02\x02\u10D5\u10D6\x07\x8C" + + "\x02\x02\u10D6\u10D7\x07\xC8\x02\x02\u10D7\u10D8\x07\u0167\x02\x02\u10D8" + + "\u10D9\x05\u0540\u02A1\x02\u10D9\u10DA\x05\u01CE\xE8\x02\u10DA\u01CD\x03" + + "\x02\x02\x02\u10DB\u10E2\x07\xC3\x02\x02\u10DC\u10DD\x07\xC3\x02\x02\u10DD" + + "\u10E2\x07\u013A\x02\x02\u10DE\u10DF\x07\xC3\x02\x02\u10DF\u10E2\x07\x8D" + + "\x02\x02\u10E0\u10E2\x07\xBC\x02\x02\u10E1\u10DB\x03\x02\x02\x02\u10E1" + + "\u10DC\x03\x02\x02\x02\u10E1\u10DE\x03\x02\x02\x02\u10E1\u10E0\x03\x02" + + "\x02\x02\u10E2\u01CF\x03\x02\x02\x02\u10E3\u10E4\x070\x02\x02\u10E4\u10E5" + + "\x07\x8E\x02\x02\u10E5\u10E6\x05\u0214\u010B\x02\u10E6\u10E7\x07,\x02" + + "\x02\u10E7\u10E8\x07\x04\x02\x02\u10E8\u10E9\x05\u048E\u0248\x02\u10E9" + + "\u10EA\x07\x05\x02\x02\u10EA\u10EB\x05\u01C0\xE1\x02\u10EB\u01D1\x03\x02" + + "\x02\x02\u10EC\u10EE\x070\x02\x02\u10ED\u10EF\x05\u0278\u013D\x02\u10EE" + + "\u10ED\x03\x02\x02\x02\u10EE\u10EF\x03\x02\x02\x02\u10EF\u10F0\x03\x02" + + "\x02\x02\u10F0\u10F1\x07\x8A\x02\x02\u10F1\u10F2\x05\u0546\u02A4\x02\u10F2" + + "\u10F3\x05\u0294\u014B\x02\u10F3\u10F4\x05\u01D4\xEB\x02\u10F4\u115F\x03" + + "\x02\x02\x02\u10F5\u10F7\x070\x02\x02\u10F6\u10F8\x05\u0278\u013D\x02" + + "\u10F7\u10F6\x03\x02\x02\x02\u10F7\u10F8\x03\x02\x02\x02\u10F8\u10F9\x03" + + "\x02\x02\x02\u10F9\u10FA\x07\x8A\x02\x02\u10FA\u10FB\x05\u0546\u02A4\x02" + + "\u10FB\u10FC\x05\u01DC\xEF\x02\u10FC\u115F\x03\x02\x02\x02\u10FD\u10FE" + + "\x070\x02\x02\u10FE\u10FF\x07\u0118\x02\x02\u10FF\u1100\x05\u02BA\u015E" + + "\x02\u1100\u1101\x05\u01D4\xEB\x02\u1101\u115F\x03\x02\x02\x02\u1102\u1103" + + "\x070\x02\x02\u1103\u1104\x07\u016A\x02\x02\u1104\u1105\x05\u0214\u010B" + + "\x02\u1105\u1106\x05\u01D4\xEB\x02\u1106\u115F\x03\x02\x02\x02\u1107\u1108" + + "\x070\x02\x02\u1108\u1109\x07\u016A\x02\x02\u1109\u115F\x05\u0214\u010B" + + "\x02\u110A\u110B\x070\x02\x02\u110B\u110C\x07\u016A\x02\x02\u110C\u110D" + + "\x05\u0214\u010B\x02\u110D\u110E\x07&\x02\x02\u110E\u1110\x07\x04\x02" + + "\x02\u110F\u1111\x05\u044E\u0228\x02\u1110\u110F\x03\x02\x02\x02\u1110" + + "\u1111\x03\x02\x02\x02\u1111\u1112\x03\x02\x02\x02\u1112\u1113\x07\x05" + + "\x02\x02\u1113\u115F\x03\x02\x02\x02\u1114\u1115\x070\x02\x02\u1115\u1116" + + "\x07\u016A\x02\x02\u1116\u1117\x05\u0214\u010B\x02\u1117\u1118\x07&\x02" + + "\x02\u1118\u1119\x07\xC6\x02\x02\u1119\u111B\x07\x04\x02\x02\u111A\u111C" + + "\x05\u01E2\xF2\x02\u111B\u111A\x03\x02\x02\x02\u111B\u111C\x03\x02\x02" + + "\x02\u111C\u111D\x03\x02\x02\x02\u111D\u111E\x07\x05\x02\x02\u111E\u115F" + + "\x03\x02\x02\x02\u111F\u1120\x070\x02\x02\u1120\u1121\x07\u016A\x02\x02" + + "\u1121\u1122\x05\u0214\u010B\x02\u1122\u1123\x07&\x02\x02\u1123\u1124" + + "\x07\u012D\x02\x02\u1124\u1125\x05\u01D4\xEB\x02\u1125\u115F\x03\x02\x02" + + "\x02\u1126\u1127\x070\x02\x02\u1127\u1128\x07\u0165\x02\x02\u1128\u1129" + + "\x07\u0147\x02\x02\u1129\u112A\x07\u011D\x02\x02\u112A\u112B\x05\u0214" + + "\u010B\x02\u112B\u112C\x05\u01D4\xEB\x02\u112C\u115F\x03\x02\x02\x02\u112D" + + "\u112E\x070\x02\x02\u112E\u112F\x07\u0165\x02\x02\u112F\u1130\x07\u0147" + + "\x02\x02\u1130\u1131\x07\xBB\x02\x02\u1131\u1132\x05\u0214\u010B\x02\u1132" + + "\u1133\x05\u01D4\xEB\x02\u1133\u115F\x03\x02\x02\x02\u1134\u1135\x070" + + "\x02\x02\u1135\u1136\x07\u0165\x02\x02\u1136\u1137\x07\u0147\x02\x02\u1137" + + "\u1138\x07\u0163\x02\x02\u1138\u1139\x05\u0214\u010B\x02\u1139\u113A\x05" + + "\u01D4\xEB\x02\u113A\u115F\x03\x02\x02\x02\u113B\u113C\x070\x02\x02\u113C" + + "\u113D\x07\u0165\x02\x02\u113D\u113E\x07\u0147\x02\x02\u113E\u113F\x07" + + "\xA5\x02\x02\u113F\u1140\x05\u0214\u010B\x02\u1140\u1141\x05\u01D4\xEB" + + "\x02\u1141\u115F\x03\x02\x02\x02\u1142\u1143\x070\x02\x02\u1143\u1144" + + "\x07n\x02\x02\u1144\u1145\x05\u0214\u010B\x02\u1145\u1146\x05\u01D4\xEB" + + "\x02\u1146\u115F\x03\x02\x02\x02\u1147\u1148\x070\x02\x02\u1148\u1149" + + "\x07n\x02\x02\u1149\u114A\x07\xDE\x02\x02\u114A\u114B\x07O\x02\x02\u114B" + + "\u114C\x07\u018E\x02\x02\u114C\u114D\x05\u0214\u010B\x02\u114D\u114E\x05" + + "\u01D4\xEB\x02\u114E\u115F\x03\x02\x02\x02\u114F\u1150\x070\x02\x02\u1150" + + "\u1151\x07n\x02\x02\u1151\u1152\x05\u0214\u010B\x02\u1152\u1153\x07B\x02" + + "\x02\u1153\u1154\x05\u0214\u010B\x02\u1154\u115F\x03\x02\x02\x02\u1155" + + "\u1156\x070\x02\x02\u1156\u1157\x07n\x02\x02\u1157\u1158\x07\xDE\x02\x02" + + "\u1158\u1159\x07O\x02\x02\u1159\u115A\x07\u018E\x02\x02\u115A\u115B\x05" + + "\u0214\u010B\x02\u115B\u115C\x07B\x02\x02\u115C\u115D\x05\u0214\u010B" + + "\x02\u115D\u115F\x03\x02\x02\x02\u115E\u10EC\x03\x02\x02\x02\u115E\u10F5" + + "\x03\x02\x02\x02\u115E\u10FD\x03\x02\x02\x02\u115E\u1102\x03\x02\x02\x02" + + "\u115E\u1107\x03\x02\x02\x02\u115E\u110A\x03\x02\x02\x02\u115E\u1114\x03" + + "\x02\x02\x02\u115E\u111F\x03\x02\x02\x02\u115E\u1126\x03\x02\x02\x02\u115E" + + "\u112D\x03\x02\x02\x02\u115E\u1134\x03\x02\x02\x02\u115E\u113B\x03\x02" + + "\x02\x02\u115E\u1142\x03\x02\x02\x02\u115E\u1147\x03\x02\x02\x02\u115E" + + "\u114F\x03\x02\x02\x02\u115E\u1155\x03\x02\x02\x02\u115F\u01D3\x03\x02" + + "\x02\x02\u1160\u1161\x07\x04\x02\x02\u1161\u1162\x05\u01D6\xEC\x02\u1162" + + "\u1163\x07\x05\x02\x02\u1163\u01D5\x03\x02\x02\x02\u1164\u1169\x05\u01D8" + + "\xED\x02\u1165\u1166\x07\b\x02\x02\u1166\u1168\x05\u01D8\xED\x02\u1167" + + "\u1165\x03\x02\x02\x02\u1168\u116B\x03\x02\x02\x02\u1169\u1167\x03\x02" + + "\x02\x02\u1169\u116A\x03\x02\x02\x02\u116A\u01D7\x03\x02\x02\x02\u116B" + + "\u1169\x03\x02\x02\x02\u116C\u116F\x05\u0570\u02B9\x02\u116D\u116E\x07" + + "\f\x02\x02\u116E\u1170\x05\u01DA\xEE\x02\u116F\u116D\x03\x02\x02\x02\u116F" + + "\u1170\x03\x02\x02\x02\u1170\u01D9\x03\x02\x02\x02\u1171\u1178\x05\u028E" + + "\u0148\x02\u1172\u1178\x05\u057C\u02BF\x02\u1173\u1178\x05\u04FE\u0280" + + "\x02\u1174\u1178\x05\u0128\x95\x02\u1175\u1178\x05\u0552\u02AA\x02\u1176" + + "\u1178\x07\u0199\x02\x02\u1177\u1171\x03\x02\x02\x02\u1177\u1172\x03\x02" + + "\x02\x02\u1177\u1173\x03\x02\x02\x02\u1177\u1174\x03\x02\x02\x02\u1177" + + "\u1175\x03\x02\x02\x02\u1177\u1176\x03\x02\x02\x02\u1178\u01DB\x03\x02" + + "\x02\x02\u1179\u117A\x07\x04\x02\x02\u117A\u117B\x05\u01DE\xF0\x02\u117B" + + "\u117C\x07\x05\x02\x02\u117C\u01DD\x03\x02\x02\x02\u117D\u1182\x05\u01E0" + + "\xF1\x02\u117E\u117F\x07\b\x02\x02\u117F\u1181\x05\u01E0\xF1\x02\u1180" + + "\u117E\x03\x02\x02\x02\u1181\u1184\x03\x02\x02\x02\u1182\u1180\x03\x02" + + "\x02\x02\u1182\u1183\x03\x02\x02\x02\u1183\u01DF\x03\x02\x02\x02\u1184" + + "\u1182\x03\x02\x02\x02\u1185\u1186\x05\u0572\u02BA\x02\u1186\u1187\x07" + + "\f\x02\x02\u1187\u1188\x05\u01DA\xEE\x02\u1188\u01E1\x03\x02\x02\x02\u1189" + + "\u118A\x05\u01E4\xF3\x02\u118A\u01E3\x03\x02\x02\x02\u118B\u1190\x05\u0552" + + "\u02AA\x02\u118C\u118D\x07\b\x02\x02\u118D\u118F\x05\u0552\u02AA\x02\u118E" + + "\u118C\x03\x02\x02\x02\u118F\u1192\x03\x02\x02\x02\u1190\u118E\x03\x02" + + "\x02\x02\u1190\u1191\x03\x02\x02\x02\u1191\u01E5\x03\x02\x02\x02\u1192" + + "\u1190\x03\x02\x02\x02\u1193\u1194\x07\x8C\x02\x02\u1194\u1195\x07\u016A" + + "\x02\x02\u1195\u1196\x05\u0214\u010B\x02\u1196\u1197\x07\x87\x02\x02\u1197" + + "\u1199\x07\u01C4\x02\x02\u1198\u119A\x05\u01E8\xF5\x02\u1199\u1198\x03" + + "\x02\x02\x02\u1199\u119A\x03\x02\x02\x02\u119A\u119B\x03\x02\x02\x02\u119B" + + "\u119C\x05\u0552\u02AA\x02\u119C\u11BF\x03\x02\x02\x02\u119D\u119E\x07" + + "\x8C\x02\x02\u119E\u119F\x07\u016A\x02\x02\u119F\u11A0\x05\u0214\u010B" + + "\x02\u11A0\u11A1\x07\x87\x02\x02\u11A1\u11A3\x07\u01C4\x02\x02\u11A2\u11A4" + + "\x05\u01E8\xF5\x02\u11A3\u11A2\x03\x02\x02\x02\u11A3\u11A4\x03\x02\x02" + + "\x02\u11A4\u11A5\x03\x02\x02\x02\u11A5\u11A6\x05\u0552\u02AA\x02\u11A6" + + "\u11A7\x07\x93\x02\x02\u11A7\u11A8\x05\u0552\u02AA\x02\u11A8\u11BF\x03" + + "\x02\x02\x02\u11A9\u11AA\x07\x8C\x02\x02\u11AA\u11AB\x07\u016A\x02\x02" + + "\u11AB\u11AC\x05\u0214\u010B\x02\u11AC\u11AD\x07\x87\x02\x02\u11AD\u11AF" + + "\x07\u01C4\x02\x02\u11AE\u11B0\x05\u01E8\xF5\x02\u11AF\u11AE\x03\x02\x02" + + "\x02\u11AF\u11B0\x03\x02\x02\x02\u11B0\u11B1\x03\x02\x02\x02\u11B1\u11B2" + + "\x05\u0552\u02AA\x02\u11B2\u11B3\x07\x89\x02\x02\u11B3\u11B4\x05\u0552" + + "\u02AA\x02\u11B4\u11BF\x03\x02\x02\x02\u11B5\u11B6\x07\x8C\x02\x02\u11B6" + + "\u11B7\x07\u016A\x02\x02\u11B7\u11B8\x05\u0214\u010B\x02\u11B8\u11B9\x07" + + "\u0137\x02\x02\u11B9\u11BA\x07\u01C4\x02\x02\u11BA\u11BB\x05\u0552\u02AA" + + "\x02\u11BB\u11BC\x07`\x02\x02\u11BC\u11BD\x05\u0552\u02AA\x02\u11BD\u11BF" + + "\x03\x02\x02\x02\u11BE\u1193\x03\x02\x02\x02\u11BE\u119D\x03\x02\x02\x02" + + "\u11BE\u11A9\x03\x02\x02\x02\u11BE\u11B5\x03\x02\x02\x02\u11BF\u01E7\x03" + + "\x02\x02\x02\u11C0\u11C1\x07\xDE\x02\x02\u11C1\u11C2\x07O\x02\x02\u11C2" + + "\u11C3\x07\u018E\x02\x02\u11C3\u01E9\x03\x02\x02\x02\u11C4\u11C5\x070" + + "\x02\x02\u11C5\u11C6\x07\u0118\x02\x02\u11C6\u11C7\x07\x9E\x02\x02\u11C7" + + "\u11C9\x05\u0214\u010B\x02\u11C8\u11CA\x05\u01F0\xF9\x02\u11C9\u11C8\x03" + + "\x02\x02\x02\u11C9\u11CA\x03\x02\x02\x02\u11CA\u11CB\x03\x02\x02\x02\u11CB" + + "\u11CC\x07@\x02\x02\u11CC\u11CD\x07\u016A\x02\x02\u11CD\u11CE\x05\u0462" + + "\u0232\x02\u11CE\u11CF\x07f\x02\x02\u11CF\u11D1\x05\u0540\u02A1\x02\u11D0" + + "\u11D2\x05\u01F2\xFA\x02\u11D1\u11D0\x03\x02\x02\x02\u11D1\u11D2\x03\x02" + + "\x02\x02\u11D2\u11D3\x03\x02\x02\x02\u11D3\u11D4\x07&\x02\x02\u11D4\u11D5" + + "\x05\u01EC\xF7\x02\u11D5\u01EB\x03\x02\x02\x02\u11D6\u11DB\x05\u01EE\xF8" + + "\x02\u11D7\u11D8\x07\b\x02\x02\u11D8\u11DA\x05\u01EE\xF8\x02\u11D9\u11D7" + + "\x03\x02\x02\x02\u11DA\u11DD\x03\x02\x02\x02\u11DB\u11D9\x03\x02\x02\x02" + + "\u11DB\u11DC\x03\x02\x02\x02\u11DC\u01ED\x03\x02\x02\x02\u11DD\u11DB\x03" + + "\x02\x02\x02\u11DE\u11DF\x07\u0118\x02\x02\u11DF\u11E0\x05\u0550\u02A9" + + "\x02\u11E0\u11E2\x05\u02BA\u015E\x02\u11E1\u11E3\x05\u01F4\xFB\x02\u11E2" + + "\u11E1\x03\x02\x02\x02\u11E2\u11E3\x03\x02\x02\x02\u11E3\u11E5\x03\x02" + + "\x02\x02\u11E4\u11E6\x05\u01F6\xFC\x02\u11E5\u11E4\x03\x02\x02\x02\u11E5" + + "\u11E6\x03\x02\x02\x02\u11E6\u11FE\x03\x02\x02\x02\u11E7\u11E8\x07\u0118" + + "\x02\x02\u11E8\u11E9\x05\u0550\u02A9\x02\u11E9\u11EB\x05\u02BE\u0160\x02" + + "\u11EA\u11EC\x05\u01F4\xFB\x02\u11EB\u11EA\x03\x02\x02\x02\u11EB\u11EC" + + "\x03\x02\x02\x02\u11EC\u11EE\x03\x02\x02\x02\u11ED\u11EF\x05\u01F6\xFC" + + "\x02\u11EE\u11ED\x03\x02\x02\x02\u11EE\u11EF\x03\x02\x02\x02\u11EF\u11FE" + + "\x03\x02\x02\x02\u11F0\u11F1\x07\xD5\x02\x02\u11F1\u11F2\x05\u0550\u02A9" + + "\x02\u11F2\u11F3\x05\u0280\u0141\x02\u11F3\u11FE\x03\x02\x02\x02\u11F4" + + "\u11F5\x07\xD5\x02\x02\u11F5\u11F6\x05\u0550\u02A9\x02\u11F6\u11F7\x07" + + "\x04\x02\x02\u11F7\u11F8\x05\u0508\u0285\x02\u11F8\u11F9\x07\x05\x02\x02" + + "\u11F9\u11FA\x05\u0280\u0141\x02\u11FA\u11FE\x03\x02\x02\x02\u11FB\u11FC" + + "\x07\u015B\x02\x02\u11FC\u11FE\x05\u0462\u0232\x02\u11FD\u11DE\x03\x02" + + "\x02\x02\u11FD\u11E7\x03\x02\x02\x02\u11FD\u11F0\x03\x02\x02\x02\u11FD" + + "\u11F4\x03\x02\x02\x02\u11FD\u11FB\x03\x02\x02\x02\u11FE\u01EF\x03\x02" + + "\x02\x02\u11FF\u1200\x077\x02\x02\u1200\u01F1\x03\x02\x02\x02\u1201\u1202" + + "\x07\xD0\x02\x02\u1202\u1203\x05\u0214\u010B\x02\u1203\u01F3\x03\x02\x02" + + "\x02\u1204\u1205\x07@\x02\x02\u1205\u120B\x07\u0147\x02\x02\u1206\u1207" + + "\x07@\x02\x02\u1207\u1208\x07U\x02\x02\u1208\u1209\x07\x95\x02\x02\u1209" + + "\u120B\x05\u0214\u010B\x02\u120A\u1204\x03\x02\x02\x02\u120A\u1206\x03" + + "\x02\x02\x02\u120B\u01F5\x03\x02\x02\x02\u120C\u120D\x07\u0130\x02\x02" + + "\u120D\u01F7\x03\x02\x02\x02\u120E\u120F\x070\x02\x02\u120F\u1210\x07" + + "\u0118\x02\x02\u1210\u1211\x07\xD0\x02\x02\u1211\u1212\x05\u0214\u010B" + + "\x02\u1212\u1213\x07f\x02\x02\u1213\u1214\x05\u0540\u02A1\x02\u1214\u01F9" + + "\x03\x02\x02\x02\u1215\u1216\x07\x8C\x02\x02\u1216\u1217\x07\u0118\x02" + + "\x02\u1217\u1218\x07\xD0\x02\x02\u1218\u1219\x05\u0214\u010B\x02\u1219" + + "\u121A\x07f\x02\x02\u121A\u121B\x05\u0540\u02A1\x02\u121B\u121C\x07\x87" + + "\x02\x02\u121C\u121D\x05\u01EC\xF7\x02\u121D\u1228\x03\x02\x02\x02\u121E" + + "\u121F\x07\x8C\x02\x02\u121F\u1220\x07\u0118\x02\x02\u1220\u1221\x07\xD0" + + "\x02\x02\u1221\u1222\x05\u0214\u010B\x02\u1222\u1223\x07f\x02\x02\u1223" + + "\u1224\x05\u0540\u02A1\x02\u1224\u1225\x07\xC1\x02\x02\u1225\u1226\x05" + + "\u01FC\xFF\x02\u1226\u1228\x03\x02\x02\x02\u1227\u1215\x03\x02\x02\x02" + + "\u1227\u121E\x03\x02\x02\x02\u1228\u01FB\x03\x02\x02\x02\u1229\u122E\x05" + + "\u01FE\u0100\x02\u122A\u122B\x07\b\x02\x02\u122B\u122D\x05\u01FE\u0100" + + "\x02\u122C\u122A\x03\x02\x02\x02\u122D\u1230\x03\x02\x02\x02\u122E\u122C" + + "\x03\x02\x02\x02\u122E\u122F\x03\x02\x02\x02\u122F\u01FD\x03\x02\x02\x02" + + "\u1230\u122E\x03\x02\x02\x02\u1231\u1232\x07\u0118\x02\x02\u1232\u1233" + + "\x05\u0550\u02A9\x02\u1233\u1234\x07\x04\x02\x02\u1234\u1235\x05\u0508" + + "\u0285\x02\u1235\u1236\x07\x05\x02\x02\u1236\u123E\x03\x02\x02\x02\u1237" + + "\u1238\x07\xD5\x02\x02\u1238\u1239\x05\u0550\u02A9\x02\u1239\u123A\x07" + + "\x04\x02\x02\u123A\u123B\x05\u0508\u0285\x02\u123B\u123C\x07\x05\x02\x02" + + "\u123C\u123E\x03\x02\x02\x02\u123D\u1231\x03\x02\x02\x02\u123D\u1237\x03" + + "\x02\x02\x02\u123E\u01FF\x03\x02\x02\x02\u123F\u1240\x07\xC1\x02\x02\u1240" + + "\u1241\x07\u0118\x02\x02\u1241\u1242\x07\x9E\x02\x02\u1242\u1243\x05\u0214" + + "\u010B\x02\u1243\u1244\x07f\x02\x02\u1244\u1246\x05\u0540\u02A1\x02\u1245" + + "\u1247\x05l7\x02\u1246\u1245\x03\x02\x02\x02\u1246\u1247\x03\x02\x02\x02" + + "\u1247\u1254\x03\x02\x02\x02\u1248\u1249\x07\xC1\x02\x02\u1249\u124A\x07" + + "\u0118\x02\x02\u124A\u124B\x07\x9E\x02\x02\u124B\u124C\x07\xDE\x02\x02" + + "\u124C\u124D\x07\u018E\x02\x02\u124D\u124E\x05\u0214\u010B\x02\u124E\u124F" + + "\x07f\x02\x02\u124F\u1251\x05\u0540\u02A1\x02\u1250\u1252\x05l7\x02\u1251" + + "\u1250\x03\x02\x02\x02\u1251\u1252\x03\x02\x02\x02\u1252\u1254\x03\x02" + + "\x02\x02\u1253\u123F\x03\x02\x02\x02\u1253\u1248\x03\x02\x02\x02\u1254" + + "\u0201\x03\x02\x02\x02\u1255\u1256\x07\xC1\x02\x02\u1256\u1257\x07\u0118" + + "\x02\x02\u1257\u1258\x07\xD0\x02\x02\u1258\u1259\x05\u0214\u010B\x02\u1259" + + "\u125A\x07f\x02\x02\u125A\u125C\x05\u0540\u02A1\x02\u125B\u125D\x05l7" + + "\x02\u125C\u125B\x03\x02\x02\x02\u125C\u125D\x03\x02\x02\x02\u125D\u126A" + + "\x03\x02\x02\x02\u125E\u125F\x07\xC1\x02\x02\u125F\u1260\x07\u0118\x02" + + "\x02\u1260\u1261\x07\xD0\x02\x02\u1261\u1262\x07\xDE\x02\x02\u1262\u1263" + + "\x07\u018E\x02\x02\u1263\u1264\x05\u0214\u010B\x02\u1264\u1265\x07f\x02" + + "\x02\u1265\u1267\x05\u0540\u02A1\x02\u1266\u1268\x05l7\x02\u1267\u1266" + + "\x03\x02\x02\x02\u1267\u1268\x03\x02\x02\x02\u1268\u126A\x03\x02\x02\x02" + + "\u1269\u1255\x03\x02\x02\x02\u1269\u125E\x03\x02\x02\x02\u126A\u0203\x03" + + "\x02\x02\x02\u126B\u126C\x07\xC1\x02\x02\u126C\u126D\x07\u011B\x02\x02" + + "\u126D\u126E\x07\x95\x02\x02\u126E\u1270\x05\u0560\u02B1\x02\u126F\u1271" + + "\x05l7\x02\u1270\u126F\x03\x02\x02\x02\u1270\u1271\x03\x02\x02\x02\u1271" + + "\u0205\x03\x02\x02\x02\u1272\u1273\x07\u012F\x02\x02\u1273\u1274\x07\u011B" + + "\x02\x02\u1274\u1275\x07\x95\x02\x02\u1275\u1276\x05\u0560\u02B1\x02\u1276" + + "\u1277\x07`\x02\x02\u1277\u1278\x05\u055E\u02B0\x02\u1278\u0207\x03\x02" + + "\x02\x02\u1279\u127A\x07\xC1\x02\x02\u127A\u127B\x05\u020A\u0106\x02\u127B" + + "\u127C\x07\xDE\x02\x02\u127C\u127D\x07\u018E\x02\x02\u127D\u127F\x05\u0212" + + "\u010A\x02\u127E\u1280\x05l7\x02\u127F\u127E\x03\x02\x02\x02\u127F\u1280" + + "\x03\x02\x02\x02\u1280\u12D4\x03\x02\x02\x02\u1281\u1282\x07\xC1\x02\x02" + + "\u1282\u1283\x05\u020A\u0106\x02\u1283\u1285\x05\u0212\u010A\x02\u1284" + + "\u1286\x05l7\x02\u1285\u1284\x03\x02\x02\x02\u1285\u1286\x03\x02\x02\x02" + + "\u1286\u12D4\x03\x02\x02\x02\u1287\u1288\x07\xC1\x02\x02\u1288\u1289\x05" + + "\u020E\u0108\x02\u1289\u128A\x07\xDE\x02\x02\u128A\u128B\x07\u018E\x02" + + "\x02\u128B\u128D\x05\u053E\u02A0\x02\u128C\u128E\x05l7\x02\u128D\u128C" + + "\x03\x02\x02\x02\u128D\u128E\x03\x02\x02\x02\u128E\u12D4\x03\x02\x02\x02" + + "\u128F\u1290\x07\xC1\x02\x02\u1290\u1291\x05\u020E\u0108\x02\u1291\u1293" + + "\x05\u053E\u02A0\x02\u1292\u1294\x05l7\x02\u1293\u1292\x03\x02\x02\x02" + + "\u1293\u1294\x03\x02\x02\x02\u1294\u12D4\x03\x02\x02\x02\u1295\u1296\x07" + + "\xC1\x02\x02\u1296\u1297\x05\u0210\u0109\x02\u1297\u1298\x05\u0540\u02A1" + + "\x02\u1298\u1299\x07R\x02\x02\u1299\u129B\x05\u0214\u010B\x02\u129A\u129C" + + "\x05l7\x02\u129B\u129A\x03\x02\x02\x02\u129B\u129C\x03\x02\x02\x02\u129C" + + "\u12D4\x03\x02\x02\x02\u129D\u129E\x07\xC1\x02\x02\u129E\u129F\x05\u0210" + + "\u0109\x02\u129F\u12A0\x07\xDE\x02\x02\u12A0\u12A1\x07\u018E\x02\x02\u12A1" + + "\u12A2\x05\u0540\u02A1\x02\u12A2\u12A3\x07R\x02\x02\u12A3\u12A5\x05\u0214" + + "\u010B\x02\u12A4\u12A6\x05l7\x02\u12A5\u12A4\x03\x02\x02\x02\u12A5\u12A6" + + "\x03\x02\x02\x02\u12A6\u12D4\x03\x02\x02\x02\u12A7\u12A8\x07\xC1\x02\x02" + + "\u12A8\u12A9\x07\u016A\x02\x02\u12A9\u12AB\x05\u0218\u010D\x02\u12AA\u12AC" + + "\x05l7\x02\u12AB\u12AA\x03\x02\x02\x02\u12AB\u12AC\x03\x02\x02\x02\u12AC" + + "\u12D4\x03\x02\x02\x02\u12AD\u12AE\x07\xC1\x02\x02\u12AE\u12AF\x07\u016A" + + "\x02\x02\u12AF\u12B0\x07\xDE\x02\x02\u12B0\u12B1\x07\u018E\x02\x02\u12B1" + + "\u12B3\x05\u0218\u010D\x02\u12B2\u12B4\x05l7\x02\u12B3\u12B2\x03\x02\x02" + + "\x02\u12B3\u12B4\x03\x02\x02\x02\u12B4\u12D4\x03\x02\x02\x02\u12B5\u12B6" + + "\x07\xC1\x02\x02\u12B6\u12B7\x07\xBF\x02\x02\u12B7\u12B9\x05\u0218\u010D" + + "\x02\u12B8\u12BA\x05l7\x02\u12B9\u12B8\x03\x02\x02\x02\u12B9\u12BA\x03" + + "\x02\x02\x02\u12BA\u12D4\x03\x02\x02\x02\u12BB\u12BC\x07\xC1\x02\x02\u12BC" + + "\u12BD\x07\xBF\x02\x02\u12BD\u12BE\x07\xDE\x02\x02\u12BE\u12BF\x07\u018E" + + "\x02\x02\u12BF\u12C1\x05\u0218\u010D\x02\u12C0\u12C2\x05l7\x02\u12C1\u12C0" + + "\x03\x02\x02\x02\u12C1\u12C2\x03\x02\x02\x02\u12C2\u12D4\x03\x02\x02\x02" + + "\u12C3\u12C4\x07\xC1\x02\x02\u12C4\u12C5\x07\xE4\x02\x02\u12C5\u12C6\x07" + + "o\x02\x02\u12C6\u12C8\x05\u0212\u010A\x02\u12C7\u12C9\x05l7\x02\u12C8" + + "\u12C7\x03\x02\x02\x02\u12C8\u12C9\x03\x02\x02\x02\u12C9\u12D4\x03\x02" + + "\x02\x02\u12CA\u12CB\x07\xC1\x02\x02\u12CB\u12CC\x07\xE4\x02\x02\u12CC" + + "\u12CD\x07o\x02\x02\u12CD\u12CE\x07\xDE\x02\x02\u12CE\u12CF\x07\u018E" + + "\x02\x02\u12CF\u12D1\x05\u0212\u010A\x02\u12D0\u12D2\x05l7\x02\u12D1\u12D0" + + "\x03\x02\x02\x02\u12D1\u12D2\x03\x02\x02\x02\u12D2\u12D4\x03\x02\x02\x02" + + "\u12D3\u1279\x03\x02\x02\x02\u12D3\u1281\x03\x02\x02\x02\u12D3\u1287\x03" + + "\x02\x02\x02\u12D3\u128F\x03\x02\x02\x02\u12D3\u1295\x03\x02\x02\x02\u12D3" + + "\u129D\x03\x02\x02\x02\u12D3\u12A7\x03\x02\x02\x02\u12D3\u12AD\x03\x02" + + "\x02\x02\u12D3\u12B5\x03\x02\x02\x02\u12D3\u12BB\x03\x02\x02\x02\u12D3" + + "\u12C3\x03\x02\x02\x02\u12D3\u12CA\x03\x02\x02\x02\u12D4\u0209\x03\x02" + + "\x02\x02\u12D5\u12ED\x07^\x02\x02\u12D6\u12ED\x07\u014A\x02\x02\u12D7" + + "\u12ED\x07\u017A\x02\x02\u12D8\u12D9\x07\u0105\x02\x02\u12D9\u12ED\x07" + + "\u017A\x02\x02\u12DA\u12ED\x07\xE4\x02\x02\u12DB\u12DC\x07A\x02\x02\u12DC" + + "\u12ED\x07^\x02\x02\u12DD\u12ED\x07n\x02\x02\u12DE\u12ED\x07\xAA\x02\x02" + + "\u12DF\u12ED\x07\u0158\x02\x02\u12E0\u12E1\x07\u0165\x02\x02\u12E1\u12E2" + + "\x07\u0147\x02\x02\u12E2\u12ED\x07\u011D\x02\x02\u12E3\u12E4\x07\u0165" + + "\x02\x02\u12E4\u12E5\x07\u0147\x02\x02\u12E5\u12ED\x07\xBB\x02\x02\u12E6" + + "\u12E7\x07\u0165\x02\x02\u12E7\u12E8\x07\u0147\x02\x02\u12E8\u12ED\x07" + + "\u0163\x02\x02\u12E9\u12EA\x07\u0165\x02\x02\u12EA\u12EB\x07\u0147\x02" + + "\x02\u12EB\u12ED\x07\xA5\x02\x02\u12EC\u12D5\x03\x02\x02\x02\u12EC\u12D6" + + "\x03\x02\x02\x02\u12EC\u12D7\x03\x02\x02\x02\u12EC\u12D8\x03\x02\x02\x02" + + "\u12EC\u12DA\x03\x02\x02\x02\u12EC\u12DB\x03\x02\x02\x02\u12EC\u12DD\x03" + + "\x02\x02\x02\u12EC\u12DE\x03\x02\x02\x02\u12EC\u12DF\x03\x02\x02\x02\u12EC" + + "\u12E0\x03\x02\x02\x02\u12EC\u12E3\x03\x02\x02\x02\u12EC\u12E6\x03\x02" + + "\x02\x02\u12EC\u12E9\x03\x02\x02\x02\u12ED\u020B\x03\x02\x02\x02\u12EE" + + "\u12F4\x05\u020E\u0108\x02\u12EF\u12F4\x07\xB1\x02\x02\u12F0\u12F4\x07" + + "\u0140\x02\x02\u12F1\u12F4\x07\u01C5\x02\x02\u12F2\u12F4\x07\u0161\x02" + + "\x02\u12F3\u12EE\x03\x02\x02\x02\u12F3\u12EF\x03\x02\x02\x02\u12F3\u12F0" + + "\x03\x02\x02\x02\u12F3\u12F1\x03\x02\x02\x02\u12F3\u12F2\x03\x02\x02\x02" + + "\u12F4\u020D\x03\x02\x02\x02\u12F5\u12F6\x07\x85\x02\x02\u12F6\u1305\x07" + + "\u01C0\x02\x02\u12F7\u12F8\x07\xC8\x02\x02\u12F8\u1305\x07\u0167\x02\x02" + + "\u12F9\u1305\x07\xCE\x02\x02\u12FA\u12FB\x07A\x02\x02\u12FB\u12FC\x07" + + "\xB0\x02\x02\u12FC\u1305\x07\u017F\x02\x02\u12FD\u12FF\x05\u0138\x9D\x02" + + "\u12FE\u12FD\x03\x02\x02\x02\u12FE\u12FF\x03\x02\x02\x02\u12FF\u1300\x03" + + "\x02\x02\x02\u1300\u1305\x07\xF9\x02\x02\u1301\u1305\x07\u01C6\x02\x02" + + "\u1302\u1305\x07\u0145\x02\x02\u1303\u1305\x07\u014D\x02\x02\u1304\u12F5" + + "\x03\x02\x02\x02\u1304\u12F7\x03\x02\x02\x02\u1304\u12F9\x03\x02\x02\x02" + + "\u1304\u12FA\x03\x02\x02\x02\u1304\u12FE\x03\x02\x02\x02\u1304\u1301\x03" + + "\x02\x02\x02\u1304\u1302\x03\x02\x02\x02\u1304\u1303\x03\x02\x02\x02\u1305" + + "\u020F\x03\x02\x02\x02\u1306\u1307\t\x1F\x02\x02\u1307\u0211\x03\x02\x02" + + "\x02\u1308\u130D\x05\u0214\u010B\x02\u1309\u130A\x07\b\x02\x02\u130A\u130C" + + "\x05\u0214\u010B\x02\u130B\u1309\x03\x02\x02\x02\u130C\u130F\x03\x02\x02" + + "\x02\u130D\u130B\x03\x02\x02\x02\u130D\u130E\x03\x02\x02\x02\u130E\u0213" + + "\x03\x02\x02\x02\u130F\u130D\x03\x02\x02\x02\u1310\u1312\x05\u0562\u02B2" + + "\x02\u1311\u1313\x05\u0216\u010C\x02\u1312\u1311\x03\x02\x02\x02\u1312" + + "\u1313\x03\x02\x02\x02\u1313\u0215\x03\x02\x02\x02\u1314\u1315\x07\r\x02" + + "\x02\u1315\u1317\x05\u0542\u02A2\x02\u1316\u1314\x03\x02\x02\x02\u1317" + + "\u1318\x03\x02\x02\x02\u1318\u1316\x03\x02\x02\x02\u1318\u1319\x03\x02" + + "\x02\x02\u1319\u0217\x03\x02\x02\x02\u131A\u131F\x05\u0462\u0232\x02\u131B" + + "\u131C\x07\b\x02\x02\u131C\u131E\x05\u0462\u0232\x02\u131D\u131B\x03\x02" + + "\x02\x02\u131E\u1321\x03\x02\x02\x02\u131F\u131D\x03\x02\x02\x02\u131F" + + "\u1320\x03\x02\x02\x02\u1320\u0219\x03\x02\x02\x02\u1321\u131F\x03\x02" + + "\x02\x02\u1322\u1324\x07\u0168\x02\x02\u1323\u1325\x05\u03E4\u01F3\x02" + + "\u1324\u1323\x03\x02\x02\x02\u1324\u1325\x03\x02\x02\x02\u1325\u1326\x03" + + "\x02\x02\x02\u1326\u1328\x05\u0438\u021D\x02\u1327\u1329\x05\u021C\u010F" + + "\x02\u1328\u1327\x03\x02\x02\x02\u1328\u1329\x03\x02\x02\x02\u1329\u132B" + + "\x03\x02\x02\x02\u132A\u132C\x05l7\x02\u132B\u132A\x03\x02\x02\x02\u132B" + + "\u132C\x03\x02\x02\x02\u132C\u021B\x03\x02\x02\x02\u132D\u132E\x07\xA9" + + "\x02\x02\u132E\u1332\x07\xDD\x02\x02\u132F\u1330\x07\u013C\x02\x02\u1330" + + "\u1332\x07\xDD\x02\x02\u1331\u132D\x03\x02\x02\x02\u1331\u132F\x03\x02" + + "\x02\x02\u1332\u021D\x03\x02\x02\x02\u1333\u1334\x07\xA1\x02\x02\u1334" + + "\u1335\x07R\x02\x02\u1335\u1336\x05\u020A\u0106\x02\u1336\u1337\x05\u0214" + + "\u010B\x02\u1337\u1338\x07v\x02\x02\u1338\u1339\x05\u0220\u0111\x02\u1339" + + "\u13C7\x03\x02\x02\x02\u133A\u133B\x07\xA1\x02\x02\u133B\u133C\x07R\x02" + + "\x02\u133C\u133D\x07.\x02\x02\u133D\u133E\x05\u0214\u010B\x02\u133E\u133F" + + "\x07v\x02\x02\u133F\u1340\x05\u0220\u0111\x02\u1340\u13C7\x03\x02\x02" + + "\x02\u1341\u1342\x07\xA1\x02\x02\u1342\u1343\x07R\x02\x02\u1343\u1344" + + "\x05\u020C\u0107\x02\u1344\u1345\x05\u0540\u02A1\x02\u1345\u1346\x07v" + + "\x02\x02\u1346\u1347\x05\u0220\u0111\x02\u1347\u13C7\x03\x02\x02\x02\u1348" + + "\u1349\x07\xA1\x02\x02\u1349\u134A\x07R\x02\x02\u134A\u134B\x07\u016A" + + "\x02\x02\u134B\u134C\x05\u0462\u0232\x02\u134C\u134D\x07v\x02\x02\u134D" + + "\u134E\x05\u0220\u0111\x02\u134E\u13C7\x03\x02\x02\x02\u134F\u1350\x07" + + "\xA1\x02\x02\u1350\u1351\x07R\x02\x02\u1351\u1352\x07\xBF\x02\x02\u1352" + + "\u1353\x05\u0462\u0232\x02\u1353\u1354\x07v\x02\x02\u1354\u1355\x05\u0220" + + "\u0111\x02\u1355\u13C7\x03\x02\x02\x02\u1356\u1357\x07\xA1\x02\x02\u1357" + + "\u1358\x07R\x02\x02\u1358\u1359\x07\x8A\x02\x02\u1359\u135A\x05\u0298" + + "\u014D\x02\u135A\u135B\x07v\x02\x02\u135B\u135C\x05\u0220\u0111\x02\u135C" + + "\u13C7\x03\x02\x02\x02\u135D\u135E\x07\xA1\x02"; private static readonly _serializedATNSegment11: string = - "\x02\u138B\u1330\x03\x02\x02\x02\u138B\u1339\x03\x02\x02\x02\u138B\u1343" + - "\x03\x02\x02\x02\u138B\u134C\x03\x02\x02\x02\u138B\u1353\x03\x02\x02\x02" + - "\u138B\u135A\x03\x02\x02\x02\u138B\u1364\x03\x02\x02\x02\u138B\u136E\x03" + - "\x02\x02\x02\u138B\u1378\x03\x02\x02\x02\u138B\u1380\x03\x02\x02\x02\u138C" + - "\u0217\x03\x02\x02\x02\u138D\u1390\x05\u0542\u02A2\x02\u138E\u1390\x07" + - "P\x02\x02\u138F\u138D\x03\x02\x02\x02\u138F\u138E\x03\x02\x02\x02\u1390" + - "\u0219\x03\x02\x02\x02\u1391\u1392\x07\u0140\x02\x02\u1392\u1394\x07\xEF" + - "\x02\x02\u1393\u1395\x05\u021C\u010F\x02\u1394\u1393\x03\x02\x02\x02\u1394" + - "\u1395\x03\x02\x02\x02\u1395\u1396\x03\x02\x02\x02\u1396\u1397\x07R\x02" + - "\x02\u1397\u1398\x05\u0202\u0102\x02\u1398\u1399\x05\u020C\u0107\x02\u1399" + - "\u139A\x07v\x02\x02\u139A\u139B\x05\u021E\u0110\x02\u139B\u1401\x03\x02" + - "\x02\x02\u139C\u139D\x07\u0140\x02\x02\u139D\u139F\x07\xEF\x02\x02\u139E" + - "\u13A0\x05\u021C\u010F\x02\u139F\u139E\x03\x02\x02\x02\u139F\u13A0\x03" + - "\x02\x02\x02\u13A0\u13A1\x03\x02\x02\x02\u13A1\u13A2\x07R\x02\x02\u13A2" + - "\u13A3\x07.\x02\x02\u13A3\u13A4\x05\u020C\u0107\x02\u13A4\u13A5\x07v\x02" + - "\x02\u13A5\u13A6\x05\u021E\u0110\x02\u13A6\u1401\x03\x02\x02\x02\u13A7" + - "\u13A8\x07\u0140\x02\x02\u13A8\u13AA\x07\xEF\x02\x02\u13A9\u13AB\x05\u021C" + - "\u010F\x02\u13AA\u13A9\x03\x02\x02\x02\u13AA\u13AB\x03\x02\x02\x02\u13AB" + - "\u13AC\x03\x02\x02\x02\u13AC\u13AD\x07R\x02\x02\u13AD\u13AE\x05\u0204" + - "\u0103\x02\u13AE\u13AF\x05\u0530\u0299\x02\u13AF\u13B0\x07v\x02\x02\u13B0" + - "\u13B1\x05\u021E\u0110\x02\u13B1\u1401\x03\x02\x02\x02\u13B2\u13B3\x07" + - "\u0140\x02\x02\u13B3\u13B5\x07\xEF\x02\x02\u13B4\u13B6\x05\u021C\u010F" + - "\x02\u13B5\u13B4\x03\x02\x02\x02\u13B5\u13B6\x03\x02\x02\x02\u13B6\u13B7" + - "\x03\x02\x02\x02\u13B7\u13B8\x07R\x02\x02\u13B8\u13B9\x07\u0161\x02\x02" + - "\u13B9\u13BA\x05\u0454\u022B\x02\u13BA\u13BB\x07v\x02\x02\u13BB\u13BC" + - "\x05\u021E\u0110\x02\u13BC\u1401\x03\x02\x02\x02\u13BD\u13BE\x07\u0140" + - "\x02\x02\u13BE\u13C0\x07\xEF\x02\x02\u13BF\u13C1\x05\u021C\u010F\x02\u13C0" + - "\u13BF\x03\x02\x02\x02\u13C0\u13C1\x03\x02\x02\x02\u13C1\u13C2\x03\x02" + - "\x02\x02\u13C2\u13C3\x07R\x02\x02\u13C3\u13C4\x07\xBF\x02\x02\u13C4\u13C5" + - "\x05\u0454\u022B\x02\u13C5\u13C6\x07v\x02\x02\u13C6\u13C7\x05\u021E\u0110" + - "\x02\u13C7\u1401\x03\x02\x02\x02\u13C8\u13C9\x07\u0140\x02\x02\u13C9\u13CB" + - "\x07\xEF\x02\x02\u13CA\u13CC\x05\u021C\u010F\x02\u13CB\u13CA\x03\x02\x02" + - "\x02\u13CB\u13CC\x03\x02\x02\x02\u13CC\u13CD\x03\x02\x02\x02\u13CD\u13CE" + - "\x07R\x02\x02\u13CE\u13CF\x07\x8A\x02\x02\u13CF\u13D0\x05\u028A\u0146" + - "\x02\u13D0\u13D1\x07v\x02\x02\u13D1\u13D2\x05\u021E\u0110\x02\u13D2\u1401" + - "\x03\x02\x02\x02\u13D3\u13D4\x07\u0140\x02\x02\u13D4\u13D6\x07\xEF\x02" + - "\x02\u13D5\u13D7\x05\u021C\u010F\x02\u13D6\u13D5\x03\x02\x02\x02\u13D6" + - "\u13D7\x03\x02\x02\x02\u13D7\u13D8\x03\x02\x02\x02\u13D8\u13D9\x07R\x02" + - "\x02\u13D9\u13DA\x07\xD5\x02\x02\u13DA\u13DB\x05\u0272\u013A\x02\u13DB" + - "\u13DC\x07v\x02\x02\u13DC\u13DD\x05\u021E\u0110\x02\u13DD\u1401\x03\x02" + - "\x02\x02\u13DE\u13DF\x07\u0140\x02\x02\u13DF\u13E1\x07\xEF\x02\x02\u13E0" + - "\u13E2\x05\u021C\u010F\x02\u13E1\u13E0\x03\x02\x02\x02\u13E1\u13E2\x03" + - "\x02\x02\x02\u13E2\u13E3\x03\x02\x02\x02\u13E3\u13E4\x07R\x02\x02\u13E4" + - "\u13E5\x07\xF1\x02\x02\u13E5\u13E6\x07\u010B\x02\x02\u13E6\u13E7\x05\u0124" + - "\x93\x02\u13E7\u13E8\x07v\x02\x02\u13E8\u13E9\x05\u021E\u0110\x02\u13E9" + - "\u1401\x03\x02\x02\x02\u13EA\u13EB\x07\u0140\x02\x02\u13EB\u13ED\x07\xEF" + - "\x02\x02\u13EC\u13EE\x05\u021C\u010F\x02\u13ED\u13EC\x03\x02\x02\x02\u13ED" + - "\u13EE\x03\x02\x02\x02\u13EE\u13EF\x03\x02\x02\x02\u13EF\u13F0\x07R\x02" + - "\x02\u13F0\u13F1\x07\u0121\x02\x02\u13F1\u13F2\x05\u0272\u013A\x02\u13F2" + - "\u13F3\x07v\x02\x02\u13F3\u13F4\x05\u021E\u0110\x02\u13F4\u1401\x03\x02" + - "\x02\x02\u13F5\u13F6\x07\u0140\x02\x02\u13F6\u13F8\x07\xEF\x02\x02\u13F7" + - "\u13F9\x05\u021C\u010F\x02\u13F8\u13F7\x03\x02\x02\x02\u13F8\u13F9\x03" + - "\x02\x02\x02\u13F9\u13FA\x03\x02\x02\x02\u13FA\u13FB\x07R\x02\x02\u13FB" + - "\u13FC\x07\u01B3\x02\x02\u13FC\u13FD\x05\u0272\u013A\x02\u13FD\u13FE\x07" + - "v\x02\x02\u13FE\u13FF\x05\u021E\u0110\x02\u13FF\u1401\x03\x02\x02\x02" + - "\u1400\u1391\x03\x02\x02\x02\u1400\u139C\x03\x02\x02\x02\u1400\u13A7\x03" + - "\x02\x02\x02\u1400\u13B2\x03\x02\x02\x02\u1400\u13BD\x03\x02\x02\x02\u1400" + - "\u13C8\x03\x02\x02\x02\u1400\u13D3\x03\x02\x02\x02\u1400\u13DE\x03\x02" + - "\x02\x02\u1400\u13EA\x03\x02\x02\x02\u1400\u13F5\x03\x02\x02\x02\u1401" + - "\u021B\x03\x02\x02\x02\u1402\u1403\x07@\x02\x02\u1403\u1404\x05H%\x02" + - "\u1404\u021D\x03\x02\x02\x02\u1405\u1408\x05\u0542\u02A2\x02\u1406\u1408" + - "\x07P\x02\x02\u1407\u1405\x03\x02\x02\x02\u1407\u1406\x03\x02\x02\x02" + - "\u1408\u021F\x03\x02\x02\x02\u1409\u140A\x07?\x02\x02\u140A\u140E\x05" + - "\u0222\u0112\x02\u140B\u140C\x07\u0102\x02\x02\u140C\u140E\x05\u0222\u0112" + - "\x02\u140D\u1409\x03\x02\x02\x02\u140D\u140B\x03\x02\x02\x02\u140E\u0221" + - "\x03\x02\x02\x02\u140F\u1465\x05\u03B2\u01DA\x02\u1410\u1411\x05\u0224" + - "\u0113\x02\u1411\u1412\x05\u03B2\u01DA\x02\u1412\u1465\x03\x02\x02\x02" + - "\u1413\u1415\x07\u0105\x02\x02\u1414\u1416\x05\u0226\u0114\x02\u1415\u1414" + - "\x03\x02\x02\x02\u1415\u1416\x03\x02\x02\x02\u1416\u1417\x03\x02\x02\x02" + - "\u1417\u1465\x05\u03B2\u01DA\x02\u1418\u141A\x07\u011E\x02\x02\u1419\u141B" + - "\x05\u0226\u0114\x02\u141A\u1419\x03\x02\x02\x02\u141A\u141B\x03\x02\x02" + - "\x02\u141B\u141C\x03\x02\x02\x02\u141C\u1465\x05\u03B2\u01DA\x02\u141D" + - "\u141F\x07\xD1\x02\x02\u141E\u1420\x05\u0226\u0114\x02\u141F\u141E\x03" + - "\x02\x02\x02\u141F\u1420\x03\x02\x02\x02\u1420\u1421\x03\x02\x02\x02\u1421" + - "\u1465\x05\u03B2\u01DA\x02\u1422\u1424\x07\xF2\x02\x02\u1423\u1425\x05" + - "\u0226\u0114\x02\u1424\u1423\x03\x02\x02\x02\u1424\u1425\x03\x02\x02\x02" + - "\u1425\u1426\x03\x02\x02\x02\u1426\u1465\x05\u03B2\u01DA\x02\u1427\u1428" + - "\x07\x84\x02\x02\u1428\u142A\x05\u0548\u02A5\x02\u1429\u142B\x05\u0226" + - "\u0114\x02\u142A\u1429\x03\x02\x02\x02\u142A\u142B\x03\x02\x02\x02\u142B" + - "\u142C\x03\x02\x02\x02\u142C\u142D\x05\u03B2\u01DA\x02\u142D\u1465\x03" + - "\x02\x02\x02\u142E\u142F\x07\u012C\x02\x02\u142F\u1431\x05\u0548\u02A5" + - "\x02\u1430\u1432\x05\u0226\u0114\x02\u1431\u1430\x03\x02\x02\x02\u1431" + - "\u1432\x03\x02\x02\x02\u1432\u1433\x03\x02\x02\x02\u1433\u1434\x05\u03B2" + - "\u01DA\x02\u1434\u1465\x03\x02\x02\x02\u1435\u1437\x05\u0548\u02A5\x02" + - "\u1436\u1438\x05\u0226\u0114\x02\u1437\u1436\x03\x02\x02\x02\u1437\u1438" + - "\x03\x02\x02\x02\u1438\u1439\x03\x02\x02\x02\u1439\u143A\x05\u03B2\u01DA" + - "\x02\u143A\u1465\x03\x02\x02\x02\u143B\u143D\x07 \x02\x02\u143C\u143E" + - "\x05\u0226\u0114\x02\u143D\u143C\x03\x02\x02\x02\u143D\u143E\x03\x02\x02" + - "\x02\u143E\u143F\x03\x02\x02\x02\u143F\u1465\x05\u03B2\u01DA\x02\u1440" + - "\u1442\x07\xD4\x02\x02\u1441\u1443\x05\u0226\u0114\x02\u1442\u1441\x03" + - "\x02\x02\x02\u1442\u1443\x03\x02\x02\x02\u1443\u1444\x03\x02\x02\x02\u1444" + - "\u1465\x05\u03B2\u01DA\x02\u1445\u1446\x07\xD4\x02\x02\u1446\u1448\x05" + - "\u0548\u02A5\x02\u1447\u1449\x05\u0226\u0114\x02\u1448\u1447\x03\x02\x02" + - "\x02\u1448\u1449\x03\x02\x02\x02\u1449\u144A\x03\x02\x02\x02\u144A\u144B" + - "\x05\u03B2\u01DA\x02\u144B\u1465\x03\x02\x02\x02\u144C\u144D\x07\xD4\x02" + - "\x02\u144D\u144F\x07 \x02\x02\u144E\u1450\x05\u0226\u0114\x02\u144F\u144E" + - "\x03\x02\x02\x02\u144F\u1450\x03\x02\x02\x02\u1450\u1451\x03\x02\x02\x02" + - "\u1451\u1465\x05\u03B2\u01DA\x02\u1452\u1454\x07\x92\x02\x02\u1453\u1455" + - "\x05\u0226\u0114\x02\u1454\u1453\x03\x02\x02\x02\u1454\u1455\x03\x02\x02" + - "\x02\u1455\u1456\x03\x02\x02\x02\u1456\u1465\x05\u03B2\u01DA\x02\u1457" + - "\u1458\x07\x92\x02\x02\u1458\u145A\x05\u0548\u02A5\x02\u1459\u145B\x05" + - "\u0226\u0114\x02\u145A\u1459\x03\x02\x02\x02\u145A\u145B\x03\x02\x02\x02" + - "\u145B\u145C\x03\x02\x02\x02\u145C\u145D\x05\u03B2\u01DA\x02\u145D\u1465" + - "\x03\x02\x02\x02\u145E\u145F\x07\x92\x02\x02\u145F\u1461\x07 \x02\x02" + - "\u1460\u1462\x05\u0226\u0114\x02\u1461\u1460\x03\x02\x02\x02\u1461\u1462" + - "\x03\x02\x02\x02\u1462\u1463\x03\x02\x02\x02\u1463\u1465\x05\u03B2\u01DA" + - "\x02\u1464\u140F\x03\x02\x02\x02\u1464\u1410\x03\x02\x02\x02\u1464\u1413" + - "\x03\x02\x02\x02\u1464\u1418\x03\x02\x02\x02\u1464\u141D\x03\x02\x02\x02" + - "\u1464\u1422\x03\x02\x02\x02\u1464\u1427\x03\x02\x02\x02\u1464\u142E\x03" + - "\x02\x02\x02\u1464\u1435\x03\x02\x02\x02\u1464\u143B\x03\x02\x02\x02\u1464" + - "\u1440\x03\x02\x02\x02\u1464\u1445\x03\x02\x02\x02\u1464\u144C\x03\x02" + - "\x02\x02\u1464\u1452\x03\x02\x02\x02\u1464\u1457\x03\x02\x02\x02\u1464" + - "\u145E\x03\x02\x02\x02\u1465\u0223\x03\x02\x02\x02\u1466\u1467\t\x1B\x02" + - "\x02\u1467\u0225\x03\x02\x02\x02\u1468\u1469\x05\u0224\u0113\x02\u1469" + - "\u0227\x03\x02\x02\x02\u146A\u146B\x07C\x02\x02\u146B\u146C\x05\u022C" + - "\u0117\x02\u146C\u146D\x07R\x02\x02\u146D\u146E\x05\u0232\u011A\x02\u146E" + - "\u146F\x07`\x02\x02\u146F\u1471\x05\u0234\u011B\x02\u1470\u1472\x05\u0238" + - "\u011D\x02\u1471\u1470\x03\x02\x02\x02\u1471\u1472\x03\x02\x02\x02\u1472" + - "\u0229\x03\x02\x02\x02\u1473\u1474\x07\u0136\x02\x02\u1474\u1475\x05\u022C" + - "\u0117\x02\u1475\u1476\x07R\x02\x02\u1476\u1477\x05\u0232\u011A\x02\u1477" + - "\u1478\x07B\x02\x02\u1478\u147A\x05\u0234\u011B\x02\u1479\u147B\x05l7" + - "\x02\u147A\u1479\x03\x02\x02\x02\u147A\u147B\x03\x02\x02\x02\u147B\u1489" + - "\x03\x02\x02\x02\u147C\u147D\x07\u0136\x02\x02\u147D\u147E\x07C\x02\x02" + - "\u147E\u147F\x07\u0110\x02\x02\u147F\u1480\x07@\x02\x02\u1480\u1481\x05" + - "\u022C\u0117\x02\u1481\u1482\x07R\x02\x02\u1482\u1483\x05\u0232\u011A" + - "\x02\u1483\u1484\x07B\x02\x02\u1484\u1486\x05\u0234\u011B\x02\u1485\u1487" + - "\x05l7\x02\u1486\u1485\x03\x02\x02\x02\u1486\u1487\x03\x02\x02\x02\u1487" + - "\u1489\x03\x02\x02\x02\u1488\u1473\x03\x02\x02\x02\u1488\u147C\x03\x02" + - "\x02\x02\u1489\u022B\x03\x02\x02\x02\u148A\u149A\x05\u022E\u0118\x02\u148B" + - "\u149A\x07 \x02\x02\u148C\u148D\x07 \x02\x02\u148D\u149A\x07\u011F\x02" + - "\x02\u148E\u148F\x07 \x02\x02\u148F\u1490\x07\x04\x02\x02\u1490\u1491" + - "\x05\xD8m\x02\u1491\u1492\x07\x05\x02\x02\u1492\u149A\x03\x02\x02\x02" + - "\u1493\u1494\x07 \x02\x02\u1494\u1495\x07\u011F\x02\x02\u1495\u1496\x07" + - "\x04\x02\x02\u1496\u1497\x05\xD8m\x02\u1497\u1498\x07\x05\x02\x02\u1498" + - "\u149A\x03\x02\x02\x02\u1499\u148A\x03\x02\x02\x02\u1499\u148B\x03\x02" + - "\x02\x02\u1499\u148C\x03\x02\x02\x02\u1499\u148E\x03\x02\x02\x02\u1499" + - "\u1493\x03\x02\x02\x02\u149A\u022D\x03\x02\x02\x02\u149B\u14A0\x05\u0230" + - "\u0119\x02\u149C\u149D\x07\b\x02\x02\u149D\u149F\x05\u0230\u0119\x02\u149E" + - "\u149C\x03\x02\x02\x02\u149F\u14A2\x03\x02\x02\x02\u14A0\u149E\x03\x02" + - "\x02\x02\u14A0\u14A1\x03\x02\x02\x02\u14A1\u022F\x03\x02\x02\x02\u14A2" + - "\u14A0\x03\x02\x02\x02\u14A3\u14A5\x07Z\x02\x02\u14A4\u14A6\x05\xD6l\x02" + - "\u14A5\u14A4\x03\x02\x02\x02\u14A5\u14A6\x03\x02\x02\x02\u14A6\u14B4\x03" + - "\x02\x02\x02\u14A7\u14A9\x07X\x02\x02\u14A8\u14AA\x05\xD6l\x02\u14A9\u14A8" + - "\x03\x02\x02\x02\u14A9\u14AA\x03\x02\x02\x02\u14AA\u14B4\x03\x02\x02\x02" + - "\u14AB\u14AD\x070\x02\x02\u14AC\u14AE\x05\xD6l\x02\u14AD\u14AC\x03\x02" + - "\x02\x02\u14AD\u14AE\x03\x02\x02\x02\u14AE\u14B4\x03\x02\x02\x02\u14AF" + - "\u14B1\x05\u0550\u02A9\x02\u14B0\u14B2\x05\xD6l\x02\u14B1\u14B0\x03\x02" + - "\x02\x02\u14B1\u14B2\x03\x02\x02\x02\u14B2\u14B4\x03\x02\x02\x02\u14B3" + - "\u14A3\x03\x02\x02\x02\u14B3\u14A7\x03\x02\x02\x02\u14B3\u14AB\x03\x02" + - "\x02\x02\u14B3\u14AF\x03\x02\x02\x02\u14B4\u0231\x03\x02\x02\x02\u14B5" + - "\u14F0\x05\u052A\u0296\x02\u14B6\u14B7\x07^\x02\x02\u14B7\u14F0\x05\u052A" + - "\u0296\x02\u14B8\u14B9\x07\u0141\x02\x02\u14B9\u14F0\x05\u052A\u0296\x02" + - "\u14BA\u14BB\x07A\x02\x02\u14BB\u14BC\x07\xB0\x02\x02\u14BC\u14BD\x07" + - "\u0176\x02\x02\u14BD\u14F0\x05\u052E\u0298\x02\u14BE\u14BF\x07A\x02\x02" + - "\u14BF\u14C0\x07\u0144\x02\x02\u14C0\u14F0\x05\u052E\u0298\x02\u14C1\u14C2" + - "\x07\xD5\x02\x02\u14C2\u14F0\x05\u0270\u0139\x02\u14C3\u14C4\x07\u0121" + - "\x02\x02\u14C4\u14F0\x05\u0270\u0139\x02\u14C5\u14C6\x07\u01B3\x02\x02" + - "\u14C6\u14F0\x05\u0270\u0139\x02\u14C7\u14C8\x07\xB1\x02\x02\u14C8\u14F0" + - "\x05\u052E\u0298\x02\u14C9\u14CA\x07\xBF\x02\x02\u14CA\u14F0\x05\u020A" + - "\u0106\x02\u14CB\u14CC\x07\xF0\x02\x02\u14CC\u14F0\x05\u052E\u0298\x02" + - "\u14CD\u14CE\x07\xF1\x02\x02\u14CE\u14CF\x07\u010B\x02\x02\u14CF\u14F0" + - "\x05\u0126\x94\x02\u14D0\u14D1\x07\u013C\x02\x02\u14D1\u14F0\x05\u052E" + - "\u0298\x02\u14D2\u14D3\x07\u0158\x02\x02\u14D3\u14F0\x05\u052E\u0298\x02" + - "\u14D4\u14D5\x07\u0161\x02\x02\u14D5\u14F0\x05\u020A\u0106\x02\u14D6\u14D7" + - "\x07 \x02\x02\u14D7\u14D8\x07\u0157\x02\x02\u14D8\u14D9\x07F\x02\x02\u14D9" + - "\u14DA\x07\u013C\x02\x02\u14DA\u14F0\x05\u052E\u0298\x02\u14DB\u14DC\x07" + - " \x02\x02\u14DC\u14DD\x07\u0142\x02\x02\u14DD\u14DE\x07F\x02\x02\u14DE" + - "\u14DF\x07\u013C\x02\x02\u14DF\u14F0\x05\u052E\u0298\x02\u14E0\u14E1\x07" + - " \x02\x02\u14E1\u14E2\x07\xD6\x02\x02\u14E2\u14E3\x07F\x02\x02\u14E3\u14E4" + - "\x07\u013C\x02\x02\u14E4\u14F0\x05\u052E\u0298\x02\u14E5\u14E6\x07 \x02" + - "\x02\u14E6\u14E7\x07\u01C2\x02\x02\u14E7\u14E8\x07F\x02\x02\u14E8\u14E9" + - "\x07\u013C\x02\x02\u14E9\u14F0\x05\u052E\u0298\x02\u14EA\u14EB\x07 \x02" + - "\x02\u14EB\u14EC\x07\u01C0\x02\x02\u14EC\u14ED\x07F\x02\x02\u14ED\u14EE" + - "\x07\u013C\x02\x02\u14EE\u14F0\x05\u052E\u0298\x02\u14EF\u14B5\x03\x02" + - "\x02\x02\u14EF\u14B6\x03\x02\x02\x02\u14EF\u14B8\x03\x02\x02\x02\u14EF" + - "\u14BA\x03\x02\x02\x02\u14EF\u14BE\x03\x02\x02\x02\u14EF\u14C1\x03\x02" + - "\x02\x02\u14EF\u14C3\x03\x02\x02\x02\u14EF\u14C5\x03\x02\x02\x02\u14EF" + - "\u14C7\x03\x02\x02\x02\u14EF\u14C9\x03\x02\x02\x02\u14EF\u14CB\x03\x02" + - "\x02\x02\u14EF\u14CD\x03\x02\x02\x02\u14EF\u14D0\x03\x02\x02\x02\u14EF" + - "\u14D2\x03\x02\x02\x02\u14EF\u14D4\x03\x02\x02\x02\u14EF\u14D6\x03\x02" + - "\x02\x02\u14EF\u14DB\x03\x02\x02\x02\u14EF\u14E0\x03\x02\x02\x02\u14EF" + - "\u14E5\x03\x02\x02\x02\u14EF\u14EA\x03\x02\x02\x02\u14F0\u0233\x03\x02" + - "\x02\x02\u14F1\u14F6\x05\u0236\u011C\x02\u14F2\u14F3\x07\b\x02\x02\u14F3" + - "\u14F5\x05\u0236\u011C\x02\u14F4\u14F2\x03\x02\x02\x02\u14F5\u14F8\x03" + - "\x02\x02\x02\u14F6\u14F4\x03\x02\x02\x02\u14F6\u14F7\x03\x02\x02\x02\u14F7" + - "\u0235\x03\x02\x02\x02\u14F8\u14F6\x03\x02\x02\x02\u14F9\u14FD\x05\u054C" + - "\u02A7\x02\u14FA\u14FB\x07D\x02\x02\u14FB\u14FD\x05\u054C\u02A7\x02\u14FC" + - "\u14F9\x03\x02\x02\x02\u14FC\u14FA\x03\x02\x02\x02\u14FD\u0237\x03\x02" + - "\x02\x02\u14FE\u14FF\x07k\x02\x02\u14FF\u1500\x07C\x02\x02\u1500\u1501" + - "\x07\u0110\x02\x02\u1501\u0239\x03\x02\x02\x02\u1502\u1503\x07C\x02\x02" + - "\u1503\u1504\x05\u022E\u0118\x02\u1504\u1505\x07`\x02\x02\u1505\u1507" + - "\x05\u054E\u02A8\x02\u1506\u1508\x05\u023E\u0120\x02\u1507\u1506\x03\x02" + - "\x02\x02\u1507\u1508\x03\x02\x02\x02\u1508\u150A\x03\x02\x02\x02\u1509" + - "\u150B\x05\u0240\u0121\x02\u150A\u1509\x03\x02\x02\x02\u150A\u150B\x03" + - "\x02\x02\x02\u150B\u023B\x03\x02\x02\x02\u150C\u150D\x07\u0136\x02\x02" + - "\u150D\u150E\x05\u022E\u0118\x02\u150E\u150F\x07B\x02\x02\u150F\u1511" + - "\x05\u054E\u02A8\x02\u1510\u1512\x05\u0240\u0121\x02\u1511\u1510\x03\x02" + - "\x02\x02\u1511\u1512\x03\x02\x02\x02\u1512\u1514\x03\x02\x02\x02\u1513" + - "\u1515\x05l7\x02\u1514\u1513\x03\x02\x02\x02\u1514\u1515\x03\x02\x02\x02" + - "\u1515\u1524\x03\x02\x02\x02\u1516\u1517\x07\u0136\x02\x02\u1517\u1518" + - "\x07\x88\x02\x02\u1518\u1519\x07\u0110\x02\x02\u1519\u151A\x07@\x02\x02" + - "\u151A\u151B\x05\u022E\u0118\x02\u151B\u151C\x07B\x02\x02\u151C\u151E" + - "\x05\u054E\u02A8\x02\u151D\u151F\x05\u0240\u0121\x02\u151E\u151D\x03\x02" + - "\x02\x02\u151E\u151F\x03\x02\x02\x02\u151F\u1521\x03\x02\x02\x02\u1520" + - "\u1522\x05l7\x02\u1521\u1520\x03\x02\x02\x02\u1521\u1522\x03\x02\x02\x02" + - "\u1522\u1524\x03\x02\x02\x02\u1523\u150C\x03\x02\x02\x02\u1523\u1516\x03" + - "\x02\x02\x02\u1524\u023D\x03\x02\x02\x02\u1525\u1526\x07k\x02\x02\u1526" + - "\u1527\x07\x88\x02\x02\u1527\u1528\x07\u0110\x02\x02\u1528\u023F\x03\x02" + - "\x02\x02\u1529\u152A\x07\xD8\x02\x02\u152A\u152B\x07\x95\x02\x02\u152B" + - "\u152C\x05\u054C\u02A7\x02\u152C\u0241\x03\x02\x02\x02\u152D\u152E\x07" + - "\x8C\x02\x02\u152E\u152F\x077\x02\x02\u152F\u1530\x07\u011F\x02\x02\u1530" + - "\u1531\x05\u0244\u0123\x02\u1531\u1532\x05\u0248\u0125\x02\u1532\u0243" + - "\x03\x02\x02\x02\u1533\u1535\x05\u0246\u0124\x02\u1534\u1533\x03\x02\x02" + - "\x02\u1535\u1538\x03\x02\x02\x02\u1536\u1534\x03\x02\x02\x02\u1536\u1537" + - "\x03\x02\x02\x02\u1537\u0245\x03\x02\x02\x02\u1538\u1536\x03\x02\x02\x02" + - "\u1539\u153A\x07F\x02\x02\u153A\u153B\x07\u013C\x02\x02\u153B\u1543\x05" + - "\u052E\u0298\x02\u153C\u153D\x07@\x02\x02\u153D\u153E\x07\u0137\x02\x02" + - "\u153E\u1543\x05\u054E\u02A8\x02\u153F\u1540\x07@\x02\x02\u1540\u1541" + - "\x07e\x02\x02\u1541\u1543\x05\u054E\u02A8\x02\u1542\u1539\x03\x02\x02" + - "\x02\u1542\u153C\x03\x02\x02\x02\u1542\u153F\x03\x02\x02\x02\u1543\u0247" + - "\x03\x02\x02\x02\u1544\u1545\x07C\x02\x02\u1545\u1546\x05\u022C\u0117" + - "\x02\u1546\u1547\x07R\x02\x02\u1547\u1548\x05\u024A\u0126\x02\u1548\u1549" + - "\x07`\x02\x02\u1549\u154B\x05\u0234\u011B\x02\u154A\u154C\x05\u0238\u011D" + - "\x02\u154B\u154A\x03\x02\x02\x02\u154B\u154C\x03\x02\x02\x02\u154C\u1563" + - "\x03\x02\x02\x02\u154D\u154E\x07\u0136\x02\x02\u154E\u154F\x05\u022C\u0117" + - "\x02\u154F\u1550\x07R\x02\x02\u1550\u1551\x05\u024A\u0126\x02\u1551\u1552" + - "\x07B\x02\x02\u1552\u1554\x05\u0234\u011B\x02\u1553\u1555\x05l7\x02\u1554" + - "\u1553\x03\x02\x02\x02\u1554\u1555\x03\x02\x02\x02\u1555\u1563\x03\x02" + - "\x02\x02\u1556\u1557\x07\u0136\x02\x02\u1557\u1558\x07C\x02\x02\u1558" + - "\u1559\x07\u0110\x02\x02\u1559\u155A\x07@\x02\x02\u155A\u155B\x05\u022C" + - "\u0117\x02\u155B\u155C\x07R\x02\x02\u155C\u155D\x05\u024A\u0126\x02\u155D" + - "\u155E\x07B\x02\x02\u155E\u1560\x05\u0234\u011B\x02\u155F\u1561\x05l7" + - "\x02\u1560\u155F\x03\x02\x02\x02\u1560\u1561\x03\x02\x02\x02\u1561\u1563" + - "\x03\x02\x02\x02\u1562\u1544\x03\x02\x02\x02\u1562\u154D\x03\x02\x02\x02" + - "\u1562\u1556\x03\x02\x02\x02\u1563\u0249\x03\x02\x02\x02\u1564\u1565\t" + - "\x1C\x02\x02\u1565\u024B\x03\x02\x02\x02\u1566\u1568\x070\x02\x02\u1567" + - "\u1569\x05\u024E\u0128\x02\u1568\u1567\x03\x02\x02\x02\u1568\u1569\x03" + - "\x02\x02\x02\u1569\u156A\x03\x02\x02\x02\u156A\u156C\x07\xE4\x02\x02\u156B" + - "\u156D\x05\u0250\u0129\x02\u156C\u156B\x03\x02\x02\x02\u156C\u156D\x03" + - "\x02\x02\x02\u156D\u156F\x03\x02\x02\x02\u156E\u1570\x05\u0252\u012A\x02" + - "\u156F\u156E\x03\x02\x02\x02\u156F\u1570\x03\x02\x02\x02\u1570\u1571\x03" + - "\x02\x02\x02\u1571\u1572\x07R\x02\x02\u1572\u1574\x05\u0428\u0215\x02" + - "\u1573\u1575\x05\u0254\u012B\x02\u1574\u1573\x03\x02\x02\x02\u1574\u1575" + - "\x03\x02\x02\x02\u1575\u1576\x03\x02\x02\x02\u1576\u1577\x07\x04\x02\x02" + - "\u1577\u1578\x05\u0256\u012C\x02\u1578\u157A\x07\x05\x02\x02\u1579\u157B" + - "\x05\u025C\u012F\x02\u157A\u1579\x03\x02\x02\x02\u157A\u157B\x03\x02\x02" + - "\x02\u157B\u157D\x03\x02\x02\x02\u157C\u157E\x05v<\x02\u157D\u157C\x03" + - "\x02\x02\x02\u157D\u157E\x03\x02\x02\x02\u157E\u1580\x03\x02\x02\x02\u157F" + - "\u1581\x05\xFE\x80\x02\u1580\u157F\x03\x02\x02\x02\u1580\u1581\x03\x02" + - "\x02\x02\u1581\u1583\x03\x02\x02\x02\u1582\u1584\x05\u043C\u021F\x02\u1583" + - "\u1582\x03\x02\x02\x02\u1583\u1584\x03\x02\x02\x02\u1584\u15A6\x03\x02" + - "\x02\x02\u1585\u1587\x070\x02\x02\u1586\u1588\x05\u024E\u0128\x02\u1587" + - "\u1586\x03\x02\x02\x02\u1587\u1588\x03\x02\x02\x02\u1588\u1589\x03\x02" + - "\x02\x02\u1589\u158B\x07\xE4\x02\x02\u158A\u158C\x05\u0250\u0129\x02\u158B" + - "\u158A\x03\x02\x02\x02\u158B\u158C\x03\x02\x02\x02\u158C\u158D\x03\x02" + - "\x02\x02\u158D\u158E\x07\xDE\x02\x02\u158E\u158F\x07O\x02\x02\u158F\u1590" + - "\x07\u0185\x02\x02\u1590\u1591\x05\u0530\u0299\x02\u1591\u1592\x07R\x02" + - "\x02\u1592\u1594\x05\u0428\u0215\x02\u1593\u1595\x05\u0254\u012B\x02\u1594" + - "\u1593\x03\x02\x02\x02\u1594\u1595\x03\x02\x02\x02\u1595\u1596\x03\x02" + - "\x02\x02\u1596\u1597\x07\x04\x02\x02\u1597\u1598\x05\u0256\u012C\x02\u1598" + - "\u159A\x07\x05\x02\x02\u1599\u159B\x05\u025C\u012F\x02\u159A\u1599\x03" + - "\x02\x02\x02\u159A\u159B\x03\x02\x02\x02\u159B\u159D\x03\x02\x02\x02\u159C" + - "\u159E\x05v<\x02\u159D\u159C\x03\x02\x02\x02\u159D\u159E\x03\x02\x02\x02" + - "\u159E\u15A0\x03\x02\x02\x02\u159F\u15A1\x05\xFE\x80\x02\u15A0\u159F\x03" + - "\x02\x02\x02\u15A0\u15A1\x03\x02\x02\x02\u15A1\u15A3\x03\x02\x02\x02\u15A2" + - "\u15A4\x05\u043C\u021F\x02\u15A3\u15A2\x03\x02\x02\x02\u15A3\u15A4\x03" + - "\x02\x02\x02\u15A4\u15A6\x03\x02\x02\x02\u15A5\u1566\x03\x02\x02\x02\u15A5" + - "\u1585\x03\x02\x02\x02\u15A6\u024D\x03\x02\x02\x02\u15A7\u15A8\x07d\x02" + - "\x02\u15A8\u024F\x03\x02\x02\x02\u15A9\u15AA\x07o\x02\x02\u15AA\u0251" + - "\x03\x02\x02\x02\u15AB\u15AC\x05\u0530\u0299\x02\u15AC\u0253\x03\x02\x02" + - "\x02\u15AD\u15AE\x07f\x02\x02\u15AE\u15AF\x05\u0530\u0299\x02\u15AF\u0255" + - "\x03\x02\x02\x02\u15B0\u15B5\x05\u025A\u012E\x02\u15B1\u15B2\x07\b\x02" + - "\x02\u15B2\u15B4\x05\u025A\u012E\x02\u15B3\u15B1\x03\x02\x02\x02\u15B4" + - "\u15B7\x03\x02\x02\x02\u15B5\u15B3\x03\x02\x02\x02\u15B5\u15B6\x03\x02" + - "\x02\x02\u15B6\u0257\x03\x02\x02\x02\u15B7\u15B5\x03\x02\x02\x02\u15B8" + - "\u15BA\x05\u0260\u0131\x02\u15B9\u15B8\x03\x02\x02\x02\u15B9\u15BA\x03" + - "\x02\x02\x02\u15BA\u15BC\x03\x02\x02\x02\u15BB\u15BD\x05\u0262\u0132\x02" + - "\u15BC\u15BB\x03\x02\x02\x02\u15BC\u15BD\x03\x02\x02\x02\u15BD\u15BF\x03" + - "\x02\x02\x02\u15BE\u15C0\x05\u0264\u0133\x02\u15BF\u15BE\x03\x02\x02\x02" + - "\u15BF\u15C0\x03\x02\x02\x02\u15C0\u15C2\x03\x02\x02\x02\u15C1\u15C3\x05" + - "\u0266\u0134\x02\u15C2\u15C1\x03\x02\x02\x02\u15C2\u15C3\x03\x02\x02\x02" + - "\u15C3\u15D0\x03\x02\x02\x02\u15C4\u15C6\x05\u0260\u0131\x02\u15C5\u15C4" + - "\x03\x02\x02\x02\u15C5\u15C6\x03\x02\x02\x02\u15C6\u15C7\x03\x02\x02\x02" + - "\u15C7\u15C8\x05\u020C\u0107\x02\u15C8\u15CA\x05t;\x02\u15C9\u15CB\x05" + - "\u0264\u0133\x02\u15CA\u15C9\x03\x02\x02\x02\u15CA\u15CB\x03\x02\x02\x02" + - "\u15CB\u15CD\x03\x02\x02\x02\u15CC\u15CE\x05\u0266\u0134\x02\u15CD\u15CC" + - "\x03\x02\x02\x02\u15CD\u15CE\x03\x02\x02\x02\u15CE\u15D0\x03\x02\x02\x02" + - "\u15CF\u15B9\x03\x02\x02\x02\u15CF\u15C5\x03\x02\x02\x02\u15D0\u0259\x03" + - "\x02\x02\x02\u15D1\u15D2\x05\u0550\u02A9\x02\u15D2\u15D3\x05\u0258\u012D" + - "\x02\u15D3\u15DD\x03\x02\x02\x02\u15D4\u15D5\x05\u04B2\u025A\x02\u15D5" + - "\u15D6\x05\u0258\u012D\x02\u15D6\u15DD\x03\x02\x02\x02\u15D7\u15D8\x07" + - "\x04\x02\x02\u15D8\u15D9\x05\u0480\u0241\x02\u15D9\u15DA\x07\x05\x02\x02" + - "\u15DA\u15DB\x05\u0258\u012D\x02\u15DB\u15DD\x03\x02\x02\x02\u15DC\u15D1" + - "\x03\x02\x02\x02\u15DC\u15D4\x03\x02\x02\x02\u15DC\u15D7\x03\x02\x02\x02" + - "\u15DD\u025B\x03\x02\x02\x02\u15DE\u15DF\x07\u01B2\x02\x02\u15DF\u15E0" + - "\x07\x04\x02\x02\u15E0\u15E1\x05\u025E\u0130\x02\u15E1\u15E2\x07\x05\x02" + - "\x02\u15E2\u025D\x03\x02\x02\x02\u15E3\u15E8\x05\u025A\u012E\x02\u15E4" + - "\u15E5\x07\b\x02\x02\u15E5\u15E7\x05\u025A\u012E\x02\u15E6\u15E4\x03\x02" + - "\x02\x02\u15E7\u15EA\x03\x02\x02\x02\u15E8\u15E6\x03\x02\x02\x02\u15E8" + - "\u15E9\x03\x02\x02\x02\u15E9\u025F\x03\x02\x02\x02\u15EA\u15E8\x03\x02" + - "\x02\x02\u15EB\u15EC\x07-\x02\x02\u15EC\u15ED\x05\u020C\u0107\x02\u15ED" + - "\u0261\x03\x02\x02\x02\u15EE\u15EF\x05\u020C\u0107\x02\u15EF\u0263\x03" + - "\x02\x02\x02\u15F0\u15F1\t\x1D\x02\x02\u15F1\u0265\x03\x02\x02\x02\u15F2" + - "\u15F3\x07\u010A\x02\x02\u15F3\u15F7\x07\xD1\x02\x02\u15F4\u15F5\x07\u010A" + - "\x02\x02\u15F5\u15F7\x07\xF2\x02\x02\u15F6\u15F2\x03\x02\x02\x02\u15F6" + - "\u15F4\x03\x02\x02\x02\u15F7\u0267\x03\x02\x02\x02\u15F8\u15FA\x070\x02" + - "\x02\u15F9\u15FB\x05\u026A\u0136\x02\u15FA\u15F9\x03\x02\x02\x02\u15FA" + - "\u15FB\x03\x02\x02\x02\u15FB\u15FC\x03\x02\x02\x02\u15FC\u15FD\t\x19\x02" + - "\x02\u15FD\u15FE\x05\u0536\u029C\x02\u15FE\u1608\x05\u0274\u013B\x02\u15FF" + - "\u1606\x07\u0135\x02\x02\u1600\u1607\x05\u027E\u0140\x02\u1601\u1602\x07" + - "^\x02\x02\u1602\u1603\x07\x04\x02\x02\u1603\u1604\x05\u029C\u014F\x02" + - "\u1604\u1605\x07\x05\x02\x02\u1605\u1607\x03\x02\x02\x02\u1606\u1600\x03" + - "\x02\x02\x02\u1606\u1601\x03\x02\x02\x02\u1607\u1609\x03\x02\x02\x02\u1608" + - "\u15FF\x03\x02\x02\x02\u1608\u1609\x03\x02\x02\x02\u1609\u160A\x03\x02" + - "\x02\x02\u160A\u160B\x05\u028E\u0148\x02\u160B\u0269\x03\x02\x02\x02\u160C" + - "\u160D\x07T\x02\x02\u160D\u160E\x07\u0130\x02\x02\u160E\u026B\x03\x02" + - "\x02\x02\u160F\u1611\x07\x04\x02\x02\u1610\u1612\x05\u026E\u0138\x02\u1611" + - "\u1610\x03\x02\x02\x02\u1611\u1612\x03\x02\x02\x02\u1612\u1613\x03\x02" + - "\x02\x02\u1613\u1614\x07\x05\x02\x02\u1614\u026D\x03\x02\x02\x02\u1615" + - "\u161A\x05\u0278\u013D\x02\u1616\u1617\x07\b\x02\x02\u1617\u1619\x05\u0278" + - "\u013D\x02\u1618\u1616\x03\x02\x02\x02\u1619\u161C\x03\x02\x02\x02\u161A" + - "\u1618\x03\x02\x02\x02\u161A\u161B\x03\x02\x02\x02\u161B\u026F\x03\x02" + - "\x02\x02\u161C\u161A\x03\x02\x02\x02\u161D\u1622\x05\u0272\u013A\x02\u161E" + - "\u161F\x07\b\x02\x02\u161F\u1621\x05\u0272\u013A\x02\u1620\u161E\x03\x02" + - "\x02\x02\u1621\u1624\x03\x02\x02\x02\u1622\u1620\x03\x02\x02\x02\u1622" + - "\u1623\x03\x02\x02\x02\u1623\u0271\x03\x02\x02\x02\u1624\u1622\x03\x02" + - "\x02\x02\u1625\u1626\x05\u0536\u029C\x02\u1626\u1627\x05\u026C\u0137\x02" + - "\u1627\u162E\x03\x02\x02\x02\u1628\u162E\x05\u0560\u02B1\x02\u1629\u162B" + - "\x05\u0550\u02A9\x02\u162A\u162C\x05\u0520\u0291\x02\u162B\u162A\x03\x02" + - "\x02\x02\u162B\u162C\x03\x02\x02\x02\u162C\u162E\x03\x02\x02\x02\u162D" + - "\u1625\x03\x02\x02\x02\u162D\u1628\x03\x02\x02\x02\u162D\u1629\x03\x02" + - "\x02\x02\u162E\u0273\x03\x02\x02\x02\u162F\u1631\x07\x04\x02\x02\u1630" + - "\u1632\x05\u0276\u013C\x02\u1631\u1630\x03\x02\x02\x02\u1631\u1632\x03" + - "\x02\x02\x02\u1632\u1633\x03\x02\x02\x02\u1633\u1634\x07\x05\x02\x02\u1634" + - "\u0275\x03\x02\x02\x02\u1635"; + "\x02\u135E\u135F\x07R\x02\x02\u135F\u1360\x07\xD5\x02\x02\u1360\u1361" + + "\x05\u0280\u0141\x02\u1361\u1362\x07v\x02\x02\u1362\u1363\x05\u0220\u0111" + + "\x02\u1363\u13C7\x03\x02\x02\x02\u1364\u1365\x07\xA1\x02\x02\u1365\u1366" + + "\x07R\x02\x02\u1366\u1367\x07\u0118\x02\x02\u1367\u1368\x05\u02BE\u0160" + + "\x02\u1368\u1369\x07v\x02\x02\u1369\u136A\x05\u0220\u0111\x02\u136A\u13C7" + + "\x03\x02\x02\x02\u136B\u136C\x07\xA1\x02\x02\u136C\u136D\x07R\x02\x02" + + "\u136D\u136E\x07/\x02\x02\u136E\u136F\x05\u0540\u02A1\x02\u136F\u1370" + + "\x07R\x02\x02\u1370\u1371\x05\u0214\u010B\x02\u1371\u1372\x07v\x02\x02" + + "\u1372\u1373\x05\u0220\u0111\x02\u1373\u13C7\x03\x02\x02\x02\u1374\u1375" + + "\x07\xA1\x02\x02\u1375\u1376\x07R\x02\x02\u1376\u1377\x07/\x02\x02\u1377" + + "\u1378\x05\u0540\u02A1\x02\u1378\u1379\x07R\x02\x02\u1379\u137A\x07\xBF" + + "\x02\x02\u137A\u137B\x05\u0214\u010B\x02\u137B\u137C\x07v\x02\x02\u137C" + + "\u137D\x05\u0220\u0111\x02\u137D\u13C7\x03\x02\x02\x02\u137E\u137F\x07" + + "\xA1\x02\x02\u137F\u1380\x07R\x02\x02\u1380\u1381\x05\u0210\u0109\x02" + + "\u1381\u1382\x05\u0540\u02A1\x02\u1382\u1383\x07R\x02\x02\u1383\u1384" + + "\x05\u0214\u010B\x02\u1384\u1385\x07v\x02\x02\u1385\u1386\x05\u0220\u0111" + + "\x02\u1386\u13C7\x03\x02\x02\x02\u1387\u1388\x07\xA1\x02\x02\u1388\u1389" + + "\x07R\x02\x02\u1389\u138A\x07\u012A\x02\x02\u138A\u138B\x05\u0280\u0141" + + "\x02\u138B\u138C\x07v\x02\x02\u138C\u138D\x05\u0220\u0111\x02\u138D\u13C7" + + "\x03\x02\x02\x02\u138E\u138F\x07\xA1\x02\x02\u138F\u1390\x07R\x02\x02" + + "\u1390\u1391\x07\u01BC\x02\x02\u1391\u1392\x05\u0280\u0141\x02\u1392\u1393" + + "\x07v\x02\x02\u1393\u1394\x05\u0220\u0111\x02\u1394\u13C7\x03\x02\x02" + + "\x02\u1395\u1396\x07\xA1\x02\x02\u1396\u1397\x07R\x02\x02\u1397\u1398" + + "\x07\u01BD\x02\x02\u1398\u1399\x07@\x02\x02\u1399\u139A\x05\u0462\u0232" + + "\x02\u139A\u139B\x07\xF9\x02\x02\u139B\u139C\x05\u0540\u02A1\x02\u139C" + + "\u139D\x07v\x02\x02\u139D\u139E\x05\u0220\u0111\x02\u139E\u13C7\x03\x02" + + "\x02\x02\u139F\u13A0\x07\xA1\x02\x02\u13A0\u13A1\x07R\x02\x02\u13A1\u13A2" + + "\x07\u0118\x02\x02\u13A2\u13A3\x07\x9E\x02\x02\u13A3\u13A4\x05\u0214\u010B" + + "\x02\u13A4\u13A5\x07f\x02\x02\u13A5\u13A6\x05\u0540\u02A1\x02\u13A6\u13A7" + + "\x07v\x02\x02\u13A7\u13A8\x05\u0220\u0111\x02\u13A8\u13C7\x03\x02\x02" + + "\x02\u13A9\u13AA\x07\xA1\x02\x02\u13AA\u13AB\x07R\x02\x02\u13AB\u13AC" + + "\x07\u0118\x02\x02\u13AC\u13AD\x07\xD0\x02\x02\u13AD\u13AE\x05\u0214\u010B" + + "\x02\u13AE\u13AF\x07f\x02\x02\u13AF\u13B0\x05\u0540\u02A1\x02\u13B0\u13B1" + + "\x07v\x02\x02\u13B1\u13B2\x05\u0220\u0111\x02\u13B2\u13C7\x03\x02\x02" + + "\x02\u13B3\u13B4\x07\xA1\x02\x02\u13B4\u13B5\x07R\x02\x02\u13B5\u13B6" + + "\x07\xFA\x02\x02\u13B6\u13B7\x07\u0114\x02\x02\u13B7\u13B8\x05\u0128\x95" + + "\x02\u13B8\u13B9\x07v\x02\x02\u13B9\u13BA\x05\u0220\u0111\x02\u13BA\u13C7" + + "\x03\x02\x02\x02\u13BB\u13BC\x07\xA1\x02\x02\u13BC\u13BD\x07R\x02\x02" + + "\u13BD\u13BE\x07+\x02\x02\u13BE\u13BF\x07\x04\x02\x02\u13BF\u13C0\x05" + + "\u0462\u0232\x02\u13C0\u13C1\x07&\x02\x02\u13C1\u13C2\x05\u0462\u0232" + + "\x02\u13C2\u13C3\x07\x05\x02\x02\u13C3\u13C4\x07v\x02\x02\u13C4\u13C5" + + "\x05\u0220\u0111\x02\u13C5\u13C7\x03\x02\x02\x02\u13C6\u1333\x03\x02\x02" + + "\x02\u13C6\u133A\x03\x02\x02\x02\u13C6\u1341\x03\x02\x02\x02\u13C6\u1348" + + "\x03\x02\x02\x02\u13C6\u134F\x03\x02\x02\x02\u13C6\u1356\x03\x02\x02\x02" + + "\u13C6\u135D\x03\x02\x02\x02\u13C6\u1364\x03\x02\x02\x02\u13C6\u136B\x03" + + "\x02\x02\x02\u13C6\u1374\x03\x02\x02\x02\u13C6\u137E\x03\x02\x02\x02\u13C6" + + "\u1387\x03\x02\x02\x02\u13C6\u138E\x03\x02\x02\x02\u13C6\u1395\x03\x02" + + "\x02\x02\u13C6\u139F\x03\x02\x02\x02\u13C6\u13A9\x03\x02\x02\x02\u13C6" + + "\u13B3\x03\x02\x02\x02\u13C6\u13BB\x03\x02\x02\x02\u13C7\u021F\x03\x02" + + "\x02\x02\u13C8\u13CB\x05\u0552\u02AA\x02\u13C9\u13CB\x07P\x02\x02\u13CA" + + "\u13C8\x03\x02\x02\x02\u13CA\u13C9\x03\x02\x02\x02\u13CB\u0221\x03\x02" + + "\x02\x02\u13CC\u13CD\x07\u0149\x02\x02\u13CD\u13CF\x07\xF8\x02\x02\u13CE" + + "\u13D0\x05\u0224\u0113\x02\u13CF\u13CE\x03\x02\x02\x02\u13CF\u13D0\x03" + + "\x02\x02\x02\u13D0\u13D1\x03\x02\x02\x02\u13D1\u13D2\x07R\x02\x02\u13D2" + + "\u13D3\x05\u020A\u0106\x02\u13D3\u13D4\x05\u0214\u010B\x02\u13D4\u13D5" + + "\x07v\x02\x02\u13D5\u13D6\x05\u0226\u0114\x02\u13D6\u143C\x03\x02\x02" + + "\x02\u13D7\u13D8\x07\u0149\x02\x02\u13D8\u13DA\x07\xF8\x02\x02\u13D9\u13DB" + + "\x05\u0224\u0113\x02\u13DA\u13D9\x03\x02\x02\x02\u13DA\u13DB\x03\x02\x02" + + "\x02\u13DB\u13DC\x03\x02\x02\x02\u13DC\u13DD\x07R\x02\x02\u13DD\u13DE" + + "\x07.\x02\x02\u13DE\u13DF\x05\u0214\u010B\x02\u13DF\u13E0\x07v\x02\x02" + + "\u13E0\u13E1\x05\u0226\u0114\x02\u13E1\u143C\x03\x02\x02\x02\u13E2\u13E3" + + "\x07\u0149\x02\x02\u13E3\u13E5\x07\xF8\x02\x02\u13E4\u13E6\x05\u0224\u0113" + + "\x02\u13E5\u13E4\x03\x02\x02\x02\u13E5\u13E6\x03\x02\x02\x02\u13E6\u13E7" + + "\x03\x02\x02\x02\u13E7\u13E8\x07R\x02\x02\u13E8\u13E9\x05\u020C\u0107" + + "\x02\u13E9\u13EA\x05\u0540\u02A1\x02\u13EA\u13EB\x07v\x02\x02\u13EB\u13EC" + + "\x05\u0226\u0114\x02\u13EC\u143C\x03\x02\x02\x02\u13ED\u13EE\x07\u0149" + + "\x02\x02\u13EE\u13F0\x07\xF8\x02\x02\u13EF\u13F1\x05\u0224\u0113\x02\u13F0" + + "\u13EF\x03\x02\x02\x02\u13F0\u13F1\x03\x02\x02\x02\u13F1\u13F2\x03\x02" + + "\x02\x02\u13F2\u13F3\x07R\x02\x02\u13F3\u13F4\x07\u016A\x02\x02\u13F4" + + "\u13F5\x05\u0462\u0232\x02\u13F5\u13F6\x07v\x02\x02\u13F6\u13F7\x05\u0226" + + "\u0114\x02\u13F7\u143C\x03\x02\x02\x02\u13F8\u13F9\x07\u0149\x02\x02\u13F9" + + "\u13FB\x07\xF8\x02\x02\u13FA\u13FC\x05\u0224\u0113\x02\u13FB\u13FA\x03" + + "\x02\x02\x02\u13FB\u13FC\x03\x02\x02\x02\u13FC\u13FD\x03\x02\x02\x02\u13FD" + + "\u13FE\x07R\x02\x02\u13FE\u13FF\x07\xBF\x02\x02\u13FF\u1400\x05\u0462" + + "\u0232\x02\u1400\u1401\x07v\x02\x02\u1401\u1402\x05\u0226\u0114\x02\u1402" + + "\u143C\x03\x02\x02\x02\u1403\u1404\x07\u0149\x02\x02\u1404\u1406\x07\xF8" + + "\x02\x02\u1405\u1407\x05\u0224\u0113\x02\u1406\u1405\x03\x02\x02\x02\u1406" + + "\u1407\x03\x02\x02\x02\u1407\u1408\x03\x02\x02\x02\u1408\u1409\x07R\x02" + + "\x02\u1409\u140A\x07\x8A\x02\x02\u140A\u140B\x05\u0298\u014D\x02\u140B" + + "\u140C\x07v\x02\x02\u140C\u140D\x05\u0226\u0114\x02\u140D\u143C\x03\x02" + + "\x02\x02\u140E\u140F\x07\u0149\x02\x02\u140F\u1411\x07\xF8\x02\x02\u1410" + + "\u1412\x05\u0224\u0113\x02\u1411\u1410\x03\x02\x02\x02\u1411\u1412\x03" + + "\x02\x02\x02\u1412\u1413\x03\x02\x02\x02\u1413\u1414\x07R\x02\x02\u1414" + + "\u1415\x07\xD5\x02\x02\u1415\u1416\x05\u0280\u0141\x02\u1416\u1417\x07" + + "v\x02\x02\u1417\u1418\x05\u0226\u0114\x02\u1418\u143C\x03\x02\x02\x02" + + "\u1419\u141A\x07\u0149\x02\x02\u141A\u141C\x07\xF8\x02\x02\u141B\u141D" + + "\x05\u0224\u0113\x02\u141C\u141B\x03\x02\x02\x02\u141C\u141D\x03\x02\x02" + + "\x02\u141D\u141E\x03\x02\x02\x02\u141E\u141F\x07R\x02\x02\u141F\u1420" + + "\x07\xFA\x02\x02\u1420\u1421\x07\u0114\x02\x02\u1421\u1422\x05\u0128\x95" + + "\x02\u1422\u1423\x07v\x02\x02\u1423\u1424\x05\u0226\u0114\x02\u1424\u143C" + + "\x03\x02\x02\x02\u1425\u1426\x07\u0149\x02\x02\u1426\u1428\x07\xF8\x02" + + "\x02\u1427\u1429\x05\u0224\u0113\x02\u1428\u1427\x03\x02\x02\x02\u1428" + + "\u1429\x03\x02\x02\x02\u1429\u142A\x03\x02\x02\x02\u142A\u142B\x07R\x02" + + "\x02\u142B\u142C\x07\u012A\x02\x02\u142C\u142D\x05\u0280\u0141\x02\u142D" + + "\u142E\x07v\x02\x02\u142E\u142F\x05\u0226\u0114\x02\u142F\u143C\x03\x02" + + "\x02\x02\u1430\u1431\x07\u0149\x02\x02\u1431\u1433\x07\xF8\x02\x02\u1432" + + "\u1434\x05\u0224\u0113\x02\u1433\u1432\x03\x02\x02\x02\u1433\u1434\x03" + + "\x02\x02\x02\u1434\u1435\x03\x02\x02\x02\u1435\u1436\x07R\x02\x02\u1436" + + "\u1437\x07\u01BC\x02\x02\u1437\u1438\x05\u0280\u0141\x02\u1438\u1439\x07" + + "v\x02\x02\u1439\u143A\x05\u0226\u0114\x02\u143A\u143C\x03\x02\x02\x02" + + "\u143B\u13CC\x03\x02\x02\x02\u143B\u13D7\x03\x02\x02\x02\u143B\u13E2\x03" + + "\x02\x02\x02\u143B\u13ED\x03\x02\x02\x02\u143B\u13F8\x03\x02\x02\x02\u143B" + + "\u1403\x03\x02\x02\x02\u143B\u140E\x03\x02\x02\x02\u143B\u1419\x03\x02" + + "\x02\x02\u143B\u1425\x03\x02\x02\x02\u143B\u1430\x03\x02\x02\x02\u143C" + + "\u0223\x03\x02\x02\x02\u143D\u143E\x07@\x02\x02\u143E\u143F\x05H%\x02" + + "\u143F\u0225\x03\x02\x02\x02\u1440\u1443\x05\u0552\u02AA\x02\u1441\u1443" + + "\x07P\x02\x02\u1442\u1440\x03\x02\x02\x02\u1442\u1441\x03\x02\x02\x02" + + "\u1443\u0227\x03\x02\x02\x02\u1444\u1445\x07?\x02\x02\u1445\u1449\x05" + + "\u022A\u0116\x02\u1446\u1447\x07\u010B\x02\x02\u1447\u1449\x05\u022A\u0116" + + "\x02\u1448\u1444\x03\x02\x02\x02\u1448\u1446\x03\x02\x02\x02\u1449\u0229" + + "\x03\x02\x02\x02\u144A\u14A0\x05\u03C0\u01E1\x02\u144B\u144C\x05\u022C" + + "\u0117\x02\u144C\u144D\x05\u03C0\u01E1\x02\u144D\u14A0\x03\x02\x02\x02" + + "\u144E\u1450\x07\u010E\x02\x02\u144F\u1451\x05\u022E\u0118\x02\u1450\u144F" + + "\x03\x02\x02\x02\u1450\u1451\x03\x02\x02\x02\u1451\u1452\x03\x02\x02\x02" + + "\u1452\u14A0\x05\u03C0\u01E1\x02\u1453\u1455\x07\u0127\x02\x02\u1454\u1456" + + "\x05\u022E\u0118\x02\u1455\u1454\x03\x02\x02\x02\u1455\u1456\x03\x02\x02" + + "\x02\u1456\u1457\x03\x02\x02\x02\u1457\u14A0\x05\u03C0\u01E1\x02\u1458" + + "\u145A\x07\xD1\x02\x02\u1459\u145B\x05\u022E\u0118\x02\u145A\u1459\x03" + + "\x02\x02\x02\u145A\u145B\x03\x02\x02\x02\u145B\u145C\x03\x02\x02\x02\u145C" + + "\u14A0\x05\u03C0\u01E1\x02\u145D\u145F\x07\xFB\x02\x02\u145E\u1460\x05" + + "\u022E\u0118\x02\u145F\u145E\x03\x02\x02\x02\u145F\u1460\x03\x02\x02\x02" + + "\u1460\u1461\x03\x02\x02\x02\u1461\u14A0\x05\u03C0\u01E1\x02\u1462\u1463" + + "\x07\x84\x02\x02\u1463\u1465\x05\u0558\u02AD\x02\u1464\u1466\x05\u022E" + + "\u0118\x02\u1465\u1464\x03\x02\x02\x02\u1465\u1466\x03\x02\x02\x02\u1466" + + "\u1467\x03\x02\x02\x02\u1467\u1468\x05\u03C0\u01E1\x02\u1468\u14A0\x03" + + "\x02\x02\x02\u1469\u146A\x07\u0135\x02\x02\u146A\u146C\x05\u0558\u02AD" + + "\x02\u146B\u146D\x05\u022E\u0118\x02\u146C\u146B\x03\x02\x02\x02\u146C" + + "\u146D\x03\x02\x02\x02\u146D\u146E\x03\x02\x02\x02\u146E\u146F\x05\u03C0" + + "\u01E1\x02\u146F\u14A0\x03\x02\x02\x02\u1470\u1472\x05\u0558\u02AD\x02" + + "\u1471\u1473\x05\u022E\u0118\x02\u1472\u1471\x03\x02\x02\x02\u1472\u1473" + + "\x03\x02\x02\x02\u1473\u1474\x03\x02\x02\x02\u1474\u1475\x05\u03C0\u01E1" + + "\x02\u1475\u14A0\x03\x02\x02\x02\u1476\u1478\x07 \x02\x02\u1477\u1479" + + "\x05\u022E\u0118\x02\u1478\u1477\x03\x02\x02\x02\u1478\u1479\x03\x02\x02" + + "\x02\u1479\u147A\x03\x02\x02\x02\u147A\u14A0\x05\u03C0\u01E1\x02\u147B" + + "\u147D\x07\xD4\x02\x02\u147C\u147E\x05\u022E\u0118\x02\u147D\u147C\x03" + + "\x02\x02\x02\u147D\u147E\x03\x02\x02\x02\u147E\u147F\x03\x02\x02\x02\u147F" + + "\u14A0\x05\u03C0\u01E1\x02\u1480\u1481\x07\xD4\x02\x02\u1481\u1483\x05" + + "\u0558\u02AD\x02\u1482\u1484\x05\u022E\u0118\x02\u1483\u1482\x03\x02\x02" + + "\x02\u1483\u1484\x03\x02\x02\x02\u1484\u1485\x03\x02\x02\x02\u1485\u1486" + + "\x05\u03C0\u01E1\x02\u1486\u14A0\x03\x02\x02\x02\u1487\u1488\x07\xD4\x02" + + "\x02\u1488\u148A\x07 \x02\x02\u1489\u148B\x05\u022E\u0118\x02\u148A\u1489" + + "\x03\x02\x02\x02\u148A\u148B\x03\x02\x02\x02\u148B\u148C\x03\x02\x02\x02" + + "\u148C\u14A0\x05\u03C0\u01E1\x02\u148D\u148F\x07\x92\x02\x02\u148E\u1490" + + "\x05\u022E\u0118\x02\u148F\u148E\x03\x02\x02\x02\u148F\u1490\x03\x02\x02" + + "\x02\u1490\u1491\x03\x02\x02\x02\u1491\u14A0\x05\u03C0\u01E1\x02\u1492" + + "\u1493\x07\x92\x02\x02\u1493\u1495\x05\u0558\u02AD\x02\u1494\u1496\x05" + + "\u022E\u0118\x02\u1495\u1494\x03\x02\x02\x02\u1495\u1496\x03\x02\x02\x02" + + "\u1496\u1497\x03\x02\x02\x02\u1497\u1498\x05\u03C0\u01E1\x02\u1498\u14A0" + + "\x03\x02\x02\x02\u1499\u149A\x07\x92\x02\x02\u149A\u149C\x07 \x02\x02" + + "\u149B\u149D\x05\u022E\u0118\x02\u149C\u149B\x03\x02\x02\x02\u149C\u149D" + + "\x03\x02\x02\x02\u149D\u149E\x03\x02\x02\x02\u149E\u14A0\x05\u03C0\u01E1" + + "\x02\u149F\u144A\x03\x02\x02\x02\u149F\u144B\x03\x02\x02\x02\u149F\u144E" + + "\x03\x02\x02\x02\u149F\u1453\x03\x02\x02\x02\u149F\u1458\x03\x02\x02\x02" + + "\u149F\u145D\x03\x02\x02\x02\u149F\u1462\x03\x02\x02\x02\u149F\u1469\x03" + + "\x02\x02\x02\u149F\u1470\x03\x02\x02\x02\u149F\u1476\x03\x02\x02\x02\u149F" + + "\u147B\x03\x02\x02\x02\u149F\u1480\x03\x02\x02\x02\u149F\u1487\x03\x02" + + "\x02\x02\u149F\u148D\x03\x02\x02\x02\u149F\u1492\x03\x02\x02\x02\u149F" + + "\u1499\x03\x02\x02\x02\u14A0\u022B\x03\x02\x02\x02\u14A1\u14A2\t \x02" + + "\x02\u14A2\u022D\x03\x02\x02\x02\u14A3\u14A4\x05\u022C\u0117\x02\u14A4" + + "\u022F\x03\x02\x02\x02\u14A5\u14A6\x07C\x02\x02\u14A6\u14A7\x05\u0234" + + "\u011B\x02\u14A7\u14A8\x07R\x02\x02\u14A8\u14A9\x05\u023E\u0120\x02\u14A9" + + "\u14AA\x07`\x02\x02\u14AA\u14AC\x05\u0240\u0121\x02\u14AB\u14AD\x05\u0244" + + "\u0123\x02\u14AC\u14AB\x03\x02\x02\x02\u14AC\u14AD\x03\x02\x02\x02\u14AD" + + "\u0231\x03\x02\x02\x02\u14AE\u14AF\x07\u013F\x02\x02\u14AF\u14B0\x05\u0234" + + "\u011B\x02\u14B0\u14B1\x07R\x02\x02\u14B1\u14B2\x05\u023E\u0120\x02\u14B2" + + "\u14B3\x07B\x02\x02\u14B3\u14B5\x05\u0240\u0121\x02\u14B4\u14B6\x05l7" + + "\x02\u14B5\u14B4\x03\x02\x02\x02\u14B5\u14B6\x03\x02\x02\x02\u14B6\u14C4" + + "\x03\x02\x02\x02\u14B7\u14B8\x07\u013F\x02\x02\u14B8\u14B9\x07C\x02\x02" + + "\u14B9\u14BA\x07\u0119\x02\x02\u14BA\u14BB\x07@\x02\x02\u14BB\u14BC\x05" + + "\u0234\u011B\x02\u14BC\u14BD\x07R\x02\x02\u14BD\u14BE\x05\u023E\u0120" + + "\x02\u14BE\u14BF\x07B\x02\x02\u14BF\u14C1\x05\u0240\u0121\x02\u14C0\u14C2" + + "\x05l7\x02\u14C1\u14C0\x03\x02\x02\x02\u14C1\u14C2\x03\x02\x02\x02\u14C2" + + "\u14C4\x03\x02\x02\x02\u14C3\u14AE\x03\x02\x02\x02\u14C3\u14B7\x03\x02" + + "\x02\x02\u14C4\u0233\x03\x02\x02\x02\u14C5\u14D6\x05\u023A\u011E\x02\u14C6" + + "\u14D6\x07 \x02\x02\u14C7\u14C8\x07 \x02\x02\u14C8\u14D6\x07\u0128\x02" + + "\x02\u14C9\u14CA\x07 \x02\x02\u14CA\u14CB\x07\x04\x02\x02\u14CB\u14CC" + + "\x05\xDCo\x02\u14CC\u14CD\x07\x05\x02\x02\u14CD\u14D6\x03\x02\x02\x02" + + "\u14CE\u14CF\x07 \x02\x02\u14CF\u14D0\x07\u0128\x02\x02\u14D0\u14D1\x07" + + "\x04\x02\x02\u14D1\u14D2\x05\xDCo\x02\u14D2\u14D3\x07\x05\x02\x02\u14D3" + + "\u14D6\x03\x02\x02\x02\u14D4\u14D6\x05\u0236\u011C\x02\u14D5\u14C5\x03" + + "\x02\x02\x02\u14D5\u14C6\x03\x02\x02\x02\u14D5\u14C7\x03\x02\x02\x02\u14D5" + + "\u14C9\x03\x02\x02\x02\u14D5\u14CE\x03\x02\x02\x02\u14D5\u14D4\x03\x02" + + "\x02\x02\u14D6\u0235\x03\x02\x02\x02\u14D7\u14DC\x05\u0238\u011D\x02\u14D8" + + "\u14D9\x07\b\x02\x02\u14D9\u14DB\x05\u0238\u011D\x02\u14DA\u14D8\x03\x02" + + "\x02\x02\u14DB\u14DE\x03\x02\x02\x02\u14DC\u14DA\x03\x02\x02\x02\u14DC" + + "\u14DD\x03\x02\x02\x02\u14DD\u0237\x03\x02\x02\x02\u14DE\u14DC\x03\x02" + + "\x02\x02\u14DF\u14E0\t!\x02\x02\u14E0\u0239\x03\x02\x02\x02\u14E1\u14E6" + + "\x05\u023C\u011F\x02\u14E2\u14E3\x07\b\x02\x02\u14E3\u14E5\x05\u023C\u011F" + + "\x02\u14E4\u14E2\x03\x02\x02\x02\u14E5\u14E8\x03\x02\x02\x02\u14E6\u14E4" + + "\x03\x02\x02\x02\u14E6\u14E7\x03\x02\x02\x02\u14E7\u023B\x03\x02\x02\x02" + + "\u14E8\u14E6\x03\x02\x02\x02\u14E9\u14EB\x07Z\x02\x02\u14EA\u14EC\x05" + + "\xDAn\x02\u14EB\u14EA\x03\x02\x02\x02\u14EB\u14EC\x03\x02\x02\x02\u14EC" + + "\u14FA\x03\x02\x02\x02\u14ED\u14EF\x07X\x02\x02\u14EE\u14F0\x05\xDAn\x02" + + "\u14EF\u14EE\x03\x02\x02\x02\u14EF\u14F0\x03\x02\x02\x02\u14F0\u14FA\x03" + + "\x02\x02\x02\u14F1\u14F3\x070\x02\x02\u14F2\u14F4\x05\xDAn\x02\u14F3\u14F2" + + "\x03\x02\x02\x02\u14F3\u14F4\x03\x02\x02\x02\u14F4\u14FA\x03\x02\x02\x02" + + "\u14F5\u14F7\x05\u0562\u02B2\x02\u14F6\u14F8\x05\xDAn\x02\u14F7\u14F6" + + "\x03\x02\x02\x02\u14F7\u14F8\x03\x02\x02\x02\u14F8\u14FA\x03\x02\x02\x02" + + "\u14F9\u14E9\x03\x02\x02\x02\u14F9\u14ED\x03\x02\x02\x02\u14F9\u14F1\x03" + + "\x02\x02\x02\u14F9\u14F5\x03\x02\x02\x02\u14FA\u023D\x03\x02\x02\x02\u14FB" + + "\u1536\x05\u0538\u029D\x02\u14FC\u14FD\x07^\x02\x02\u14FD\u1536\x05\u0538" + + "\u029D\x02\u14FE\u14FF\x07\u014A\x02\x02\u14FF\u1536\x05\u0538\u029D\x02" + + "\u1500\u1501\x07A\x02\x02\u1501\u1502\x07\xB0\x02\x02\u1502\u1503\x07" + + "\u017F\x02\x02\u1503\u1536\x05\u053E\u02A0\x02\u1504\u1505\x07A\x02\x02" + + "\u1505\u1506\x07\u014D\x02\x02\u1506\u1536\x05\u053E\u02A0\x02\u1507\u1508" + + "\x07\xD5\x02\x02\u1508\u1536\x05\u027E\u0140\x02\u1509\u150A\x07\u012A" + + "\x02\x02\u150A\u1536\x05\u027E\u0140\x02\u150B\u150C\x07\u01BC\x02\x02" + + "\u150C\u1536\x05\u027E\u0140\x02\u150D\u150E\x07\xB1\x02\x02\u150E\u1536" + + "\x05\u053E\u02A0\x02\u150F\u1510\x07\xBF\x02\x02\u1510\u1536\x05\u0212" + + "\u010A\x02\u1511\u1512\x07\xF9\x02\x02\u1512\u1536\x05\u053E\u02A0\x02" + + "\u1513\u1514\x07\xFA\x02\x02\u1514\u1515\x07\u0114\x02\x02\u1515\u1536" + + "\x05\u012A\x96\x02\u1516\u1517\x07\u0145\x02\x02\u1517\u1536\x05\u053E" + + "\u02A0\x02\u1518\u1519\x07\u0161\x02\x02\u1519\u1536\x05\u053E\u02A0\x02" + + "\u151A\u151B\x07\u016A\x02\x02\u151B\u1536\x05\u0212\u010A\x02\u151C\u151D" + + "\x07 \x02\x02\u151D\u151E\x07\u0160\x02\x02\u151E\u151F\x07F\x02\x02\u151F" + + "\u1520\x07\u0145\x02\x02\u1520\u1536\x05\u053E\u02A0\x02\u1521\u1522\x07" + + " \x02\x02\u1522\u1523\x07\u014B\x02\x02\u1523\u1524\x07F\x02\x02\u1524" + + "\u1525\x07\u0145\x02\x02\u1525\u1536\x05\u053E\u02A0\x02\u1526\u1527\x07" + + " \x02\x02\u1527\u1528\x07\xD6\x02\x02\u1528\u1529\x07F\x02\x02\u1529\u152A" + + "\x07\u0145\x02\x02\u152A\u1536\x05\u053E\u02A0\x02\u152B\u152C\x07 \x02" + + "\x02\u152C\u152D\x07\u01CB\x02\x02\u152D\u152E\x07F\x02\x02\u152E\u152F" + + "\x07\u0145\x02\x02\u152F\u1536\x05\u053E\u02A0\x02\u1530\u1531\x07 \x02" + + "\x02\u1531\u1532\x07\u01C9\x02\x02\u1532\u1533\x07F\x02\x02\u1533\u1534" + + "\x07\u0145\x02\x02\u1534\u1536\x05\u053E\u02A0\x02\u1535\u14FB\x03\x02" + + "\x02\x02\u1535\u14FC\x03\x02\x02\x02\u1535\u14FE\x03\x02\x02\x02\u1535" + + "\u1500\x03\x02\x02\x02\u1535\u1504\x03\x02\x02\x02\u1535\u1507\x03\x02" + + "\x02\x02\u1535\u1509\x03\x02\x02\x02\u1535\u150B\x03\x02\x02\x02\u1535" + + "\u150D\x03\x02\x02\x02\u1535\u150F\x03\x02\x02\x02\u1535\u1511\x03\x02" + + "\x02\x02\u1535\u1513\x03\x02\x02\x02\u1535\u1516\x03\x02\x02\x02\u1535" + + "\u1518\x03\x02\x02\x02\u1535\u151A\x03\x02\x02\x02\u1535\u151C\x03\x02" + + "\x02\x02\u1535\u1521\x03\x02\x02\x02\u1535\u1526\x03\x02\x02\x02\u1535" + + "\u152B\x03\x02\x02\x02\u1535\u1530\x03\x02\x02\x02\u1536\u023F\x03\x02" + + "\x02\x02\u1537\u153C\x05\u0242\u0122\x02\u1538\u1539\x07\b\x02\x02\u1539" + + "\u153B\x05\u0242\u0122\x02\u153A\u1538\x03\x02\x02\x02\u153B\u153E\x03" + + "\x02\x02\x02\u153C\u153A\x03\x02\x02\x02\u153C\u153D\x03\x02\x02\x02\u153D" + + "\u0241\x03\x02\x02\x02\u153E\u153C\x03\x02\x02\x02\u153F\u1543\x05\u055E" + + "\u02B0\x02\u1540\u1541\x07D\x02\x02\u1541\u1543\x05\u055E\u02B0\x02\u1542" + + "\u153F\x03\x02\x02\x02\u1542\u1540\x03\x02\x02\x02\u1543\u0243\x03\x02" + + "\x02\x02\u1544\u1545\x07k\x02\x02\u1545\u1546\x07C\x02\x02\u1546\u1547" + + "\x07\u0119\x02\x02\u1547\u0245\x03\x02\x02\x02\u1548\u1549\x07C\x02\x02" + + "\u1549\u154A\x05\u023A\u011E\x02\u154A\u154B\x07`\x02\x02\u154B\u154D" + + "\x05\u0560\u02B1\x02\u154C\u154E\x05\u024A\u0126\x02\u154D\u154C\x03\x02" + + "\x02\x02\u154D\u154E\x03\x02\x02\x02\u154E\u1550\x03\x02\x02\x02\u154F" + + "\u1551\x05\u024C\u0127\x02\u1550\u154F\x03\x02\x02\x02\u1550\u1551\x03" + + "\x02\x02\x02\u1551\u0247\x03\x02\x02\x02\u1552\u1553\x07\u013F\x02\x02" + + "\u1553\u1554\x05\u023A\u011E\x02\u1554\u1555\x07B\x02\x02\u1555\u1557" + + "\x05\u0560\u02B1\x02\u1556\u1558\x05\u024C\u0127\x02\u1557\u1556\x03\x02" + + "\x02\x02\u1557\u1558\x03\x02\x02\x02\u1558\u155A\x03\x02\x02\x02\u1559" + + "\u155B\x05l7\x02\u155A\u1559\x03\x02\x02\x02\u155A\u155B\x03\x02\x02\x02" + + "\u155B\u156A\x03\x02\x02\x02\u155C\u155D\x07\u013F\x02\x02\u155D\u155E" + + "\x07\x88\x02\x02\u155E\u155F\x07\u0119\x02\x02\u155F\u1560\x07@\x02\x02" + + "\u1560\u1561\x05\u023A\u011E\x02\u1561\u1562\x07B\x02\x02\u1562\u1564" + + "\x05\u0560\u02B1\x02\u1563\u1565\x05\u024C\u0127\x02\u1564\u1563\x03\x02" + + "\x02\x02\u1564\u1565\x03\x02\x02\x02\u1565\u1567\x03\x02\x02\x02\u1566" + + "\u1568\x05l7\x02\u1567\u1566\x03\x02\x02\x02\u1567\u1568\x03\x02\x02\x02" + + "\u1568\u156A\x03\x02\x02\x02\u1569\u1552\x03\x02\x02\x02\u1569\u155C\x03" + + "\x02\x02\x02\u156A\u0249\x03\x02\x02\x02\u156B\u156C\x07k\x02\x02\u156C" + + "\u156D\x07\x88\x02\x02\u156D\u156E\x07\u0119\x02\x02\u156E\u024B\x03\x02" + + "\x02\x02\u156F\u1570\x07\xD8\x02\x02\u1570\u1571\x07\x95\x02\x02\u1571" + + "\u1572\x05\u055E\u02B0\x02\u1572\u024D\x03\x02\x02\x02\u1573\u1574\x07" + + "\x8C\x02\x02\u1574\u1575\x077\x02\x02\u1575\u1576\x07\u0128\x02\x02\u1576" + + "\u1577\x05\u0250\u0129\x02\u1577\u1578\x05\u0254\u012B\x02\u1578\u024F" + + "\x03\x02\x02\x02\u1579\u157B\x05\u0252\u012A\x02\u157A\u1579\x03\x02\x02" + + "\x02\u157B\u157E\x03\x02\x02\x02\u157C\u157A\x03\x02\x02\x02\u157C\u157D" + + "\x03\x02\x02\x02\u157D\u0251\x03\x02\x02\x02\u157E\u157C\x03\x02\x02\x02" + + "\u157F\u1580\x07F\x02\x02\u1580\u1581\x07\u0145\x02\x02\u1581\u1589\x05" + + "\u053E\u02A0\x02\u1582\u1583\x07@\x02\x02\u1583\u1584\x07\u0140\x02\x02" + + "\u1584\u1589\x05\u0560\u02B1\x02\u1585\u1586\x07@\x02\x02\u1586\u1587" + + "\x07e\x02\x02\u1587\u1589\x05\u0560\u02B1\x02\u1588\u157F\x03\x02\x02" + + "\x02\u1588\u1582\x03\x02\x02\x02\u1588\u1585\x03\x02\x02\x02\u1589\u0253" + + "\x03\x02\x02\x02\u158A\u158B\x07C\x02\x02\u158B\u158C\x05\u0234\u011B" + + "\x02\u158C\u158D\x07R\x02\x02\u158D\u158E\x05\u0256\u012C\x02\u158E\u158F" + + "\x07`\x02\x02\u158F\u1591\x05\u0240\u0121\x02\u1590\u1592\x05\u0244\u0123" + + "\x02\u1591\u1590\x03\x02\x02\x02\u1591\u1592\x03\x02\x02\x02\u1592\u15A9" + + "\x03\x02\x02\x02\u1593\u1594\x07\u013F\x02\x02\u1594\u1595\x05\u0234\u011B" + + "\x02\u1595\u1596\x07R\x02\x02\u1596\u1597\x05\u0256\u012C\x02\u1597\u1598" + + "\x07B\x02\x02\u1598\u159A\x05\u0240\u0121\x02\u1599\u159B\x05l7\x02\u159A" + + "\u1599\x03\x02\x02\x02\u159A\u159B\x03\x02\x02\x02\u159B\u15A9\x03\x02" + + "\x02\x02\u159C\u159D\x07\u013F\x02\x02\u159D\u159E\x07C\x02\x02\u159E" + + "\u159F\x07\u0119\x02\x02\u159F\u15A0\x07@\x02\x02\u15A0\u15A1\x05\u0234" + + "\u011B\x02\u15A1\u15A2\x07R\x02\x02\u15A2\u15A3\x05\u0256\u012C\x02\u15A3" + + "\u15A4\x07B\x02\x02\u15A4\u15A6\x05\u0240\u0121\x02\u15A5\u15A7\x05l7" + + "\x02\u15A6\u15A5\x03\x02\x02\x02\u15A6\u15A7\x03\x02\x02\x02\u15A7\u15A9" + + "\x03\x02\x02\x02\u15A8\u158A\x03\x02\x02\x02\u15A8\u1593\x03\x02\x02\x02" + + "\u15A8\u159C\x03\x02\x02\x02\u15A9\u0255\x03\x02\x02\x02\u15AA\u15AB\t" + + "\"\x02\x02\u15AB\u0257\x03\x02\x02\x02\u15AC\u15AE\x070\x02\x02\u15AD" + + "\u15AF\x05\u025A\u012E\x02\u15AE\u15AD\x03\x02\x02\x02\u15AE\u15AF\x03" + + "\x02\x02\x02\u15AF\u15B0\x03\x02\x02\x02\u15B0\u15B2\x07\xE4\x02\x02\u15B1" + + "\u15B3\x05\u025C\u012F\x02\u15B2\u15B1\x03\x02\x02\x02\u15B2\u15B3\x03" + + "\x02\x02\x02\u15B3\u15B5\x03\x02\x02\x02\u15B4\u15B6\x05\u025E\u0130\x02" + + "\u15B5\u15B4\x03\x02\x02\x02\u15B5\u15B6\x03\x02\x02\x02\u15B6\u15B7\x03" + + "\x02\x02\x02\u15B7\u15B8\x07R\x02\x02\u15B8\u15BA\x05\u0436\u021C\x02" + + "\u15B9\u15BB\x05\u0260\u0131\x02\u15BA\u15B9\x03\x02\x02\x02\u15BA\u15BB" + + "\x03\x02\x02\x02\u15BB\u15BC\x03\x02\x02\x02\u15BC\u15BD\x07\x04\x02\x02" + + "\u15BD\u15BE\x05\u0262\u0132\x02\u15BE\u15C0\x07\x05\x02\x02\u15BF\u15C1" + + "\x05\u0268\u0135\x02\u15C0\u15BF\x03\x02\x02\x02\u15C0\u15C1\x03\x02\x02" + + "\x02\u15C1\u15C3\x03\x02\x02\x02\u15C2\u15C4\x05v<\x02\u15C3\u15C2\x03" + + "\x02\x02\x02\u15C3\u15C4\x03\x02\x02\x02\u15C4\u15C6\x03\x02\x02\x02\u15C5" + + "\u15C7\x05\u0102\x82\x02\u15C6\u15C5\x03\x02\x02\x02\u15C6\u15C7\x03\x02" + + "\x02\x02\u15C7\u15C9\x03\x02\x02\x02\u15C8\u15CA\x05\u044A\u0226\x02\u15C9" + + "\u15C8\x03\x02\x02\x02\u15C9\u15CA\x03\x02\x02\x02\u15CA\u15EC\x03\x02" + + "\x02\x02\u15CB\u15CD\x070\x02\x02\u15CC\u15CE\x05\u025A\u012E\x02\u15CD" + + "\u15CC\x03\x02\x02\x02\u15CD\u15CE\x03\x02\x02\x02\u15CE\u15CF\x03\x02" + + "\x02\x02\u15CF\u15D1\x07\xE4\x02\x02\u15D0\u15D2\x05\u025C\u012F\x02\u15D1" + + "\u15D0\x03\x02\x02\x02\u15D1\u15D2\x03\x02\x02\x02\u15D2\u15D3\x03\x02" + + "\x02\x02\u15D3\u15D4\x07\xDE\x02\x02\u15D4\u15D5\x07O\x02\x02\u15D5\u15D6" + + "\x07\u018E\x02\x02\u15D6\u15D7\x05\u0540\u02A1\x02\u15D7\u15D8\x07R\x02" + + "\x02\u15D8\u15DA\x05\u0436\u021C\x02\u15D9\u15DB\x05\u0260\u0131\x02\u15DA" + + "\u15D9\x03\x02\x02\x02\u15DA\u15DB\x03\x02\x02\x02\u15DB\u15DC\x03\x02" + + "\x02\x02\u15DC\u15DD\x07\x04\x02\x02\u15DD\u15DE\x05\u0262\u0132\x02\u15DE" + + "\u15E0\x07\x05\x02\x02\u15DF\u15E1\x05\u0268\u0135\x02\u15E0\u15DF\x03" + + "\x02\x02\x02\u15E0\u15E1\x03\x02\x02\x02\u15E1\u15E3\x03\x02\x02\x02\u15E2" + + "\u15E4\x05v<\x02\u15E3\u15E2\x03\x02\x02\x02\u15E3\u15E4\x03\x02\x02\x02" + + "\u15E4\u15E6\x03\x02\x02\x02\u15E5\u15E7\x05\u0102\x82\x02\u15E6\u15E5" + + "\x03\x02\x02\x02\u15E6\u15E7\x03\x02\x02\x02\u15E7\u15E9\x03\x02\x02\x02" + + "\u15E8\u15EA\x05\u044A\u0226\x02\u15E9\u15E8\x03\x02\x02\x02\u15E9\u15EA" + + "\x03\x02\x02\x02\u15EA\u15EC\x03\x02\x02\x02\u15EB\u15AC\x03\x02\x02\x02" + + "\u15EB\u15CB\x03\x02\x02\x02\u15EC\u0259\x03\x02\x02\x02\u15ED\u15EE\x07" + + "d\x02\x02\u15EE\u025B\x03\x02\x02\x02\u15EF\u15F0\x07o\x02\x02\u15F0\u025D" + + "\x03\x02\x02\x02\u15F1\u15F2\x05\u0540\u02A1\x02\u15F2\u025F\x03\x02\x02" + + "\x02\u15F3\u15F4\x07f\x02\x02\u15F4\u15F5\x05\u0540\u02A1\x02\u15F5\u0261" + + "\x03\x02\x02\x02\u15F6\u15FB\x05\u0266\u0134\x02\u15F7\u15F8\x07\b\x02" + + "\x02\u15F8\u15FA\x05\u0266\u0134\x02\u15F9\u15F7\x03\x02\x02\x02\u15FA" + + "\u15FD\x03\x02\x02\x02\u15FB\u15F9\x03\x02\x02\x02\u15FB\u15FC\x03\x02" + + "\x02\x02\u15FC\u0263\x03\x02\x02\x02\u15FD\u15FB\x03\x02\x02\x02\u15FE" + + "\u1600\x05\u026C\u0137\x02\u15FF\u15FE\x03\x02\x02\x02\u15FF\u1600\x03" + + "\x02\x02\x02\u1600\u1602\x03\x02\x02\x02\u1601\u1603\x05\u026E\u0138\x02" + + "\u1602\u1601\x03\x02\x02\x02\u1602\u1603\x03\x02\x02\x02\u1603\u1605\x03" + + "\x02\x02\x02\u1604\u1606\x05\u0270\u0139\x02\u1605\u1604\x03\x02\x02\x02" + + "\u1605\u1606\x03\x02\x02\x02\u1606\u1608\x03\x02\x02\x02\u1607\u1609\x05" + + "\u0272\u013A\x02\u1608\u1607\x03\x02\x02\x02\u1608\u1609\x03\x02\x02\x02" + + "\u1609\u1616\x03\x02\x02\x02\u160A\u160C\x05\u026C\u0137\x02\u160B\u160A" + + "\x03\x02\x02\x02\u160B\u160C\x03\x02\x02\x02\u160C\u160D\x03\x02\x02\x02" + + "\u160D\u160E\x05\u0214\u010B\x02\u160E\u1610\x05t;\x02\u160F"; private static readonly _serializedATNSegment12: string = - "\u163A\x05\u0282\u0142\x02\u1636\u1637\x07\b\x02\x02\u1637\u1639\x05\u0282" + - "\u0142\x02\u1638\u1636\x03\x02\x02\x02\u1639\u163C\x03\x02\x02\x02\u163A" + - "\u1638\x03\x02\x02\x02\u163A\u163B\x03\x02\x02\x02\u163B\u0277\x03\x02" + - "\x02\x02\u163C\u163A\x03\x02\x02\x02\u163D\u163F\x05\u027A\u013E\x02\u163E" + - "\u1640\x05\u027C\u013F\x02\u163F\u163E\x03\x02\x02\x02\u163F\u1640\x03" + - "\x02\x02\x02\u1640\u1641\x03\x02\x02\x02\u1641\u1642\x05\u0280\u0141\x02" + - "\u1642\u164B\x03\x02\x02\x02\u1643\u1645\x05\u027C\u013F\x02\u1644\u1646" + - "\x05\u027A\u013E\x02\u1645\u1644\x03\x02\x02\x02\u1645\u1646\x03\x02\x02" + - "\x02\u1646\u1647\x03\x02\x02\x02\u1647\u1648\x05\u0280\u0141\x02\u1648" + - "\u164B\x03\x02\x02\x02\u1649\u164B\x05\u0280\u0141\x02\u164A\u163D\x03" + - "\x02\x02\x02\u164A\u1643\x03\x02\x02\x02\u164A\u1649\x03\x02\x02\x02\u164B" + - "\u0279\x03\x02\x02\x02\u164C\u164E\x07F\x02\x02\u164D\u164F\x07\u01BE" + - "\x02\x02\u164E\u164D\x03\x02\x02\x02\u164E\u164F\x03\x02\x02\x02\u164F" + - "\u1654\x03\x02\x02\x02\u1650\u1654\x07\u01BE\x02\x02\u1651\u1654\x07\u0189" + - "\x02\x02\u1652\u1654\x07g\x02\x02\u1653\u164C\x03\x02\x02\x02\u1653\u1650" + - "\x03\x02\x02\x02\u1653\u1651\x03\x02\x02\x02\u1653\u1652\x03\x02\x02\x02" + - "\u1654\u027B\x03\x02\x02\x02\u1655\u1656\x05\u0552\u02AA\x02\u1656\u027D" + - "\x03\x02\x02\x02\u1657\u1658\x05\u0280\u0141\x02\u1658\u027F\x03\x02\x02" + - "\x02\u1659\u1666\x05\u0454\u022B\x02\u165A\u165B\x05\u0552\u02AA\x02\u165B" + - "\u165C\x05\u020E\u0108\x02\u165C\u165D\x07\x1D\x02\x02\u165D\u165E\x07" + - "\u0161\x02\x02\u165E\u1666\x03\x02\x02\x02\u165F\u1660\x07\u0198\x02\x02" + - "\u1660\u1661\x05\u0552\u02AA\x02\u1661\u1662\x05\u020E\u0108\x02\u1662" + - "\u1663\x07\x1D\x02\x02\u1663\u1664\x07\u0161\x02\x02\u1664\u1666\x03\x02" + - "\x02\x02\u1665\u1659\x03\x02\x02\x02\u1665\u165A\x03\x02\x02\x02\u1665" + - "\u165F\x03\x02\x02\x02\u1666\u0281\x03\x02\x02\x02\u1667\u166A\x05\u0278" + - "\u013D\x02\u1668\u1669\t\x1E\x02\x02\u1669\u166B\x05\u0480\u0241\x02\u166A" + - "\u1668\x03\x02\x02\x02\u166A\u166B\x03\x02\x02\x02\u166B\u0283\x03\x02" + - "\x02\x02\u166C\u166D\x05\u0278\u013D\x02\u166D\u0285\x03\x02\x02\x02\u166E" + - "\u1679\x07\x04\x02\x02\u166F\u167A\x07\v\x02\x02\u1670\u167A\x05\u0288" + - "\u0145\x02\u1671\u1672\x07U\x02\x02\u1672\u1673\x07\x95\x02\x02\u1673" + - "\u167A\x05\u0288\u0145\x02\u1674\u1675\x05\u0288\u0145\x02\u1675\u1676" + - "\x07U\x02\x02\u1676\u1677\x07\x95\x02\x02\u1677\u1678\x05\u0288\u0145" + - "\x02\u1678\u167A\x03\x02\x02\x02\u1679\u166F\x03\x02\x02\x02\u1679\u1670" + - "\x03\x02\x02\x02\u1679\u1671\x03\x02\x02\x02\u1679\u1674\x03\x02\x02\x02" + - "\u167A\u167B\x03\x02\x02\x02\u167B\u167C\x07\x05\x02\x02\u167C\u0287\x03" + - "\x02\x02\x02\u167D\u1682\x05\u0284\u0143\x02\u167E\u167F\x07\b\x02\x02" + - "\u167F\u1681\x05\u0284\u0143\x02\u1680\u167E\x03\x02\x02\x02\u1681\u1684" + - "\x03\x02\x02\x02\u1682\u1680\x03\x02\x02\x02\u1682\u1683\x03\x02\x02\x02" + - "\u1683\u0289\x03\x02\x02\x02\u1684\u1682\x03\x02\x02\x02\u1685\u1686\x05" + - "\u0536\u029C\x02\u1686\u1687\x05\u0286\u0144\x02\u1687\u028B\x03\x02\x02" + - "\x02\u1688\u168D\x05\u028A\u0146\x02\u1689\u168A\x07\b\x02\x02\u168A\u168C" + - "\x05\u028A\u0146\x02\u168B\u1689\x03\x02\x02\x02\u168C\u168F\x03\x02\x02" + - "\x02\u168D\u168B\x03\x02\x02\x02\u168D\u168E\x03\x02\x02\x02\u168E\u028D" + - "\x03\x02\x02\x02\u168F\u168D\x03\x02\x02\x02\u1690\u1692\x05\u0292\u014A" + - "\x02\u1691\u1690\x03\x02\x02\x02\u1692\u1693\x03\x02\x02\x02\u1693\u1691" + - "\x03\x02\x02\x02\u1693\u1694\x03\x02\x02\x02\u1694\u1695\x03\x02\x02\x02" + - "\u1695\u1696\b\u0148\x01\x02\u1696\u028F\x03\x02\x02\x02\u1697\u1698\x07" + - "\x97\x02\x02\u1698\u1699\x07R\x02\x02\u1699\u169A\x07P\x02\x02\u169A\u16BB" + - "\x07\u01C3\x02\x02\u169B\u169C\x07\u0135\x02\x02\u169C\u169D\x07P\x02" + - "\x02\u169D\u169E\x07R\x02\x02\u169E\u169F\x07P\x02\x02\u169F\u16BB\x07" + - "\u01C3\x02\x02\u16A0\u16BB\x07\u0153\x02\x02\u16A1\u16BB\x07\xE0\x02\x02" + - "\u16A2\u16BB\x07\u014B\x02\x02\u16A3\u16BB\x07\u0172\x02\x02\u16A4\u16A5" + - "\x07\xCF\x02\x02\u16A5\u16A6\x07\u0140\x02\x02\u16A6\u16BB\x07\xB7\x02" + - "\x02\u16A7\u16A8\x07\xCF\x02\x02\u16A8\u16A9\x07\u0140\x02\x02\u16A9\u16BB" + - "\x07\xEC\x02\x02\u16AA\u16AB\x07\u0140\x02\x02\u16AB\u16BB\x07\xB7\x02" + - "\x02\u16AC\u16AD\x07\u0140\x02\x02\u16AD\u16BB\x07\xEC\x02\x02\u16AE\u16BB" + - "\x07\xF3\x02\x02\u16AF\u16B0\x07O\x02\x02\u16B0\u16BB\x07\xF3\x02\x02" + - "\u16B1\u16B2\x07\xAC\x02\x02\u16B2\u16BB\x05\u0124\x93\x02\u16B3\u16B4" + - "\x07\u0139\x02\x02\u16B4\u16BB\x05\u0124\x93\x02\u16B5\u16B6\x07\u01C4" + - "\x02\x02\u16B6\u16BB\x05\u020C\u0107\x02\u16B7\u16BB\x05R*\x02\u16B8\u16B9" + - "\x07\u01C5\x02\x02\u16B9\u16BB\x05\u0550\u02A9\x02\u16BA\u1697\x03\x02" + - "\x02\x02\u16BA\u169B\x03\x02\x02\x02\u16BA\u16A0\x03\x02\x02\x02\u16BA" + - "\u16A1\x03\x02\x02\x02\u16BA\u16A2\x03\x02\x02\x02\u16BA\u16A3\x03\x02" + - "\x02\x02\u16BA\u16A4\x03\x02\x02\x02\u16BA\u16A7\x03\x02\x02\x02\u16BA" + - "\u16AA\x03\x02\x02\x02\u16BA\u16AC\x03\x02\x02\x02\u16BA\u16AE\x03\x02" + - "\x02\x02\u16BA\u16AF\x03\x02\x02\x02\u16BA\u16B1\x03\x02\x02\x02\u16BA" + - "\u16B3\x03\x02\x02\x02\u16BA\u16B5\x03\x02\x02\x02\u16BA\u16B7\x03\x02" + - "\x02\x02\u16BA\u16B8\x03\x02\x02\x02\u16BB\u0291\x03\x02\x02\x02\u16BC" + - "\u16BD\x07&\x02\x02\u16BD\u16C5\x05\u0294\u014B\x02\u16BE\u16BF\x07\xF0" + - "\x02\x02\u16BF\u16C5\x05H%\x02\u16C0\u16C1\x07\u01B4\x02\x02\u16C1\u16C5" + - "\x05\u0296\u014C\x02\u16C2\u16C5\x07j\x02\x02\u16C3\u16C5\x05\u0290\u0149" + - "\x02\u16C4\u16BC\x03\x02\x02\x02\u16C4\u16BE\x03\x02\x02\x02\u16C4\u16C0" + - "\x03\x02\x02\x02\u16C4\u16C2\x03\x02\x02\x02\u16C4\u16C3\x03\x02\x02\x02" + - "\u16C5\u0293\x03\x02\x02\x02\u16C6\u16CC\x05\u0542\u02A2\x02\u16C7\u16C8" + - "\x05\u0542\u02A2\x02\u16C8\u16C9\x07\b\x02\x02\u16C9\u16CA\x05\u0542\u02A2" + - "\x02\u16CA\u16CC\x03\x02\x02\x02\u16CB\u16C6\x03\x02\x02\x02\u16CB\u16C7" + - "\x03\x02\x02\x02\u16CC\u0295\x03\x02\x02\x02\u16CD\u16CE\x07@\x02\x02" + - "\u16CE\u16CF\x07\u0161\x02\x02\u16CF\u16D6\x05\u0454\u022B\x02\u16D0\u16D1" + - "\x07\b\x02\x02\u16D1\u16D2\x07@\x02\x02\u16D2\u16D3\x07\u0161\x02\x02" + - "\u16D3\u16D5\x05\u0454\u022B\x02\u16D4\u16D0\x03\x02\x02\x02\u16D5\u16D8" + - "\x03\x02\x02\x02\u16D6\u16D4\x03\x02\x02\x02\u16D6\u16D7\x03\x02\x02\x02" + - "\u16D7\u0297\x03\x02\x02\x02\u16D8\u16D6\x03\x02\x02\x02\u16D9\u16DA\x07" + - "k\x02\x02\u16DA\u16DB\x05\u01CC\xE7\x02\u16DB\u0299\x03\x02\x02\x02\u16DC" + - "\u16DD\x05\u027C\u013F\x02\u16DD\u16DE\x05\u0280\u0141\x02\u16DE\u029B" + - "\x03\x02\x02\x02\u16DF\u16E4\x05\u029A\u014E\x02\u16E0\u16E1\x07\b\x02" + - "\x02\u16E1\u16E3\x05\u029A\u014E\x02\u16E2\u16E0\x03\x02\x02\x02\u16E3" + - "\u16E6\x03\x02\x02\x02\u16E4\u16E2\x03\x02\x02\x02\u16E4\u16E5\x03\x02" + - "\x02\x02\u16E5\u029D\x03\x02\x02\x02\u16E6\u16E4\x03\x02\x02\x02\u16E7" + - "\u16E8\x07\x8C\x02\x02\u16E8\u16E9\t\x1F\x02\x02\u16E9\u16EA\x05\u0272" + - "\u013A\x02\u16EA\u16EC\x05\u02A0\u0151\x02\u16EB\u16ED\x05\u02A2\u0152" + - "\x02\u16EC\u16EB\x03\x02\x02\x02\u16EC\u16ED\x03\x02\x02\x02\u16ED\u029F" + - "\x03\x02\x02\x02\u16EE\u16F0\x05\u0290\u0149\x02\u16EF\u16EE\x03\x02\x02" + - "\x02\u16F0\u16F1\x03\x02\x02\x02\u16F1\u16EF\x03\x02\x02\x02\u16F1\u16F2" + - "\x03\x02\x02\x02\u16F2\u02A1\x03\x02\x02\x02\u16F3\u16F4\x07\u0134\x02" + - "\x02\u16F4\u02A3\x03\x02\x02\x02\u16F5\u16F6\x07\xC1\x02\x02\u16F6\u16F7" + - "\x07\xD5\x02\x02\u16F7\u16F9\x05\u0270\u0139\x02\u16F8\u16FA\x05l7\x02" + - "\u16F9\u16F8\x03\x02\x02\x02\u16F9\u16FA\x03\x02\x02\x02\u16FA\u1720\x03" + - "\x02\x02\x02\u16FB\u16FC\x07\xC1\x02\x02\u16FC\u16FD\x07\xD5\x02\x02\u16FD" + - "\u16FE\x07\xDE\x02\x02\u16FE\u16FF\x07\u0185\x02\x02\u16FF\u1701\x05\u0270" + - "\u0139\x02\u1700\u1702\x05l7\x02\u1701\u1700\x03\x02\x02\x02\u1701\u1702" + - "\x03\x02\x02\x02\u1702\u1720\x03\x02\x02\x02\u1703\u1704\x07\xC1\x02\x02" + - "\u1704\u1705\x07\u0121\x02\x02\u1705\u1707\x05\u0270\u0139\x02\u1706\u1708" + - "\x05l7\x02\u1707\u1706\x03\x02\x02\x02\u1707\u1708\x03\x02\x02\x02\u1708" + - "\u1720\x03\x02\x02\x02\u1709\u170A\x07\xC1\x02\x02\u170A\u170B\x07\u0121" + - "\x02\x02\u170B\u170C\x07\xDE\x02\x02\u170C\u170D\x07\u0185\x02\x02\u170D" + - "\u170F\x05\u0270\u0139\x02\u170E\u1710\x05l7\x02\u170F\u170E\x03\x02\x02" + - "\x02\u170F\u1710\x03\x02\x02\x02\u1710\u1720\x03\x02\x02\x02\u1711\u1712" + - "\x07\xC1\x02\x02\u1712\u1713\x07\u01B3\x02\x02\u1713\u1715\x05\u0270\u0139" + - "\x02\u1714\u1716\x05l7\x02\u1715\u1714\x03\x02\x02\x02\u1715\u1716\x03" + - "\x02\x02\x02\u1716\u1720\x03\x02\x02\x02\u1717\u1718\x07\xC1\x02\x02\u1718" + - "\u1719\x07\u01B3\x02\x02\u1719\u171A\x07\xDE\x02\x02\u171A\u171B\x07\u0185" + - "\x02\x02\u171B\u171D\x05\u0270\u0139\x02\u171C\u171E\x05l7\x02\u171D\u171C" + - "\x03\x02\x02\x02\u171D\u171E\x03\x02\x02\x02\u171E\u1720\x03\x02\x02\x02" + - "\u171F\u16F5\x03\x02\x02\x02\u171F\u16FB\x03\x02\x02\x02\u171F\u1703\x03" + - "\x02\x02\x02\u171F\u1709\x03\x02\x02\x02\u171F\u1711\x03\x02\x02\x02\u171F" + - "\u1717\x03\x02\x02\x02\u1720\u02A5\x03\x02\x02\x02\u1721\u1722\x07\xC1" + - "\x02\x02\u1722\u1723\x07\x8A\x02\x02\u1723\u1725\x05\u028C\u0147\x02\u1724" + - "\u1726\x05l7\x02\u1725\u1724\x03\x02\x02\x02\u1725\u1726\x03\x02\x02\x02" + - "\u1726\u1730\x03\x02\x02\x02\u1727\u1728\x07\xC1\x02\x02\u1728\u1729\x07" + - "\x8A\x02\x02\u1729\u172A\x07\xDE\x02\x02\u172A\u172B\x07\u0185\x02\x02" + - "\u172B\u172D\x05\u028C\u0147\x02\u172C\u172E\x05l7\x02\u172D\u172C\x03" + - "\x02\x02\x02\u172D\u172E\x03\x02\x02\x02\u172E\u1730\x03\x02\x02\x02\u172F" + - "\u1721\x03\x02\x02\x02\u172F\u1727\x03\x02\x02\x02\u1730\u02A7\x03\x02" + - "\x02\x02\u1731\u1732\x07\xC1\x02\x02\u1732\u1733\x07\u010F\x02\x02\u1733" + - "\u1735\x05\u02AE\u0158\x02\u1734\u1736\x05l7\x02\u1735\u1734\x03\x02\x02" + - "\x02\u1735\u1736\x03\x02\x02\x02\u1736\u1740\x03\x02\x02\x02\u1737\u1738" + - "\x07\xC1\x02\x02\u1738\u1739\x07\u010F\x02\x02\u1739\u173A\x07\xDE\x02" + - "\x02\u173A\u173B\x07\u0185\x02\x02\u173B\u173D\x05\u02AE\u0158\x02\u173C" + - "\u173E\x05l7\x02\u173D\u173C\x03\x02\x02\x02\u173D\u173E\x03\x02\x02\x02" + - "\u173E\u1740\x03\x02\x02\x02\u173F\u1731\x03\x02\x02\x02\u173F\u1737\x03" + - "\x02\x02\x02\u1740\u02A9\x03\x02\x02\x02\u1741\u1742\x07\x04\x02\x02\u1742" + - "\u1743\x05\u0454\u022B\x02\u1743\u1744\x07\x05\x02\x02\u1744\u1758\x03" + - "\x02\x02\x02\u1745\u1746\x07\x04\x02\x02\u1746\u1747\x05\u0454\u022B\x02" + - "\u1747\u1748\x07\b\x02\x02\u1748\u1749\x05\u0454\u022B\x02\u1749\u174A" + - "\x07\x05\x02\x02\u174A\u1758\x03\x02\x02\x02\u174B\u174C\x07\x04\x02\x02" + - "\u174C\u174D\x07\u0190\x02\x02\u174D\u174E\x07\b\x02\x02\u174E\u174F\x05" + - "\u0454\u022B\x02\u174F\u1750\x07\x05\x02\x02\u1750\u1758\x03\x02\x02\x02" + - "\u1751\u1752\x07\x04\x02\x02\u1752\u1753\x05\u0454\u022B\x02\u1753\u1754" + - "\x07\b\x02\x02\u1754\u1755\x07\u0190\x02\x02\u1755\u1756\x07\x05\x02\x02" + - "\u1756\u1758\x03\x02\x02\x02\u1757\u1741\x03\x02\x02\x02\u1757\u1745\x03" + - "\x02\x02\x02\u1757\u174B\x03\x02\x02\x02\u1757\u1751\x03\x02\x02\x02\u1758" + - "\u02AB\x03\x02\x02\x02\u1759\u175A\x05\u0550\u02A9\x02\u175A\u175B\x07" + - "\r\x02\x02\u175B\u175D\x03\x02\x02\x02\u175C\u1759\x03\x02\x02\x02\u175D" + - "\u1760\x03\x02\x02\x02\u175E\u175C\x03\x02\x02\x02\u175E\u175F\x03\x02" + - "\x02\x02\u175F\u1761\x03\x02\x02\x02\u1760\u175E\x03\x02\x02\x02\u1761" + - "\u1762\x05\u04EA\u0276\x02\u1762\u02AD\x03\x02\x02\x02\u1763\u1768\x05" + - "\u02B0\u0159\x02\u1764\u1765\x07\b\x02\x02\u1765\u1767\x05\u02B0\u0159" + - "\x02\u1766\u1764\x03\x02\x02\x02\u1767\u176A\x03\x02\x02\x02\u1768\u1766" + - "\x03\x02\x02\x02\u1768\u1769\x03\x02\x02\x02\u1769\u02AF\x03\x02\x02\x02" + - "\u176A\u1768\x03\x02\x02\x02\u176B\u176C\x05\u02AC\u0157\x02\u176C\u176D" + - "\x05\u02AA\u0156\x02\u176D\u02B1\x03\x02\x02\x02\u176E\u176F\x07;\x02" + - "\x02\u176F\u1770\x05\u02B4\u015B\x02\u1770\u02B3\x03\x02\x02\x02\u1771" + - "\u1773\x05\u02B6\u015C\x02\u1772\u1771\x03\x02\x02\x02\u1773\u1774\x03" + - "\x02\x02\x02\u1774\u1772\x03\x02\x02\x02\u1774\u1775\x03\x02\x02\x02\u1775" + - "\u02B5\x03\x02\x02\x02\u1776\u177A\x05\u0542\u02A2\x02\u1777\u1778\x07" + - "\xF0\x02\x02\u1778\u177A\x05H%\x02\u1779\u1776\x03\x02\x02\x02\u1779\u1777" + - "\x03\x02\x02\x02\u177A\u02B7\x03\x02\x02\x02\u177B\u177C\x070\x02\x02" + - "\u177C\u177D\x07+\x02\x02\u177D\u177E\x07\x04\x02\x02\u177E\u177F\x05" + - "\u0454\u022B\x02\u177F\u1780\x07&\x02\x02\u1780\u1781\x05\u0454\u022B" + - "\x02\u1781\u1782\x07\x05\x02\x02\u1782\u1783\x07k\x02\x02\u1783\u1784" + - "\x07\xD5\x02\x02\u1784\u1786\x05\u0272\u013A\x02\u1785\u1787\x05\u02BA" + - "\u015E\x02\u1786\u1785\x03\x02\x02\x02\u1786\u1787\x03\x02\x02\x02\u1787" + - "\u17A1\x03\x02\x02\x02\u1788\u1789\x070\x02\x02\u1789\u178A\x07+\x02\x02" + - "\u178A\u178B\x07\x04\x02\x02\u178B\u178C\x05\u0454\u022B\x02\u178C\u178D" + - "\x07&\x02\x02\u178D\u178E\x05\u0454\u022B\x02\u178E\u178F\x07\x05\x02" + - "\x02\u178F\u1790\x07\u0174\x02\x02\u1790\u1792\x07\xD5\x02\x02\u1791\u1793" + - "\x05\u02BA\u015E\x02\u1792\u1791\x03\x02\x02\x02\u1792\u1793\x03\x02\x02" + - "\x02\u1793\u17A1\x03\x02\x02\x02\u1794\u1795\x070\x02\x02\u1795\u1796" + - "\x07+\x02\x02\u1796\u1797\x07\x04\x02\x02\u1797\u1798\x05\u0454\u022B" + - "\x02\u1798\u1799\x07&\x02\x02\u1799\u179A\x05\u0454\u022B\x02\u179A\u179B" + - "\x07\x05\x02\x02\u179B\u179C\x07k\x02\x02\u179C\u179E\x07\u0189\x02\x02" + - "\u179D\u179F\x05\u02BA\u015E\x02\u179E\u179D\x03\x02\x02\x02\u179E\u179F" + - "\x03\x02\x02\x02\u179F\u17A1\x03\x02\x02\x02\u17A0\u177B\x03\x02\x02\x02" + - "\u17A0\u1788\x03\x02\x02\x02\u17A0\u1794\x03\x02\x02\x02\u17A1\u02B9\x03" + - "\x02\x02\x02\u17A2\u17A3\x07&\x02\x02\u17A3\u17A7\x07\xE1\x02\x02\u17A4" + - "\u17A5\x07&\x02\x02\u17A5\u17A7\x07\x8F\x02\x02\u17A6\u17A2\x03\x02\x02" + - "\x02\u17A6\u17A4\x03\x02\x02\x02\u17A7\u02BB\x03\x02\x02\x02\u17A8\u17A9" + - "\x07\xC1\x02\x02\u17A9\u17AB\x07+\x02\x02\u17AA\u17AC\x05\u02BE\u0160" + - "\x02\u17AB\u17AA\x03\x02\x02\x02\u17AB\u17AC\x03\x02\x02\x02\u17AC\u17AD" + - "\x03\x02\x02\x02\u17AD\u17AE\x07\x04\x02\x02\u17AE\u17AF\x05\u0454\u022B" + - "\x02\u17AF\u17B0\x07&\x02\x02\u17B0\u17B1\x05\u0454\u022B\x02\u17B1\u17B3" + - "\x07\x05\x02\x02\u17B2\u17B4\x05l7\x02\u17B3\u17B2\x03\x02\x02\x02\u17B3" + - "\u17B4\x03\x02\x02\x02\u17B4\u02BD\x03\x02\x02\x02\u17B5\u17B6\x07\xDE" + - "\x02\x02\u17B6\u17B7\x07\u0185\x02\x02\u17B7\u02BF\x03\x02\x02\x02\u17B8" + - "\u17BA\x070\x02\x02\u17B9\u17BB\x05\u026A\u0136\x02\u17BA\u17B9\x03\x02" + - "\x02\x02\u17BA\u17BB\x03\x02\x02\x02\u17BB\u17BC\x03\x02\x02\x02\u17BC" + - "\u17BD\x07\u01B4\x02\x02\u17BD\u17BE\x07@\x02\x02\u17BE\u17BF\x05\u0454" + - "\u022B\x02\u17BF\u17C0\x07\xF0\x02\x02\u17C0\u17C1\x05\u0530\u0299\x02" + - "\u17C1\u17C2\x07\x04\x02\x02\u17C2\u17C3\x05\u02C2\u0162\x02\u17C3\u17C4" + - "\x07\x05\x02\x02\u17C4\u02C1\x03\x02\x02\x02\u17C5\u17C6\x07B\x02\x02" + - "\u17C6\u17C7\x07\u01C6\x02\x02\u17C7\u17C8\x07k\x02\x02\u17C8\u17C9\x07" + - "\xD5\x02\x02\u17C9\u17CA\x05\u0272\u013A\x02\u17CA\u17CB\x07\b\x02\x02" + - "\u17CB\u17CC\x07`\x02\x02\u17CC\u17CD\x07\u01C6\x02\x02\u17CD\u17CE\x07" + - "k\x02\x02\u17CE\u17CF\x07\xD5\x02\x02\u17CF\u17D0\x05\u0272\u013A\x02" + - "\u17D0\u17E8\x03\x02\x02\x02\u17D1\u17D2\x07`\x02\x02\u17D2\u17D3\x07" + - "\u01C6\x02\x02\u17D3\u17D4\x07k\x02\x02\u17D4\u17D5\x07\xD5\x02\x02\u17D5" + - "\u17D6\x05\u0272\u013A\x02\u17D6\u17D7\x07\b\x02\x02\u17D7\u17D8\x07B" + - "\x02\x02\u17D8\u17D9\x07\u01C6\x02\x02\u17D9\u17DA\x07k\x02\x02\u17DA" + - "\u17DB\x07\xD5\x02\x02\u17DB\u17DC\x05\u0272\u013A\x02\u17DC\u17E8\x03" + - "\x02\x02\x02\u17DD\u17DE\x07B\x02\x02\u17DE\u17DF\x07\u01C6\x02\x02\u17DF" + - "\u17E0\x07k\x02\x02\u17E0\u17E1\x07\xD5\x02\x02\u17E1\u17E8\x05\u0272" + - "\u013A\x02\u17E2\u17E3\x07`\x02\x02\u17E3\u17E4\x07\u01C6\x02\x02\u17E4" + - "\u17E5\x07k\x02\x02\u17E5\u17E6\x07\xD5\x02\x02\u17E6\u17E8\x05\u0272" + - "\u013A\x02\u17E7\u17C5\x03\x02\x02\x02\u17E7\u17D1\x03\x02\x02\x02\u17E7" + - "\u17DD\x03\x02\x02\x02\u17E7\u17E2\x03\x02\x02\x02\u17E8\u02C3\x03\x02" + - "\x02\x02\u17E9\u17EA\x07\xC1\x02\x02\u17EA\u17EC\x07\u01B4\x02\x02\u17EB" + - "\u17ED\x05\u02BE\u0160\x02\u17EC\u17EB\x03\x02\x02\x02\u17EC\u17ED\x03" + - "\x02\x02\x02\u17ED\u17EE\x03\x02\x02\x02\u17EE\u17EF\x07@\x02\x02\u17EF" + - "\u17F0\x05\u0454\u022B\x02\u17F0\u17F1\x07\xF0\x02\x02\u17F1\u17F3\x05" + - "\u0530\u0299\x02\u17F2\u17F4\x05l7\x02\u17F3\u17F2\x03\x02\x02\x02\u17F3" + - "\u17F4\x03\x02\x02\x02\u17F4\u02C5\x03\x02\x02\x02\u17F5\u17F6\x07\u012B" + - "\x02\x02\u17F6\u17F8\x05\u02C8\u0165\x02\u17F7\u17F9\x05\u0250\u0129\x02" + - "\u17F8\u17F7\x03\x02\x02\x02\u17F8\u17F9\x03\x02\x02\x02\u17F9\u17FA\x03" + - "\x02\x02\x02\u17FA\u17FB\x05\u052C\u0297\x02\u17FB\u1818\x03\x02\x02\x02" + - "\u17FC\u17FD\x07\u012B\x02\x02\u17FD\u17FF\x05\u02CA\u0166\x02\u17FE\u1800" + - "\x05\u0250\u0129\x02\u17FF\u17FE\x03\x02\x02\x02\u17FF\u1800\x03\x02\x02" + - "\x02\u1800\u1801\x03\x02\x02\x02\u1801\u1802\x05\u0530\u0299\x02\u1802" + - "\u1818\x03\x02\x02\x02\u1803\u1804\x07\u012B\x02\x02\u1804\u1805\x07\x04" + - "\x02\x02\u1805\u1806\x05\u02CC\u0167\x02\u1806\u1807\x07\x05\x02\x02\u1807" + - "\u1809\x05\u02C8\u0165\x02\u1808\u180A\x05\u0250\u0129\x02\u1809\u1808" + - "\x03\x02\x02\x02\u1809\u180A\x03\x02\x02\x02\u180A\u180B\x03\x02\x02\x02" + - "\u180B\u180C\x05\u052C\u0297\x02\u180C\u1818\x03\x02\x02\x02\u180D\u180E" + - "\x07\u012B\x02\x02\u180E\u180F\x07\x04\x02\x02\u180F\u1810\x05\u02CC\u0167" + - "\x02\u1810\u1811\x07\x05\x02\x02\u1811\u1813\x05\u02CA\u0166\x02\u1812" + - "\u1814\x05\u0250\u0129\x02\u1813\u1812\x03\x02\x02\x02\u1813\u1814\x03" + - "\x02\x02\x02\u1814\u1815\x03\x02\x02\x02\u1815\u1816\x05\u0530\u0299\x02" + - "\u1816\u1818\x03\x02\x02\x02\u1817\u17F5\x03\x02\x02\x02\u1817\u17FC\x03" + - "\x02\x02\x02\u1817\u1803\x03\x02\x02\x02\u1817\u180D\x03\x02\x02\x02\u1818" + - "\u02C7\x03\x02\x02\x02\u1819\u181A\t\x15\x02\x02\u181A\u02C9\x03\x02\x02" + - "\x02\u181B\u181C\t \x02\x02\u181C\u02CB\x03\x02\x02\x02\u181D\u1822\x05" + - "\u02CE\u0168\x02\u181E\u181F\x07\b\x02\x02\u181F\u1821\x05\u02CE\u0168" + - "\x02\u1820\u181E\x03\x02\x02\x02\u1821\u1824\x03\x02\x02\x02\u1822\u1820" + - "\x03\x02\x02\x02\u1822\u1823\x03\x02\x02\x02\u1823\u02CD\x03\x02\x02\x02" + - "\u1824\u1822\x03\x02\x02\x02\u1825\u1826\x07\x82\x02\x02\u1826\u02CF\x03" + - "\x02\x02\x02\u1827\u1828\x07\x8C\x02\x02\u1828\u1829\x07\u0158\x02\x02" + - "\u1829\u182A\x05\u0530\u0299\x02\u182A\u182B\x07\u0146\x02\x02\u182B\u182C" + - "\x05t;\x02\u182C\u1834\x03\x02\x02\x02\u182D\u182E\x07\x8C\x02\x02\u182E" + - "\u182F\x07\u0158\x02\x02\u182F\u1830\x05\u0530\u0299\x02\u1830\u1831\x07" + - "\u0132\x02\x02\u1831\u1832\x05t;\x02\u1832\u1834\x03\x02\x02\x02\u1833" + - "\u1827\x03\x02\x02\x02\u1833\u182D\x03\x02\x02\x02\u1834\u02D1\x03\x02" + - "\x02\x02\u1835\u1836\x07\x8C\x02\x02\u1836\u1837\x07\x8A\x02\x02\u1837" + - "\u1838\x05\u028A\u0146\x02\u1838\u1839\x07\u012E\x02\x02\u1839\u183A\x07" + - "`\x02\x02\u183A\u183B\x05\u0530\u0299\x02\u183B\u1A1D\x03\x02\x02\x02" + - "\u183C\u183D\x07\x8C\x02\x02\u183D\u183E\x07n\x02\x02\u183E\u183F\x05" + - "\u020C\u0107\x02\u183F\u1840\x07\u012E\x02\x02\u1840\u1841\x07`\x02\x02" + - "\u1841\u1842\x05\u0530\u0299\x02\u1842\u1A1D\x03\x02\x02\x02\u1843\u1844" + - "\x07\x8C\x02\x02\u1844\u1845\x07\xAA\x02\x02\u1845\u1846\x05\u020C\u0107" + - "\x02\u1846\u1847\x07\u012E\x02\x02\u1847\u1848\x07`\x02\x02\u1848\u1849" + - "\x05\u0530\u0299\x02\u1849\u1A1D\x03\x02\x02\x02\u184A\u184B\x07\x8C\x02" + - "\x02\u184B\u184C\x07\xB1\x02\x02\u184C\u184D\x05\u0530\u0299\x02\u184D" + - "\u184E\x07\u012E\x02\x02\u184E\u184F\x07`\x02\x02\u184F\u1850\x05\u0530" + - "\u0299\x02\u1850\u1A1D\x03\x02\x02\x02\u1851\u1852\x07\x8C\x02\x02\u1852" + - "\u1853\x07\xBF\x02\x02\u1853\u1854\x05\u020C\u0107\x02\u1854\u1855\x07" + - "\u012E\x02\x02\u1855\u1856\x07`\x02\x02\u1856\u1857\x05\u0530\u0299\x02" + - "\u1857\u1A1D\x03\x02\x02\x02\u1858\u1859\x07\x8C\x02\x02\u1859\u185A\x07" + - "\xBF\x02\x02\u185A\u185B\x05\u020C\u0107\x02\u185B\u185C\x07\u012E\x02" + - "\x02\u185C\u185D\x07/\x02\x02\u185D\u185E\x05\u0530\u0299\x02\u185E\u185F" + - "\x07`\x02\x02\u185F\u1860\x05\u0530\u0299\x02\u1860\u1A1D\x03\x02\x02" + - "\x02\u1861\u1862\x07\x8C\x02\x02\u1862\u1863\x07A\x02\x02\u1863\u1864" + - "\x07\xB0\x02\x02\u1864\u1865\x07\u0176\x02\x02\u1865\u1866\x05\u0530\u0299" + - "\x02\u1866\u1867\x07\u012E\x02\x02\u1867\u1868\x07`\x02\x02\u1868\u1869" + - "\x05\u0530\u0299\x02\u1869\u1A1D\x03\x02\x02\x02\u186A\u186B\x07\x8C\x02" + - "\x02\u186B\u186C\x07\xD5\x02\x02\u186C\u186D\x05\u0272\u013A\x02\u186D" + - "\u186E\x07\u012E\x02\x02\u186E\u186F\x07`\x02\x02\u186F\u1870\x05\u0530" + - "\u0299\x02\u1870\u1A1D\x03\x02\x02\x02\u1871\u1872\x07\x8C\x02\x02\u1872" + - "\u1873\x07D\x02\x02\u1873\u1874\x05\u054A\u02A6\x02\u1874\u1875\x07\u012E" + - "\x02\x02\u1875\u1876\x07`\x02\x02\u1876\u1877\x05\u054A\u02A6\x02\u1877" + - "\u1A1D\x03\x02\x02\x02\u1878\u187A\x07\x8C\x02\x02\u1879\u187B\x05\u0134" + - "\x9B\x02\u187A\u1879\x03\x02\x02\x02\u187A\u187B\x03\x02\x02\x02\u187B" + - "\u187C\x03\x02\x02\x02\u187C\u187D\x07\xF0\x02\x02\u187D\u187E\x05\u0530" + - "\u0299\x02\u187E\u187F\x07\u012E\x02\x02\u187F\u1880\x07`\x02\x02\u1880" + - "\u1881\x05\u0530\u0299\x02\u1881\u1A1D\x03\x02\x02\x02\u1882\u1883\x07" + - "\x8C\x02\x02\u1883\u1884\x07\u010F\x02\x02\u1884\u1885\x07\x9E\x02\x02" + - "\u1885\u1886\x05\u020C\u0107\x02\u1886\u1887\x07f\x02\x02\u1887\u1888" + - "\x05\u0530\u0299\x02\u1888\u1889\x07\u012E\x02\x02\u1889\u188A\x07`\x02" + - "\x02\u188A\u188B\x05\u0530\u0299\x02\u188B\u1A1D\x03\x02\x02\x02\u188C" + - "\u188D\x07\x8C\x02\x02\u188D\u188E\x07\u010F\x02\x02\u188E\u188F\x07\xD0" + - "\x02\x02\u188F\u1890\x05\u020C\u0107\x02\u1890\u1891\x07f\x02\x02\u1891" + - "\u1892\x05\u0530\u0299\x02\u1892\u1893\x07\u012E\x02\x02\u1893\u1894\x07" + - "`\x02\x02\u1894\u1895\x05\u0530\u0299\x02\u1895\u1A1D\x03\x02\x02\x02" + - "\u1896\u1897\x07\x8C\x02\x02\u1897\u1898\x07\u01B6\x02\x02\u1898\u1899" + - "\x05\u0530\u0299\x02\u1899\u189A\x07R\x02\x02\u189A\u189B\x05\u052C\u0297" + - "\x02\u189B\u189C\x07\u012E\x02\x02\u189C\u189D\x07`\x02\x02\u189D\u189E" + - "\x05\u0530\u0299\x02\u189E\u1A1D\x03\x02\x02\x02\u189F\u18A0\x07\x8C\x02" + - "\x02\u18A0\u18A1\x07\u01B6\x02\x02\u18A1\u18A2\x07\xDE\x02\x02\u18A2\u18A3" + - "\x07\u0185\x02\x02\u18A3\u18A4\x05\u0530\u0299\x02\u18A4\u18A5\x07R\x02" + - "\x02\u18A5\u18A6\x05\u052C\u0297\x02\u18A6\u18A7\x07\u012E\x02\x02\u18A7" + - "\u18A8\x07`\x02\x02\u18A8\u18A9\x05\u0530\u0299\x02\u18A9\u1A1D\x03\x02" + - "\x02\x02\u18AA\u18AB\x07\x8C\x02\x02\u18AB\u18AC\x07\u0121\x02\x02\u18AC" + - "\u18AD\x05\u0272\u013A\x02\u18AD\u18AE\x07\u012E\x02\x02\u18AE\u18AF\x07" + - "`\x02\x02\u18AF\u18B0\x05\u0530\u0299\x02\u18B0\u1A1D\x03\x02\x02\x02" + - "\u18B1\u18B2\x07\x8C\x02\x02\u18B2\u18B3\x07\u01BD\x02\x02\u18B3\u18B4" + - "\x05\u0530\u0299\x02\u18B4\u18B5\x07\u012E\x02\x02\u18B5\u18B6\x07`\x02" + - "\x02\u18B6\u18B7\x05\u0530\u0299\x02\u18B7\u1A1D\x03\x02\x02\x02\u18B8" + - "\u18B9\x07\x8C\x02\x02\u18B9\u18BA\x07\u01B3\x02\x02\u18BA\u18BB\x05\u0272" + - "\u013A\x02\u18BB\u18BC\x07\u012E\x02\x02\u18BC\u18BD\x07`\x02\x02\u18BD" + - "\u18BE\x05\u0530\u0299\x02\u18BE\u1A1D\x03\x02\x02\x02\u18BF\u18C0\x07" + - "\x8C\x02\x02\u18C0\u18C1\x07\u013C\x02\x02\u18C1\u18C2\x05\u0530\u0299" + - "\x02\u18C2\u18C3\x07\u012E\x02\x02\u18C3\u18C4\x07`\x02\x02\u18C4\u18C5" + - "\x05\u0530\u0299\x02\u18C5\u1A1D\x03\x02\x02\x02\u18C6\u18C7\x07\x8C\x02" + - "\x02\u18C7\u18C8\x07\u0144\x02\x02\u18C8\u18C9\x05\u0530\u0299\x02\u18C9" + - "\u18CA\x07\u012E\x02\x02\u18CA\u18CB\x07`\x02\x02\u18CB\u18CC\x05\u0530" + - "\u0299\x02\u18CC\u1A1D\x03\x02\x02\x02\u18CD\u18CE\x07\x8C\x02\x02\u18CE" + - "\u18CF\x07\u01BC\x02\x02\u18CF\u18D0\x05\u0530\u0299\x02\u18D0\u18D1\x07" + - "\u012E\x02\x02\u18D1\u18D2\x07`\x02\x02\u18D2\u18D3\x05\u0530\u0299\x02" + - "\u18D3\u1A1D\x03\x02\x02\x02\u18D4\u18D5\x07\x8C\x02\x02\u18D5\u18D6\x07" + - "^\x02\x02\u18D6\u18D7\x05\u0428\u0215\x02\u18D7\u18D8\x07\u012E\x02\x02" + - "\u18D8\u18D9\x07`\x02\x02\u18D9\u18DA\x05\u0530\u0299\x02\u18DA\u1A1D" + - "\x03\x02\x02\x02\u18DB\u18DC\x07\x8C\x02\x02\u18DC\u18DD\x07^\x02\x02" + - "\u18DD\u18DE\x07\xDE\x02\x02\u18DE\u18DF\x07\u0185\x02\x02\u18DF\u18E0" + - "\x05\u0428\u0215\x02\u18E0\u18E1\x07\u012E\x02\x02\u18E1\u18E2\x07`\x02" + - "\x02\u18E2\u18E3\x05\u0530\u0299\x02\u18E3\u1A1D\x03\x02\x02\x02\u18E4" + - "\u18E5\x07\x8C\x02\x02\u18E5\u18E6\x07\u0141\x02\x02\u18E6\u18E7\x05\u052C" + - "\u0297\x02\u18E7\u18E8\x07\u012E\x02\x02\u18E8\u18E9\x07`\x02\x02\u18E9" + - "\u18EA\x05\u0530\u0299\x02\u18EA\u1A1D\x03\x02\x02\x02\u18EB\u18EC\x07" + - "\x8C\x02\x02\u18EC\u18ED\x07\u0141\x02\x02\u18ED\u18EE\x07\xDE\x02\x02" + - "\u18EE\u18EF\x07\u0185\x02\x02\u18EF\u18F0\x05\u052C\u0297\x02\u18F0\u18F1" + - "\x07\u012E\x02\x02\u18F1\u18F2\x07`\x02\x02\u18F2\u18F3\x05\u0530\u0299" + - "\x02\u18F3\u1A1D\x03\x02\x02\x02\u18F4\u18F5\x07\x8C\x02\x02\u18F5\u18F6" + - "\x07\u0171\x02\x02\u18F6\u18F7\x05\u052C\u0297\x02\u18F7\u18F8\x07\u012E" + - "\x02\x02\u18F8\u18F9\x07`\x02\x02\u18F9\u18FA\x05\u0530\u0299\x02\u18FA" + - "\u1A1D\x03\x02\x02\x02\u18FB\u18FC\x07\x8C\x02\x02\u18FC\u18FD\x07\u0171" + - "\x02\x02\u18FD\u18FE\x07\xDE\x02\x02\u18FE\u18FF\x07\u0185\x02\x02\u18FF" + - "\u1900\x05\u052C\u0297\x02\u1900\u1901\x07\u012E\x02\x02\u1901\u1902\x07" + - "`\x02\x02\u1902\u1903\x05\u0530\u0299\x02\u1903\u1A1D\x03\x02\x02\x02" + - "\u1904\u1905\x07\x8C\x02\x02\u1905\u1906\x07\xFC\x02\x02\u1906\u1907\x07" + - "\u0171\x02\x02\u1907\u1908\x05\u052C\u0297\x02\u1908\u1909\x07\u012E\x02" + - "\x02\u1909\u190A\x07`\x02\x02\u190A\u190B\x05\u0530\u0299\x02\u190B\u1A1D" + - "\x03\x02\x02\x02\u190C\u190D\x07\x8C\x02\x02\u190D\u190E\x07\xFC\x02\x02" + - "\u190E\u190F\x07\u0171\x02\x02\u190F\u1910\x07\xDE\x02\x02\u1910\u1911" + - "\x07\u0185\x02\x02\u1911\u1912\x05\u052C\u0297\x02\u1912\u1913\x07\u012E" + - "\x02\x02\u1913\u1914\x07`\x02\x02\u1914\u1915\x05\u0530\u0299\x02\u1915" + - "\u1A1D\x03\x02\x02\x02\u1916\u1917\x07\x8C\x02\x02\u1917\u1918\x07\xE4" + - "\x02\x02\u1918\u1919\x05\u052C\u0297\x02\u1919\u191A\x07\u012E\x02\x02" + - "\u191A\u191B\x07`\x02\x02\u191B\u191C\x05"; + "\u1611\x05\u0270\u0139\x02\u1610\u160F\x03\x02\x02\x02\u1610\u1611\x03" + + "\x02\x02\x02\u1611\u1613\x03\x02\x02\x02\u1612\u1614\x05\u0272\u013A\x02" + + "\u1613\u1612\x03\x02\x02\x02\u1613\u1614\x03\x02\x02\x02\u1614\u1616\x03" + + "\x02\x02\x02\u1615\u15FF\x03\x02\x02\x02\u1615\u160B\x03\x02\x02\x02\u1616" + + "\u0265\x03\x02\x02\x02\u1617\u1618\x05\u0562\u02B2\x02\u1618\u1619\x05" + + "\u0264\u0133\x02\u1619\u1623\x03\x02\x02\x02\u161A\u161B\x05\u04C0\u0261" + + "\x02\u161B\u161C\x05\u0264\u0133\x02\u161C\u1623\x03\x02\x02\x02\u161D" + + "\u161E\x07\x04\x02\x02\u161E\u161F\x05\u048E\u0248\x02\u161F\u1620\x07" + + "\x05\x02\x02\u1620\u1621\x05\u0264\u0133\x02\u1621\u1623\x03\x02\x02\x02" + + "\u1622\u1617\x03\x02\x02\x02\u1622\u161A\x03\x02\x02\x02\u1622\u161D\x03" + + "\x02\x02\x02\u1623\u0267\x03\x02\x02\x02\u1624\u1625\x07\u01BB\x02\x02" + + "\u1625\u1626\x07\x04\x02\x02\u1626\u1627\x05\u026A\u0136\x02\u1627\u1628" + + "\x07\x05\x02\x02\u1628\u0269\x03\x02\x02\x02\u1629\u162E\x05\u0266\u0134" + + "\x02\u162A\u162B\x07\b\x02\x02\u162B\u162D\x05\u0266\u0134\x02\u162C\u162A" + + "\x03\x02\x02\x02\u162D\u1630\x03\x02\x02\x02\u162E\u162C\x03\x02\x02\x02" + + "\u162E\u162F\x03\x02\x02\x02\u162F\u026B\x03\x02\x02\x02\u1630\u162E\x03" + + "\x02\x02\x02\u1631\u1632\x07-\x02\x02\u1632\u1633\x05\u0214\u010B\x02" + + "\u1633\u026D\x03\x02\x02\x02\u1634\u1635\x05\u0214\u010B\x02\u1635\u026F" + + "\x03\x02\x02\x02\u1636\u1637\t#\x02\x02\u1637\u0271\x03\x02\x02\x02\u1638" + + "\u1639\x07\u0113\x02\x02\u1639\u163D\x07\xD1\x02\x02\u163A\u163B\x07\u0113" + + "\x02\x02\u163B\u163D\x07\xFB\x02\x02\u163C\u1638\x03\x02\x02\x02\u163C" + + "\u163A\x03\x02\x02\x02\u163D\u0273\x03\x02\x02\x02\u163E\u1640\x070\x02" + + "\x02\u163F\u1641\x05\u0278\u013D\x02\u1640\u163F\x03\x02\x02\x02\u1640" + + "\u1641\x03\x02\x02\x02\u1641\u1642\x03\x02\x02\x02\u1642\u1643\t\x1E\x02" + + "\x02\u1643\u1644\x05\u0546\u02A4\x02\u1644\u164E\x05\u0282\u0142\x02\u1645" + + "\u164C\x07\u013E\x02\x02\u1646\u164D\x05\u028C\u0147\x02\u1647\u1648\x07" + + "^\x02\x02\u1648\u1649\x07\x04\x02\x02\u1649\u164A\x05\u02AA\u0156\x02" + + "\u164A\u164B\x07\x05\x02\x02\u164B\u164D\x03\x02\x02\x02\u164C\u1646\x03" + + "\x02\x02\x02\u164C\u1647\x03\x02\x02\x02\u164D\u164F\x03\x02\x02\x02\u164E" + + "\u1645\x03\x02\x02\x02\u164E\u164F\x03\x02\x02\x02\u164F\u1650\x03\x02" + + "\x02\x02\u1650\u1653\x05\u029C\u014F\x02\u1651\u1652\x07k\x02\x02\u1652" + + "\u1654\x05\u0276\u013C\x02\u1653\u1651\x03\x02\x02\x02\u1653\u1654\x03" + + "\x02\x02\x02\u1654\u0275\x03\x02\x02\x02\u1655\u1656\x07\x04\x02\x02\u1656" + + "\u165B\x05\u0562\u02B2\x02\u1657\u1658\x07\b\x02\x02\u1658\u165A\x05\u0562" + + "\u02B2\x02\u1659\u1657\x03\x02\x02\x02\u165A\u165D\x03\x02\x02\x02\u165B" + + "\u1659\x03\x02\x02\x02\u165B\u165C\x03\x02\x02\x02\u165C\u165E\x03\x02" + + "\x02\x02\u165D\u165B\x03\x02\x02\x02\u165E\u165F\x07\x05\x02\x02\u165F" + + "\u0277\x03\x02\x02\x02\u1660\u1661\x07T\x02\x02\u1661\u1662\x07\u0139" + + "\x02\x02\u1662\u0279\x03\x02\x02\x02\u1663\u1665\x07\x04\x02\x02\u1664" + + "\u1666\x05\u027C\u013F\x02\u1665\u1664\x03\x02\x02\x02\u1665\u1666\x03" + + "\x02\x02\x02\u1666\u1667\x03\x02\x02\x02\u1667\u1668\x07\x05\x02\x02\u1668" + + "\u027B\x03\x02\x02\x02\u1669\u166E\x05\u0286\u0144\x02\u166A\u166B\x07" + + "\b\x02\x02\u166B\u166D\x05\u0286\u0144\x02\u166C\u166A\x03\x02\x02\x02" + + "\u166D\u1670\x03\x02\x02\x02\u166E\u166C\x03\x02\x02\x02\u166E\u166F\x03" + + "\x02\x02\x02\u166F\u027D\x03\x02\x02\x02\u1670\u166E\x03\x02\x02\x02\u1671" + + "\u1676\x05\u0280\u0141\x02\u1672\u1673\x07\b\x02\x02\u1673\u1675\x05\u0280" + + "\u0141\x02\u1674\u1672\x03\x02\x02\x02\u1675\u1678\x03\x02\x02\x02\u1676" + + "\u1674\x03\x02\x02\x02\u1676\u1677\x03\x02\x02\x02\u1677\u027F\x03\x02" + + "\x02\x02\u1678\u1676\x03\x02\x02\x02\u1679\u167A\x05\u0546\u02A4\x02\u167A" + + "\u167B\x05\u027A\u013E\x02\u167B\u1682\x03\x02\x02\x02\u167C\u1682\x05" + + "\u057A\u02BE\x02\u167D\u167F\x05\u0562\u02B2\x02\u167E\u1680\x05\u052E" + + "\u0298\x02\u167F\u167E\x03\x02\x02\x02\u167F\u1680\x03\x02\x02\x02\u1680" + + "\u1682\x03\x02\x02\x02\u1681\u1679\x03\x02\x02\x02\u1681\u167C\x03\x02" + + "\x02\x02\u1681\u167D\x03\x02\x02\x02\u1682\u0281\x03\x02\x02\x02\u1683" + + "\u1685\x07\x04\x02\x02\u1684\u1686\x05\u0284\u0143\x02\u1685\u1684\x03" + + "\x02\x02\x02\u1685\u1686\x03\x02\x02\x02\u1686\u1687\x03\x02\x02\x02\u1687" + + "\u1688\x07\x05\x02\x02\u1688\u0283\x03\x02\x02\x02\u1689\u168E\x05\u0290" + + "\u0149\x02\u168A\u168B\x07\b\x02\x02\u168B\u168D\x05\u0290\u0149\x02\u168C" + + "\u168A\x03\x02\x02\x02\u168D\u1690\x03\x02\x02\x02\u168E\u168C\x03\x02" + + "\x02\x02\u168E\u168F\x03\x02\x02\x02\u168F\u0285\x03\x02\x02\x02\u1690" + + "\u168E\x03\x02\x02\x02\u1691\u1693\x05\u0288\u0145\x02\u1692\u1694\x05" + + "\u028A\u0146\x02\u1693\u1692\x03\x02\x02\x02\u1693\u1694\x03\x02\x02\x02" + + "\u1694\u1695\x03\x02\x02\x02\u1695\u1696\x05\u028E\u0148\x02\u1696\u169F" + + "\x03\x02\x02\x02\u1697\u1699\x05\u028A\u0146\x02\u1698\u169A\x05\u0288" + + "\u0145\x02\u1699\u1698\x03\x02\x02\x02\u1699\u169A\x03\x02\x02\x02\u169A" + + "\u169B\x03\x02\x02\x02\u169B\u169C\x05\u028E\u0148\x02\u169C\u169F\x03" + + "\x02\x02\x02\u169D\u169F\x05\u028E\u0148\x02\u169E\u1691\x03\x02\x02\x02" + + "\u169E\u1697\x03\x02\x02\x02\u169E\u169D\x03\x02\x02\x02\u169F\u0287\x03" + + "\x02\x02\x02\u16A0\u16A2\x07F\x02\x02\u16A1\u16A3\x07\u01C7\x02\x02\u16A2" + + "\u16A1\x03\x02\x02\x02\u16A2\u16A3\x03\x02\x02\x02\u16A3\u16A8\x03\x02" + + "\x02\x02\u16A4\u16A8\x07\u01C7\x02\x02\u16A5\u16A8\x07\u0192\x02\x02\u16A6" + + "\u16A8\x07g\x02\x02\u16A7\u16A0\x03\x02\x02\x02\u16A7\u16A4\x03\x02\x02" + + "\x02\u16A7\u16A5\x03\x02\x02\x02\u16A7\u16A6\x03\x02\x02\x02\u16A8\u0289" + + "\x03\x02\x02\x02\u16A9\u16AA\x05\u056C\u02B7\x02\u16AA\u028B\x03\x02\x02" + + "\x02\u16AB\u16AC\x05\u028E\u0148\x02\u16AC\u028D\x03\x02\x02\x02\u16AD" + + "\u16BA\x05\u0462\u0232\x02\u16AE\u16AF\x05\u056C\u02B7\x02\u16AF\u16B0" + + "\x05\u0216\u010C\x02\u16B0\u16B1\x07\x1D\x02\x02\u16B1\u16B2\x07\u016A" + + "\x02\x02\u16B2\u16BA\x03\x02\x02\x02\u16B3\u16B4\x07\u01A1\x02\x02\u16B4" + + "\u16B5\x05\u056C\u02B7\x02\u16B5\u16B6\x05\u0216\u010C\x02\u16B6\u16B7" + + "\x07\x1D\x02\x02\u16B7\u16B8\x07\u016A\x02\x02\u16B8\u16BA\x03\x02\x02" + + "\x02\u16B9\u16AD\x03\x02\x02\x02\u16B9\u16AE\x03\x02\x02\x02\u16B9\u16B3" + + "\x03\x02\x02\x02\u16BA\u028F\x03\x02\x02\x02\u16BB\u16BE\x05\u0286\u0144" + + "\x02\u16BC\u16BD\t$\x02\x02\u16BD\u16BF\x05\u048E\u0248\x02\u16BE\u16BC" + + "\x03\x02\x02\x02\u16BE\u16BF\x03\x02\x02\x02\u16BF\u0291\x03\x02\x02\x02" + + "\u16C0\u16C1\x05\u0286\u0144\x02\u16C1\u0293\x03\x02\x02\x02\u16C2\u16CD" + + "\x07\x04\x02\x02\u16C3\u16CE\x07\v\x02\x02\u16C4\u16CE\x05\u0296\u014C" + + "\x02\u16C5\u16C6\x07U\x02\x02\u16C6\u16C7\x07\x95\x02\x02\u16C7\u16CE" + + "\x05\u0296\u014C\x02\u16C8\u16C9\x05\u0296\u014C\x02\u16C9\u16CA\x07U" + + "\x02\x02\u16CA\u16CB\x07\x95\x02\x02\u16CB\u16CC\x05\u0296\u014C\x02\u16CC" + + "\u16CE\x03\x02\x02\x02\u16CD\u16C3\x03\x02\x02\x02\u16CD\u16C4\x03\x02" + + "\x02\x02\u16CD\u16C5\x03\x02\x02\x02\u16CD\u16C8\x03\x02\x02\x02\u16CE" + + "\u16CF\x03\x02\x02\x02\u16CF\u16D0\x07\x05\x02\x02\u16D0\u0295\x03\x02" + + "\x02\x02\u16D1\u16D6\x05\u0292\u014A\x02\u16D2\u16D3\x07\b\x02\x02\u16D3" + + "\u16D5\x05\u0292\u014A\x02\u16D4\u16D2\x03\x02\x02\x02\u16D5\u16D8\x03" + + "\x02\x02\x02\u16D6\u16D4\x03\x02\x02\x02\u16D6\u16D7\x03\x02\x02\x02\u16D7" + + "\u0297\x03\x02\x02\x02\u16D8\u16D6\x03\x02\x02\x02\u16D9\u16DA\x05\u0546" + + "\u02A4\x02\u16DA\u16DB\x05\u0294\u014B\x02\u16DB\u0299\x03\x02\x02\x02" + + "\u16DC\u16E1\x05\u0298\u014D\x02\u16DD\u16DE\x07\b\x02\x02\u16DE\u16E0" + + "\x05\u0298\u014D\x02\u16DF\u16DD\x03\x02\x02\x02\u16E0\u16E3\x03\x02\x02" + + "\x02\u16E1\u16DF\x03\x02\x02\x02\u16E1\u16E2\x03\x02\x02\x02\u16E2\u029B" + + "\x03\x02\x02\x02\u16E3\u16E1\x03\x02\x02\x02\u16E4\u16E6\x05\u02A0\u0151" + + "\x02\u16E5\u16E4\x03\x02\x02\x02\u16E6\u16E7\x03\x02\x02\x02\u16E7\u16E5" + + "\x03\x02\x02\x02\u16E7\u16E8\x03\x02\x02\x02\u16E8\u029D\x03\x02\x02\x02" + + "\u16E9\u16EA\x07\x97\x02\x02\u16EA\u16EB\x07R\x02\x02\u16EB\u16EC\x07" + + "P\x02\x02\u16EC\u170D\x07\u01CC\x02\x02\u16ED\u16EE\x07\u013E\x02\x02" + + "\u16EE\u16EF\x07P\x02\x02\u16EF\u16F0\x07R\x02\x02\u16F0\u16F1\x07P\x02" + + "\x02\u16F1\u170D\x07\u01CC\x02\x02\u16F2\u170D\x07\u015C\x02\x02\u16F3" + + "\u170D\x07\xE0\x02\x02\u16F4\u170D\x07\u0154\x02\x02\u16F5\u170D\x07\u017B" + + "\x02\x02\u16F6\u16F7\x07\xCF\x02\x02\u16F7\u16F8\x07\u0149\x02\x02\u16F8" + + "\u170D\x07\xB7\x02\x02\u16F9\u16FA\x07\xCF\x02\x02\u16FA\u16FB\x07\u0149" + + "\x02\x02\u16FB\u170D\x07\xF5\x02\x02\u16FC\u16FD\x07\u0149\x02\x02\u16FD" + + "\u170D\x07\xB7\x02\x02\u16FE\u16FF\x07\u0149\x02\x02\u16FF\u170D\x07\xF5" + + "\x02\x02\u1700\u170D\x07\xFC\x02\x02\u1701\u1702\x07O\x02\x02\u1702\u170D" + + "\x07\xFC\x02\x02\u1703\u1704\x07\xAC\x02\x02\u1704\u170D\x05\u0128\x95" + + "\x02\u1705\u1706\x07\u0142\x02\x02\u1706\u170D\x05\u0128\x95\x02\u1707" + + "\u1708\x07\u01CD\x02\x02\u1708\u170D\x05\u0214\u010B\x02\u1709\u170D\x05" + + "R*\x02\u170A\u170B\x07\u01CE\x02\x02\u170B\u170D\x05\u0562\u02B2\x02\u170C" + + "\u16E9\x03\x02\x02\x02\u170C\u16ED\x03\x02\x02\x02\u170C\u16F2\x03\x02" + + "\x02\x02\u170C\u16F3\x03\x02\x02\x02\u170C\u16F4\x03\x02\x02\x02\u170C" + + "\u16F5\x03\x02\x02\x02\u170C\u16F6\x03\x02\x02\x02\u170C\u16F9\x03\x02" + + "\x02\x02\u170C\u16FC\x03\x02\x02\x02\u170C\u16FE\x03\x02\x02\x02\u170C" + + "\u1700\x03\x02\x02\x02\u170C\u1701\x03\x02\x02\x02\u170C\u1703\x03\x02" + + "\x02\x02\u170C\u1705\x03\x02\x02\x02\u170C\u1707\x03\x02\x02\x02\u170C" + + "\u1709\x03\x02\x02\x02\u170C\u170A\x03\x02\x02\x02\u170D\u029F\x03\x02" + + "\x02\x02\u170E\u170F\x07&\x02\x02\u170F\u1717\x05\u02A2\u0152\x02\u1710" + + "\u1711\x07\xF9\x02\x02\u1711\u1717\x05H%\x02\u1712\u1713\x07\u01BD\x02" + + "\x02\u1713\u1717\x05\u02A4\u0153\x02\u1714\u1717\x07j\x02\x02\u1715\u1717" + + "\x05\u029E\u0150\x02\u1716\u170E\x03\x02\x02\x02\u1716\u1710\x03\x02\x02" + + "\x02\u1716\u1712\x03\x02\x02\x02\u1716\u1714\x03\x02\x02\x02\u1716\u1715" + + "\x03\x02\x02\x02\u1717\u02A1\x03\x02\x02\x02\u1718\u171E\x05\u0552\u02AA" + + "\x02\u1719\u171A\x05\u0552\u02AA\x02\u171A\u171B\x07\b\x02\x02\u171B\u171C" + + "\x05\u0552\u02AA\x02\u171C\u171E\x03\x02\x02\x02\u171D\u1718\x03\x02\x02" + + "\x02\u171D\u1719\x03\x02\x02\x02\u171E\u02A3\x03\x02\x02\x02\u171F\u1720" + + "\x07@\x02\x02\u1720\u1721\x07\u016A\x02\x02\u1721\u1728\x05\u0462\u0232" + + "\x02\u1722\u1723\x07\b\x02\x02\u1723\u1724\x07@\x02\x02\u1724\u1725\x07" + + "\u016A\x02\x02\u1725\u1727\x05\u0462\u0232\x02\u1726\u1722\x03\x02\x02" + + "\x02\u1727\u172A\x03\x02\x02\x02\u1728\u1726\x03\x02\x02\x02\u1728\u1729" + + "\x03\x02\x02\x02\u1729\u02A5\x03\x02\x02\x02\u172A\u1728\x03\x02\x02\x02" + + "\u172B\u172C\x07k\x02\x02\u172C\u172D\x05\u01D4\xEB\x02\u172D\u02A7\x03" + + "\x02\x02\x02\u172E\u172F\x05\u028A\u0146\x02\u172F\u1730\x05\u028E\u0148" + + "\x02\u1730\u02A9\x03\x02\x02\x02\u1731\u1736\x05\u02A8\u0155\x02\u1732" + + "\u1733\x07\b\x02\x02\u1733\u1735\x05\u02A8\u0155\x02\u1734\u1732\x03\x02" + + "\x02\x02\u1735\u1738\x03\x02\x02\x02\u1736\u1734\x03\x02\x02\x02\u1736" + + "\u1737\x03\x02\x02\x02\u1737\u02AB\x03\x02\x02\x02\u1738\u1736\x03\x02" + + "\x02\x02\u1739\u173A\x07\x8C\x02\x02\u173A\u173B\t%\x02\x02\u173B\u173C" + + "\x05\u0280\u0141\x02\u173C\u173E\x05\u02AE\u0158\x02\u173D\u173F\x05\u02B0" + + "\u0159\x02\u173E\u173D\x03\x02\x02\x02\u173E\u173F\x03\x02\x02\x02\u173F" + + "\u02AD\x03\x02\x02\x02\u1740\u1742\x05\u029E\u0150\x02\u1741\u1740\x03" + + "\x02\x02\x02\u1742\u1743\x03\x02\x02\x02\u1743\u1741\x03\x02\x02\x02\u1743" + + "\u1744\x03\x02\x02\x02\u1744\u02AF\x03\x02\x02\x02\u1745\u1746\x07\u013D" + + "\x02\x02\u1746\u02B1\x03\x02\x02\x02\u1747\u1748\x07\xC1\x02\x02\u1748" + + "\u1749\x07\xD5\x02\x02\u1749\u174B\x05\u027E\u0140\x02\u174A\u174C\x05" + + "l7\x02\u174B\u174A\x03\x02\x02\x02\u174B\u174C\x03\x02\x02\x02\u174C\u1772" + + "\x03\x02\x02\x02\u174D\u174E\x07\xC1\x02\x02\u174E\u174F\x07\xD5\x02\x02" + + "\u174F\u1750\x07\xDE\x02\x02\u1750\u1751\x07\u018E\x02\x02\u1751\u1753" + + "\x05\u027E\u0140\x02\u1752\u1754\x05l7\x02\u1753\u1752\x03\x02\x02\x02" + + "\u1753\u1754\x03\x02\x02\x02\u1754\u1772\x03\x02\x02\x02\u1755\u1756\x07" + + "\xC1\x02\x02\u1756\u1757\x07\u012A\x02\x02\u1757\u1759\x05\u027E\u0140" + + "\x02\u1758\u175A\x05l7\x02\u1759\u1758\x03\x02\x02\x02\u1759\u175A\x03" + + "\x02\x02\x02\u175A\u1772\x03\x02\x02\x02\u175B\u175C\x07\xC1\x02\x02\u175C" + + "\u175D\x07\u012A\x02\x02\u175D\u175E\x07\xDE\x02\x02\u175E\u175F\x07\u018E" + + "\x02\x02\u175F\u1761\x05\u027E\u0140\x02\u1760\u1762\x05l7\x02\u1761\u1760" + + "\x03\x02\x02\x02\u1761\u1762\x03\x02\x02\x02\u1762\u1772\x03\x02\x02\x02" + + "\u1763\u1764\x07\xC1\x02\x02\u1764\u1765\x07\u01BC\x02\x02\u1765\u1767" + + "\x05\u027E\u0140\x02\u1766\u1768\x05l7\x02\u1767\u1766\x03\x02\x02\x02" + + "\u1767\u1768\x03\x02\x02\x02\u1768\u1772\x03\x02\x02\x02\u1769\u176A\x07" + + "\xC1\x02\x02\u176A\u176B\x07\u01BC\x02\x02\u176B\u176C\x07\xDE\x02\x02" + + "\u176C\u176D\x07\u018E\x02\x02\u176D\u176F\x05\u027E\u0140\x02\u176E\u1770" + + "\x05l7\x02\u176F\u176E\x03\x02\x02\x02\u176F\u1770\x03\x02\x02\x02\u1770" + + "\u1772\x03\x02\x02\x02\u1771\u1747\x03\x02\x02\x02\u1771\u174D\x03\x02" + + "\x02\x02\u1771\u1755\x03\x02\x02\x02\u1771\u175B\x03\x02\x02\x02\u1771" + + "\u1763\x03\x02\x02\x02\u1771\u1769\x03\x02\x02\x02\u1772\u02B3\x03\x02" + + "\x02\x02\u1773\u1774\x07\xC1\x02\x02\u1774\u1775\x07\x8A\x02\x02\u1775" + + "\u1777\x05\u029A\u014E\x02\u1776\u1778\x05l7\x02\u1777\u1776\x03\x02\x02" + + "\x02\u1777\u1778\x03\x02\x02\x02\u1778\u1782\x03\x02\x02\x02\u1779\u177A" + + "\x07\xC1\x02\x02\u177A\u177B\x07\x8A\x02\x02\u177B\u177C\x07\xDE\x02\x02" + + "\u177C\u177D\x07\u018E\x02\x02\u177D\u177F\x05\u029A\u014E\x02\u177E\u1780" + + "\x05l7\x02\u177F\u177E\x03\x02\x02\x02\u177F\u1780\x03\x02\x02\x02\u1780" + + "\u1782\x03\x02\x02\x02\u1781\u1773\x03\x02\x02\x02\u1781\u1779\x03\x02" + + "\x02\x02\u1782\u02B5\x03\x02\x02\x02\u1783\u1784\x07\xC1\x02\x02\u1784" + + "\u1785\x07\u0118\x02\x02\u1785\u1787\x05\u02BC\u015F\x02\u1786\u1788\x05" + + "l7\x02\u1787\u1786\x03\x02\x02\x02\u1787\u1788\x03\x02\x02\x02\u1788\u1792" + + "\x03\x02\x02\x02\u1789\u178A\x07\xC1\x02\x02\u178A\u178B\x07\u0118\x02" + + "\x02\u178B\u178C\x07\xDE\x02\x02\u178C\u178D\x07\u018E\x02\x02\u178D\u178F" + + "\x05\u02BC\u015F\x02\u178E\u1790\x05l7\x02\u178F\u178E\x03\x02\x02\x02" + + "\u178F\u1790\x03\x02\x02\x02\u1790\u1792\x03\x02\x02\x02\u1791\u1783\x03" + + "\x02\x02\x02\u1791\u1789\x03\x02\x02\x02\u1792\u02B7\x03\x02\x02\x02\u1793" + + "\u1794\x07\x04\x02\x02\u1794\u1795\x05\u0462\u0232\x02\u1795\u1796\x07" + + "\x05\x02\x02\u1796\u17AA\x03\x02\x02\x02\u1797\u1798\x07\x04\x02\x02\u1798" + + "\u1799\x05\u0462\u0232\x02\u1799\u179A\x07\b\x02\x02\u179A\u179B\x05\u0462" + + "\u0232\x02\u179B\u179C\x07\x05\x02\x02\u179C\u17AA\x03\x02\x02\x02\u179D" + + "\u179E\x07\x04\x02\x02\u179E\u179F\x07\u0199\x02\x02\u179F\u17A0\x07\b" + + "\x02\x02\u17A0\u17A1\x05\u0462\u0232\x02\u17A1\u17A2\x07\x05\x02\x02\u17A2" + + "\u17AA\x03\x02\x02\x02\u17A3\u17A4\x07\x04\x02\x02\u17A4\u17A5\x05\u0462" + + "\u0232\x02\u17A5\u17A6\x07\b\x02\x02\u17A6\u17A7\x07\u0199\x02\x02\u17A7" + + "\u17A8\x07\x05\x02\x02\u17A8\u17AA\x03\x02\x02\x02\u17A9\u1793\x03\x02" + + "\x02\x02\u17A9\u1797\x03\x02\x02\x02\u17A9\u179D\x03\x02\x02\x02\u17A9" + + "\u17A3\x03\x02\x02\x02\u17AA\u02B9\x03\x02\x02\x02\u17AB\u17AC\x05\u0562" + + "\u02B2\x02\u17AC\u17AD\x07\r\x02\x02\u17AD\u17AF\x03\x02\x02\x02\u17AE" + + "\u17AB\x03\x02\x02\x02\u17AF\u17B2\x03\x02\x02\x02\u17B0\u17AE\x03\x02" + + "\x02\x02\u17B0\u17B1\x03\x02\x02\x02\u17B1\u17B3\x03\x02\x02\x02\u17B2" + + "\u17B0\x03\x02\x02\x02\u17B3\u17B4\x05\u04F8\u027D\x02\u17B4\u02BB\x03" + + "\x02\x02\x02\u17B5\u17BA\x05\u02BE\u0160\x02\u17B6\u17B7\x07\b\x02\x02" + + "\u17B7\u17B9\x05\u02BE\u0160\x02\u17B8\u17B6\x03\x02\x02\x02\u17B9\u17BC" + + "\x03\x02\x02\x02\u17BA\u17B8\x03\x02\x02\x02\u17BA\u17BB\x03\x02\x02\x02" + + "\u17BB\u02BD\x03\x02\x02\x02\u17BC\u17BA\x03\x02\x02\x02\u17BD\u17BE\x05" + + "\u02BA\u015E\x02\u17BE\u17BF\x05\u02B8\u015D\x02\u17BF\u02BF\x03\x02\x02" + + "\x02\u17C0\u17C1\x07;\x02\x02\u17C1\u17C2\x05\u02C2\u0162\x02\u17C2\u02C1" + + "\x03\x02\x02\x02\u17C3\u17C5\x05\u02C4\u0163\x02\u17C4\u17C3\x03\x02\x02" + + "\x02\u17C5\u17C6\x03\x02\x02\x02\u17C6\u17C4\x03\x02\x02\x02\u17C6\u17C7" + + "\x03\x02\x02\x02\u17C7\u02C3\x03\x02\x02\x02\u17C8\u17CC\x05\u0552\u02AA" + + "\x02\u17C9\u17CA\x07\xF9\x02\x02\u17CA\u17CC\x05H%\x02\u17CB\u17C8\x03" + + "\x02\x02\x02\u17CB\u17C9\x03\x02\x02\x02\u17CC\u02C5\x03\x02\x02\x02\u17CD" + + "\u17CE\x070\x02\x02\u17CE\u17CF\x07+\x02\x02\u17CF\u17D0\x07\x04\x02\x02" + + "\u17D0\u17D1\x05\u0462\u0232\x02\u17D1\u17D2\x07&\x02\x02\u17D2\u17D3" + + "\x05\u0462\u0232\x02\u17D3\u17D4\x07\x05\x02\x02\u17D4\u17D5\x07k\x02" + + "\x02\u17D5\u17D6\x07\xD5\x02\x02\u17D6\u17D8\x05\u0280\u0141\x02\u17D7" + + "\u17D9\x05\u02C8\u0165\x02\u17D8\u17D7\x03\x02\x02\x02\u17D8\u17D9\x03" + + "\x02\x02\x02\u17D9\u17F3\x03\x02\x02\x02\u17DA\u17DB\x070\x02\x02\u17DB" + + "\u17DC\x07+\x02\x02\u17DC\u17DD\x07\x04\x02\x02\u17DD\u17DE\x05\u0462" + + "\u0232\x02\u17DE\u17DF\x07&\x02\x02\u17DF\u17E0\x05\u0462\u0232\x02\u17E0" + + "\u17E1\x07\x05\x02\x02\u17E1\u17E2\x07\u017D\x02\x02\u17E2\u17E4\x07\xD5" + + "\x02\x02\u17E3\u17E5\x05\u02C8\u0165\x02\u17E4\u17E3\x03\x02\x02\x02\u17E4" + + "\u17E5\x03\x02\x02\x02\u17E5\u17F3\x03\x02\x02\x02\u17E6\u17E7\x070\x02" + + "\x02\u17E7\u17E8\x07+\x02\x02\u17E8\u17E9\x07\x04\x02\x02\u17E9\u17EA" + + "\x05\u0462\u0232\x02\u17EA\u17EB\x07&\x02\x02\u17EB\u17EC\x05\u0462\u0232" + + "\x02\u17EC\u17ED\x07\x05\x02\x02\u17ED\u17EE\x07k\x02\x02\u17EE\u17F0" + + "\x07\u0192\x02\x02\u17EF\u17F1\x05\u02C8\u0165\x02\u17F0\u17EF\x03\x02" + + "\x02\x02\u17F0\u17F1\x03\x02\x02\x02\u17F1\u17F3\x03\x02\x02\x02\u17F2" + + "\u17CD\x03\x02\x02\x02\u17F2\u17DA\x03\x02\x02\x02\u17F2\u17E6\x03\x02" + + "\x02\x02\u17F3\u02C7\x03\x02\x02\x02\u17F4\u17F5\x07&\x02\x02\u17F5\u17F9" + + "\x07\xE1\x02\x02\u17F6\u17F7\x07&\x02\x02\u17F7\u17F9\x07\x8F\x02\x02" + + "\u17F8\u17F4\x03\x02\x02\x02\u17F8\u17F6\x03\x02\x02\x02\u17F9\u02C9\x03" + + "\x02\x02\x02\u17FA\u17FB\x07\xC1\x02\x02\u17FB\u17FD\x07+\x02\x02\u17FC" + + "\u17FE\x05\u02CC\u0167\x02\u17FD\u17FC\x03\x02\x02\x02\u17FD\u17FE\x03" + + "\x02\x02\x02\u17FE\u17FF\x03\x02\x02\x02\u17FF\u1800\x07\x04\x02\x02\u1800" + + "\u1801\x05\u0462\u0232\x02\u1801\u1802\x07&\x02\x02\u1802\u1803\x05\u0462" + + "\u0232\x02\u1803\u1805\x07\x05\x02\x02\u1804\u1806\x05l7\x02\u1805\u1804" + + "\x03\x02\x02\x02\u1805\u1806\x03\x02\x02\x02\u1806\u02CB\x03\x02\x02\x02" + + "\u1807\u1808\x07\xDE\x02\x02\u1808\u1809\x07\u018E\x02\x02\u1809\u02CD" + + "\x03\x02\x02\x02\u180A\u180C\x070\x02\x02\u180B\u180D\x05\u0278\u013D" + + "\x02\u180C\u180B\x03\x02\x02\x02\u180C\u180D\x03\x02\x02\x02\u180D\u180E" + + "\x03\x02\x02\x02\u180E\u180F\x07\u01BD\x02\x02\u180F\u1810\x07@\x02\x02" + + "\u1810\u1811\x05\u0462\u0232\x02\u1811\u1812\x07\xF9\x02\x02\u1812\u1813" + + "\x05\u0540\u02A1\x02\u1813\u1814\x07\x04\x02\x02\u1814\u1815\x05\u02D0" + + "\u0169\x02\u1815\u1816\x07\x05\x02\x02\u1816\u02CF\x03\x02\x02\x02\u1817" + + "\u1818\x07B\x02\x02\u1818\u1819\x07\u01CF\x02\x02\u1819\u181A\x07k\x02" + + "\x02\u181A\u181B\x07\xD5\x02\x02\u181B\u181C\x05\u0280\u0141\x02\u181C" + + "\u181D\x07\b\x02\x02\u181D\u181E\x07`\x02\x02\u181E\u181F\x07\u01CF\x02" + + "\x02\u181F\u1820\x07k\x02\x02\u1820\u1821\x07\xD5\x02\x02\u1821\u1822" + + "\x05\u0280\u0141\x02\u1822\u183A\x03\x02\x02\x02\u1823\u1824\x07`\x02" + + "\x02\u1824\u1825\x07\u01CF\x02\x02\u1825\u1826\x07k\x02\x02\u1826\u1827" + + "\x07\xD5\x02\x02\u1827\u1828\x05\u0280\u0141\x02\u1828\u1829\x07\b\x02" + + "\x02\u1829\u182A\x07B\x02\x02\u182A\u182B\x07\u01CF\x02\x02\u182B\u182C" + + "\x07k\x02\x02\u182C\u182D\x07\xD5\x02\x02\u182D\u182E\x05\u0280\u0141" + + "\x02\u182E\u183A\x03\x02\x02\x02\u182F\u1830\x07B\x02\x02\u1830\u1831" + + "\x07\u01CF\x02\x02\u1831\u1832\x07k\x02\x02\u1832\u1833\x07\xD5\x02\x02" + + "\u1833\u183A\x05\u0280\u0141\x02\u1834\u1835\x07`\x02\x02\u1835\u1836" + + "\x07\u01CF\x02\x02\u1836\u1837\x07k\x02\x02\u1837\u1838\x07\xD5\x02\x02" + + "\u1838\u183A\x05\u0280\u0141\x02\u1839\u1817\x03\x02\x02\x02\u1839\u1823" + + "\x03\x02\x02\x02\u1839\u182F\x03\x02\x02\x02\u1839\u1834\x03\x02\x02\x02" + + "\u183A\u02D1\x03\x02\x02\x02\u183B\u183C\x07\xC1\x02\x02\u183C\u183E\x07" + + "\u01BD\x02\x02\u183D\u183F\x05\u02CC\u0167\x02\u183E\u183D\x03\x02\x02" + + "\x02\u183E\u183F\x03\x02\x02\x02\u183F\u1840\x03\x02\x02\x02\u1840\u1841" + + "\x07@\x02\x02\u1841\u1842\x05\u0462\u0232\x02\u1842\u1843\x07\xF9\x02" + + "\x02\u1843\u1845\x05\u0540\u02A1\x02\u1844\u1846\x05l7\x02\u1845\u1844" + + "\x03\x02\x02\x02\u1845\u1846\x03\x02\x02\x02\u1846\u02D3\x03\x02\x02\x02" + + "\u1847\u1848\x07\u0134\x02\x02\u1848\u184A\x05\u02D6\u016C\x02\u1849\u184B" + + "\x05\u025C\u012F\x02\u184A\u1849\x03\x02\x02\x02\u184A\u184B\x03\x02\x02" + + "\x02\u184B\u184C\x03\x02\x02\x02\u184C\u184D\x05\u053C\u029F\x02\u184D" + + "\u186A\x03\x02\x02\x02\u184E\u184F\x07\u0134\x02\x02\u184F\u1851\x05\u02D8" + + "\u016D\x02\u1850\u1852\x05\u025C\u012F\x02\u1851\u1850\x03\x02\x02\x02" + + "\u1851\u1852\x03\x02\x02\x02\u1852\u1853\x03\x02\x02\x02\u1853\u1854\x05" + + "\u0540\u02A1\x02\u1854\u186A\x03\x02\x02\x02\u1855\u1856\x07\u0134\x02" + + "\x02\u1856\u1857\x07\x04\x02\x02\u1857\u1858\x05\u02DA\u016E\x02\u1858" + + "\u1859\x07\x05\x02\x02\u1859\u185B\x05\u02D6\u016C\x02\u185A\u185C\x05" + + "\u025C\u012F\x02\u185B\u185A\x03\x02\x02\x02\u185B\u185C\x03\x02\x02\x02" + + "\u185C\u185D\x03\x02\x02\x02\u185D\u185E\x05\u053C\u029F\x02\u185E\u186A" + + "\x03\x02\x02\x02\u185F\u1860\x07\u0134\x02\x02\u1860\u1861\x07\x04\x02" + + "\x02\u1861\u1862\x05\u02DA\u016E\x02\u1862\u1863\x07\x05\x02\x02\u1863" + + "\u1865\x05\u02D8\u016D\x02\u1864\u1866\x05\u025C\u012F\x02\u1865\u1864" + + "\x03\x02\x02\x02\u1865\u1866\x03\x02\x02\x02\u1866\u1867\x03\x02\x02\x02" + + "\u1867\u1868\x05\u0540\u02A1\x02\u1868\u186A\x03\x02\x02\x02\u1869\u1847" + + "\x03\x02\x02\x02\u1869\u184E\x03\x02\x02\x02\u1869\u1855\x03\x02\x02\x02" + + "\u1869\u185F\x03\x02\x02\x02\u186A\u02D5\x03\x02\x02\x02\u186B\u186C\t" + + "\x1A\x02\x02\u186C\u02D7\x03\x02\x02\x02\u186D\u186E\t&\x02\x02\u186E" + + "\u02D9\x03\x02\x02\x02\u186F\u1874\x05\u02DC\u016F\x02\u1870\u1871\x07" + + "\b\x02\x02\u1871\u1873\x05\u02DC\u016F\x02\u1872\u1870\x03\x02\x02\x02" + + "\u1873\u1876\x03\x02\x02\x02\u1874\u1872\x03\x02\x02\x02\u1874\u1875\x03" + + "\x02\x02\x02\u1875\u02DB\x03\x02\x02\x02\u1876\u1874\x03\x02\x02\x02\u1877" + + "\u1878\x07\x82\x02\x02\u1878\u02DD\x03\x02\x02\x02\u1879\u187A\x07\x8C" + + "\x02\x02\u187A\u187B\x07\u0161\x02\x02\u187B\u187C\x05\u0540\u02A1\x02" + + "\u187C\u187D\x07\u014F\x02\x02\u187D\u187E\x05t;\x02\u187E\u1886\x03\x02" + + "\x02\x02\u187F\u1880\x07\x8C\x02\x02\u1880\u1881\x07\u0161\x02\x02\u1881" + + "\u1882\x05\u0540\u02A1\x02\u1882\u1883\x07\u013B\x02\x02\u1883\u1884\x05" + + "t;\x02\u1884\u1886\x03\x02\x02\x02\u1885\u1879\x03\x02\x02\x02\u1885\u187F" + + "\x03\x02\x02\x02\u1886\u02DF\x03\x02\x02\x02\u1887\u1888\x07\x8C\x02\x02" + + "\u1888\u1889\x07\x8A\x02\x02\u1889\u188A\x05\u0298\u014D\x02\u188A\u188B" + + "\x07\u0137\x02\x02\u188B\u188C\x07`\x02\x02\u188C\u188D\x05\u0540\u02A1" + + "\x02\u188D\u1A6F\x03\x02\x02\x02\u188E\u188F\x07\x8C\x02\x02\u188F\u1890" + + "\x07n\x02\x02\u1890\u1891\x05\u0214\u010B\x02\u1891\u1892\x07\u0137\x02" + + "\x02\u1892\u1893\x07`\x02\x02\u1893\u1894\x05\u0540\u02A1\x02\u1894\u1A6F" + + "\x03\x02\x02\x02\u1895\u1896\x07\x8C\x02\x02\u1896\u1897\x07\xAA\x02\x02" + + "\u1897\u1898\x05\u0214\u010B\x02\u1898\u1899\x07\u0137\x02\x02\u1899\u189A" + + "\x07`\x02\x02\u189A\u189B\x05\u0540\u02A1\x02\u189B\u1A6F\x03\x02\x02" + + "\x02\u189C\u189D\x07\x8C\x02\x02\u189D\u189E\x07\xB1\x02\x02\u189E\u189F" + + "\x05\u0540\u02A1\x02\u189F\u18A0\x07\u0137\x02\x02\u18A0\u18A1\x07`\x02" + + "\x02\u18A1\u18A2\x05\u0540\u02A1\x02\u18A2\u1A6F\x03\x02\x02\x02\u18A3" + + "\u18A4\x07\x8C\x02\x02\u18A4\u18A5\x07\xBF\x02\x02\u18A5\u18A6\x05\u0214" + + "\u010B\x02\u18A6\u18A7\x07\u0137\x02\x02\u18A7\u18A8\x07`\x02\x02\u18A8" + + "\u18A9\x05\u0540\u02A1\x02\u18A9\u1A6F\x03\x02\x02\x02\u18AA\u18AB\x07" + + "\x8C\x02\x02\u18AB\u18AC\x07\xBF\x02\x02\u18AC\u18AD\x05\u0214\u010B\x02" + + "\u18AD\u18AE\x07\u0137\x02\x02\u18AE\u18AF\x07/\x02\x02\u18AF\u18B0\x05" + + "\u0540\u02A1\x02\u18B0\u18B1\x07`\x02\x02\u18B1\u18B2\x05\u0540\u02A1" + + "\x02\u18B2\u1A6F\x03\x02\x02\x02\u18B3\u18B4\x07\x8C\x02\x02\u18B4\u18B5" + + "\x07A\x02\x02\u18B5\u18B6\x07\xB0\x02\x02\u18B6\u18B7\x07\u017F\x02\x02" + + "\u18B7\u18B8\x05\u0540\u02A1\x02\u18B8\u18B9\x07\u0137\x02\x02\u18B9\u18BA" + + "\x07`\x02\x02\u18BA\u18BB\x05\u0540\u02A1\x02\u18BB\u1A6F\x03\x02\x02" + + "\x02\u18BC\u18BD\x07\x8C\x02\x02\u18BD\u18BE\x07\xD5\x02\x02\u18BE\u18BF" + + "\x05\u0280\u0141\x02\u18BF\u18C0\x07\u0137\x02\x02\u18C0\u18C1\x07`\x02" + + "\x02\u18C1\u18C2\x05\u0540\u02A1\x02\u18C2\u1A6F\x03\x02\x02\x02\u18C3" + + "\u18C4\x07\x8C\x02\x02\u18C4\u18C5\x07D\x02\x02\u18C5\u18C6\x05\u055C" + + "\u02AF\x02\u18C6\u18C7\x07\u0137\x02\x02\u18C7\u18C8\x07`\x02\x02\u18C8" + + "\u18C9\x05\u055C\u02AF\x02\u18C9\u1A6F\x03\x02\x02\x02\u18CA\u18CC\x07" + + "\x8C\x02\x02\u18CB\u18CD\x05\u0138\x9D\x02\u18CC\u18CB\x03\x02\x02\x02" + + "\u18CC\u18CD\x03\x02\x02\x02\u18CD\u18CE\x03\x02\x02\x02\u18CE\u18CF\x07" + + "\xF9\x02\x02\u18CF\u18D0\x05\u0540\u02A1\x02\u18D0\u18D1\x07\u0137\x02" + + "\x02\u18D1\u18D2\x07`\x02\x02\u18D2\u18D3\x05\u0540\u02A1\x02\u18D3\u1A6F" + + "\x03\x02\x02\x02\u18D4\u18D5\x07\x8C\x02\x02\u18D5\u18D6\x07\u0118\x02" + + "\x02\u18D6\u18D7\x07\x9E\x02\x02\u18D7\u18D8\x05\u0214\u010B\x02\u18D8" + + "\u18D9\x07f\x02\x02\u18D9\u18DA\x05\u0540\u02A1\x02\u18DA\u18DB\x07\u0137" + + "\x02\x02\u18DB\u18DC\x07`\x02\x02\u18DC\u18DD\x05\u0540\u02A1\x02\u18DD" + + "\u1A6F\x03\x02\x02\x02\u18DE\u18DF\x07\x8C\x02\x02\u18DF\u18E0\x07\u0118" + + "\x02\x02\u18E0\u18E1\x07\xD0\x02\x02\u18E1\u18E2\x05\u0214\u010B\x02\u18E2" + + "\u18E3\x07"; private static readonly _serializedATNSegment13: string = - "\u0530\u0299\x02\u191C\u1A1D\x03\x02\x02\x02\u191D\u191E\x07\x8C\x02\x02" + - "\u191E\u191F\x07\xE4\x02\x02\u191F\u1920\x07\xDE\x02\x02\u1920\u1921\x07" + - "\u0185\x02\x02\u1921\u1922\x05\u052C\u0297\x02\u1922\u1923\x07\u012E\x02" + - "\x02\u1923\u1924\x07`\x02\x02\u1924\u1925\x05\u0530\u0299\x02\u1925\u1A1D" + - "\x03\x02\x02\x02\u1926\u1927\x07\x8C\x02\x02\u1927\u1928\x07A\x02\x02" + - "\u1928\u1929\x07^\x02\x02\u1929\u192A\x05\u0428\u0215\x02\u192A\u192B" + - "\x07\u012E\x02\x02\u192B\u192C\x07`\x02\x02\u192C\u192D\x05\u0530\u0299" + - "\x02\u192D\u1A1D\x03\x02\x02\x02\u192E\u192F\x07\x8C\x02\x02\u192F\u1930" + - "\x07A\x02\x02\u1930\u1931\x07^\x02\x02\u1931\u1932\x07\xDE\x02\x02\u1932" + - "\u1933\x07\u0185\x02\x02\u1933\u1934\x05\u0428\u0215\x02\u1934\u1935\x07" + - "\u012E\x02\x02\u1935\u1936\x07`\x02\x02\u1936\u1937\x05\u0530\u0299\x02" + - "\u1937\u1A1D\x03\x02\x02\x02\u1938\u1939\x07\x8C\x02\x02\u1939\u193A\x07" + - "^\x02\x02\u193A\u193B\x05\u0428\u0215\x02\u193B\u193D\x07\u012E\x02\x02" + - "\u193C\u193E\x05\u02D4\u016B\x02\u193D\u193C\x03\x02\x02\x02\u193D\u193E" + - "\x03\x02\x02\x02\u193E\u193F\x03\x02\x02\x02\u193F\u1940\x05\u0530\u0299" + - "\x02\u1940\u1941\x07`\x02\x02\u1941\u1942\x05\u0530\u0299\x02\u1942\u1A1D" + - "\x03\x02\x02\x02\u1943\u1944\x07\x8C\x02\x02\u1944\u1945\x07^\x02\x02" + - "\u1945\u1946\x07\xDE\x02\x02\u1946\u1947\x07\u0185\x02\x02\u1947\u1948" + - "\x05\u0428\u0215\x02\u1948\u194A\x07\u012E\x02\x02\u1949\u194B\x05\u02D4" + - "\u016B\x02\u194A\u1949\x03\x02\x02\x02\u194A\u194B\x03\x02\x02\x02\u194B" + - "\u194C\x03\x02\x02\x02\u194C\u194D\x05\u0530\u0299\x02\u194D\u194E\x07" + - "`\x02\x02\u194E\u194F\x05\u0530\u0299\x02\u194F\u1A1D\x03\x02\x02\x02" + - "\u1950\u1951\x07\x8C\x02\x02\u1951\u1952\x07\u0171\x02\x02\u1952\u1953" + - "\x05\u052C\u0297\x02\u1953\u1955\x07\u012E\x02\x02\u1954\u1956\x05\u02D4" + - "\u016B\x02\u1955\u1954\x03\x02\x02\x02\u1955\u1956\x03\x02\x02\x02\u1956" + - "\u1957\x03\x02\x02\x02\u1957\u1958\x05\u0530\u0299\x02\u1958\u1959\x07" + - "`\x02\x02\u1959\u195A\x05\u0530\u0299\x02\u195A\u1A1D\x03\x02\x02\x02" + - "\u195B\u195C\x07\x8C\x02\x02\u195C\u195D\x07\u0171\x02\x02\u195D\u195E" + - "\x07\xDE\x02\x02\u195E\u195F\x07\u0185\x02\x02\u195F\u1960\x05\u052C\u0297" + - "\x02\u1960\u1962\x07\u012E\x02\x02\u1961\u1963\x05\u02D4\u016B\x02\u1962" + - "\u1961\x03\x02\x02\x02\u1962\u1963\x03\x02\x02\x02\u1963\u1964\x03\x02" + - "\x02\x02\u1964\u1965\x05\u0530\u0299\x02\u1965\u1966\x07`\x02\x02\u1966" + - "\u1967\x05\u0530\u0299\x02\u1967\u1A1D\x03\x02\x02\x02\u1968\u1969\x07" + - "\x8C\x02\x02\u1969\u196A\x07\xFC\x02\x02\u196A\u196B\x07\u0171\x02\x02" + - "\u196B\u196C\x05\u052C\u0297\x02\u196C\u196E\x07\u012E\x02\x02\u196D\u196F" + - "\x05\u02D4\u016B\x02\u196E\u196D\x03\x02\x02\x02\u196E\u196F\x03\x02\x02" + - "\x02\u196F\u1970\x03\x02\x02\x02\u1970\u1971\x05\u0530\u0299\x02\u1971" + - "\u1972\x07`\x02\x02\u1972\u1973\x05\u0530\u0299\x02\u1973\u1A1D\x03\x02" + - "\x02\x02\u1974\u1975\x07\x8C\x02\x02\u1975\u1976\x07\xFC\x02\x02\u1976" + - "\u1977\x07\u0171\x02\x02\u1977\u1978\x07\xDE\x02\x02\u1978\u1979\x07\u0185" + - "\x02\x02\u1979\u197A\x05\u052C\u0297\x02\u197A\u197C\x07\u012E\x02\x02" + - "\u197B\u197D\x05\u02D4\u016B\x02\u197C\u197B\x03\x02\x02\x02\u197C\u197D" + - "\x03\x02\x02\x02\u197D\u197E\x03\x02\x02\x02\u197E\u197F\x05\u0530\u0299" + - "\x02\u197F\u1980\x07`\x02\x02\u1980\u1981\x05\u0530\u0299\x02\u1981\u1A1D" + - "\x03\x02\x02\x02\u1982\u1983\x07\x8C\x02\x02\u1983\u1984\x07^\x02\x02" + - "\u1984\u1985\x05\u0428\u0215\x02\u1985\u1986\x07\u012E\x02\x02\u1986\u1987" + - "\x07/\x02\x02\u1987\u1988\x05\u0530\u0299\x02\u1988\u1989\x07`\x02\x02" + - "\u1989\u198A\x05\u0530\u0299\x02\u198A\u1A1D\x03\x02\x02\x02\u198B\u198C" + - "\x07\x8C\x02\x02\u198C\u198D\x07^\x02\x02\u198D\u198E\x07\xDE\x02\x02" + - "\u198E\u198F\x07\u0185\x02\x02\u198F\u1990\x05\u0428\u0215\x02\u1990\u1991" + - "\x07\u012E\x02\x02\u1991\u1992\x07/\x02\x02\u1992\u1993\x05\u0530\u0299" + - "\x02\u1993\u1994\x07`\x02\x02\u1994\u1995\x05\u0530\u0299\x02\u1995\u1A1D" + - "\x03\x02\x02\x02\u1996\u1997\x07\x8C\x02\x02\u1997\u1998\x07A\x02\x02" + - "\u1998\u1999\x07^\x02\x02\u1999\u199A\x05\u0428\u0215\x02\u199A\u199C" + - "\x07\u012E\x02\x02\u199B\u199D\x05\u02D4\u016B\x02\u199C\u199B\x03\x02" + - "\x02\x02\u199C\u199D\x03\x02\x02\x02\u199D\u199E\x03\x02\x02\x02\u199E" + - "\u199F\x05\u0530\u0299\x02\u199F\u19A0\x07`\x02\x02\u19A0\u19A1\x05\u0530" + - "\u0299\x02\u19A1\u1A1D\x03\x02\x02\x02\u19A2\u19A3\x07\x8C\x02\x02\u19A3" + - "\u19A4\x07A\x02\x02\u19A4\u19A5\x07^\x02\x02\u19A5\u19A6\x07\xDE\x02\x02" + - "\u19A6\u19A7\x07\u0185\x02\x02\u19A7\u19A8\x05\u0428\u0215\x02\u19A8\u19AA" + - "\x07\u012E\x02\x02\u19A9\u19AB\x05\u02D4\u016B\x02\u19AA\u19A9\x03\x02" + - "\x02\x02\u19AA\u19AB\x03\x02\x02\x02\u19AB\u19AC\x03\x02\x02\x02\u19AC" + - "\u19AD\x05\u0530\u0299\x02\u19AD\u19AE\x07`\x02\x02\u19AE\u19AF\x05\u0530" + - "\u0299\x02\u19AF\u1A1D\x03\x02\x02\x02\u19B0\u19B1\x07\x8C\x02\x02\u19B1" + - "\u19B2\x07\u013A\x02\x02\u19B2\u19B3\x05\u0530\u0299\x02\u19B3\u19B4\x07" + - "R\x02\x02\u19B4\u19B5\x05\u052C\u0297\x02\u19B5\u19B6\x07\u012E\x02\x02" + - "\u19B6\u19B7\x07`\x02\x02\u19B7\u19B8\x05\u0530\u0299\x02\u19B8\u1A1D" + - "\x03\x02\x02\x02\u19B9\u19BA\x07\x8C\x02\x02\u19BA\u19BB\x07\u015E\x02" + - "\x02\u19BB\u19BC\x05\u0530\u0299\x02\u19BC\u19BD\x07R\x02\x02\u19BD\u19BE" + - "\x05\u052C\u0297\x02\u19BE\u19BF\x07\u012E\x02\x02\u19BF\u19C0\x07`\x02" + - "\x02\u19C0\u19C1\x05\u0530\u0299\x02\u19C1\u1A1D\x03\x02\x02\x02\u19C2" + - "\u19C3\x07\x8C\x02\x02\u19C3\u19C4\x07\xC8\x02\x02\u19C4\u19C5\x07\u015E" + - "\x02\x02\u19C5\u19C6\x05\u0530\u0299\x02\u19C6\u19C7\x07\u012E\x02\x02" + - "\u19C7\u19C8\x07`\x02\x02\u19C8\u19C9\x05\u0530\u0299\x02\u19C9\u1A1D" + - "\x03\x02\x02\x02\u19CA\u19CB\x07\x8C\x02\x02\u19CB\u19CC\x07\u0137\x02" + - "\x02\u19CC\u19CD\x05\u054A\u02A6\x02\u19CD\u19CE\x07\u012E\x02\x02\u19CE" + - "\u19CF\x07`\x02\x02\u19CF\u19D0\x05\u054A\u02A6\x02\u19D0\u1A1D\x03\x02" + - "\x02\x02\u19D1\u19D2\x07\x8C\x02\x02\u19D2\u19D3\x07e\x02\x02\u19D3\u19D4" + - "\x05\u054A\u02A6\x02\u19D4\u19D5\x07\u012E\x02\x02\u19D5\u19D6\x07`\x02" + - "\x02\u19D6\u19D7\x05\u054A\u02A6\x02\u19D7\u1A1D\x03\x02\x02\x02\u19D8" + - "\u19D9\x07\x8C\x02\x02\u19D9\u19DA\x07\u0158\x02\x02\u19DA\u19DB\x05\u0530" + - "\u0299\x02\u19DB\u19DC\x07\u012E\x02\x02\u19DC\u19DD\x07`\x02\x02\u19DD" + - "\u19DE\x05\u0530\u0299\x02\u19DE\u1A1D\x03\x02\x02\x02\u19DF\u19E0\x07" + - "\x8C\x02\x02\u19E0\u19E1\x07\u014F\x02\x02\u19E1\u19E2\x05\u020C\u0107" + - "\x02\u19E2\u19E3\x07\u012E\x02\x02\u19E3\u19E4\x07`\x02\x02\u19E4\u19E5" + - "\x05\u0530\u0299\x02\u19E5\u1A1D\x03\x02\x02\x02\u19E6\u19E7\x07\x8C\x02" + - "\x02\u19E7\u19E8\x07\u015C\x02\x02\u19E8\u19E9\x07\u013E\x02\x02\u19E9" + - "\u19EA\x07\u0114\x02\x02\u19EA\u19EB\x05\u020C\u0107\x02\u19EB\u19EC\x07" + - "\u012E\x02\x02\u19EC\u19ED\x07`\x02\x02\u19ED\u19EE\x05\u0530\u0299\x02" + - "\u19EE\u1A1D\x03\x02\x02\x02\u19EF\u19F0\x07\x8C\x02\x02\u19F0\u19F1\x07" + - "\u015C\x02\x02\u19F1\u19F2\x07\u013E\x02\x02\u19F2\u19F3\x07\xBB\x02\x02" + - "\u19F3\u19F4\x05\u020C\u0107\x02\u19F4\u19F5\x07\u012E\x02\x02\u19F5\u19F6" + - "\x07`\x02\x02\u19F6\u19F7\x05\u0530\u0299\x02\u19F7\u1A1D\x03\x02\x02" + - "\x02\u19F8\u19F9\x07\x8C\x02\x02\u19F9\u19FA\x07\u015C\x02\x02\u19FA\u19FB" + - "\x07\u013E\x02\x02\u19FB\u19FC\x07\u015A\x02\x02\u19FC\u19FD\x05\u020C" + - "\u0107\x02\u19FD\u19FE\x07\u012E\x02\x02\u19FE\u19FF\x07`\x02\x02\u19FF" + - "\u1A00\x05\u0530\u0299\x02\u1A00\u1A1D\x03\x02\x02\x02\u1A01\u1A02\x07" + - "\x8C\x02\x02\u1A02\u1A03\x07\u015C\x02\x02\u1A03\u1A04\x07\u013E\x02\x02" + - "\u1A04\u1A05\x07\xA5\x02\x02\u1A05\u1A06\x05\u020C\u0107\x02\u1A06\u1A07" + - "\x07\u012E\x02\x02\u1A07\u1A08\x07`\x02\x02\u1A08\u1A09\x05\u0530\u0299" + - "\x02\u1A09\u1A1D\x03\x02\x02\x02\u1A0A\u1A0B\x07\x8C\x02\x02\u1A0B\u1A0C" + - "\x07\u0161\x02\x02\u1A0C\u1A0D\x05\u020C\u0107\x02\u1A0D\u1A0E\x07\u012E" + - "\x02\x02\u1A0E\u1A0F\x07`\x02\x02\u1A0F\u1A10\x05\u0530\u0299\x02\u1A10" + - "\u1A1D\x03\x02\x02\x02\u1A11\u1A12\x07\x8C\x02\x02\u1A12\u1A13\x07\u0161" + - "\x02\x02\u1A13\u1A14\x05\u020C\u0107\x02\u1A14\u1A15\x07\u012E\x02\x02" + - "\u1A15\u1A16\x07\x91\x02\x02\u1A16\u1A17\x05\u0530\u0299\x02\u1A17\u1A18" + - "\x07`\x02\x02\u1A18\u1A1A\x05\u0530\u0299\x02\u1A19\u1A1B\x05l7\x02\u1A1A" + - "\u1A19\x03\x02\x02\x02\u1A1A\u1A1B\x03\x02\x02\x02\u1A1B\u1A1D\x03\x02" + - "\x02\x02\u1A1C\u1835\x03\x02\x02\x02\u1A1C\u183C\x03\x02\x02\x02\u1A1C" + - "\u1843\x03\x02\x02\x02\u1A1C\u184A\x03\x02\x02\x02\u1A1C\u1851\x03\x02" + - "\x02\x02\u1A1C\u1858\x03\x02\x02\x02\u1A1C\u1861\x03\x02\x02\x02\u1A1C" + - "\u186A\x03\x02\x02\x02\u1A1C\u1871\x03\x02\x02\x02\u1A1C\u1878\x03\x02" + - "\x02\x02\u1A1C\u1882\x03\x02\x02\x02\u1A1C\u188C\x03\x02\x02\x02\u1A1C" + - "\u1896\x03\x02\x02\x02\u1A1C\u189F\x03\x02\x02\x02\u1A1C\u18AA\x03\x02" + - "\x02\x02\u1A1C\u18B1\x03\x02\x02\x02\u1A1C\u18B8\x03\x02\x02\x02\u1A1C" + - "\u18BF\x03\x02\x02\x02\u1A1C\u18C6\x03\x02\x02\x02\u1A1C\u18CD\x03\x02" + - "\x02\x02\u1A1C\u18D4\x03\x02\x02\x02\u1A1C\u18DB\x03\x02\x02\x02\u1A1C" + - "\u18E4\x03\x02\x02\x02\u1A1C\u18EB\x03\x02\x02\x02\u1A1C\u18F4\x03\x02" + - "\x02\x02\u1A1C\u18FB\x03\x02\x02\x02\u1A1C\u1904\x03\x02\x02\x02\u1A1C" + - "\u190C\x03\x02\x02\x02\u1A1C\u1916\x03\x02\x02\x02\u1A1C\u191D\x03\x02" + - "\x02\x02\u1A1C\u1926\x03\x02\x02\x02\u1A1C\u192E\x03\x02\x02\x02\u1A1C" + - "\u1938\x03\x02\x02\x02\u1A1C\u1943\x03\x02\x02\x02\u1A1C\u1950\x03\x02" + - "\x02\x02\u1A1C\u195B\x03\x02\x02\x02\u1A1C\u1968\x03\x02\x02\x02\u1A1C" + - "\u1974\x03\x02\x02\x02\u1A1C\u1982\x03\x02\x02\x02\u1A1C\u198B\x03\x02" + - "\x02\x02\u1A1C\u1996\x03\x02\x02\x02\u1A1C\u19A2\x03\x02\x02\x02\u1A1C" + - "\u19B0\x03\x02\x02\x02\u1A1C\u19B9\x03\x02\x02\x02\u1A1C\u19C2\x03\x02" + - "\x02\x02\u1A1C\u19CA\x03\x02\x02\x02\u1A1C\u19D1\x03\x02\x02\x02\u1A1C" + - "\u19D8\x03\x02\x02\x02\u1A1C\u19DF\x03\x02\x02\x02\u1A1C\u19E6\x03\x02" + - "\x02\x02\u1A1C\u19EF\x03\x02\x02\x02\u1A1C\u19F8\x03\x02\x02\x02\u1A1C" + - "\u1A01\x03\x02\x02\x02\u1A1C\u1A0A\x03\x02\x02\x02\u1A1C\u1A11\x03\x02" + - "\x02\x02\u1A1D\u02D3\x03\x02\x02\x02\u1A1E\u1A1F\x07.\x02\x02\u1A1F\u02D5" + - "\x03\x02\x02\x02\u1A20\u1A21\x07\u0146\x02\x02\u1A21\u1A22\x07\xB0\x02" + - "\x02\u1A22\u02D7\x03\x02\x02\x02\u1A23\u1A24\x07\x8C\x02\x02\u1A24\u1A25" + - "\x07\xD5\x02\x02\u1A25\u1A27\x05\u0272\u013A\x02\u1A26\u1A28\x05\u02DA" + - "\u016E\x02\u1A27\u1A26\x03\x02\x02\x02\u1A27\u1A28\x03\x02\x02\x02\u1A28" + - "\u1A29\x03\x02\x02\x02\u1A29\u1A2A\x07\u01C7\x02\x02\u1A2A\u1A2B\x07R" + - "\x02\x02\u1A2B\u1A2C\x07\xCE\x02\x02\u1A2C\u1A2D\x05\u0530\u0299\x02\u1A2D" + - "\u1A69\x03\x02\x02\x02\u1A2E\u1A2F\x07\x8C\x02\x02\u1A2F\u1A30\x07\u0121" + - "\x02\x02\u1A30\u1A32\x05\u0272\u013A\x02\u1A31\u1A33\x05\u02DA\u016E\x02" + - "\u1A32\u1A31\x03\x02\x02\x02\u1A32\u1A33\x03\x02\x02\x02\u1A33\u1A34\x03" + - "\x02\x02\x02\u1A34\u1A35\x07\u01C7\x02\x02\u1A35\u1A36\x07R\x02\x02\u1A36" + - "\u1A37\x07\xCE\x02\x02\u1A37\u1A38\x05\u0530\u0299\x02\u1A38\u1A69\x03" + - "\x02\x02\x02\u1A39\u1A3A\x07\x8C\x02\x02\u1A3A\u1A3B\x07\u01B3\x02\x02" + - "\u1A3B\u1A3D\x05\u0272\u013A\x02\u1A3C\u1A3E\x05\u02DA\u016E\x02\u1A3D" + - "\u1A3C\x03\x02\x02\x02\u1A3D\u1A3E\x03\x02\x02\x02\u1A3E\u1A3F\x03\x02" + - "\x02\x02\u1A3F\u1A40\x07\u01C7\x02\x02\u1A40\u1A41\x07R\x02\x02\u1A41" + - "\u1A42\x07\xCE\x02\x02\u1A42\u1A43\x05\u0530\u0299\x02\u1A43\u1A69\x03" + - "\x02\x02\x02\u1A44\u1A45\x07\x8C\x02\x02\u1A45\u1A46\x07\u015E\x02\x02" + - "\u1A46\u1A47\x05\u0530\u0299\x02\u1A47\u1A48\x07R\x02\x02\u1A48\u1A4A" + - "\x05\u052C\u0297\x02\u1A49\u1A4B\x05\u02DA\u016E\x02\u1A4A\u1A49\x03\x02" + - "\x02\x02\u1A4A\u1A4B\x03\x02\x02\x02\u1A4B\u1A4C\x03\x02\x02\x02\u1A4C" + - "\u1A4D\x07\u01C7\x02\x02\u1A4D\u1A4E\x07R\x02\x02\u1A4E\u1A4F\x07\xCE" + - "\x02\x02\u1A4F\u1A50\x05\u0530\u0299\x02\u1A50\u1A69\x03\x02\x02\x02\u1A51" + - "\u1A52\x07\x8C\x02\x02\u1A52\u1A53\x07\xFC\x02\x02\u1A53\u1A54\x07\u0171" + - "\x02\x02\u1A54\u1A56\x05\u052C\u0297\x02\u1A55\u1A57\x05\u02DA\u016E\x02" + - "\u1A56\u1A55\x03\x02\x02\x02\u1A56\u1A57\x03\x02\x02\x02\u1A57\u1A58\x03" + - "\x02\x02\x02\u1A58\u1A59\x07\u01C7\x02\x02\u1A59\u1A5A\x07R\x02\x02\u1A5A" + - "\u1A5B\x07\xCE\x02\x02\u1A5B\u1A5C\x05\u0530\u0299\x02\u1A5C\u1A69\x03" + - "\x02\x02\x02\u1A5D\u1A5E\x07\x8C\x02\x02\u1A5E\u1A5F\x07\xE4\x02\x02\u1A5F" + - "\u1A61\x05\u052C\u0297\x02\u1A60\u1A62\x05\u02DA\u016E\x02\u1A61\u1A60" + - "\x03\x02\x02\x02\u1A61\u1A62\x03\x02\x02\x02\u1A62\u1A63\x03\x02\x02\x02" + - "\u1A63\u1A64\x07\u01C7\x02\x02\u1A64\u1A65\x07R\x02\x02\u1A65\u1A66\x07" + - "\xCE\x02\x02\u1A66\u1A67\x05\u0530\u0299\x02\u1A67\u1A69\x03\x02\x02\x02" + - "\u1A68\u1A23\x03\x02\x02\x02\u1A68\u1A2E\x03\x02\x02\x02\u1A68\u1A39\x03" + - "\x02\x02\x02\u1A68\u1A44\x03\x02\x02\x02\u1A68\u1A51\x03\x02\x02\x02\u1A68" + - "\u1A5D\x03\x02\x02\x02\u1A69\u02D9\x03\x02\x02\x02\u1A6A\u1A6B\x07\u0106" + - "\x02\x02\u1A6B\u02DB\x03\x02\x02\x02\u1A6C\u1A6D\x07\x8C\x02\x02\u1A6D" + - "\u1A6E\x07\x8A\x02\x02\u1A6E\u1A6F\x05\u028A\u0146\x02\u1A6F\u1A70\x07" + - "\u0146\x02\x02\u1A70\u1A71\x07\u013C\x02\x02\u1A71\u1A72\x05\u0530\u0299" + - "\x02\u1A72\u1B46\x03\x02\x02\x02\u1A73\u1A74\x07\x8C\x02\x02\u1A74\u1A75" + - "\x07n\x02\x02\u1A75\u1A76\x05\u020C\u0107\x02\u1A76\u1A77\x07\u0146\x02" + - "\x02\u1A77\u1A78\x07\u013C\x02\x02\u1A78\u1A79\x05\u0530\u0299\x02\u1A79" + - "\u1B46\x03\x02\x02\x02\u1A7A\u1A7B\x07\x8C\x02\x02\u1A7B\u1A7C\x07\xAA" + - "\x02\x02\u1A7C\u1A7D\x05\u020C\u0107\x02\u1A7D\u1A7E\x07\u0146\x02\x02" + - "\u1A7E\u1A7F\x07\u013C\x02\x02\u1A7F\u1A80\x05\u0530\u0299\x02\u1A80\u1B46" + - "\x03\x02\x02\x02\u1A81\u1A82\x07\x8C\x02\x02\u1A82\u1A83\x07\xBF\x02\x02" + - "\u1A83\u1A84\x05\u020C\u0107\x02\u1A84\u1A85\x07\u0146\x02\x02\u1A85\u1A86" + - "\x07\u013C\x02\x02\u1A86\u1A87\x05\u0530\u0299\x02\u1A87\u1B46\x03\x02" + - "\x02\x02\u1A88\u1A89\x07\x8C\x02\x02\u1A89\u1A8A\x07\xCE\x02\x02\u1A8A" + - "\u1A8B\x05\u0530\u0299\x02\u1A8B\u1A8C\x07\u0146\x02\x02\u1A8C\u1A8D\x07" + - "\u013C\x02\x02\u1A8D\u1A8E\x05\u0530\u0299\x02\u1A8E\u1B46\x03\x02\x02" + - "\x02\u1A8F\u1A90\x07\x8C\x02\x02\u1A90\u1A91\x07\xD5\x02\x02\u1A91\u1A92" + - "\x05\u0272\u013A\x02\u1A92\u1A93\x07\u0146\x02\x02\u1A93\u1A94\x07\u013C" + - "\x02\x02\u1A94\u1A95\x05\u0530\u0299\x02\u1A95\u1B46\x03\x02\x02\x02\u1A96" + - "\u1A97\x07\x8C\x02\x02\u1A97\u1A98\x07\u010F\x02\x02\u1A98\u1A99\x05\u02B0" + - "\u0159\x02\u1A99\u1A9A\x07\u0146\x02\x02\u1A9A\u1A9B\x07\u013C\x02\x02" + - "\u1A9B\u1A9C\x05\u0530\u0299\x02\u1A9C\u1B46\x03\x02\x02\x02\u1A9D\u1A9E" + - "\x07\x8C\x02\x02\u1A9E\u1A9F\x07\u010F\x02\x02\u1A9F\u1AA0\x07\x9E\x02" + - "\x02\u1AA0\u1AA1\x05\u020C\u0107\x02\u1AA1\u1AA2\x07f\x02\x02\u1AA2\u1AA3" + - "\x05\u0530\u0299\x02\u1AA3\u1AA4\x07\u0146\x02\x02\u1AA4\u1AA5\x07\u013C" + - "\x02\x02\u1AA5\u1AA6\x05\u0530\u0299\x02\u1AA6\u1B46\x03\x02\x02\x02\u1AA7" + - "\u1AA8\x07\x8C\x02\x02\u1AA8\u1AA9\x07\u010F\x02\x02\u1AA9\u1AAA\x07\xD0" + - "\x02\x02\u1AAA\u1AAB\x05\u020C\u0107\x02\u1AAB\u1AAC\x07f\x02\x02\u1AAC" + - "\u1AAD\x05\u0530\u0299\x02\u1AAD\u1AAE\x07\u0146\x02\x02\u1AAE\u1AAF\x07" + - "\u013C\x02\x02\u1AAF\u1AB0\x05\u0530\u0299\x02\u1AB0\u1B46\x03\x02\x02" + - "\x02\u1AB1\u1AB2\x07\x8C\x02\x02\u1AB2\u1AB3\x07\u0121\x02\x02\u1AB3\u1AB4" + - "\x05\u0272\u013A\x02\u1AB4\u1AB5\x07\u0146\x02\x02\u1AB5\u1AB6\x07\u013C" + - "\x02\x02\u1AB6\u1AB7\x05\u0530\u0299\x02\u1AB7\u1B46\x03\x02\x02\x02\u1AB8" + - "\u1AB9\x07\x8C\x02\x02\u1AB9\u1ABA\x07\u01B3\x02\x02\u1ABA\u1ABB\x05\u0272" + - "\u013A\x02\u1ABB\u1ABC\x07\u0146\x02\x02\u1ABC\u1ABD\x07\u013C\x02\x02" + - "\u1ABD\u1ABE\x05\u0530\u0299\x02\u1ABE\u1B46\x03\x02\x02\x02\u1ABF\u1AC0" + - "\x07\x8C\x02\x02\u1AC0\u1AC1\x07^\x02\x02\u1AC1\u1AC2\x05\u0428\u0215" + - "\x02\u1AC2\u1AC3\x07\u0146\x02\x02\u1AC3\u1AC4\x07\u013C\x02\x02\u1AC4" + - "\u1AC5\x05\u0530\u0299\x02\u1AC5\u1B46\x03\x02\x02\x02\u1AC6\u1AC7\x07" + - "\x8C\x02\x02\u1AC7\u1AC8\x07^\x02\x02\u1AC8\u1AC9\x07\xDE\x02\x02\u1AC9" + - "\u1ACA\x07\u0185\x02\x02\u1ACA\u1ACB\x05\u0428\u0215\x02\u1ACB\u1ACC\x07" + - "\u0146\x02\x02\u1ACC\u1ACD\x07\u013C\x02\x02\u1ACD\u1ACE\x05\u0530\u0299" + - "\x02\u1ACE\u1B46\x03\x02\x02\x02\u1ACF\u1AD0\x07\x8C\x02\x02\u1AD0\u1AD1" + - "\x07\u014F\x02\x02\u1AD1\u1AD2\x05\u020C\u0107\x02\u1AD2\u1AD3\x07\u0146" + - "\x02\x02\u1AD3\u1AD4\x07\u013C\x02\x02\u1AD4\u1AD5\x05\u0530\u0299\x02" + - "\u1AD5\u1B46\x03\x02\x02\x02\u1AD6\u1AD7\x07\x8C\x02\x02\u1AD7\u1AD8\x07" + - "\u015C\x02\x02\u1AD8\u1AD9\x07\u013E\x02\x02\u1AD9\u1ADA\x07\u0114\x02" + - "\x02\u1ADA\u1ADB\x05\u020C\u0107\x02\u1ADB\u1ADC\x07\u0146\x02\x02\u1ADC" + - "\u1ADD\x07\u013C\x02\x02\u1ADD\u1ADE\x05\u0530\u0299\x02\u1ADE\u1B46\x03" + - "\x02\x02\x02\u1ADF\u1AE0\x07\x8C\x02\x02\u1AE0\u1AE1\x07\u015C\x02\x02" + - "\u1AE1\u1AE2\x07\u013E\x02\x02\u1AE2\u1AE3\x07\xBB\x02\x02\u1AE3\u1AE4" + - "\x05\u020C\u0107\x02\u1AE4\u1AE5\x07\u0146\x02\x02\u1AE5\u1AE6\x07\u013C" + - "\x02\x02\u1AE6\u1AE7\x05\u0530\u0299\x02\u1AE7\u1B46\x03\x02\x02\x02\u1AE8" + - "\u1AE9\x07\x8C\x02\x02\u1AE9\u1AEA\x07\u015C\x02\x02\u1AEA\u1AEB\x07\u013E" + - "\x02\x02\u1AEB\u1AEC\x07\u015A\x02\x02\u1AEC\u1AED\x05\u020C\u0107\x02" + - "\u1AED\u1AEE\x07\u0146\x02\x02\u1AEE\u1AEF\x07\u013C\x02\x02\u1AEF\u1AF0" + - "\x05\u0530\u0299\x02\u1AF0\u1B46\x03\x02\x02\x02\u1AF1\u1AF2\x07\x8C\x02" + - "\x02\u1AF2\u1AF3\x07\u015C\x02\x02\u1AF3\u1AF4\x07\u013E\x02\x02\u1AF4" + - "\u1AF5\x07\xA5\x02\x02\u1AF5\u1AF6\x05\u020C\u0107\x02\u1AF6\u1AF7\x07" + - "\u0146\x02\x02\u1AF7\u1AF8\x07\u013C\x02\x02\u1AF8\u1AF9\x05\u0530\u0299" + - "\x02\u1AF9\u1B46\x03\x02\x02\x02\u1AFA\u1AFB\x07\x8C\x02\x02\u1AFB\u1AFC" + - "\x07\u0141\x02\x02\u1AFC\u1AFD\x05\u052C\u0297\x02\u1AFD\u1AFE\x07\u0146" + - "\x02\x02\u1AFE\u1AFF\x07\u013C\x02\x02\u1AFF\u1B00\x05\u0530\u0299\x02" + - "\u1B00\u1B46\x03\x02\x02\x02\u1B01\u1B02\x07\x8C\x02\x02\u1B02\u1B03\x07" + - "\u0141\x02\x02\u1B03\u1B04\x07\xDE\x02\x02\u1B04\u1B05\x07\u0185\x02\x02" + - "\u1B05\u1B06\x05\u052C\u0297\x02\u1B06\u1B07\x07\u0146\x02\x02\u1B07\u1B08" + - "\x07\u013C\x02\x02\u1B08\u1B09\x05\u0530\u0299\x02\u1B09\u1B46\x03\x02" + - "\x02\x02\u1B0A\u1B0B\x07\x8C\x02\x02\u1B0B\u1B0C\x07\u0171\x02\x02\u1B0C" + - "\u1B0D\x05\u052C\u0297\x02\u1B0D\u1B0E\x07\u0146\x02\x02\u1B0E\u1B0F\x07" + - "\u013C\x02\x02\u1B0F\u1B10\x05\u0530\u0299\x02\u1B10\u1B46\x03\x02\x02" + - "\x02\u1B11\u1B12\x07\x8C\x02\x02\u1B12\u1B13\x07\u0171\x02\x02\u1B13\u1B14" + - "\x07\xDE\x02\x02\u1B14\u1B15\x07\u0185\x02\x02\u1B15\u1B16\x05\u052C\u0297" + - "\x02\u1B16\u1B17\x07\u0146\x02\x02\u1B17\u1B18\x07\u013C\x02\x02\u1B18" + - "\u1B19\x05\u0530\u0299\x02\u1B19\u1B46\x03\x02\x02\x02\u1B1A\u1B1B\x07" + - "\x8C\x02\x02\u1B1B\u1B1C\x07\xFC\x02\x02\u1B1C\u1B1D\x07\u0171\x02\x02" + - "\u1B1D\u1B1E\x05\u052C\u0297\x02\u1B1E\u1B1F\x07\u0146\x02\x02\u1B1F\u1B20" + - "\x07\u013C\x02\x02\u1B20\u1B21\x05\u0530\u0299\x02\u1B21\u1B46\x03\x02" + - "\x02\x02\u1B22\u1B23\x07\x8C\x02\x02\u1B23\u1B24\x07\xFC\x02\x02\u1B24" + - "\u1B25\x07\u0171\x02\x02\u1B25\u1B26\x07\xDE\x02\x02\u1B26\u1B27\x07\u0185" + - "\x02\x02\u1B27\u1B28\x05\u052C\u0297\x02\u1B28\u1B29\x07\u0146\x02\x02" + - "\u1B29\u1B2A\x07\u013C\x02\x02\u1B2A\u1B2B\x05\u0530\u0299\x02\u1B2B\u1B46" + - "\x03\x02\x02\x02\u1B2C\u1B2D\x07\x8C\x02\x02\u1B2D\u1B2E\x07A\x02\x02" + - "\u1B2E\u1B2F\x07^\x02\x02\u1B2F\u1B30\x05\u0428\u0215\x02\u1B30\u1B31" + - "\x07\u0146\x02\x02\u1B31\u1B32\x07\u013C\x02\x02\u1B32\u1B33\x05\u0530" + - "\u0299\x02\u1B33\u1B46\x03\x02\x02\x02\u1B34\u1B35\x07\x8C\x02\x02\u1B35" + - "\u1B36\x07A\x02\x02\u1B36\u1B37\x07^\x02\x02\u1B37\u1B38\x07\xDE\x02\x02" + - "\u1B38\u1B39\x07\u0185\x02\x02\u1B39\u1B3A\x05\u0428\u0215\x02\u1B3A\u1B3B" + - "\x07\u0146\x02\x02\u1B3B\u1B3C\x07\u013C\x02\x02\u1B3C\u1B3D\x05\u0530" + - "\u0299\x02\u1B3D\u1B46\x03\x02\x02\x02\u1B3E\u1B3F\x07\x8C\x02\x02\u1B3F" + - "\u1B40\x07\u0161\x02\x02\u1B40\u1B41\x05\u020C\u0107\x02\u1B41\u1B42\x07" + - "\u0146\x02\x02\u1B42\u1B43\x07\u013C\x02\x02\u1B43\u1B44\x05\u0530\u0299" + - "\x02\u1B44\u1B46\x03\x02\x02\x02\u1B45\u1A6C\x03\x02\x02\x02\u1B45\u1A73" + - "\x03\x02\x02\x02\u1B45\u1A7A\x03\x02\x02\x02\u1B45\u1A81\x03\x02\x02\x02" + - "\u1B45\u1A88\x03\x02\x02\x02\u1B45\u1A8F\x03\x02\x02\x02\u1B45\u1A96\x03" + - "\x02\x02\x02\u1B45\u1A9D\x03\x02\x02\x02\u1B45\u1AA7\x03\x02\x02\x02\u1B45" + - "\u1AB1\x03\x02\x02\x02\u1B45\u1AB8\x03\x02\x02\x02\u1B45\u1ABF\x03\x02" + - "\x02\x02\u1B45\u1AC6\x03\x02\x02\x02\u1B45\u1ACF\x03\x02\x02\x02\u1B45" + - "\u1AD6\x03\x02\x02\x02\u1B45\u1ADF\x03\x02\x02\x02\u1B45\u1AE8\x03\x02" + - "\x02\x02\u1B45\u1AF1\x03\x02\x02\x02\u1B45\u1AFA\x03\x02\x02\x02\u1B45" + - "\u1B01\x03\x02\x02\x02\u1B45\u1B0A\x03\x02\x02\x02\u1B45\u1B11\x03\x02" + - "\x02\x02\u1B45\u1B1A\x03\x02\x02\x02\u1B45\u1B22\x03\x02\x02\x02\u1B45" + - "\u1B2C\x03\x02\x02\x02\u1B45\u1B34\x03\x02\x02\x02\u1B45\u1B3E\x03\x02" + - "\x02\x02\u1B46\u02DD\x03\x02\x02\x02\u1B47\u1B48\x07\x8C\x02\x02\u1B48" + - "\u1B49\x07\u010F\x02\x02\u1B49\u1B4A\x05\u02B0\u0159\x02\u1B4A\u1B4B\x07" + - "\u0146\x02\x02\u1B4B\u1B4C\x07\x04\x02\x02\u1B4C\u1B4D\x05\u02E0\u0171" + - "\x02\u1B4D\u1B4E\x07\x05\x02\x02\u1B4E\u02DF\x03\x02\x02\x02\u1B4F\u1B54" + - "\x05\u02E2\u0172\x02\u1B50\u1B51\x07\b\x02\x02\u1B51\u1B53\x05\u02E2\u0172" + - "\x02\u1B52\u1B50\x03\x02\x02\x02\u1B53\u1B56\x03\x02\x02\x02\u1B54\u1B52" + - "\x03\x02\x02\x02\u1B54\u1B55\x03\x02\x02\x02\u1B55\u02E1\x03\x02\x02\x02" + - "\u1B56\u1B54\x03\x02\x02\x02\u1B57\u1B58\x05\u0556\u02AC\x02\u1B58\u1B59" + - "\x07\f\x02\x02\u1B59\u1B5A\x07\u0190\x02\x02\u1B5A\u1B60\x03\x02\x02\x02" + - "\u1B5B\u1B5C\x05\u0556\u02AC\x02\u1B5C\u1B5D\x07\f\x02\x02\u1B5D\u1B5E" + - "\x05\u02E4\u0173\x02\u1B5E\u1B60\x03\x02\x02\x02\u1B5F\u1B57\x03\x02\x02" + - "\x02\u1B5F\u1B5B\x03\x02\x02\x02\u1B60\u02E3\x03\x02\x02\x02\u1B61\u1B67" + - "\x05\u0280\u0141\x02\u1B62\u1B67\x05\u0562\u02B2\x02\u1B63\u1B67\x05\u04F0" + - "\u0279\x02\u1B64\u1B67\x05\u0124\x93\x02\u1B65\u1B67\x05\u0542\u02A2\x02" + - "\u1B66\u1B61\x03\x02\x02\x02\u1B66\u1B62\x03\x02\x02\x02\u1B66\u1B63\x03" + - "\x02\x02\x02\u1B66\u1B64\x03\x02\x02\x02\u1B66\u1B65\x03\x02\x02\x02\u1B67" + - "\u02E5\x03\x02\x02\x02\u1B68\u1B69\x07\x8C\x02\x02\u1B69\u1B6A\x07\u0161" + - "\x02\x02\u1B6A\u1B6B\x05\u020C\u0107\x02\u1B6B\u1B6C\x07\u0146\x02\x02" + - "\u1B6C\u1B6D\x07\x04\x02\x02\u1B6D\u1B6E\x05\u02E0\u0171\x02\u1B6E\u1B6F" + - "\x07\x05\x02\x02\u1B6F\u02E7\x03\x02\x02\x02\u1B70\u1B71\x07\x8C\x02\x02" + - "\u1B71\u1B72\x07\x8A\x02\x02\u1B72\u1B73\x05\u028A\u0146\x02\u1B73\u1B74" + - "\x07\u0113\x02\x02\u1B74\u1B75\x07`\x02\x02\u1B75\u1B76\x05\u054C\u02A7" + - "\x02\u1B76\u1C2A\x03\x02\x02\x02\u1B77\u1B78\x07\x8C\x02\x02\u1B78\u1B79" + - "\x07n\x02\x02\u1B79\u1B7A\x05\u020C\u0107\x02\u1B7A\u1B7B\x07\u0113\x02" + - "\x02\u1B7B\u1B7C\x07`\x02\x02\u1B7C\u1B7D\x05\u054C\u02A7\x02\u1B7D\u1C2A" + - "\x03\x02\x02\x02\u1B7E\u1B7F\x07\x8C\x02\x02\u1B7F\u1B80\x07\xAA\x02\x02" + - "\u1B80\u1B81\x05\u020C\u0107\x02\u1B81\u1B82\x07\u0113\x02\x02\u1B82\u1B83" + - "\x07`\x02\x02\u1B83\u1B84\x05\u054C\u02A7\x02\u1B84\u1C2A\x03\x02\x02" + - "\x02\u1B85\u1B86\x07\x8C\x02\x02\u1B86\u1B87\x07\xB1\x02\x02\u1B87\u1B88" + - "\x05\u0530\u0299\x02\u1B88\u1B89\x07\u0113\x02\x02\u1B89\u1B8A\x07`\x02" + - "\x02\u1B8A\u1B8B\x05\u054C\u02A7\x02\u1B8B\u1C2A\x03\x02\x02\x02\u1B8C" + - "\u1B8D\x07\x8C\x02\x02\u1B8D\u1B8E\x07\xBF\x02\x02\u1B8E\u1B8F\x05\u020C" + - "\u0107\x02\u1B8F\u1B90\x07\u0113\x02\x02\u1B90\u1B91\x07`\x02\x02\u1B91" + - "\u1B92\x05\u054C\u02A7\x02\u1B92\u1C2A\x03\x02\x02\x02\u1B93\u1B94\x07" + - "\x8C\x02\x02\u1B94\u1B95\x07\xD5\x02\x02\u1B95\u1B96\x05\u0272\u013A\x02" + - "\u1B96\u1B97\x07\u0113\x02\x02\u1B97\u1B98\x07`\x02\x02\u1B98\u1B99\x05" + - "\u054C\u02A7\x02\u1B99\u1C2A\x03\x02\x02\x02\u1B9A\u1B9C\x07\x8C\x02\x02" + - "\u1B9B\u1B9D\x05\u0134\x9B\x02\u1B9C\u1B9B\x03\x02\x02\x02\u1B9C\u1B9D" + - "\x03\x02\x02\x02\u1B9D\u1B9E\x03\x02\x02\x02\u1B9E\u1B9F\x07\xF0\x02\x02" + - "\u1B9F\u1BA0\x05\u0530\u0299\x02\u1BA0\u1BA1\x07\u0113\x02\x02\u1BA1\u1BA2" + - "\x07`\x02\x02\u1BA2\u1BA3\x05\u054C\u02A7\x02\u1BA3\u1C2A\x03\x02\x02" + - "\x02\u1BA4\u1BA5\x07\x8C\x02\x02\u1BA5\u1BA6\x07\xF1\x02\x02\u1BA6\u1BA7" + - "\x07\u010B\x02\x02\u1BA7\u1BA8\x05\u0124\x93\x02\u1BA8\u1BA9\x07\u0113" + - "\x02\x02\u1BA9\u1BAA\x07`\x02\x02\u1BAA\u1BAB\x05\u054C\u02A7\x02\u1BAB" + - "\u1C2A\x03\x02\x02\x02\u1BAC\u1BAD\x07\x8C\x02\x02\u1BAD\u1BAE\x07\u010F" + - "\x02\x02\u1BAE\u1BAF\x05\u02B0\u0159\x02\u1BAF\u1BB0\x07\u0113\x02\x02" + - "\u1BB0\u1BB1\x07`\x02\x02\u1BB1\u1BB2\x05\u054C\u02A7\x02\u1BB2\u1C2A" + - "\x03\x02\x02\x02\u1BB3\u1BB4\x07\x8C\x02\x02\u1BB4\u1BB5\x07\u010F\x02" + - "\x02\u1BB5\u1BB6\x07\x9E\x02\x02\u1BB6\u1BB7\x05\u020C\u0107\x02\u1BB7" + - "\u1BB8\x07f\x02\x02\u1BB8\u1BB9\x05\u0530\u0299\x02\u1BB9\u1BBA\x07\u0113" + - "\x02\x02\u1BBA\u1BBB\x07`\x02\x02\u1BBB\u1BBC\x05\u054C\u02A7\x02\u1BBC" + - "\u1C2A\x03\x02\x02\x02\u1BBD\u1BBE\x07\x8C\x02\x02\u1BBE\u1BBF\x07\u010F" + - "\x02\x02\u1BBF\u1BC0\x07\xD0\x02\x02\u1BC0\u1BC1\x05\u020C\u0107\x02\u1BC1" + - "\u1BC2\x07f\x02\x02\u1BC2\u1BC3\x05\u0530\u0299\x02\u1BC3\u1BC4\x07\u0113" + - "\x02\x02\u1BC4\u1BC5\x07`\x02\x02\u1BC5\u1BC6\x05\u054C\u02A7\x02\u1BC6" + - "\u1C2A\x03\x02\x02\x02\u1BC7\u1BC8\x07\x8C\x02\x02\u1BC8\u1BC9\x07\u0121" + - "\x02\x02\u1BC9\u1BCA\x05\u0272\u013A\x02\u1BCA\u1BCB\x07\u0113\x02\x02" + - "\u1BCB\u1BCC\x07`\x02\x02\u1BCC\u1BCD\x05\u054C\u02A7\x02\u1BCD\u1C2A" + - "\x03\x02\x02\x02\u1BCE\u1BCF\x07\x8C\x02\x02\u1BCF\u1BD0\x07\u01B3\x02" + - "\x02\u1BD0\u1BD1\x05\u0272\u013A\x02\u1BD1\u1BD2\x07\u0113\x02\x02\u1BD2" + - "\u1BD3\x07`\x02\x02\u1BD3\u1BD4\x05\u054C\u02A7\x02\u1BD4\u1C2A\x03\x02" + - "\x02\x02\u1BD5\u1BD6\x07\x8C\x02\x02\u1BD6\u1BD7\x07\u013C\x02\x02\u1BD7" + - "\u1BD8\x05\u0530\u0299\x02\u1BD8\u1BD9\x07\u0113\x02\x02\u1BD9\u1BDA\x07" + - "`\x02\x02\u1BDA\u1BDB\x05\u054C\u02A7\x02\u1BDB\u1C2A\x03\x02\x02\x02" + - "\u1BDC\u1BDD\x07\x8C\x02\x02\u1BDD\u1BDE\x07\u0161\x02\x02\u1BDE\u1BDF" + - "\x05\u020C\u0107\x02\u1BDF\u1BE0\x07\u0113\x02\x02\u1BE0\u1BE1\x07`\x02" + - "\x02\u1BE1\u1BE2\x05\u054C\u02A7\x02\u1BE2\u1C2A\x03\x02\x02\x02\u1BE3" + - "\u1BE4\x07\x8C\x02\x02\u1BE4\u1BE5\x07\u0158\x02\x02\u1BE5\u1BE6\x05\u0530" + - "\u0299\x02\u1BE6\u1BE7\x07\u0113\x02\x02\u1BE7\u1BE8\x07`\x02\x02\u1BE8" + - "\u1BE9\x05\u054C\u02A7\x02\u1BE9\u1C2A\x03\x02\x02\x02\u1BEA\u1BEB\x07" + - "\x8C\x02\x02\u1BEB\u1BEC\x07\u014F\x02\x02\u1BEC\u1BED\x05\u020C\u0107" + - "\x02\u1BED\u1BEE\x07\u0113\x02\x02\u1BEE\u1BEF\x07`\x02\x02\u1BEF\u1BF0" + - "\x05\u054C\u02A7\x02\u1BF0\u1C2A\x03\x02\x02\x02\u1BF1\u1BF2\x07\x8C\x02"; + "f\x02\x02\u18E3\u18E4\x05\u0540\u02A1\x02\u18E4\u18E5\x07\u0137\x02\x02" + + "\u18E5\u18E6\x07`\x02\x02\u18E6\u18E7\x05\u0540\u02A1\x02\u18E7\u1A6F" + + "\x03\x02\x02\x02\u18E8\u18E9\x07\x8C\x02\x02\u18E9\u18EA\x07\u01BF\x02" + + "\x02\u18EA\u18EB\x05\u0540\u02A1\x02\u18EB\u18EC\x07R\x02\x02\u18EC\u18ED" + + "\x05\u053C\u029F\x02\u18ED\u18EE\x07\u0137\x02\x02\u18EE\u18EF\x07`\x02" + + "\x02\u18EF\u18F0\x05\u0540\u02A1\x02\u18F0\u1A6F\x03\x02\x02\x02\u18F1" + + "\u18F2\x07\x8C\x02\x02\u18F2\u18F3\x07\u01BF\x02\x02\u18F3\u18F4\x07\xDE" + + "\x02\x02\u18F4\u18F5\x07\u018E\x02\x02\u18F5\u18F6\x05\u0540\u02A1\x02" + + "\u18F6\u18F7\x07R\x02\x02\u18F7\u18F8\x05\u053C\u029F\x02\u18F8\u18F9" + + "\x07\u0137\x02\x02\u18F9\u18FA\x07`\x02\x02\u18FA\u18FB\x05\u0540\u02A1" + + "\x02\u18FB\u1A6F\x03\x02\x02\x02\u18FC\u18FD\x07\x8C\x02\x02\u18FD\u18FE" + + "\x07\u012A\x02\x02\u18FE\u18FF\x05\u0280\u0141\x02\u18FF\u1900\x07\u0137" + + "\x02\x02\u1900\u1901\x07`\x02\x02\u1901\u1902\x05\u0540\u02A1\x02\u1902" + + "\u1A6F\x03\x02\x02\x02\u1903\u1904\x07\x8C\x02\x02\u1904\u1905\x07\u01C6" + + "\x02\x02\u1905\u1906\x05\u0540\u02A1\x02\u1906\u1907\x07\u0137\x02\x02" + + "\u1907\u1908\x07`\x02\x02\u1908\u1909\x05\u0540\u02A1\x02\u1909\u1A6F" + + "\x03\x02\x02\x02\u190A\u190B\x07\x8C\x02\x02\u190B\u190C\x07\u01BC\x02" + + "\x02\u190C\u190D\x05\u0280\u0141\x02\u190D\u190E\x07\u0137\x02\x02\u190E" + + "\u190F\x07`\x02\x02\u190F\u1910\x05\u0540\u02A1\x02\u1910\u1A6F\x03\x02" + + "\x02\x02\u1911\u1912\x07\x8C\x02\x02\u1912\u1913\x07\u0145\x02\x02\u1913" + + "\u1914\x05\u0540\u02A1\x02\u1914\u1915\x07\u0137\x02\x02\u1915\u1916\x07" + + "`\x02\x02\u1916\u1917\x05\u0540\u02A1\x02\u1917\u1A6F\x03\x02\x02\x02" + + "\u1918\u1919\x07\x8C\x02\x02\u1919\u191A\x07\u014D\x02\x02\u191A\u191B" + + "\x05\u0540\u02A1\x02\u191B\u191C\x07\u0137\x02\x02\u191C\u191D\x07`\x02" + + "\x02\u191D\u191E\x05\u0540\u02A1\x02\u191E\u1A6F\x03\x02\x02\x02\u191F" + + "\u1920\x07\x8C\x02\x02\u1920\u1921\x07\u01C5\x02\x02\u1921\u1922\x05\u0540" + + "\u02A1\x02\u1922\u1923\x07\u0137\x02\x02\u1923\u1924\x07`\x02\x02\u1924" + + "\u1925\x05\u0540\u02A1\x02\u1925\u1A6F\x03\x02\x02\x02\u1926\u1927\x07" + + "\x8C\x02\x02\u1927\u1928\x07^\x02\x02\u1928\u1929\x05\u0436\u021C\x02" + + "\u1929\u192A\x07\u0137\x02\x02\u192A\u192B\x07`\x02\x02\u192B\u192C\x05" + + "\u0540\u02A1\x02\u192C\u1A6F\x03\x02\x02\x02\u192D\u192E\x07\x8C\x02\x02" + + "\u192E\u192F\x07^\x02\x02\u192F\u1930\x07\xDE\x02\x02\u1930\u1931\x07" + + "\u018E\x02\x02\u1931\u1932\x05\u0436\u021C\x02\u1932\u1933\x07\u0137\x02" + + "\x02\u1933\u1934\x07`\x02\x02\u1934\u1935\x05\u0540\u02A1\x02\u1935\u1A6F" + + "\x03\x02\x02\x02\u1936\u1937\x07\x8C\x02\x02\u1937\u1938\x07\u014A\x02" + + "\x02\u1938\u1939\x05\u053C\u029F\x02\u1939\u193A\x07\u0137\x02\x02\u193A" + + "\u193B\x07`\x02\x02\u193B\u193C\x05\u0540\u02A1\x02\u193C\u1A6F\x03\x02" + + "\x02\x02\u193D\u193E\x07\x8C\x02\x02\u193E\u193F\x07\u014A\x02\x02\u193F" + + "\u1940\x07\xDE\x02\x02\u1940\u1941\x07\u018E\x02\x02\u1941\u1942\x05\u053C" + + "\u029F\x02\u1942\u1943\x07\u0137\x02\x02\u1943\u1944\x07`\x02\x02\u1944" + + "\u1945\x05\u0540\u02A1\x02\u1945\u1A6F\x03\x02\x02\x02\u1946\u1947\x07" + + "\x8C\x02\x02\u1947\u1948\x07\u017A\x02\x02\u1948\u1949\x05\u053C\u029F" + + "\x02\u1949\u194A\x07\u0137\x02\x02\u194A\u194B\x07`\x02\x02\u194B\u194C" + + "\x05\u0540\u02A1\x02\u194C\u1A6F\x03\x02\x02\x02\u194D\u194E\x07\x8C\x02" + + "\x02\u194E\u194F\x07\u017A\x02\x02\u194F\u1950\x07\xDE\x02\x02\u1950\u1951" + + "\x07\u018E\x02\x02\u1951\u1952\x05\u053C\u029F\x02\u1952\u1953\x07\u0137" + + "\x02\x02\u1953\u1954\x07`\x02\x02\u1954\u1955\x05\u0540\u02A1\x02\u1955" + + "\u1A6F\x03\x02\x02\x02\u1956\u1957\x07\x8C\x02\x02\u1957\u1958\x07\u0105" + + "\x02\x02\u1958\u1959\x07\u017A\x02\x02\u1959\u195A\x05\u053C\u029F\x02" + + "\u195A\u195B\x07\u0137\x02\x02\u195B\u195C\x07`\x02\x02\u195C\u195D\x05" + + "\u0540\u02A1\x02\u195D\u1A6F\x03\x02\x02\x02\u195E\u195F\x07\x8C\x02\x02" + + "\u195F\u1960\x07\u0105\x02\x02\u1960\u1961\x07\u017A\x02\x02\u1961\u1962" + + "\x07\xDE\x02\x02\u1962\u1963\x07\u018E\x02\x02\u1963\u1964\x05\u053C\u029F" + + "\x02\u1964\u1965\x07\u0137\x02\x02\u1965\u1966\x07`\x02\x02\u1966\u1967" + + "\x05\u0540\u02A1\x02\u1967\u1A6F\x03\x02\x02\x02\u1968\u1969\x07\x8C\x02" + + "\x02\u1969\u196A\x07\xE4\x02\x02\u196A\u196B\x05\u053C\u029F\x02\u196B" + + "\u196C\x07\u0137\x02\x02\u196C\u196D\x07`\x02\x02\u196D\u196E\x05\u0540" + + "\u02A1\x02\u196E\u1A6F\x03\x02\x02\x02\u196F\u1970\x07\x8C\x02\x02\u1970" + + "\u1971\x07\xE4\x02\x02\u1971\u1972\x07\xDE\x02\x02\u1972\u1973\x07\u018E" + + "\x02\x02\u1973\u1974\x05\u053C\u029F\x02\u1974\u1975\x07\u0137\x02\x02" + + "\u1975\u1976\x07`\x02\x02\u1976\u1977\x05\u0540\u02A1\x02\u1977\u1A6F" + + "\x03\x02\x02\x02\u1978\u1979\x07\x8C\x02\x02\u1979\u197A\x07A\x02\x02" + + "\u197A\u197B\x07^\x02\x02\u197B\u197C\x05\u0436\u021C\x02\u197C\u197D" + + "\x07\u0137\x02\x02\u197D\u197E\x07`\x02\x02\u197E\u197F\x05\u0540\u02A1" + + "\x02\u197F\u1A6F\x03\x02\x02\x02\u1980\u1981\x07\x8C\x02\x02\u1981\u1982" + + "\x07A\x02\x02\u1982\u1983\x07^\x02\x02\u1983\u1984\x07\xDE\x02\x02\u1984" + + "\u1985\x07\u018E\x02\x02\u1985\u1986\x05\u0436\u021C\x02\u1986\u1987\x07" + + "\u0137\x02\x02\u1987\u1988\x07`\x02\x02\u1988\u1989\x05\u0540\u02A1\x02" + + "\u1989\u1A6F\x03\x02\x02\x02\u198A\u198B\x07\x8C\x02\x02\u198B\u198C\x07" + + "^\x02\x02\u198C\u198D\x05\u0436\u021C\x02\u198D\u198F\x07\u0137\x02\x02" + + "\u198E\u1990\x05\u02E2\u0172\x02\u198F\u198E\x03\x02\x02\x02\u198F\u1990" + + "\x03\x02\x02\x02\u1990\u1991\x03\x02\x02\x02\u1991\u1992\x05\u0540\u02A1" + + "\x02\u1992\u1993\x07`\x02\x02\u1993\u1994\x05\u0540\u02A1\x02\u1994\u1A6F" + + "\x03\x02\x02\x02\u1995\u1996\x07\x8C\x02\x02\u1996\u1997\x07^\x02\x02" + + "\u1997\u1998\x07\xDE\x02\x02\u1998\u1999\x07\u018E\x02\x02\u1999\u199A" + + "\x05\u0436\u021C\x02\u199A\u199C\x07\u0137\x02\x02\u199B\u199D\x05\u02E2" + + "\u0172\x02\u199C\u199B\x03\x02\x02\x02\u199C\u199D\x03\x02\x02\x02\u199D" + + "\u199E\x03\x02\x02\x02\u199E\u199F\x05\u0540\u02A1\x02\u199F\u19A0\x07" + + "`\x02\x02\u19A0\u19A1\x05\u0540\u02A1\x02\u19A1\u1A6F\x03\x02\x02\x02" + + "\u19A2\u19A3\x07\x8C\x02\x02\u19A3\u19A4\x07\u017A\x02\x02\u19A4\u19A5" + + "\x05\u053C\u029F\x02\u19A5\u19A7\x07\u0137\x02\x02\u19A6\u19A8\x05\u02E2" + + "\u0172\x02\u19A7\u19A6\x03\x02\x02\x02\u19A7\u19A8\x03\x02\x02\x02\u19A8" + + "\u19A9\x03\x02\x02\x02\u19A9\u19AA\x05\u0540\u02A1\x02\u19AA\u19AB\x07" + + "`\x02\x02\u19AB\u19AC\x05\u0540\u02A1\x02\u19AC\u1A6F\x03\x02\x02\x02" + + "\u19AD\u19AE\x07\x8C\x02\x02\u19AE\u19AF\x07\u017A\x02\x02\u19AF\u19B0" + + "\x07\xDE\x02\x02\u19B0\u19B1\x07\u018E\x02\x02\u19B1\u19B2\x05\u053C\u029F" + + "\x02\u19B2\u19B4\x07\u0137\x02\x02\u19B3\u19B5\x05\u02E2\u0172\x02\u19B4" + + "\u19B3\x03\x02\x02\x02\u19B4\u19B5\x03\x02\x02\x02\u19B5\u19B6\x03\x02" + + "\x02\x02\u19B6\u19B7\x05\u0540\u02A1\x02\u19B7\u19B8\x07`\x02\x02\u19B8" + + "\u19B9\x05\u0540\u02A1\x02\u19B9\u1A6F\x03\x02\x02\x02\u19BA\u19BB\x07" + + "\x8C\x02\x02\u19BB\u19BC\x07\u0105\x02\x02\u19BC\u19BD\x07\u017A\x02\x02" + + "\u19BD\u19BE\x05\u053C\u029F\x02\u19BE\u19C0\x07\u0137\x02\x02\u19BF\u19C1" + + "\x05\u02E2\u0172\x02\u19C0\u19BF\x03\x02\x02\x02\u19C0\u19C1\x03\x02\x02" + + "\x02\u19C1\u19C2\x03\x02\x02\x02\u19C2\u19C3\x05\u0540\u02A1\x02\u19C3" + + "\u19C4\x07`\x02\x02\u19C4\u19C5\x05\u0540\u02A1\x02\u19C5\u1A6F\x03\x02" + + "\x02\x02\u19C6\u19C7\x07\x8C\x02\x02\u19C7\u19C8\x07\u0105\x02\x02\u19C8" + + "\u19C9\x07\u017A\x02\x02\u19C9\u19CA\x07\xDE\x02\x02\u19CA\u19CB\x07\u018E" + + "\x02\x02\u19CB\u19CC\x05\u053C\u029F\x02\u19CC\u19CE\x07\u0137\x02\x02" + + "\u19CD\u19CF\x05\u02E2\u0172\x02\u19CE\u19CD\x03\x02\x02\x02\u19CE\u19CF" + + "\x03\x02\x02\x02\u19CF\u19D0\x03\x02\x02\x02\u19D0\u19D1\x05\u0540\u02A1" + + "\x02\u19D1\u19D2\x07`\x02\x02\u19D2\u19D3\x05\u0540\u02A1\x02\u19D3\u1A6F" + + "\x03\x02\x02\x02\u19D4\u19D5\x07\x8C\x02\x02\u19D5\u19D6\x07^\x02\x02" + + "\u19D6\u19D7\x05\u0436\u021C\x02\u19D7\u19D8\x07\u0137\x02\x02\u19D8\u19D9" + + "\x07/\x02\x02\u19D9\u19DA\x05\u0540\u02A1\x02\u19DA\u19DB\x07`\x02\x02" + + "\u19DB\u19DC\x05\u0540\u02A1\x02\u19DC\u1A6F\x03\x02\x02\x02\u19DD\u19DE" + + "\x07\x8C\x02\x02\u19DE\u19DF\x07^\x02\x02\u19DF\u19E0\x07\xDE\x02\x02" + + "\u19E0\u19E1\x07\u018E\x02\x02\u19E1\u19E2\x05\u0436\u021C\x02\u19E2\u19E3" + + "\x07\u0137\x02\x02\u19E3\u19E4\x07/\x02\x02\u19E4\u19E5\x05\u0540\u02A1" + + "\x02\u19E5\u19E6\x07`\x02\x02\u19E6\u19E7\x05\u0540\u02A1\x02\u19E7\u1A6F" + + "\x03\x02\x02\x02\u19E8\u19E9\x07\x8C\x02\x02\u19E9\u19EA\x07A\x02\x02" + + "\u19EA\u19EB\x07^\x02\x02\u19EB\u19EC\x05\u0436\u021C\x02\u19EC\u19EE" + + "\x07\u0137\x02\x02\u19ED\u19EF\x05\u02E2\u0172\x02\u19EE\u19ED\x03\x02" + + "\x02\x02\u19EE\u19EF\x03\x02\x02\x02\u19EF\u19F0\x03\x02\x02\x02\u19F0" + + "\u19F1\x05\u0540\u02A1\x02\u19F1\u19F2\x07`\x02\x02\u19F2\u19F3\x05\u0540" + + "\u02A1\x02\u19F3\u1A6F\x03\x02\x02\x02\u19F4\u19F5\x07\x8C\x02\x02\u19F5" + + "\u19F6\x07A\x02\x02\u19F6\u19F7\x07^\x02\x02\u19F7\u19F8\x07\xDE\x02\x02" + + "\u19F8\u19F9\x07\u018E\x02\x02\u19F9\u19FA\x05\u0436\u021C\x02\u19FA\u19FC" + + "\x07\u0137\x02\x02\u19FB\u19FD\x05\u02E2\u0172\x02\u19FC\u19FB\x03\x02" + + "\x02\x02\u19FC\u19FD\x03\x02\x02\x02\u19FD\u19FE\x03\x02\x02\x02\u19FE" + + "\u19FF\x05\u0540\u02A1\x02\u19FF\u1A00\x07`\x02\x02\u1A00\u1A01\x05\u0540" + + "\u02A1\x02\u1A01\u1A6F\x03\x02\x02\x02\u1A02\u1A03\x07\x8C\x02\x02\u1A03" + + "\u1A04\x07\u0143\x02\x02\u1A04\u1A05\x05\u0540\u02A1\x02\u1A05\u1A06\x07" + + "R\x02\x02\u1A06\u1A07\x05\u053C\u029F\x02\u1A07\u1A08\x07\u0137\x02\x02" + + "\u1A08\u1A09\x07`\x02\x02\u1A09\u1A0A\x05\u0540\u02A1\x02\u1A0A\u1A6F" + + "\x03\x02\x02\x02\u1A0B\u1A0C\x07\x8C\x02\x02\u1A0C\u1A0D\x07\u0167\x02" + + "\x02\u1A0D\u1A0E\x05\u0540\u02A1\x02\u1A0E\u1A0F\x07R\x02\x02\u1A0F\u1A10" + + "\x05\u053C\u029F\x02\u1A10\u1A11\x07\u0137\x02\x02\u1A11\u1A12\x07`\x02" + + "\x02\u1A12\u1A13\x05\u0540\u02A1\x02\u1A13\u1A6F\x03\x02\x02\x02\u1A14" + + "\u1A15\x07\x8C\x02\x02\u1A15\u1A16\x07\xC8\x02\x02\u1A16\u1A17\x07\u0167" + + "\x02\x02\u1A17\u1A18\x05\u0540\u02A1\x02\u1A18\u1A19\x07\u0137\x02\x02" + + "\u1A19\u1A1A\x07`\x02\x02\u1A1A\u1A1B\x05\u0540\u02A1\x02\u1A1B\u1A6F" + + "\x03\x02\x02\x02\u1A1C\u1A1D\x07\x8C\x02\x02\u1A1D\u1A1E\x07\u0140\x02" + + "\x02\u1A1E\u1A1F\x05\u055C\u02AF\x02\u1A1F\u1A20\x07\u0137\x02\x02\u1A20" + + "\u1A21\x07`\x02\x02\u1A21\u1A22\x05\u055C\u02AF\x02\u1A22\u1A6F\x03\x02" + + "\x02\x02\u1A23\u1A24\x07\x8C\x02\x02\u1A24\u1A25\x07e\x02\x02\u1A25\u1A26" + + "\x05\u055C\u02AF\x02\u1A26\u1A27\x07\u0137\x02\x02\u1A27\u1A28\x07`\x02" + + "\x02\u1A28\u1A29\x05\u055C\u02AF\x02\u1A29\u1A6F\x03\x02\x02\x02\u1A2A" + + "\u1A2B\x07\x8C\x02\x02\u1A2B\u1A2C\x07\u0161\x02\x02\u1A2C\u1A2D\x05\u0540" + + "\u02A1\x02\u1A2D\u1A2E\x07\u0137\x02\x02\u1A2E\u1A2F\x07`\x02\x02\u1A2F" + + "\u1A30\x05\u0540\u02A1\x02\u1A30\u1A6F\x03\x02\x02\x02\u1A31\u1A32\x07" + + "\x8C\x02\x02\u1A32\u1A33\x07\u0158\x02\x02\u1A33\u1A34\x05\u0214\u010B" + + "\x02\u1A34\u1A35\x07\u0137\x02\x02\u1A35\u1A36\x07`\x02\x02\u1A36\u1A37" + + "\x05\u0540\u02A1\x02\u1A37\u1A6F\x03\x02\x02\x02\u1A38\u1A39\x07\x8C\x02" + + "\x02\u1A39\u1A3A\x07\u0165\x02\x02\u1A3A\u1A3B\x07\u0147\x02\x02\u1A3B" + + "\u1A3C\x07\u011D\x02\x02\u1A3C\u1A3D\x05\u0214\u010B\x02\u1A3D\u1A3E\x07" + + "\u0137\x02\x02\u1A3E\u1A3F\x07`\x02\x02\u1A3F\u1A40\x05\u0540\u02A1\x02" + + "\u1A40\u1A6F\x03\x02\x02\x02\u1A41\u1A42\x07\x8C\x02\x02\u1A42\u1A43\x07" + + "\u0165\x02\x02\u1A43\u1A44\x07\u0147\x02\x02\u1A44\u1A45\x07\xBB\x02\x02" + + "\u1A45\u1A46\x05\u0214\u010B\x02\u1A46\u1A47\x07\u0137\x02\x02\u1A47\u1A48" + + "\x07`\x02\x02\u1A48\u1A49\x05\u0540\u02A1\x02\u1A49\u1A6F\x03\x02\x02" + + "\x02\u1A4A\u1A4B\x07\x8C\x02\x02\u1A4B\u1A4C\x07\u0165\x02\x02\u1A4C\u1A4D" + + "\x07\u0147\x02\x02\u1A4D\u1A4E\x07\u0163\x02\x02\u1A4E\u1A4F\x05\u0214" + + "\u010B\x02\u1A4F\u1A50\x07\u0137\x02\x02\u1A50\u1A51\x07`\x02\x02\u1A51" + + "\u1A52\x05\u0540\u02A1\x02\u1A52\u1A6F\x03\x02\x02\x02\u1A53\u1A54\x07" + + "\x8C\x02\x02\u1A54\u1A55\x07\u0165\x02\x02\u1A55\u1A56\x07\u0147\x02\x02" + + "\u1A56\u1A57\x07\xA5\x02\x02\u1A57\u1A58\x05\u0214\u010B\x02\u1A58\u1A59" + + "\x07\u0137\x02\x02\u1A59\u1A5A\x07`\x02\x02\u1A5A\u1A5B\x05\u0540\u02A1" + + "\x02\u1A5B\u1A6F\x03\x02\x02\x02\u1A5C\u1A5D\x07\x8C\x02\x02\u1A5D\u1A5E" + + "\x07\u016A\x02\x02\u1A5E\u1A5F\x05\u0214\u010B\x02\u1A5F\u1A60\x07\u0137" + + "\x02\x02\u1A60\u1A61\x07`\x02\x02\u1A61\u1A62\x05\u0540\u02A1\x02\u1A62" + + "\u1A6F\x03\x02\x02\x02\u1A63\u1A64\x07\x8C\x02\x02\u1A64\u1A65\x07\u016A" + + "\x02\x02\u1A65\u1A66\x05\u0214\u010B\x02\u1A66\u1A67\x07\u0137\x02\x02" + + "\u1A67\u1A68\x07\x91\x02\x02\u1A68\u1A69\x05\u0540\u02A1\x02\u1A69\u1A6A" + + "\x07`\x02\x02\u1A6A\u1A6C\x05\u0540\u02A1\x02\u1A6B\u1A6D\x05l7\x02\u1A6C" + + "\u1A6B\x03\x02\x02\x02\u1A6C\u1A6D\x03\x02\x02\x02\u1A6D\u1A6F\x03\x02" + + "\x02\x02\u1A6E\u1887\x03\x02\x02\x02\u1A6E\u188E\x03\x02\x02\x02\u1A6E" + + "\u1895\x03\x02\x02\x02\u1A6E\u189C\x03\x02\x02\x02\u1A6E\u18A3\x03\x02" + + "\x02\x02\u1A6E\u18AA\x03\x02\x02\x02\u1A6E\u18B3\x03\x02\x02\x02\u1A6E" + + "\u18BC\x03\x02\x02\x02\u1A6E\u18C3\x03\x02\x02\x02\u1A6E\u18CA\x03\x02" + + "\x02\x02\u1A6E\u18D4\x03\x02\x02\x02\u1A6E\u18DE\x03\x02\x02\x02\u1A6E" + + "\u18E8\x03\x02\x02\x02\u1A6E\u18F1\x03\x02\x02\x02\u1A6E\u18FC\x03\x02" + + "\x02\x02\u1A6E\u1903\x03\x02\x02\x02\u1A6E\u190A\x03\x02\x02\x02\u1A6E" + + "\u1911\x03\x02\x02\x02\u1A6E\u1918\x03\x02\x02\x02\u1A6E\u191F\x03\x02" + + "\x02\x02\u1A6E\u1926\x03\x02\x02\x02\u1A6E\u192D\x03\x02\x02\x02\u1A6E" + + "\u1936\x03\x02\x02\x02\u1A6E\u193D\x03\x02\x02\x02\u1A6E\u1946\x03\x02" + + "\x02\x02\u1A6E\u194D\x03\x02\x02\x02\u1A6E\u1956\x03\x02\x02\x02\u1A6E" + + "\u195E\x03\x02\x02\x02\u1A6E\u1968\x03\x02\x02\x02\u1A6E\u196F\x03\x02" + + "\x02\x02\u1A6E\u1978\x03\x02\x02\x02\u1A6E\u1980\x03\x02\x02\x02\u1A6E" + + "\u198A\x03\x02\x02\x02\u1A6E\u1995\x03\x02\x02\x02\u1A6E\u19A2\x03\x02" + + "\x02\x02\u1A6E\u19AD\x03\x02\x02\x02\u1A6E\u19BA\x03\x02\x02\x02\u1A6E" + + "\u19C6\x03\x02\x02\x02\u1A6E\u19D4\x03\x02\x02\x02\u1A6E\u19DD\x03\x02" + + "\x02\x02\u1A6E\u19E8\x03\x02\x02\x02\u1A6E\u19F4\x03\x02\x02\x02\u1A6E" + + "\u1A02\x03\x02\x02\x02\u1A6E\u1A0B\x03\x02\x02\x02\u1A6E\u1A14\x03\x02" + + "\x02\x02\u1A6E\u1A1C\x03\x02\x02\x02\u1A6E\u1A23\x03\x02\x02\x02\u1A6E" + + "\u1A2A\x03\x02\x02\x02\u1A6E\u1A31\x03\x02\x02\x02\u1A6E\u1A38\x03\x02" + + "\x02\x02\u1A6E\u1A41\x03\x02\x02\x02\u1A6E\u1A4A\x03\x02\x02\x02\u1A6E" + + "\u1A53\x03\x02\x02\x02\u1A6E\u1A5C\x03\x02\x02\x02\u1A6E\u1A63\x03\x02" + + "\x02\x02\u1A6F\u02E1\x03\x02\x02\x02\u1A70\u1A71\x07.\x02\x02\u1A71\u02E3" + + "\x03\x02\x02\x02\u1A72\u1A73\x07\u014F\x02\x02\u1A73\u1A74\x07\xB0\x02" + + "\x02\u1A74\u02E5\x03\x02\x02\x02\u1A75\u1A76\x07\x8C\x02\x02\u1A76\u1A77" + + "\x07\xD5\x02\x02\u1A77\u1A79\x05\u0280\u0141\x02\u1A78\u1A7A\x05\u02E8" + + "\u0175\x02\u1A79\u1A78\x03\x02\x02\x02\u1A79\u1A7A\x03\x02\x02\x02\u1A7A" + + "\u1A7B\x03\x02\x02\x02\u1A7B\u1A7C\x07\u01D0\x02\x02\u1A7C\u1A7D\x07R" + + "\x02\x02\u1A7D\u1A7E\x07\xCE\x02\x02\u1A7E\u1A7F\x05\u0540\u02A1\x02\u1A7F" + + "\u1ABB\x03\x02\x02\x02\u1A80\u1A81\x07\x8C\x02\x02\u1A81\u1A82\x07\u012A" + + "\x02\x02\u1A82\u1A84\x05\u0280\u0141\x02\u1A83\u1A85\x05\u02E8\u0175\x02" + + "\u1A84\u1A83\x03\x02\x02\x02\u1A84\u1A85\x03\x02\x02\x02\u1A85\u1A86\x03" + + "\x02\x02\x02\u1A86\u1A87\x07\u01D0\x02\x02\u1A87\u1A88\x07R\x02\x02\u1A88" + + "\u1A89\x07\xCE\x02\x02\u1A89\u1A8A\x05\u0540\u02A1\x02\u1A8A\u1ABB\x03" + + "\x02\x02\x02\u1A8B\u1A8C\x07\x8C\x02\x02\u1A8C\u1A8D\x07\u01BC\x02\x02" + + "\u1A8D\u1A8F\x05\u0280\u0141\x02\u1A8E\u1A90\x05\u02E8\u0175\x02\u1A8F" + + "\u1A8E\x03\x02\x02\x02\u1A8F\u1A90\x03\x02\x02\x02\u1A90\u1A91\x03\x02" + + "\x02\x02\u1A91\u1A92\x07\u01D0\x02\x02\u1A92\u1A93\x07R\x02\x02\u1A93" + + "\u1A94\x07\xCE\x02\x02\u1A94\u1A95\x05\u0540\u02A1\x02\u1A95\u1ABB\x03" + + "\x02\x02\x02\u1A96\u1A97\x07\x8C\x02\x02\u1A97\u1A98\x07\u0167\x02\x02" + + "\u1A98\u1A99\x05\u0540\u02A1\x02\u1A99\u1A9A\x07R\x02\x02\u1A9A\u1A9C" + + "\x05\u053C\u029F\x02\u1A9B\u1A9D\x05\u02E8\u0175\x02\u1A9C\u1A9B\x03\x02" + + "\x02\x02\u1A9C\u1A9D\x03\x02\x02\x02\u1A9D\u1A9E\x03\x02\x02\x02\u1A9E" + + "\u1A9F\x07\u01D0\x02\x02\u1A9F\u1AA0\x07R\x02\x02\u1AA0\u1AA1\x07\xCE" + + "\x02\x02\u1AA1\u1AA2\x05\u0540\u02A1\x02\u1AA2\u1ABB\x03\x02\x02\x02\u1AA3" + + "\u1AA4\x07\x8C\x02\x02\u1AA4\u1AA5\x07\u0105\x02\x02\u1AA5\u1AA6\x07\u017A" + + "\x02\x02\u1AA6\u1AA8\x05\u053C\u029F\x02\u1AA7\u1AA9\x05\u02E8\u0175\x02" + + "\u1AA8\u1AA7\x03\x02\x02\x02\u1AA8\u1AA9\x03\x02\x02\x02\u1AA9\u1AAA\x03" + + "\x02\x02\x02\u1AAA\u1AAB\x07\u01D0\x02\x02\u1AAB\u1AAC\x07R\x02\x02\u1AAC" + + "\u1AAD\x07\xCE\x02\x02\u1AAD\u1AAE\x05\u0540\u02A1\x02\u1AAE\u1ABB\x03" + + "\x02\x02\x02\u1AAF\u1AB0\x07\x8C\x02\x02\u1AB0\u1AB1\x07\xE4\x02\x02\u1AB1" + + "\u1AB3\x05\u053C\u029F\x02\u1AB2\u1AB4\x05\u02E8\u0175\x02\u1AB3\u1AB2" + + "\x03\x02\x02\x02\u1AB3\u1AB4\x03\x02\x02\x02\u1AB4\u1AB5\x03\x02\x02\x02" + + "\u1AB5\u1AB6\x07\u01D0\x02\x02\u1AB6\u1AB7\x07R\x02\x02\u1AB7\u1AB8\x07" + + "\xCE\x02\x02\u1AB8\u1AB9\x05\u0540\u02A1\x02\u1AB9\u1ABB\x03\x02\x02\x02" + + "\u1ABA\u1A75\x03\x02\x02\x02\u1ABA\u1A80\x03\x02\x02\x02\u1ABA\u1A8B\x03" + + "\x02\x02\x02\u1ABA\u1A96\x03\x02\x02\x02\u1ABA\u1AA3\x03\x02\x02\x02\u1ABA" + + "\u1AAF\x03\x02\x02\x02\u1ABB\u02E7\x03\x02\x02\x02\u1ABC\u1ABD\x07\u010F" + + "\x02\x02\u1ABD\u02E9\x03\x02\x02\x02\u1ABE\u1ABF\x07\x8C\x02\x02\u1ABF" + + "\u1AC0\x07\x8A\x02\x02\u1AC0\u1AC1\x05\u0298\u014D\x02\u1AC1\u1AC2\x07" + + "\u014F\x02\x02\u1AC2\u1AC3\x07\u0145\x02\x02\u1AC3\u1AC4\x05\u0540\u02A1" + + "\x02\u1AC4\u1B98\x03\x02\x02\x02\u1AC5\u1AC6\x07\x8C\x02\x02\u1AC6\u1AC7" + + "\x07n\x02\x02\u1AC7\u1AC8\x05\u0214\u010B\x02\u1AC8\u1AC9\x07\u014F\x02" + + "\x02\u1AC9\u1ACA\x07\u0145\x02\x02\u1ACA\u1ACB\x05\u0540\u02A1\x02\u1ACB" + + "\u1B98\x03\x02\x02\x02\u1ACC\u1ACD\x07\x8C\x02\x02\u1ACD\u1ACE\x07\xAA" + + "\x02\x02\u1ACE\u1ACF\x05\u0214\u010B\x02\u1ACF\u1AD0\x07\u014F\x02\x02" + + "\u1AD0\u1AD1\x07\u0145\x02\x02\u1AD1\u1AD2\x05\u0540\u02A1\x02\u1AD2\u1B98" + + "\x03\x02\x02\x02\u1AD3\u1AD4\x07\x8C\x02\x02\u1AD4\u1AD5\x07\xBF\x02\x02" + + "\u1AD5\u1AD6\x05\u0214\u010B\x02\u1AD6\u1AD7\x07\u014F\x02\x02\u1AD7\u1AD8" + + "\x07\u0145\x02\x02\u1AD8\u1AD9\x05\u0540\u02A1\x02\u1AD9\u1B98\x03\x02" + + "\x02\x02\u1ADA\u1ADB\x07\x8C\x02\x02\u1ADB\u1ADC\x07\xCE\x02\x02\u1ADC" + + "\u1ADD\x05\u0540\u02A1\x02\u1ADD\u1ADE\x07\u014F\x02\x02\u1ADE\u1ADF\x07" + + "\u0145\x02\x02\u1ADF\u1AE0\x05\u0540\u02A1\x02\u1AE0\u1B98\x03\x02\x02" + + "\x02\u1AE1\u1AE2\x07\x8C\x02\x02\u1AE2\u1AE3\x07\xD5\x02\x02\u1AE3\u1AE4" + + "\x05\u0280\u0141\x02\u1AE4\u1AE5\x07\u014F\x02\x02\u1AE5\u1AE6\x07\u0145" + + "\x02\x02\u1AE6\u1AE7\x05\u0540\u02A1\x02\u1AE7\u1B98\x03\x02\x02\x02\u1AE8" + + "\u1AE9\x07\x8C\x02\x02\u1AE9\u1AEA\x07\u0118\x02\x02\u1AEA\u1AEB\x05\u02BE" + + "\u0160\x02\u1AEB\u1AEC\x07\u014F\x02\x02\u1AEC\u1AED\x07\u0145\x02\x02" + + "\u1AED\u1AEE\x05\u0540\u02A1\x02\u1AEE\u1B98\x03\x02\x02\x02\u1AEF\u1AF0" + + "\x07\x8C\x02\x02\u1AF0\u1AF1\x07\u0118\x02\x02\u1AF1\u1AF2\x07\x9E\x02" + + "\x02\u1AF2\u1AF3\x05\u0214\u010B\x02\u1AF3\u1AF4\x07f\x02\x02\u1AF4\u1AF5" + + "\x05\u0540\u02A1\x02\u1AF5\u1AF6\x07\u014F\x02\x02\u1AF6\u1AF7\x07\u0145" + + "\x02\x02\u1AF7\u1AF8\x05\u0540\u02A1\x02\u1AF8\u1B98\x03\x02\x02\x02\u1AF9" + + "\u1AFA\x07\x8C\x02\x02\u1AFA\u1AFB\x07\u0118\x02\x02\u1AFB\u1AFC\x07\xD0" + + "\x02\x02\u1AFC\u1AFD\x05\u0214\u010B\x02\u1AFD\u1AFE\x07f\x02\x02\u1AFE" + + "\u1AFF\x05\u0540\u02A1\x02\u1AFF\u1B00\x07\u014F\x02\x02\u1B00\u1B01\x07" + + "\u0145\x02\x02\u1B01\u1B02\x05\u0540\u02A1\x02\u1B02\u1B98\x03\x02\x02" + + "\x02\u1B03\u1B04\x07\x8C\x02\x02\u1B04\u1B05\x07\u012A\x02\x02\u1B05\u1B06" + + "\x05\u0280\u0141\x02\u1B06\u1B07\x07\u014F\x02\x02\u1B07\u1B08\x07\u0145" + + "\x02\x02\u1B08\u1B09\x05\u0540\u02A1\x02\u1B09\u1B98\x03\x02\x02\x02\u1B0A" + + "\u1B0B\x07\x8C\x02\x02\u1B0B\u1B0C\x07\u01BC\x02\x02\u1B0C\u1B0D\x05\u0280" + + "\u0141\x02\u1B0D\u1B0E\x07\u014F\x02\x02\u1B0E\u1B0F\x07\u0145\x02\x02" + + "\u1B0F\u1B10\x05\u0540\u02A1\x02\u1B10\u1B98\x03\x02\x02\x02\u1B11\u1B12" + + "\x07\x8C\x02\x02\u1B12\u1B13\x07^\x02\x02\u1B13\u1B14\x05\u0436\u021C" + + "\x02\u1B14\u1B15\x07\u014F\x02\x02\u1B15\u1B16\x07\u0145\x02\x02\u1B16" + + "\u1B17\x05\u0540\u02A1\x02\u1B17\u1B98\x03\x02\x02\x02\u1B18\u1B19\x07" + + "\x8C\x02\x02\u1B19\u1B1A\x07^\x02\x02\u1B1A\u1B1B\x07\xDE\x02\x02\u1B1B" + + "\u1B1C\x07\u018E\x02\x02\u1B1C\u1B1D\x05\u0436\u021C\x02\u1B1D\u1B1E\x07" + + "\u014F\x02\x02\u1B1E\u1B1F\x07\u0145\x02\x02\u1B1F\u1B20\x05\u0540\u02A1" + + "\x02\u1B20\u1B98\x03\x02\x02\x02\u1B21\u1B22\x07\x8C\x02\x02\u1B22\u1B23" + + "\x07\u0158\x02\x02\u1B23\u1B24\x05\u0214\u010B\x02\u1B24\u1B25\x07\u014F" + + "\x02\x02\u1B25\u1B26\x07\u0145\x02\x02\u1B26\u1B27\x05\u0540\u02A1\x02" + + "\u1B27\u1B98\x03\x02\x02\x02\u1B28\u1B29\x07\x8C\x02\x02\u1B29\u1B2A\x07" + + "\u0165\x02\x02\u1B2A\u1B2B\x07\u0147\x02\x02\u1B2B\u1B2C\x07\u011D\x02" + + "\x02\u1B2C\u1B2D\x05\u0214\u010B\x02\u1B2D\u1B2E\x07\u014F\x02\x02\u1B2E" + + "\u1B2F\x07\u0145\x02\x02\u1B2F\u1B30\x05\u0540\u02A1\x02\u1B30\u1B98\x03" + + "\x02\x02\x02\u1B31\u1B32\x07\x8C\x02\x02\u1B32\u1B33\x07\u0165\x02\x02" + + "\u1B33\u1B34\x07\u0147\x02\x02\u1B34\u1B35\x07\xBB\x02\x02\u1B35\u1B36" + + "\x05\u0214\u010B\x02\u1B36\u1B37\x07\u014F\x02\x02\u1B37\u1B38\x07\u0145" + + "\x02\x02\u1B38\u1B39\x05\u0540\u02A1\x02\u1B39\u1B98\x03\x02\x02\x02\u1B3A" + + "\u1B3B\x07\x8C\x02\x02\u1B3B\u1B3C\x07\u0165\x02\x02\u1B3C\u1B3D\x07\u0147" + + "\x02\x02\u1B3D\u1B3E\x07\u0163\x02\x02\u1B3E\u1B3F\x05\u0214\u010B\x02" + + "\u1B3F\u1B40\x07\u014F\x02\x02\u1B40\u1B41\x07\u0145\x02\x02\u1B41\u1B42" + + "\x05\u0540\u02A1\x02\u1B42\u1B98\x03\x02\x02\x02\u1B43\u1B44\x07\x8C\x02" + + "\x02\u1B44\u1B45\x07\u0165\x02\x02\u1B45\u1B46\x07\u0147\x02\x02\u1B46" + + "\u1B47\x07\xA5\x02\x02\u1B47\u1B48\x05\u0214\u010B\x02\u1B48\u1B49\x07" + + "\u014F\x02\x02\u1B49\u1B4A\x07\u0145\x02\x02\u1B4A\u1B4B\x05\u0540\u02A1" + + "\x02\u1B4B\u1B98\x03\x02\x02\x02\u1B4C\u1B4D\x07\x8C\x02\x02\u1B4D\u1B4E" + + "\x07\u014A\x02\x02\u1B4E\u1B4F\x05\u053C\u029F\x02\u1B4F\u1B50\x07\u014F" + + "\x02\x02\u1B50\u1B51\x07\u0145\x02\x02\u1B51\u1B52\x05\u0540\u02A1\x02" + + "\u1B52\u1B98\x03\x02\x02\x02\u1B53\u1B54\x07\x8C\x02\x02\u1B54\u1B55\x07" + + "\u014A\x02\x02\u1B55\u1B56\x07\xDE\x02\x02\u1B56\u1B57\x07\u018E\x02\x02" + + "\u1B57\u1B58\x05\u053C\u029F\x02\u1B58\u1B59\x07\u014F\x02\x02\u1B59\u1B5A" + + "\x07\u0145\x02\x02\u1B5A\u1B5B\x05\u0540\u02A1\x02\u1B5B\u1B98\x03\x02" + + "\x02\x02\u1B5C\u1B5D\x07\x8C\x02\x02\u1B5D\u1B5E\x07\u017A\x02\x02\u1B5E" + + "\u1B5F\x05\u053C\u029F\x02\u1B5F\u1B60\x07\u014F\x02\x02\u1B60\u1B61\x07" + + "\u0145\x02\x02\u1B61\u1B62\x05\u0540\u02A1\x02\u1B62\u1B98\x03\x02\x02" + + "\x02\u1B63\u1B64\x07\x8C\x02\x02\u1B64\u1B65\x07\u017A\x02\x02\u1B65\u1B66" + + "\x07\xDE\x02\x02\u1B66\u1B67\x07\u018E\x02\x02\u1B67\u1B68\x05\u053C\u029F" + + "\x02\u1B68\u1B69\x07\u014F\x02\x02\u1B69\u1B6A\x07\u0145\x02\x02\u1B6A" + + "\u1B6B\x05\u0540\u02A1\x02\u1B6B\u1B98\x03\x02\x02\x02\u1B6C\u1B6D\x07" + + "\x8C\x02\x02\u1B6D\u1B6E\x07\u0105\x02\x02\u1B6E\u1B6F\x07\u017A\x02\x02" + + "\u1B6F\u1B70\x05\u053C\u029F\x02\u1B70\u1B71\x07\u014F\x02\x02\u1B71\u1B72" + + "\x07\u0145\x02\x02\u1B72\u1B73\x05\u0540\u02A1\x02\u1B73\u1B98\x03\x02" + + "\x02\x02\u1B74\u1B75\x07\x8C\x02\x02\u1B75\u1B76\x07\u0105\x02\x02\u1B76" + + "\u1B77\x07\u017A\x02\x02\u1B77\u1B78\x07\xDE\x02\x02\u1B78\u1B79\x07\u018E" + + "\x02\x02\u1B79\u1B7A\x05\u053C\u029F\x02\u1B7A\u1B7B\x07\u014F\x02\x02" + + "\u1B7B\u1B7C\x07\u0145\x02\x02\u1B7C\u1B7D\x05\u0540\u02A1\x02\u1B7D\u1B98" + + "\x03\x02\x02\x02\u1B7E\u1B7F\x07\x8C\x02\x02\u1B7F\u1B80\x07A\x02\x02" + + "\u1B80\u1B81\x07^\x02\x02\u1B81\u1B82\x05\u0436\u021C\x02\u1B82\u1B83" + + "\x07\u014F\x02\x02\u1B83\u1B84\x07\u0145\x02\x02\u1B84\u1B85\x05\u0540" + + "\u02A1\x02\u1B85\u1B98\x03\x02\x02\x02\u1B86\u1B87\x07\x8C\x02\x02\u1B87" + + "\u1B88\x07A\x02\x02\u1B88\u1B89\x07^\x02\x02\u1B89\u1B8A\x07\xDE\x02\x02" + + "\u1B8A\u1B8B\x07\u018E\x02\x02\u1B8B\u1B8C\x05\u0436\u021C\x02\u1B8C\u1B8D" + + "\x07\u014F\x02\x02\u1B8D\u1B8E\x07\u0145\x02\x02\u1B8E\u1B8F\x05\u0540" + + "\u02A1\x02\u1B8F\u1B98\x03\x02\x02\x02\u1B90\u1B91\x07\x8C\x02\x02\u1B91" + + "\u1B92\x07\u016A\x02\x02\u1B92\u1B93\x05\u0214\u010B\x02\u1B93\u1B94\x07" + + "\u014F\x02\x02\u1B94\u1B95\x07\u0145\x02\x02\u1B95\u1B96\x05\u0540\u02A1" + + "\x02\u1B96\u1B98\x03\x02\x02\x02\u1B97\u1ABE\x03\x02\x02\x02\u1B97\u1AC5" + + "\x03\x02\x02\x02\u1B97\u1ACC\x03\x02\x02\x02\u1B97\u1AD3\x03\x02\x02\x02" + + "\u1B97\u1ADA\x03\x02\x02\x02\u1B97\u1AE1\x03\x02\x02\x02\u1B97\u1AE8\x03" + + "\x02\x02\x02\u1B97\u1AEF\x03\x02\x02\x02\u1B97\u1AF9\x03\x02\x02\x02\u1B97" + + "\u1B03\x03\x02\x02\x02\u1B97\u1B0A\x03\x02\x02\x02\u1B97\u1B11\x03\x02" + + "\x02\x02\u1B97\u1B18\x03\x02\x02\x02\u1B97\u1B21\x03\x02\x02\x02\u1B97" + + "\u1B28\x03\x02\x02\x02\u1B97\u1B31\x03\x02\x02\x02\u1B97\u1B3A\x03\x02" + + "\x02\x02\u1B97\u1B43\x03\x02\x02\x02\u1B97\u1B4C\x03\x02\x02\x02\u1B97" + + "\u1B53\x03\x02\x02\x02\u1B97\u1B5C\x03\x02\x02\x02\u1B97\u1B63\x03\x02" + + "\x02\x02\u1B97\u1B6C\x03\x02\x02\x02\u1B97\u1B74\x03\x02\x02\x02\u1B97" + + "\u1B7E\x03\x02\x02\x02\u1B97\u1B86\x03\x02\x02\x02\u1B97\u1B90\x03\x02" + + "\x02\x02\u1B98\u02EB\x03\x02\x02\x02\u1B99\u1B9A\x07\x8C\x02\x02\u1B9A" + + "\u1B9B\x07\u0118\x02\x02\u1B9B\u1B9C\x05\u02BE\u0160\x02\u1B9C\u1B9D\x07" + + "\u014F\x02\x02\u1B9D\u1B9E\x07\x04\x02\x02\u1B9E\u1B9F\x05\u02EE\u0178" + + "\x02\u1B9F\u1BA0\x07\x05\x02\x02\u1BA0\u02ED\x03\x02\x02\x02\u1BA1\u1BA6" + + "\x05\u02F0\u0179\x02\u1BA2\u1BA3\x07\b\x02\x02\u1BA3\u1BA5\x05\u02F0\u0179" + + "\x02\u1BA4\u1BA2\x03\x02\x02\x02\u1BA5\u1BA8\x03\x02\x02\x02\u1BA6\u1BA4" + + "\x03\x02\x02\x02\u1BA6\u1BA7\x03\x02\x02\x02\u1BA7\u02EF\x03\x02\x02\x02" + + "\u1BA8\u1BA6\x03\x02\x02\x02\u1BA9\u1BAA\x05\u0570\u02B9\x02\u1BAA\u1BAB" + + "\x07\f\x02\x02\u1BAB\u1BAC\x07\u0199\x02\x02\u1BAC\u1BB2\x03\x02\x02\x02" + + "\u1BAD\u1BAE\x05\u0570\u02B9\x02\u1BAE\u1BAF\x07\f\x02\x02\u1BAF\u1BB0" + + "\x05\u02F2\u017A\x02\u1BB0\u1BB2\x03\x02\x02\x02\u1BB1\u1BA9\x03\x02\x02" + + "\x02\u1BB1\u1BAD\x03\x02\x02\x02\u1BB2\u02F1\x03\x02\x02\x02\u1BB3\u1BB9" + + "\x05\u028E\u0148\x02\u1BB4\u1BB9\x05\u057C\u02BF\x02\u1BB5\u1BB9\x05\u04FE" + + "\u0280\x02\u1BB6\u1BB9\x05\u0128\x95\x02\u1BB7\u1BB9\x05\u0552\u02AA\x02" + + "\u1BB8\u1BB3\x03\x02\x02\x02\u1BB8\u1BB4\x03\x02\x02\x02\u1BB8\u1BB5\x03" + + "\x02\x02\x02\u1BB8\u1BB6\x03\x02\x02\x02\u1BB8\u1BB7\x03\x02\x02\x02\u1BB9" + + "\u02F3\x03\x02\x02"; private static readonly _serializedATNSegment14: string = - "\x02\u1BF2\u1BF3\x07\u015C\x02\x02\u1BF3\u1BF4\x07\u013E\x02\x02\u1BF4" + - "\u1BF5\x07\xBB\x02\x02\u1BF5\u1BF6\x05\u020C\u0107\x02\u1BF6\u1BF7\x07" + - "\u0113\x02\x02\u1BF7\u1BF8\x07`\x02\x02\u1BF8\u1BF9\x05\u054C\u02A7\x02" + - "\u1BF9\u1C2A\x03\x02\x02\x02\u1BFA\u1BFB\x07\x8C\x02\x02\u1BFB\u1BFC\x07" + - "\u015C\x02\x02\u1BFC\u1BFD\x07\u013E\x02\x02\u1BFD\u1BFE\x07\xA5\x02\x02" + - "\u1BFE\u1BFF\x05\u020C\u0107\x02\u1BFF\u1C00\x07\u0113\x02\x02\u1C00\u1C01" + - "\x07`\x02\x02\u1C01\u1C02\x05\u054C\u02A7\x02\u1C02\u1C2A\x03\x02\x02" + - "\x02\u1C03\u1C04\x07\x8C\x02\x02\u1C04\u1C05\x07A\x02\x02\u1C05\u1C06" + - "\x07\xB0\x02\x02\u1C06\u1C07\x07\u0176\x02\x02\u1C07\u1C08\x05\u0530\u0299" + - "\x02\u1C08\u1C09\x07\u0113\x02\x02\u1C09\u1C0A\x07`\x02\x02\u1C0A\u1C0B" + - "\x05\u054C\u02A7\x02\u1C0B\u1C2A\x03\x02\x02\x02\u1C0C\u1C0D\x07\x8C\x02" + - "\x02\u1C0D\u1C0E\x07\u0144\x02\x02\u1C0E\u1C0F\x05\u0530\u0299\x02\u1C0F" + - "\u1C10\x07\u0113\x02\x02\u1C10\u1C11\x07`\x02\x02\u1C11\u1C12\x05\u054C" + - "\u02A7\x02\u1C12\u1C2A\x03\x02\x02\x02\u1C13\u1C14\x07\x8C\x02\x02\u1C14" + - "\u1C15\x07\xC8\x02\x02\u1C15\u1C16\x07\u015E\x02\x02\u1C16\u1C17\x05\u0530" + - "\u0299\x02\u1C17\u1C18\x07\u0113\x02\x02\u1C18\u1C19\x07`\x02\x02\u1C19" + - "\u1C1A\x05\u054C\u02A7\x02\u1C1A\u1C2A\x03\x02\x02\x02\u1C1B\u1C1C\x07" + - "\x8C\x02\x02\u1C1C\u1C1D\x07\u01BD\x02\x02\u1C1D\u1C1E\x05\u0530\u0299" + - "\x02\u1C1E\u1C1F\x07\u0113\x02\x02\u1C1F\u1C20\x07`\x02\x02\u1C20\u1C21" + - "\x05\u054C\u02A7\x02\u1C21\u1C2A\x03\x02\x02\x02\u1C22\u1C23\x07\x8C\x02" + - "\x02\u1C23\u1C24\x07\u01BC\x02\x02\u1C24\u1C25\x05\u0530\u0299\x02\u1C25" + - "\u1C26\x07\u0113\x02\x02\u1C26\u1C27\x07`\x02\x02\u1C27\u1C28\x05\u054C" + - "\u02A7\x02\u1C28\u1C2A\x03\x02\x02\x02\u1C29\u1B70\x03\x02\x02\x02\u1C29" + - "\u1B77\x03\x02\x02\x02\u1C29\u1B7E\x03\x02\x02\x02\u1C29\u1B85\x03\x02" + - "\x02\x02\u1C29\u1B8C\x03\x02\x02\x02\u1C29\u1B93\x03\x02\x02\x02\u1C29" + - "\u1B9A\x03\x02\x02\x02\u1C29\u1BA4\x03\x02\x02\x02\u1C29\u1BAC\x03\x02" + - "\x02\x02\u1C29\u1BB3\x03\x02\x02\x02\u1C29\u1BBD\x03\x02\x02\x02\u1C29" + - "\u1BC7\x03\x02\x02\x02\u1C29\u1BCE\x03\x02\x02\x02\u1C29\u1BD5\x03\x02" + - "\x02\x02\u1C29\u1BDC\x03\x02\x02\x02\u1C29\u1BE3\x03\x02\x02\x02\u1C29" + - "\u1BEA\x03\x02\x02\x02\u1C29\u1BF1\x03\x02\x02\x02\u1C29\u1BFA\x03\x02" + - "\x02\x02\u1C29\u1C03\x03\x02\x02\x02\u1C29\u1C0C\x03\x02\x02\x02\u1C29" + - "\u1C13\x03\x02\x02\x02\u1C29\u1C1B\x03\x02\x02\x02\u1C29\u1C22\x03\x02" + - "\x02\x02\u1C2A\u02E9\x03\x02\x02\x02\u1C2B\u1C2C\x070\x02\x02\u1C2C\u1C2D" + - "\x07\u01BD\x02\x02\u1C2D\u1C2F\x05\u0530\u0299\x02\u1C2E\u1C30\x05\u02EC" + - "\u0177\x02\u1C2F\u1C2E\x03\x02\x02\x02\u1C2F\u1C30\x03\x02\x02\x02\u1C30" + - "\u1C32\x03\x02\x02\x02\u1C31\u1C33\x05\u0298\u014D\x02\u1C32\u1C31\x03" + - "\x02\x02\x02\u1C32\u1C33\x03\x02\x02\x02\u1C33\u02EB\x03\x02\x02\x02\u1C34" + - "\u1C35\x05\u02EE\u0178\x02\u1C35\u02ED\x03\x02\x02\x02\u1C36\u1C37\x07" + - "@\x02\x02\u1C37\u1C38\x07^\x02\x02\u1C38\u1C3D\x05\u042A\u0216\x02\u1C39" + - "\u1C3A\x07@\x02\x02\u1C3A\u1C3B\x07 \x02\x02\u1C3B\u1C3D\x07\u0157\x02" + - "\x02\u1C3C\u1C36\x03\x02\x02\x02\u1C3C\u1C39\x03\x02\x02\x02\u1C3D\u02EF" + - "\x03\x02\x02\x02\u1C3E\u1C3F\x07\x8C\x02\x02\u1C3F\u1C40\x07\u01BD\x02" + - "\x02\u1C40\u1C41\x05\u0530\u0299\x02\u1C41\u1C42\x07\u0146\x02\x02\u1C42" + - "\u1C43\x05\u01CC\xE7\x02\u1C43\u1C5A\x03\x02\x02\x02\u1C44\u1C45\x07\x8C" + - "\x02\x02\u1C45\u1C46\x07\u01BD\x02\x02\u1C46\u1C47\x05\u0530\u0299\x02" + - "\u1C47\u1C48\x07\x87\x02\x02\u1C48\u1C49\x07^\x02\x02\u1C49\u1C4A\x05" + - "\u042A\u0216\x02\u1C4A\u1C5A\x03\x02\x02\x02\u1C4B\u1C4C\x07\x8C\x02\x02" + - "\u1C4C\u1C4D\x07\u01BD\x02\x02\u1C4D\u1C4E\x05\u0530\u0299\x02\u1C4E\u1C4F" + - "\x07\u0146\x02\x02\u1C4F\u1C50\x07^\x02\x02\u1C50\u1C51\x05\u042A\u0216" + - "\x02\u1C51\u1C5A\x03\x02\x02\x02\u1C52\u1C53\x07\x8C\x02\x02\u1C53\u1C54" + - "\x07\u01BD\x02\x02\u1C54\u1C55\x05\u0530\u0299\x02\u1C55\u1C56\x07\xC1" + - "\x02\x02\u1C56\u1C57\x07^\x02\x02\u1C57\u1C58\x05\u042A\u0216\x02\u1C58" + - "\u1C5A\x03\x02\x02\x02\u1C59\u1C3E\x03\x02\x02\x02\u1C59\u1C44\x03\x02" + - "\x02\x02\u1C59\u1C4B\x03\x02\x02\x02\u1C59\u1C52\x03\x02\x02\x02\u1C5A" + - "\u02F1\x03\x02\x02\x02\u1C5B\u1C5C\x070\x02\x02\u1C5C\u1C5D\x07\u01BC" + - "\x02\x02\u1C5D\u1C5E\x05\u0530\u0299\x02\u1C5E\u1C5F\x07\xA6\x02\x02\u1C5F" + - "\u1C60\x05\u0542\u02A2\x02\u1C60\u1C61\x07\u01BD\x02\x02\u1C61\u1C63\x05" + - "\u02F4\u017B\x02\u1C62\u1C64\x05\u0298\u014D\x02\u1C63\u1C62\x03\x02\x02" + - "\x02\u1C63\u1C64\x03\x02\x02\x02\u1C64\u02F3\x03\x02\x02\x02\u1C65\u1C6A" + - "\x05\u02F6\u017C\x02\u1C66\u1C67\x07\b\x02\x02\u1C67\u1C69\x05\u02F6\u017C" + - "\x02\u1C68\u1C66\x03\x02\x02\x02\u1C69\u1C6C\x03\x02\x02\x02\u1C6A\u1C68" + - "\x03\x02\x02\x02\u1C6A\u1C6B\x03\x02\x02\x02\u1C6B\u02F5\x03\x02\x02\x02" + - "\u1C6C\u1C6A\x03\x02\x02\x02\u1C6D\u1C6E\x05\u0556\u02AC\x02\u1C6E\u02F7" + - "\x03\x02\x02\x02\u1C6F\u1C70\x07\x8C\x02\x02\u1C70\u1C71\x07\u01BC\x02" + - "\x02\u1C71\u1C72\x05\u0530\u0299\x02\u1C72\u1C73\x07\u0146\x02\x02\u1C73" + - "\u1C74\x05\u01CC\xE7\x02\u1C74\u1C97\x03\x02\x02\x02\u1C75\u1C76\x07\x8C" + - "\x02\x02\u1C76\u1C77\x07\u01BC\x02\x02\u1C77\u1C78\x05\u0530\u0299\x02" + - "\u1C78\u1C79\x07\xA6\x02\x02\u1C79\u1C7A\x05\u0542\u02A2\x02\u1C7A\u1C97" + - "\x03\x02\x02\x02\u1C7B\u1C7C\x07\x8C\x02\x02\u1C7C\u1C7D\x07\u01BC\x02" + - "\x02\u1C7D\u1C7E\x05\u0530\u0299\x02\u1C7E\u1C7F\x07\u012A\x02\x02\u1C7F" + - "\u1C81\x07\u01BD\x02\x02\u1C80\u1C82\x05\u0298\u014D\x02\u1C81\u1C80\x03" + - "\x02\x02\x02\u1C81\u1C82\x03\x02\x02\x02\u1C82\u1C97\x03\x02\x02\x02\u1C83" + - "\u1C84\x07\x8C\x02\x02\u1C84\u1C85\x07\u01BC\x02\x02\u1C85\u1C86\x05\u0530" + - "\u0299\x02\u1C86\u1C87\x07\u0146\x02\x02\u1C87\u1C88\x07\u01BD\x02\x02" + - "\u1C88\u1C8A\x05\u02F4\u017B\x02\u1C89\u1C8B\x05\u0298\u014D\x02\u1C8A" + - "\u1C89\x03\x02\x02\x02\u1C8A\u1C8B\x03\x02\x02\x02\u1C8B\u1C97\x03\x02" + - "\x02\x02\u1C8C\u1C8D\x07\x8C\x02\x02\u1C8D\u1C8E\x07\u01BC\x02\x02\u1C8E" + - "\u1C8F\x05\u0530\u0299\x02\u1C8F\u1C90\x07\xC3\x02\x02\u1C90\u1C97\x03" + - "\x02\x02\x02\u1C91\u1C92\x07\x8C\x02\x02\u1C92\u1C93\x07\u01BC\x02\x02" + - "\u1C93\u1C94\x05\u0530\u0299\x02\u1C94\u1C95\x07\xBC\x02\x02\u1C95\u1C97" + - "\x03\x02\x02\x02\u1C96\u1C6F\x03\x02\x02\x02\u1C96\u1C75\x03\x02\x02\x02" + - "\u1C96\u1C7B\x03\x02\x02\x02\u1C96\u1C83\x03\x02\x02\x02\u1C96\u1C8C\x03" + - "\x02\x02\x02\u1C96\u1C91\x03\x02\x02\x02\u1C97\u02F9\x03\x02\x02\x02\u1C98" + - "\u1C99\x07\xC1\x02\x02\u1C99\u1C9A\x07\u01BC\x02\x02\u1C9A\u1C9C\x05\u0530" + - "\u0299\x02\u1C9B\u1C9D\x05l7\x02\u1C9C\u1C9B\x03\x02\x02\x02\u1C9C\u1C9D" + - "\x03\x02\x02\x02\u1C9D\u1CA7\x03\x02\x02\x02\u1C9E\u1C9F\x07\xC1\x02\x02" + - "\u1C9F\u1CA0\x07\u01BC\x02\x02\u1CA0\u1CA1\x07\xDE\x02\x02\u1CA1\u1CA2" + - "\x07\u0185\x02\x02\u1CA2\u1CA4\x05\u0530\u0299\x02\u1CA3\u1CA5\x05l7\x02" + - "\u1CA4\u1CA3\x03\x02\x02\x02\u1CA4\u1CA5\x03\x02\x02\x02\u1CA5\u1CA7\x03" + - "\x02\x02\x02\u1CA6\u1C98\x03\x02\x02\x02\u1CA6\u1C9E\x03\x02\x02\x02\u1CA7" + - "\u02FB\x03\x02\x02\x02\u1CA8\u1CAA\x070\x02\x02\u1CA9\u1CAB\x05\u026A" + - "\u0136\x02\u1CAA\u1CA9\x03\x02\x02\x02\u1CAA\u1CAB\x03\x02\x02\x02\u1CAB" + - "\u1CAC\x03\x02\x02\x02\u1CAC\u1CAD\x07\u013A\x02\x02\u1CAD\u1CAE\x05\u0530" + - "\u0299\x02\u1CAE\u1CAF\x07&\x02\x02\u1CAF\u1CB0\x07R\x02\x02\u1CB0\u1CB1" + - "\x05\u0306\u0184\x02\u1CB1\u1CB2\x07`\x02\x02\u1CB2\u1CB4\x05\u052C\u0297" + - "\x02\u1CB3\u1CB5\x05\u043C\u021F\x02\u1CB4\u1CB3\x03\x02\x02\x02\u1CB4" + - "\u1CB5\x03\x02\x02\x02\u1CB5\u1CB6\x03\x02\x02\x02\u1CB6\u1CB8\x07;\x02" + - "\x02\u1CB7\u1CB9\x05\u0308\u0185\x02\u1CB8\u1CB7\x03\x02\x02\x02\u1CB8" + - "\u1CB9\x03\x02\x02\x02\u1CB9\u1CBA\x03\x02\x02\x02\u1CBA\u1CBB\x05\u02FE" + - "\u0180\x02\u1CBB\u02FD\x03\x02\x02\x02\u1CBC\u1CC3\x07\u0107\x02\x02\u1CBD" + - "\u1CC3\x05\u0302\u0182\x02\u1CBE\u1CBF\x07\x04\x02\x02\u1CBF\u1CC0\x05" + - "\u0300\u0181\x02\u1CC0\u1CC1\x07\x05\x02\x02\u1CC1\u1CC3\x03\x02\x02\x02" + - "\u1CC2\u1CBC\x03\x02\x02\x02\u1CC2\u1CBD\x03\x02\x02\x02\u1CC2\u1CBE\x03" + - "\x02\x02\x02\u1CC3\u02FF\x03\x02\x02\x02\u1CC4\u1CC6\x05\u0304\u0183\x02" + - "\u1CC5\u1CC4\x03\x02\x02\x02\u1CC5\u1CC6\x03\x02\x02\x02\u1CC6\u1CCD\x03" + - "\x02\x02\x02\u1CC7\u1CC9\x07\t\x02\x02\u1CC8\u1CCA\x05\u0304\u0183\x02" + - "\u1CC9\u1CC8\x03\x02\x02\x02\u1CC9\u1CCA\x03\x02\x02\x02\u1CCA\u1CCC\x03" + - "\x02\x02\x02\u1CCB\u1CC7\x03\x02\x02\x02\u1CCC\u1CCF\x03\x02\x02\x02\u1CCD" + - "\u1CCB\x03\x02\x02\x02\u1CCD\u1CCE\x03\x02\x02\x02\u1CCE\u0301\x03\x02" + - "\x02\x02\u1CCF\u1CCD\x03\x02\x02\x02\u1CD0\u1CD6\x05\u03B8\u01DD\x02\u1CD1" + - "\u1CD6\x05\u0386\u01C4\x02\u1CD2\u1CD6\x05\u03A6\u01D4\x02\u1CD3\u1CD6" + - "\x05\u0398\u01CD\x02\u1CD4\u1CD6\x05\u030A\u0186\x02\u1CD5\u1CD0\x03\x02" + - "\x02\x02\u1CD5\u1CD1\x03\x02\x02\x02\u1CD5\u1CD2\x03\x02\x02\x02\u1CD5" + - "\u1CD3\x03\x02\x02\x02\u1CD5\u1CD4\x03\x02\x02\x02\u1CD6\u0303\x03\x02" + - "\x02\x02\u1CD7\u1CD8\x05\u0302\u0182\x02\u1CD8\u0305\x03\x02\x02\x02\u1CD9" + - "\u1CDA\t!\x02\x02\u1CDA\u0307\x03\x02\x02\x02\u1CDB\u1CDC\t\"\x02\x02" + - "\u1CDC\u0309\x03\x02\x02\x02\u1CDD\u1CDE\x07\u0108\x02\x02\u1CDE\u1CE0" + - "\x05\u0550\u02A9\x02\u1CDF\u1CE1\x05\u030C\u0187\x02\u1CE0\u1CDF\x03\x02" + - "\x02\x02\u1CE0\u1CE1\x03\x02\x02\x02\u1CE1\u030B\x03\x02\x02\x02\u1CE2" + - "\u1CE3\x07\b\x02\x02\u1CE3\u1CE4\x05\u0542\u02A2\x02\u1CE4\u030D\x03\x02" + - "\x02\x02\u1CE5\u1CE6\x07\xF5\x02\x02\u1CE6\u1CE7\x05\u0550\u02A9\x02\u1CE7" + - "\u030F\x03\x02\x02\x02\u1CE8\u1CE9\x07\u0167\x02\x02\u1CE9\u1CED\x05\u0550" + - "\u02A9\x02\u1CEA\u1CEB\x07\u0167\x02\x02\u1CEB\u1CED\x07\v\x02\x02\u1CEC" + - "\u1CE8\x03\x02\x02\x02\u1CEC\u1CEA\x03\x02\x02\x02\u1CED\u0311\x03\x02" + - "\x02\x02\u1CEE\u1CF0\x07\x83\x02\x02\u1CEF\u1CF1\x05\u0314\u018B\x02\u1CF0" + - "\u1CEF\x03\x02\x02\x02\u1CF0\u1CF1\x03\x02\x02\x02\u1CF1\u1CF3\x03\x02" + - "\x02\x02\u1CF2\u1CF4\x05\u031C\u018F\x02\u1CF3\u1CF2\x03\x02\x02\x02\u1CF3" + - "\u1CF4\x03\x02\x02\x02\u1CF4\u1D34\x03\x02\x02\x02\u1CF5\u1CF7\x07\x94" + - "\x02\x02\u1CF6\u1CF8\x05\u0314\u018B\x02\u1CF7\u1CF6\x03\x02\x02\x02\u1CF7" + - "\u1CF8\x03\x02\x02\x02\u1CF8\u1CFA\x03\x02\x02\x02\u1CF9\u1CFB\x05\u031A" + - "\u018E\x02\u1CFA\u1CF9\x03\x02\x02\x02\u1CFA\u1CFB\x03\x02\x02\x02\u1CFB" + - "\u1D34\x03\x02\x02\x02\u1CFC\u1CFD\x07\u014D\x02\x02\u1CFD\u1CFF\x07\u015D" + - "\x02\x02\u1CFE\u1D00\x05\u031A\u018E\x02\u1CFF\u1CFE\x03\x02\x02\x02\u1CFF" + - "\u1D00\x03\x02\x02\x02\u1D00\u1D34\x03\x02\x02\x02\u1D01\u1D03\x07\xA3" + - "\x02\x02\u1D02\u1D04\x05\u0314\u018B\x02\u1D03\u1D02\x03\x02\x02\x02\u1D03" + - "\u1D04\x03\x02\x02\x02\u1D04\u1D06\x03\x02\x02\x02\u1D05\u1D07\x05\u031C" + - "\u018F\x02\u1D06\u1D05\x03\x02\x02\x02\u1D06\u1D07\x03\x02\x02\x02\u1D07" + - "\u1D34\x03\x02\x02\x02\u1D08\u1D0A\x07\u01BF\x02\x02\u1D09\u1D0B\x05\u0314" + - "\u018B\x02\u1D0A\u1D09\x03\x02\x02\x02\u1D0A\u1D0B\x03\x02\x02\x02\u1D0B" + - "\u1D0D\x03\x02\x02\x02\u1D0C\u1D0E\x05\u031C\u018F\x02\u1D0D\u1D0C\x03" + - "\x02\x02\x02\u1D0D\u1D0E\x03\x02\x02\x02\u1D0E\u1D34\x03\x02\x02\x02\u1D0F" + - "\u1D11\x07\u0138\x02\x02\u1D10\u1D12\x05\u0314\u018B\x02\u1D11\u1D10\x03" + - "\x02\x02\x02\u1D11\u1D12\x03\x02\x02\x02\u1D12\u1D14\x03\x02\x02\x02\u1D13" + - "\u1D15\x05\u031C\u018F\x02\u1D14\u1D13\x03\x02\x02\x02\u1D14\u1D15\x03" + - "\x02\x02\x02\u1D15\u1D34\x03\x02\x02\x02\u1D16\u1D17\x07\u013B\x02\x02" + - "\u1D17\u1D34\x05\u0550\u02A9\x02\u1D18\u1D19\x07\u012D\x02\x02\u1D19\u1D1A" + - "\x07\u013B\x02\x02\u1D1A\u1D34\x05\u0550\u02A9\x02\u1D1B\u1D1C\x07\u012D" + - "\x02\x02\u1D1C\u1D34\x05\u0550\u02A9\x02\u1D1D\u1D1F\x07\u0138\x02\x02" + - "\u1D1E\u1D20\x05\u0314\u018B\x02\u1D1F\u1D1E\x03\x02\x02\x02\u1D1F\u1D20" + - "\x03\x02\x02\x02\u1D20\u1D21\x03\x02\x02\x02\u1D21\u1D22\x07`\x02\x02" + - "\u1D22\u1D23\x07\u013B\x02\x02\u1D23\u1D34\x05\u0550\u02A9\x02\u1D24\u1D26" + - "\x07\u0138\x02\x02\u1D25\u1D27\x05\u0314\u018B\x02\u1D26\u1D25\x03\x02" + - "\x02\x02\u1D26\u1D27\x03\x02\x02\x02\u1D27\u1D28\x03\x02\x02\x02\u1D28" + - "\u1D29\x07`\x02\x02\u1D29\u1D34\x05\u0550\u02A9\x02\u1D2A\u1D2B\x07\u011B" + - "\x02\x02\u1D2B\u1D2C\x07\u015D\x02\x02\u1D2C\u1D34\x05\u0542\u02A2\x02" + - "\u1D2D\u1D2E\x07\xA3\x02\x02\u1D2E\u1D2F\x07\u011C\x02\x02\u1D2F\u1D34" + - "\x05\u0542\u02A2\x02\u1D30\u1D31\x07\u0138\x02\x02\u1D31\u1D32\x07\u011C" + - "\x02\x02\u1D32\u1D34\x05\u0542\u02A2\x02\u1D33\u1CEE\x03\x02\x02\x02\u1D33" + - "\u1CF5\x03\x02\x02\x02\u1D33\u1CFC\x03\x02\x02\x02\u1D33\u1D01\x03\x02" + - "\x02\x02\u1D33\u1D08\x03\x02\x02\x02\u1D33\u1D0F\x03\x02\x02\x02\u1D33" + - "\u1D16\x03\x02\x02\x02\u1D33\u1D18\x03\x02\x02\x02\u1D33\u1D1B\x03\x02" + - "\x02\x02\u1D33\u1D1D\x03\x02\x02\x02\u1D33\u1D24\x03\x02\x02\x02\u1D33" + - "\u1D2A\x03\x02\x02\x02\u1D33\u1D2D\x03\x02\x02\x02\u1D33\u1D30\x03\x02" + - "\x02\x02\u1D34\u0313\x03\x02\x02\x02\u1D35\u1D36\t#\x02\x02\u1D36\u0315" + - "\x03\x02\x02\x02\u1D37\u1D38\x07\xED\x02\x02\u1D38\u1D39\x07\xF4\x02\x02" + - "\u1D39\u1D42\x05@!\x02\u1D3A\u1D3B\x07\u0125\x02\x02\u1D3B\u1D42\x07S" + - "\x02\x02\u1D3C\u1D3D\x07\u0125\x02\x02\u1D3D\u1D42\x07\u0177\x02\x02\u1D3E" + - "\u1D42\x078\x02\x02\u1D3F\u1D40\x07O\x02\x02\u1D40\u1D42\x078\x02\x02" + - "\u1D41\u1D37\x03\x02\x02\x02\u1D41\u1D3A\x03\x02\x02\x02\u1D41\u1D3C\x03" + - "\x02\x02\x02\u1D41\u1D3E\x03\x02\x02\x02\u1D41\u1D3F\x03\x02\x02\x02\u1D42" + - "\u0317\x03\x02\x02\x02\u1D43\u1D4A\x05\u0316\u018C\x02\u1D44\u1D46\x07" + - "\b\x02\x02\u1D45\u1D44\x03\x02\x02\x02\u1D45\u1D46\x03\x02\x02\x02\u1D46" + - "\u1D47\x03\x02\x02\x02\u1D47\u1D49\x05\u0316\u018C\x02\u1D48\u1D45\x03" + - "\x02\x02\x02\u1D49\u1D4C\x03\x02\x02\x02\u1D4A\u1D48\x03\x02\x02\x02\u1D4A" + - "\u1D4B\x03\x02\x02\x02\u1D4B\u0319\x03\x02\x02\x02\u1D4C\u1D4A\x03\x02" + - "\x02\x02\u1D4D\u1D4E\x05\u0318\u018D\x02\u1D4E\u031B\x03\x02\x02\x02\u1D4F" + - "\u1D51\x07#\x02\x02\u1D50\u1D52\x07\u0106\x02\x02\u1D51\u1D50\x03\x02" + - "\x02\x02\u1D51\u1D52\x03\x02\x02\x02\u1D52\u1D53\x03\x02\x02\x02\u1D53" + - "\u1D54\x07\x9B\x02\x02\u1D54\u031D\x03\x02\x02\x02\u1D55\u1D58\x070\x02" + - "\x02\u1D56\u1D57\x07T\x02\x02\u1D57\u1D59\x07\u0130\x02\x02\u1D58\u1D56" + - "\x03\x02\x02\x02\u1D58\u1D59\x03\x02\x02\x02\u1D59\u1D5B\x03\x02\x02\x02" + - "\u1D5A\u1D5C\x05\xAEX\x02\u1D5B\u1D5A\x03\x02\x02\x02\u1D5B\u1D5C\x03" + - "\x02\x02\x02\u1D5C\u1D6E\x03\x02\x02\x02\u1D5D\u1D5E\x07\u0171\x02\x02" + - "\u1D5E\u1D60\x05\u052C\u0297\x02\u1D5F\u1D61\x05\xD6l\x02\u1D60\u1D5F" + - "\x03\x02\x02\x02\u1D60\u1D61\x03\x02\x02\x02\u1D61\u1D63\x03\x02\x02\x02" + - "\u1D62\u1D64\x05v<\x02\u1D63\u1D62\x03\x02\x02\x02\u1D63\u1D64\x03\x02" + - "\x02\x02\u1D64\u1D6F\x03\x02\x02\x02\u1D65\u1D66\x07\u0128\x02\x02\u1D66" + - "\u1D67\x07\u0171\x02\x02\u1D67\u1D68\x05\u052C\u0297\x02\u1D68\u1D69\x07" + - "\x04\x02\x02\u1D69\u1D6A\x05\xD8m\x02\u1D6A\u1D6C\x07\x05\x02\x02\u1D6B" + - "\u1D6D\x05v<\x02\u1D6C\u1D6B\x03\x02\x02\x02\u1D6C\u1D6D\x03\x02\x02\x02" + - "\u1D6D\u1D6F\x03\x02\x02\x02\u1D6E\u1D5D\x03\x02\x02\x02\u1D6E\u1D65\x03" + - "\x02\x02\x02\u1D6F\u1D70\x03\x02\x02\x02\u1D70\u1D71\x07&\x02\x02\u1D71" + - "\u1D73\x05\u03B8\u01DD\x02\u1D72\u1D74\x05\u0320\u0191\x02\u1D73\u1D72" + - "\x03\x02\x02\x02\u1D73\u1D74\x03\x02\x02\x02\u1D74\u031F\x03\x02\x02\x02" + - "\u1D75\u1D77\x07k\x02\x02\u1D76\u1D78\t$\x02\x02\u1D77\u1D76\x03\x02\x02" + - "\x02\u1D77\u1D78\x03\x02\x02\x02\u1D78\u1D79\x03\x02\x02\x02\u1D79\u1D7A" + - "\x07,\x02\x02\u1D7A\u1D7B\x07\u0110\x02\x02\u1D7B\u0321\x03\x02\x02\x02" + - "\u1D7C\u1D7D\x07\xF6\x02\x02\u1D7D\u1D7E\x05\u0534\u029B\x02\u1D7E\u0323" + - "\x03\x02\x02\x02\u1D7F\u1D80\x070\x02\x02\u1D80\u1D81\x07\xB1\x02\x02" + - "\u1D81\u1D83\x05\u0530\u0299\x02\u1D82\u1D84\x05\x10\t\x02\u1D83\u1D82" + - "\x03\x02\x02\x02\u1D83\u1D84\x03\x02\x02\x02\u1D84\u1D86\x03\x02\x02\x02" + - "\u1D85\u1D87\x05\u0326\u0194\x02\u1D86\u1D85\x03\x02\x02\x02\u1D86\u1D87" + - "\x03\x02\x02\x02\u1D87\u0325\x03\x02\x02\x02\u1D88\u1D89\x05\u0328\u0195" + - "\x02\u1D89\u0327\x03\x02\x02\x02\u1D8A\u1D8C\x05\u032A\u0196\x02\u1D8B" + - "\u1D8A\x03\x02\x02\x02\u1D8C\u1D8D\x03\x02\x02\x02\u1D8D\u1D8B\x03\x02" + - "\x02\x02\u1D8D\u1D8E\x03\x02\x02\x02\u1D8E\u0329\x03\x02\x02\x02\u1D8F" + - "\u1D91\x05\u032C\u0197\x02\u1D90\u1D92\x05\u032E\u0198\x02\u1D91\u1D90" + - "\x03\x02\x02\x02\u1D91\u1D92\x03\x02\x02\x02\u1D92\u1D96\x03\x02\x02\x02" + - "\u1D93\u1D97\x05\u0548\u02A5\x02\u1D94\u1D97\x05B\"\x02\u1D95\u1D97\x07" + - "7\x02\x02\u1D96\u1D93\x03\x02\x02\x02\u1D96\u1D94\x03\x02\x02\x02\u1D96" + - "\u1D95\x03\x02\x02\x02\u1D97\u032B\x03\x02\x02\x02\u1D98\u1DA1\x05\u0558" + - "\u02AD\x02\u1D99\u1D9A\x07\xA6\x02\x02\u1D9A\u1DA1\x07L\x02\x02\u1D9B" + - "\u1DA1\x07\xC4\x02\x02\u1D9C\u1DA1\x07\xF8\x02\x02\u1D9D\u1DA1\x07\u0113" + - "\x02\x02\u1D9E\u1DA1\x07\u0158\x02\x02\u1D9F\u1DA1\x07\u015A\x02\x02\u1DA0" + - "\u1D98\x03\x02\x02\x02\u1DA0\u1D99\x03\x02\x02\x02\u1DA0\u1D9B\x03\x02" + - "\x02\x02\u1DA0\u1D9C\x03\x02\x02\x02\u1DA0\u1D9D\x03\x02\x02\x02\u1DA0" + - "\u1D9E\x03\x02\x02\x02\u1DA0\u1D9F\x03\x02\x02\x02\u1DA1\u032D\x03\x02" + - "\x02\x02\u1DA2\u1DA3\x07\f\x02\x02\u1DA3\u032F\x03\x02\x02\x02\u1DA4\u1DA5" + - "\x07\x8C\x02\x02\u1DA5\u1DA6\x07\xB1\x02\x02\u1DA6\u1DB1\x05\u0530\u0299" + - "\x02\u1DA7\u1DA9\x07k\x02\x02\u1DA8\u1DAA\x05\u0326\u0194\x02\u1DA9\u1DA8" + - "\x03\x02\x02\x02\u1DA9\u1DAA\x03\x02\x02\x02\u1DAA\u1DB2\x03\x02\x02\x02" + - "\u1DAB\u1DAD\x05\u0326\u0194\x02\u1DAC\u1DAB\x03\x02\x02\x02\u1DAC\u1DAD" + - "\x03\x02\x02\x02\u1DAD\u1DB2\x03\x02\x02\x02\u1DAE\u1DAF\x07\u0146\x02" + - "\x02\u1DAF\u1DB0\x07\u0158\x02\x02\u1DB0\u1DB2\x05\u0530\u0299\x02\u1DB1" + - "\u1DA7\x03\x02\x02\x02\u1DB1\u1DAC\x03\x02\x02\x02\u1DB1\u1DAE\x03\x02" + - "\x02\x02\u1DB2\u0331\x03\x02\x02\x02\u1DB3\u1DB4\x07\x8C\x02\x02\u1DB4" + - "\u1DB5\x07\xB1\x02\x02\u1DB5\u1DB6\x05\u0530\u0299\x02\u1DB6\u1DB7\x05" + - "P)\x02\u1DB7\u0333\x03\x02\x02\x02\u1DB8\u1DB9\x07\xC1\x02\x02\u1DB9\u1DBC" + - "\x07\xB1\x02\x02\u1DBA\u1DBB\x07\xDE\x02\x02\u1DBB\u1DBD\x07\u0185\x02" + - "\x02\u1DBC\u1DBA\x03\x02\x02\x02\u1DBC\u1DBD\x03\x02\x02\x02\u1DBD\u1DBE" + - "\x03\x02\x02\x02\u1DBE\u1DC6\x05\u0530\u0299\x02\u1DBF\u1DC1\x05\x10\t" + - "\x02\u1DC0\u1DBF\x03\x02\x02\x02\u1DC0\u1DC1\x03\x02\x02\x02\u1DC1\u1DC2" + - "\x03\x02\x02\x02\u1DC2\u1DC3\x07\x04\x02\x02\u1DC3\u1DC4\x05\u0336\u019C" + - "\x02\u1DC4\u1DC5\x07\x05\x02\x02\u1DC5\u1DC7\x03\x02\x02\x02\u1DC6\u1DC0" + - "\x03\x02\x02\x02\u1DC6\u1DC7\x03\x02\x02\x02\u1DC7\u0335\x03\x02\x02\x02" + - "\u1DC8\u1DCD\x05\u0338\u019D\x02\u1DC9\u1DCA\x07\b\x02\x02\u1DCA\u1DCC" + - "\x05\u0338\u019D\x02\u1DCB\u1DC9\x03\x02\x02\x02\u1DCC\u1DCF\x03\x02\x02" + - "\x02\u1DCD\u1DCB\x03\x02\x02\x02\u1DCD\u1DCE\x03\x02\x02\x02\u1DCE\u0337" + - "\x03\x02\x02\x02\u1DCF\u1DCD\x03\x02\x02\x02\u1DD0\u1DD1\x07\xD3\x02\x02" + - "\u1DD1\u0339\x03\x02\x02\x02\u1DD2\u1DD3\x07\x8C\x02\x02\u1DD3\u1DD4\x07" + - "n\x02\x02\u1DD4\u1DD5\x05\u020C\u0107\x02\u1DD5\u1DD6\x07\u012A\x02\x02" + - "\u1DD6\u1DD7\x07\u0170\x02\x02\u1DD7\u033B\x03\x02\x02\x02\u1DD8\u1DD9" + - "\x07\x8C\x02\x02\u1DD9\u1DDA\x07\u0156\x02\x02\u1DDA\u1DDB\t%\x02\x02" + - "\u1DDB\u1DDC\x056\x1C\x02\u1DDC\u033D\x03\x02\x02\x02\u1DDD\u1DDE\x07" + - "0\x02\x02\u1DDE\u1DDF\x07\xBF\x02\x02\u1DDF\u1DE1\x05\u020C\u0107\x02" + - "\u1DE0\u1DE2\x05\u0342\u01A2\x02\u1DE1\u1DE0\x03\x02\x02\x02\u1DE1\u1DE2" + - "\x03\x02\x02\x02\u1DE2\u1DE3\x03\x02\x02\x02\u1DE3\u1DE4\x05\u0454\u022B" + - "\x02\u1DE4\u1DE5\x05\xC0a\x02\u1DE5\u033F\x03\x02\x02\x02\u1DE6\u1DE7" + - "\x07\x8C\x02\x02\u1DE7\u1DE8\x07\xBF\x02\x02\u1DE8\u1DFF\x05\u020C\u0107" + - "\x02\u1DE9\u1E00\x05j6\x02\u1DEA\u1DEB\x07\xC1\x02\x02\u1DEB\u1DEC\x07" + - "O\x02\x02\u1DEC\u1E00\x07P\x02\x02\u1DED\u1DEE\x07\u0146\x02\x02\u1DEE" + - "\u1DEF\x07O\x02\x02\u1DEF\u1E00\x07P\x02\x02\u1DF0\u1DF1\x07\x87\x02\x02" + - "\u1DF1\u1E00\x05\xD0i\x02\u1DF2\u1DF3\x07\xC1\x02\x02\u1DF3\u1DF6\x07" + - "/\x02\x02\u1DF4\u1DF5\x07\xDE\x02\x02\u1DF5\u1DF7\x07\u0185\x02\x02\u1DF6" + - "\u1DF4\x03\x02\x02\x02\u1DF6\u1DF7\x03\x02\x02\x02\u1DF7\u1DF8\x03\x02" + - "\x02\x02\u1DF8\u1DFA\x05\u0530\u0299\x02\u1DF9\u1DFB\x05l7\x02\u1DFA\u1DF9" + - "\x03\x02\x02\x02\u1DFA\u1DFB\x03\x02\x02\x02\u1DFB\u1E00\x03\x02\x02\x02" + - "\u1DFC\u1DFD\x07\u016D\x02\x02\u1DFD\u1DFE\x07/\x02\x02\u1DFE\u1E00\x05" + - "\u0530\u0299\x02\u1DFF\u1DE9\x03\x02\x02\x02\u1DFF\u1DEA\x03\x02\x02\x02" + - "\u1DFF\u1DED\x03\x02\x02\x02\u1DFF\u1DF0\x03\x02\x02\x02\u1DFF\u1DF2\x03" + - "\x02\x02\x02\u1DFF\u1DFC\x03\x02\x02\x02\u1E00\u0341\x03\x02\x02\x02\u1E01" + - "\u1E02\x07&\x02\x02\u1E02\u0343\x03\x02\x02\x02\u1E03\u1E04\x07\x8C\x02" + - "\x02\u1E04\u1E05\x07\u015C\x02\x02\u1E05\u1E06\x07\u013E\x02\x02\u1E06" + - "\u1E07\x07\xBB\x02\x02\u1E07\u1E08\x05\u020C\u0107\x02\u1E08\u1E09\x05" + - "\u01CC\xE7\x02\u1E09\u0345\x03\x02\x02\x02\u1E0A\u1E0B\x07\x8C\x02\x02" + - "\u1E0B\u1E0C\x07\u015C\x02\x02\u1E0C\u1E0D\x07\u013E\x02\x02\u1E0D\u1E0E" + - "\x07\xA5\x02\x02\u1E0E\u1E0F\x05\u020C\u0107\x02\u1E0F\u1E10\x07\x87\x02" + - "\x02\u1E10\u1E11\x07\xFA\x02\x02\u1E11\u1E12\x07@\x02\x02\u1E12\u1E13" + - "\x05\u052E\u0298\x02\u1E13\u1E14\x05\u0348\u01A5\x02\u1E14\u1E15\x05\u020A" + - "\u0106\x02\u1E15\u1E53\x03\x02\x02\x02\u1E16\u1E17\x07\x8C\x02\x02\u1E17" + - "\u1E18\x07\u015C\x02\x02\u1E18\u1E19\x07\u013E\x02\x02\u1E19\u1E1A\x07" + - "\xA5\x02\x02\u1E1A\u1E1B\x05\u020C\u0107\x02\u1E1B\u1E1C\x07\x8C\x02\x02" + - "\u1E1C\u1E1D\x07\xFA\x02\x02\u1E1D\u1E1E\x07@\x02\x02\u1E1E\u1E1F\x05" + - "\u052E\u0298\x02\u1E1F\u1E20\x05\u0348\u01A5\x02\u1E20\u1E21\x05\u020A" + - "\u0106\x02\u1E21\u1E53\x03\x02\x02\x02\u1E22\u1E23\x07\x8C\x02\x02\u1E23" + - "\u1E24\x07\u015C\x02\x02\u1E24\u1E25\x07\u013E\x02\x02\u1E25\u1E26\x07" + - "\xA5\x02\x02\u1E26\u1E27\x05\u020C\u0107\x02\u1E27\u1E28\x07\x8C\x02\x02" + - "\u1E28\u1E29\x07\xFA\x02\x02\u1E29\u1E2A\x07\u0130\x02\x02\u1E2A\u1E2B" + - "\x05\u020C\u0107\x02\u1E2B\u1E2C\x05\u0348\u01A5\x02\u1E2C\u1E2D\x05\u020C" + - "\u0107\x02\u1E2D\u1E53\x03\x02\x02\x02\u1E2E\u1E2F\x07\x8C\x02\x02\u1E2F" + - "\u1E30\x07\u015C\x02\x02\u1E30\u1E31\x07\u013E\x02\x02\u1E31\u1E32\x07" + - "\xA5\x02\x02\u1E32\u1E33\x05\u020C\u0107\x02\u1E33\u1E34\x07\x8C\x02\x02" + - "\u1E34\u1E35\x07\xFA\x02\x02\u1E35\u1E36\x07@\x02\x02\u1E36\u1E37\x05" + - "\u052E\u0298\x02\u1E37\u1E38\x07\u0130\x02\x02\u1E38\u1E39\x05\u020C\u0107" + - "\x02\u1E39\u1E3A\x05\u0348\u01A5\x02\u1E3A\u1E3B\x05\u020C\u0107\x02\u1E3B" + - "\u1E53\x03\x02\x02\x02\u1E3C\u1E3D\x07\x8C\x02\x02\u1E3D\u1E3E\x07\u015C" + - "\x02\x02\u1E3E\u1E3F\x07\u013E\x02\x02\u1E3F\u1E40\x07\xA5\x02\x02\u1E40" + - "\u1E41\x05\u020C\u0107\x02\u1E41\u1E42\x07\xC1\x02\x02\u1E42\u1E43\x07" + - "\xFA\x02\x02\u1E43\u1E44\x07@\x02\x02\u1E44\u1E45\x05\u052E\u0298\x02" + - "\u1E45\u1E53\x03\x02\x02\x02\u1E46\u1E47\x07\x8C\x02\x02\u1E47\u1E48\x07" + - "\u015C\x02\x02\u1E48\u1E49\x07\u013E\x02\x02\u1E49\u1E4A\x07\xA5\x02\x02" + - "\u1E4A\u1E4B\x05\u020C\u0107\x02\u1E4B\u1E4C\x07\xC1\x02\x02\u1E4C\u1E4D" + - "\x07\xFA\x02\x02\u1E4D\u1E4E\x07\xDE\x02\x02\u1E4E\u1E4F\x07\u0185\x02" + - "\x02\u1E4F\u1E50\x07@\x02\x02\u1E50\u1E51\x05\u052E\u0298\x02\u1E51\u1E53" + - "\x03\x02\x02\x02\u1E52\u1E0A\x03\x02\x02\x02\u1E52\u1E16\x03\x02\x02\x02" + - "\u1E52\u1E22\x03\x02\x02\x02\u1E52\u1E2E\x03\x02\x02\x02\u1E52\u1E3C\x03" + - "\x02\x02\x02\u1E52\u1E46\x03\x02\x02\x02\u1E53\u0347\x03\x02\x02\x02\u1E54" + - "\u1E55\x07k\x02\x02\u1E55\u0349\x03\x02\x02\x02\u1E56\u1E58\x070\x02\x02" + - "\u1E57\u1E59\x05\u01E8\xF5\x02\u1E58\u1E57\x03\x02\x02\x02\u1E58\u1E59" + - "\x03\x02\x02\x02\u1E59\u1E5A\x03\x02\x02\x02\u1E5A\u1E5B\x07\xAA\x02\x02" + - "\u1E5B\u1E5C\x05\u020C\u0107\x02\u1E5C\u1E5D\x07@\x02\x02\u1E5D\u1E5E" + - "\x05\u0542\u02A2\x02\u1E5E\u1E5F\x07`\x02\x02\u1E5F\u1E60\x05\u0542\u02A2" + - "\x02\u1E60\u1E61\x07B\x02\x02\u1E61\u1E62\x05\u020C\u0107\x02\u1E62\u034B" + - "\x03\x02\x02\x02\u1E63\u1E65\x07\xA0\x02\x02\u1E64\u1E66\x05\u0360\u01B1" + - "\x02\u1E65\u1E64\x03\x02\x02\x02\u1E65\u1E66\x03\x02\x02\x02\u1E66\u1E67" + - "\x03\x02\x02\x02\u1E67\u1E69\x05\u052C\u0297\x02\u1E68\u1E6A\x05\u034E" + - "\u01A8\x02\u1E69\u1E68\x03\x02\x02\x02\u1E69\u1E6A\x03\x02\x02\x02\u1E6A" + - "\u1E78\x03\x02\x02\x02\u1E6B\u1E6D\x07\xA0\x02\x02\u1E6C\u1E6E\x05\u0360" + - "\u01B1\x02\u1E6D\u1E6C\x03\x02\x02\x02\u1E6D\u1E6E\x03\x02\x02\x02\u1E6E" + - "\u1E78\x03\x02\x02\x02\u1E6F\u1E71\x07\xA0\x02\x02\u1E70\u1E72\x05\u0360" + - "\u01B1\x02\u1E71\u1E70\x03\x02\x02\x02\u1E71\u1E72\x03\x02\x02\x02\u1E72" + - "\u1E73\x03\x02\x02\x02\u1E73\u1E74\x05\u0530\u0299\x02\u1E74\u1E75\x07" + - "R\x02\x02\u1E75\u1E76\x05\u052C\u0297\x02\u1E76\u1E78\x03\x02\x02\x02" + - "\u1E77\u1E63\x03\x02\x02\x02\u1E77\u1E6B\x03\x02\x02\x02\u1E77\u1E6F\x03" + - "\x02\x02\x02\u1E78\u034D\x03\x02\x02\x02\u1E79\u1E7A\x07f\x02\x02\u1E7A" + - "\u1E7B\x05\u0530\u0299\x02\u1E7B\u034F\x03\x02\x02\x02\u1E7C\u1E7E\x07" + - "\u016B\x02\x02\u1E7D\u1E7F\x05\u0362\u01B2\x02\u1E7E\u1E7D\x03\x02\x02" + - "\x02\u1E7E\u1E7F\x03\x02\x02\x02\u1E7F\u1E81\x03\x02\x02\x02\u1E80\u1E82" + - "\x05\u0364\u01B3\x02\u1E81\u1E80\x03\x02\x02\x02\u1E81\u1E82\x03\x02\x02" + - "\x02\u1E82\u1E84\x03\x02\x02\x02\u1E83\u1E85\x05\u0360\u01B1\x02\u1E84" + - "\u1E83\x03\x02\x02\x02\u1E84\u1E85\x03\x02\x02\x02\u1E85\u1E87\x03\x02" + - "\x02\x02\u1E86\u1E88\x05\u035E\u01B0\x02\u1E87\u1E86\x03\x02\x02\x02\u1E87" + - "\u1E88\x03\x02\x02\x02\u1E88\u1E8A\x03\x02\x02\x02\u1E89\u1E8B\x05\u036C" + - "\u01B7\x02\u1E8A\u1E89\x03\x02\x02\x02\u1E8A\u1E8B\x03\x02\x02\x02\u1E8B" + - "\u1E94\x03\x02\x02\x02\u1E8C\u1E8D\x07\u016B\x02\x02\u1E8D\u1E8E\x07\x04" + - "\x02\x02\u1E8E\u1E8F\x05\u0354\u01AB\x02\u1E8F\u1E91\x07\x05\x02\x02\u1E90" + - "\u1E92\x05\u036C\u01B7\x02\u1E91\u1E90\x03\x02\x02\x02\u1E91\u1E92\x03" + - "\x02\x02\x02\u1E92\u1E94\x03\x02\x02\x02\u1E93\u1E7C\x03\x02\x02\x02\u1E93" + - "\u1E8C\x03\x02\x02\x02\u1E94\u0351\x03\x02\x02\x02\u1E95\u1E97\x05\u0356" + - "\u01AC\x02\u1E96\u1E98\x05\u0360\u01B1\x02\u1E97\u1E96\x03\x02\x02\x02" + - "\u1E97\u1E98\x03\x02\x02\x02\u1E98\u1E9A\x03\x02\x02\x02\u1E99\u1E9B\x05" + - "\u036C\u01B7\x02\u1E9A\u1E99\x03\x02\x02\x02\u1E9A\u1E9B\x03\x02\x02\x02" + - "\u1E9B\u1EA4\x03\x02\x02\x02\u1E9C\u1E9D\x05\u0356\u01AC\x02\u1E9D\u1E9E" + - "\x07\x04\x02\x02\u1E9E\u1E9F\x05\u0354\u01AB\x02\u1E9F\u1EA1\x07\x05\x02" + - "\x02\u1EA0\u1EA2\x05\u036C\u01B7\x02\u1EA1\u1EA0\x03\x02\x02\x02\u1EA1"; + "\x02\u1BBA\u1BBB\x07\x8C\x02\x02\u1BBB\u1BBC\x07\u016A\x02\x02\u1BBC\u1BBD" + + "\x05\u0214\u010B\x02\u1BBD\u1BBE\x07\u014F\x02\x02\u1BBE\u1BBF\x07\x04" + + "\x02\x02\u1BBF\u1BC0\x05\u02EE\u0178\x02\u1BC0\u1BC1\x07\x05\x02\x02\u1BC1" + + "\u02F5\x03\x02\x02\x02\u1BC2\u1BC3\x07\x8C\x02\x02\u1BC3\u1BC4\x07\x8A" + + "\x02\x02\u1BC4\u1BC5\x05\u0298\u014D\x02\u1BC5\u1BC6\x07\u011C\x02\x02" + + "\u1BC6\u1BC7\x07`\x02\x02\u1BC7\u1BC8\x05\u055E\u02B0\x02\u1BC8\u1C7C" + + "\x03\x02\x02\x02\u1BC9\u1BCA\x07\x8C\x02\x02\u1BCA\u1BCB\x07n\x02\x02" + + "\u1BCB\u1BCC\x05\u0214\u010B\x02\u1BCC\u1BCD\x07\u011C\x02\x02\u1BCD\u1BCE" + + "\x07`\x02\x02\u1BCE\u1BCF\x05\u055E\u02B0\x02\u1BCF\u1C7C\x03\x02\x02" + + "\x02\u1BD0\u1BD1\x07\x8C\x02\x02\u1BD1\u1BD2\x07\xAA\x02\x02\u1BD2\u1BD3" + + "\x05\u0214\u010B\x02\u1BD3\u1BD4\x07\u011C\x02\x02\u1BD4\u1BD5\x07`\x02" + + "\x02\u1BD5\u1BD6\x05\u055E\u02B0\x02\u1BD6\u1C7C\x03\x02\x02\x02\u1BD7" + + "\u1BD8\x07\x8C\x02\x02\u1BD8\u1BD9\x07\xB1\x02\x02\u1BD9\u1BDA\x05\u0540" + + "\u02A1\x02\u1BDA\u1BDB\x07\u011C\x02\x02\u1BDB\u1BDC\x07`\x02\x02\u1BDC" + + "\u1BDD\x05\u055E\u02B0\x02\u1BDD\u1C7C\x03\x02\x02\x02\u1BDE\u1BDF\x07" + + "\x8C\x02\x02\u1BDF\u1BE0\x07\xBF\x02\x02\u1BE0\u1BE1\x05\u0214\u010B\x02" + + "\u1BE1\u1BE2\x07\u011C\x02\x02\u1BE2\u1BE3\x07`\x02\x02\u1BE3\u1BE4\x05" + + "\u055E\u02B0\x02\u1BE4\u1C7C\x03\x02\x02\x02\u1BE5\u1BE6\x07\x8C\x02\x02" + + "\u1BE6\u1BE7\x07\xD5\x02\x02\u1BE7\u1BE8\x05\u0280\u0141\x02\u1BE8\u1BE9" + + "\x07\u011C\x02\x02\u1BE9\u1BEA\x07`\x02\x02\u1BEA\u1BEB\x05\u055E\u02B0" + + "\x02\u1BEB\u1C7C\x03\x02\x02\x02\u1BEC\u1BEE\x07\x8C\x02\x02\u1BED\u1BEF" + + "\x05\u0138\x9D\x02\u1BEE\u1BED\x03\x02\x02\x02\u1BEE\u1BEF\x03\x02\x02" + + "\x02\u1BEF\u1BF0\x03\x02\x02\x02\u1BF0\u1BF1\x07\xF9\x02\x02\u1BF1\u1BF2" + + "\x05\u0540\u02A1\x02\u1BF2\u1BF3\x07\u011C\x02\x02\u1BF3\u1BF4\x07`\x02" + + "\x02\u1BF4\u1BF5\x05\u055E\u02B0\x02\u1BF5\u1C7C\x03\x02\x02\x02\u1BF6" + + "\u1BF7\x07\x8C\x02\x02\u1BF7\u1BF8\x07\xFA\x02\x02\u1BF8\u1BF9\x07\u0114" + + "\x02\x02\u1BF9\u1BFA\x05\u0128\x95\x02\u1BFA\u1BFB\x07\u011C\x02\x02\u1BFB" + + "\u1BFC\x07`\x02\x02\u1BFC\u1BFD\x05\u055E\u02B0\x02\u1BFD\u1C7C\x03\x02" + + "\x02\x02\u1BFE\u1BFF\x07\x8C\x02\x02\u1BFF\u1C00\x07\u0118\x02\x02\u1C00" + + "\u1C01\x05\u02BE\u0160\x02\u1C01\u1C02\x07\u011C\x02\x02\u1C02\u1C03\x07" + + "`\x02\x02\u1C03\u1C04\x05\u055E\u02B0\x02\u1C04\u1C7C\x03\x02\x02\x02" + + "\u1C05\u1C06\x07\x8C\x02\x02\u1C06\u1C07\x07\u0118\x02\x02\u1C07\u1C08" + + "\x07\x9E\x02\x02\u1C08\u1C09\x05\u0214\u010B\x02\u1C09\u1C0A\x07f\x02" + + "\x02\u1C0A\u1C0B\x05\u0540\u02A1\x02\u1C0B\u1C0C\x07\u011C\x02\x02\u1C0C" + + "\u1C0D\x07`\x02\x02\u1C0D\u1C0E\x05\u055E\u02B0\x02\u1C0E\u1C7C\x03\x02" + + "\x02\x02\u1C0F\u1C10\x07\x8C\x02\x02\u1C10\u1C11\x07\u0118\x02\x02\u1C11" + + "\u1C12\x07\xD0\x02\x02\u1C12\u1C13\x05\u0214\u010B\x02\u1C13\u1C14\x07" + + "f\x02\x02\u1C14\u1C15\x05\u0540\u02A1\x02\u1C15\u1C16\x07\u011C\x02\x02" + + "\u1C16\u1C17\x07`\x02\x02\u1C17\u1C18\x05\u055E\u02B0\x02\u1C18\u1C7C" + + "\x03\x02\x02\x02\u1C19\u1C1A\x07\x8C\x02\x02\u1C1A\u1C1B\x07\u012A\x02" + + "\x02\u1C1B\u1C1C\x05\u0280\u0141\x02\u1C1C\u1C1D\x07\u011C\x02\x02\u1C1D" + + "\u1C1E\x07`\x02\x02\u1C1E\u1C1F\x05\u055E\u02B0\x02\u1C1F\u1C7C\x03\x02" + + "\x02\x02\u1C20\u1C21\x07\x8C\x02\x02\u1C21\u1C22\x07\u01BC\x02\x02\u1C22" + + "\u1C23\x05\u0280\u0141\x02\u1C23\u1C24\x07\u011C\x02\x02\u1C24\u1C25\x07" + + "`\x02\x02\u1C25\u1C26\x05\u055E\u02B0\x02\u1C26\u1C7C\x03\x02\x02\x02" + + "\u1C27\u1C28\x07\x8C\x02\x02\u1C28\u1C29\x07\u0145\x02\x02\u1C29\u1C2A" + + "\x05\u0540\u02A1\x02\u1C2A\u1C2B\x07\u011C\x02\x02\u1C2B\u1C2C\x07`\x02" + + "\x02\u1C2C\u1C2D\x05\u055E\u02B0\x02\u1C2D\u1C7C\x03\x02\x02\x02\u1C2E" + + "\u1C2F\x07\x8C\x02\x02\u1C2F\u1C30\x07\u016A\x02\x02\u1C30\u1C31\x05\u0214" + + "\u010B\x02\u1C31\u1C32\x07\u011C\x02\x02\u1C32\u1C33\x07`\x02\x02\u1C33" + + "\u1C34\x05\u055E\u02B0\x02\u1C34\u1C7C\x03\x02\x02\x02\u1C35\u1C36\x07" + + "\x8C\x02\x02\u1C36\u1C37\x07\u0161\x02\x02\u1C37\u1C38\x05\u0540\u02A1" + + "\x02\u1C38\u1C39\x07\u011C\x02\x02\u1C39\u1C3A\x07`\x02\x02\u1C3A\u1C3B" + + "\x05\u055E\u02B0\x02\u1C3B\u1C7C\x03\x02\x02\x02\u1C3C\u1C3D\x07\x8C\x02" + + "\x02\u1C3D\u1C3E\x07\u0158\x02\x02\u1C3E\u1C3F\x05\u0214\u010B\x02\u1C3F" + + "\u1C40\x07\u011C\x02\x02\u1C40\u1C41\x07`\x02\x02\u1C41\u1C42\x05\u055E" + + "\u02B0\x02\u1C42\u1C7C\x03\x02\x02\x02\u1C43\u1C44\x07\x8C\x02\x02\u1C44" + + "\u1C45\x07\u0165\x02\x02\u1C45\u1C46\x07\u0147\x02\x02\u1C46\u1C47\x07" + + "\xBB\x02\x02\u1C47\u1C48\x05\u0214\u010B\x02\u1C48\u1C49\x07\u011C\x02" + + "\x02\u1C49\u1C4A\x07`\x02\x02\u1C4A\u1C4B\x05\u055E\u02B0\x02\u1C4B\u1C7C" + + "\x03\x02\x02\x02\u1C4C\u1C4D\x07\x8C\x02\x02\u1C4D\u1C4E\x07\u0165\x02" + + "\x02\u1C4E\u1C4F\x07\u0147\x02\x02\u1C4F\u1C50\x07\xA5\x02\x02\u1C50\u1C51" + + "\x05\u0214\u010B\x02\u1C51\u1C52\x07\u011C\x02\x02\u1C52\u1C53\x07`\x02" + + "\x02\u1C53\u1C54\x05\u055E\u02B0\x02\u1C54\u1C7C\x03\x02\x02\x02\u1C55" + + "\u1C56\x07\x8C\x02\x02\u1C56\u1C57\x07A\x02\x02\u1C57\u1C58\x07\xB0\x02" + + "\x02\u1C58\u1C59\x07\u017F\x02\x02\u1C59\u1C5A\x05\u0540\u02A1\x02\u1C5A" + + "\u1C5B\x07\u011C\x02\x02\u1C5B\u1C5C\x07`\x02\x02\u1C5C\u1C5D\x05\u055E" + + "\u02B0\x02\u1C5D\u1C7C\x03\x02\x02\x02\u1C5E\u1C5F\x07\x8C\x02\x02\u1C5F" + + "\u1C60\x07\u014D\x02\x02\u1C60\u1C61\x05\u0540\u02A1\x02\u1C61\u1C62\x07" + + "\u011C\x02\x02\u1C62\u1C63\x07`\x02\x02\u1C63\u1C64\x05\u055E\u02B0\x02" + + "\u1C64\u1C7C\x03\x02\x02\x02\u1C65\u1C66\x07\x8C\x02\x02\u1C66\u1C67\x07" + + "\xC8\x02\x02\u1C67\u1C68\x07\u0167\x02\x02\u1C68\u1C69\x05\u0540\u02A1" + + "\x02\u1C69\u1C6A\x07\u011C\x02\x02\u1C6A\u1C6B\x07`\x02\x02\u1C6B\u1C6C" + + "\x05\u055E\u02B0\x02\u1C6C\u1C7C\x03\x02\x02\x02\u1C6D\u1C6E\x07\x8C\x02" + + "\x02\u1C6E\u1C6F\x07\u01C6\x02\x02\u1C6F\u1C70\x05\u0540\u02A1\x02\u1C70" + + "\u1C71\x07\u011C\x02\x02\u1C71\u1C72\x07`\x02\x02\u1C72\u1C73\x05\u055E" + + "\u02B0\x02\u1C73\u1C7C\x03\x02\x02\x02\u1C74\u1C75\x07\x8C\x02\x02\u1C75" + + "\u1C76\x07\u01C5\x02\x02\u1C76\u1C77\x05\u0540\u02A1\x02\u1C77\u1C78\x07" + + "\u011C\x02\x02\u1C78\u1C79\x07`\x02\x02\u1C79\u1C7A\x05\u055E\u02B0\x02" + + "\u1C7A\u1C7C\x03\x02\x02\x02\u1C7B\u1BC2\x03\x02\x02\x02\u1C7B\u1BC9\x03" + + "\x02\x02\x02\u1C7B\u1BD0\x03\x02\x02\x02\u1C7B\u1BD7\x03\x02\x02\x02\u1C7B" + + "\u1BDE\x03\x02\x02\x02\u1C7B\u1BE5\x03\x02\x02\x02\u1C7B\u1BEC\x03\x02" + + "\x02\x02\u1C7B\u1BF6\x03\x02\x02\x02\u1C7B\u1BFE\x03\x02\x02\x02\u1C7B" + + "\u1C05\x03\x02\x02\x02\u1C7B\u1C0F\x03\x02\x02\x02\u1C7B\u1C19\x03\x02" + + "\x02\x02\u1C7B\u1C20\x03\x02\x02\x02\u1C7B\u1C27\x03\x02\x02\x02\u1C7B" + + "\u1C2E\x03\x02\x02\x02\u1C7B\u1C35\x03\x02\x02\x02\u1C7B\u1C3C\x03\x02" + + "\x02\x02\u1C7B\u1C43\x03\x02\x02\x02\u1C7B\u1C4C\x03\x02\x02\x02\u1C7B" + + "\u1C55\x03\x02\x02\x02\u1C7B\u1C5E\x03\x02\x02\x02\u1C7B\u1C65\x03\x02" + + "\x02\x02\u1C7B\u1C6D\x03\x02\x02\x02\u1C7B\u1C74\x03\x02\x02\x02\u1C7C" + + "\u02F7\x03\x02\x02\x02\u1C7D\u1C7E\x070\x02\x02\u1C7E\u1C7F\x07\u01C6" + + "\x02\x02\u1C7F\u1C81\x05\u0540\u02A1\x02\u1C80\u1C82\x05\u02FA\u017E\x02" + + "\u1C81\u1C80\x03\x02\x02\x02\u1C81\u1C82\x03\x02\x02\x02\u1C82\u1C84\x03" + + "\x02\x02\x02\u1C83\u1C85\x05\u02A6\u0154\x02\u1C84\u1C83\x03\x02\x02\x02" + + "\u1C84\u1C85\x03\x02\x02\x02\u1C85\u02F9\x03\x02\x02\x02\u1C86\u1C87\x05" + + "\u02FC\u017F\x02\u1C87\u02FB\x03\x02\x02\x02\u1C88\u1C89\x07@\x02\x02" + + "\u1C89\u1C8A\x07^\x02\x02\u1C8A\u1C8F\x05\u0438\u021D\x02\u1C8B\u1C8C" + + "\x07@\x02\x02\u1C8C\u1C8D\x07 \x02\x02\u1C8D\u1C8F\x07\u0160\x02\x02\u1C8E" + + "\u1C88\x03\x02\x02\x02\u1C8E\u1C8B\x03\x02\x02\x02\u1C8F\u02FD\x03\x02" + + "\x02\x02\u1C90\u1C91\x07\x8C\x02\x02\u1C91\u1C92\x07\u01C6\x02\x02\u1C92" + + "\u1C93\x05\u0540\u02A1\x02\u1C93\u1C94\x07\u014F\x02\x02\u1C94\u1C95\x05" + + "\u01D4\xEB\x02\u1C95\u1CAC\x03\x02\x02\x02\u1C96\u1C97\x07\x8C\x02\x02" + + "\u1C97\u1C98\x07\u01C6\x02\x02\u1C98\u1C99\x05\u0540\u02A1\x02\u1C99\u1C9A" + + "\x07\x87\x02\x02\u1C9A\u1C9B\x07^\x02\x02\u1C9B\u1C9C\x05\u0438\u021D" + + "\x02\u1C9C\u1CAC\x03\x02\x02\x02\u1C9D\u1C9E\x07\x8C\x02\x02\u1C9E\u1C9F" + + "\x07\u01C6\x02\x02\u1C9F\u1CA0\x05\u0540\u02A1\x02\u1CA0\u1CA1\x07\u014F" + + "\x02\x02\u1CA1\u1CA2\x07^\x02\x02\u1CA2\u1CA3\x05\u0438\u021D\x02\u1CA3" + + "\u1CAC\x03\x02\x02\x02\u1CA4\u1CA5\x07\x8C\x02\x02\u1CA5\u1CA6\x07\u01C6" + + "\x02\x02\u1CA6\u1CA7\x05\u0540\u02A1\x02\u1CA7\u1CA8\x07\xC1\x02\x02\u1CA8" + + "\u1CA9\x07^\x02\x02\u1CA9\u1CAA\x05\u0438\u021D\x02\u1CAA\u1CAC\x03\x02" + + "\x02\x02\u1CAB\u1C90\x03\x02\x02\x02\u1CAB\u1C96\x03\x02\x02\x02\u1CAB" + + "\u1C9D\x03\x02\x02\x02\u1CAB\u1CA4\x03\x02\x02\x02\u1CAC\u02FF\x03\x02" + + "\x02\x02\u1CAD\u1CAE\x070\x02\x02\u1CAE\u1CAF\x07\u01C5\x02\x02\u1CAF" + + "\u1CB0\x05\u0540\u02A1\x02\u1CB0\u1CB1\x07\xA6\x02\x02\u1CB1\u1CB2\x05" + + "\u0552\u02AA\x02\u1CB2\u1CB3\x07\u01C6\x02\x02\u1CB3\u1CB5\x05\u0302\u0182" + + "\x02\u1CB4\u1CB6\x05\u02A6\u0154\x02\u1CB5\u1CB4\x03\x02\x02\x02\u1CB5" + + "\u1CB6\x03\x02\x02\x02\u1CB6\u0301\x03\x02\x02\x02\u1CB7\u1CBC\x05\u0304" + + "\u0183\x02\u1CB8\u1CB9\x07\b\x02\x02\u1CB9\u1CBB\x05\u0304\u0183\x02\u1CBA" + + "\u1CB8\x03\x02\x02\x02\u1CBB\u1CBE\x03\x02\x02\x02\u1CBC\u1CBA\x03\x02" + + "\x02\x02\u1CBC\u1CBD\x03\x02\x02\x02\u1CBD\u0303\x03\x02\x02\x02\u1CBE" + + "\u1CBC\x03\x02\x02\x02\u1CBF\u1CC0\x05\u0570\u02B9\x02\u1CC0\u0305\x03" + + "\x02\x02\x02\u1CC1\u1CC2\x07\x8C\x02\x02\u1CC2\u1CC3\x07\u01C5\x02\x02" + + "\u1CC3\u1CC4\x05\u0540\u02A1\x02\u1CC4\u1CC5\x07\u014F\x02\x02\u1CC5\u1CC6" + + "\x05\u01D4\xEB\x02\u1CC6\u1CE9\x03\x02\x02\x02\u1CC7\u1CC8\x07\x8C\x02" + + "\x02\u1CC8\u1CC9\x07\u01C5\x02\x02\u1CC9\u1CCA\x05\u0540\u02A1\x02\u1CCA" + + "\u1CCB\x07\xA6\x02\x02\u1CCB\u1CCC\x05\u0552\u02AA\x02\u1CCC\u1CE9\x03" + + "\x02\x02\x02\u1CCD\u1CCE\x07\x8C\x02\x02\u1CCE\u1CCF\x07\u01C5\x02\x02" + + "\u1CCF\u1CD0\x05\u0540\u02A1\x02\u1CD0\u1CD1\x07\u0133\x02\x02\u1CD1\u1CD3" + + "\x07\u01C6\x02\x02\u1CD2\u1CD4\x05\u02A6\u0154\x02\u1CD3\u1CD2\x03\x02" + + "\x02\x02\u1CD3\u1CD4\x03\x02\x02\x02\u1CD4\u1CE9\x03\x02\x02\x02\u1CD5" + + "\u1CD6\x07\x8C\x02\x02\u1CD6\u1CD7\x07\u01C5\x02\x02\u1CD7\u1CD8\x05\u0540" + + "\u02A1\x02\u1CD8\u1CD9\x07\u014F\x02\x02\u1CD9\u1CDA\x07\u01C6\x02\x02" + + "\u1CDA\u1CDC\x05\u0302\u0182\x02\u1CDB\u1CDD\x05\u02A6\u0154\x02\u1CDC" + + "\u1CDB\x03\x02\x02\x02\u1CDC\u1CDD\x03\x02\x02\x02\u1CDD\u1CE9\x03\x02" + + "\x02\x02\u1CDE\u1CDF\x07\x8C\x02\x02\u1CDF\u1CE0\x07\u01C5\x02\x02\u1CE0" + + "\u1CE1\x05\u0540\u02A1\x02\u1CE1\u1CE2\x07\xC3\x02\x02\u1CE2\u1CE9\x03" + + "\x02\x02\x02\u1CE3\u1CE4\x07\x8C\x02\x02\u1CE4\u1CE5\x07\u01C5\x02\x02" + + "\u1CE5\u1CE6\x05\u0540\u02A1\x02\u1CE6\u1CE7\x07\xBC\x02\x02\u1CE7\u1CE9" + + "\x03\x02\x02\x02\u1CE8\u1CC1\x03\x02\x02\x02\u1CE8\u1CC7\x03\x02\x02\x02" + + "\u1CE8\u1CCD\x03\x02\x02\x02\u1CE8\u1CD5\x03\x02\x02\x02\u1CE8\u1CDE\x03" + + "\x02\x02\x02\u1CE8\u1CE3\x03\x02\x02\x02\u1CE9\u0307\x03\x02\x02\x02\u1CEA" + + "\u1CEB\x07\xC1\x02\x02\u1CEB\u1CEC\x07\u01C5\x02\x02\u1CEC\u1CEE\x05\u0540" + + "\u02A1\x02\u1CED\u1CEF\x05l7\x02\u1CEE\u1CED\x03\x02\x02\x02\u1CEE\u1CEF" + + "\x03\x02\x02\x02\u1CEF\u1CF9\x03\x02\x02\x02\u1CF0\u1CF1\x07\xC1\x02\x02" + + "\u1CF1\u1CF2\x07\u01C5\x02\x02\u1CF2\u1CF3\x07\xDE\x02\x02\u1CF3\u1CF4" + + "\x07\u018E\x02\x02\u1CF4\u1CF6\x05\u0540\u02A1\x02\u1CF5\u1CF7\x05l7\x02" + + "\u1CF6\u1CF5\x03\x02\x02\x02\u1CF6\u1CF7\x03\x02\x02\x02\u1CF7\u1CF9\x03" + + "\x02\x02\x02\u1CF8\u1CEA\x03\x02\x02\x02\u1CF8\u1CF0\x03\x02\x02\x02\u1CF9" + + "\u0309\x03\x02\x02\x02\u1CFA\u1CFC\x070\x02\x02\u1CFB\u1CFD\x05\u0278" + + "\u013D\x02\u1CFC\u1CFB\x03\x02\x02\x02\u1CFC\u1CFD\x03\x02\x02\x02\u1CFD" + + "\u1CFE\x03\x02\x02\x02\u1CFE\u1CFF\x07\u0143\x02\x02\u1CFF\u1D00\x05\u0540" + + "\u02A1\x02\u1D00\u1D01\x07&\x02\x02\u1D01\u1D02\x07R\x02\x02\u1D02\u1D03" + + "\x05\u0314\u018B\x02\u1D03\u1D04\x07`\x02\x02\u1D04\u1D06\x05\u053C\u029F" + + "\x02\u1D05\u1D07\x05\u044A\u0226\x02\u1D06\u1D05\x03\x02\x02\x02\u1D06" + + "\u1D07\x03\x02\x02\x02\u1D07\u1D08\x03\x02\x02\x02\u1D08\u1D0A\x07;\x02" + + "\x02\u1D09\u1D0B\x05\u0316\u018C\x02\u1D0A\u1D09\x03\x02\x02\x02\u1D0A" + + "\u1D0B\x03\x02\x02\x02\u1D0B\u1D0C\x03\x02\x02\x02\u1D0C\u1D0D\x05\u030C" + + "\u0187\x02\u1D0D\u030B\x03\x02\x02\x02\u1D0E\u1D15\x07\u0110\x02\x02\u1D0F" + + "\u1D15\x05\u0310\u0189\x02\u1D10\u1D11\x07\x04\x02\x02\u1D11\u1D12\x05" + + "\u030E\u0188\x02\u1D12\u1D13\x07\x05\x02\x02\u1D13\u1D15\x03\x02\x02\x02" + + "\u1D14\u1D0E\x03\x02\x02\x02\u1D14\u1D0F\x03\x02\x02\x02\u1D14\u1D10\x03" + + "\x02\x02\x02\u1D15\u030D\x03\x02\x02\x02\u1D16\u1D18\x05\u0312\u018A\x02" + + "\u1D17\u1D16\x03\x02\x02\x02\u1D17\u1D18\x03\x02\x02\x02\u1D18\u1D1F\x03" + + "\x02\x02\x02\u1D19\u1D1B\x07\t\x02\x02\u1D1A\u1D1C\x05\u0312\u018A\x02" + + "\u1D1B\u1D1A\x03\x02\x02\x02\u1D1B\u1D1C\x03\x02\x02\x02\u1D1C\u1D1E\x03" + + "\x02\x02\x02\u1D1D\u1D19\x03\x02\x02\x02\u1D1E\u1D21\x03\x02\x02\x02\u1D1F" + + "\u1D1D\x03\x02\x02\x02\u1D1F\u1D20\x03\x02\x02\x02\u1D20\u030F\x03\x02" + + "\x02\x02\u1D21\u1D1F\x03\x02\x02\x02\u1D22\u1D28\x05\u03C6\u01E4\x02\u1D23" + + "\u1D28\x05\u0394\u01CB\x02\u1D24\u1D28\x05\u03B4\u01DB\x02\u1D25\u1D28" + + "\x05\u03A6\u01D4\x02\u1D26\u1D28\x05\u0318\u018D\x02\u1D27\u1D22\x03\x02" + + "\x02\x02\u1D27\u1D23\x03\x02\x02\x02\u1D27\u1D24\x03\x02\x02\x02\u1D27" + + "\u1D25\x03\x02\x02\x02\u1D27\u1D26\x03\x02\x02\x02\u1D28\u0311\x03\x02" + + "\x02\x02\u1D29\u1D2A\x05\u0310\u0189\x02\u1D2A\u0313\x03\x02\x02\x02\u1D2B" + + "\u1D2C\t\'\x02\x02\u1D2C\u0315\x03\x02\x02\x02\u1D2D\u1D2E\t(\x02\x02" + + "\u1D2E\u0317\x03\x02\x02\x02\u1D2F\u1D30\x07\u0111\x02\x02\u1D30\u1D32" + + "\x05\u0562\u02B2\x02\u1D31\u1D33\x05\u031A\u018E\x02\u1D32\u1D31\x03\x02" + + "\x02\x02\u1D32\u1D33\x03\x02\x02\x02\u1D33\u0319\x03\x02\x02\x02\u1D34" + + "\u1D35\x07\b\x02\x02\u1D35\u1D36\x05\u0552\u02AA\x02\u1D36\u031B\x03\x02" + + "\x02\x02\u1D37\u1D38\x07\xFE\x02\x02\u1D38\u1D39\x05\u0562\u02B2\x02\u1D39" + + "\u031D\x03\x02\x02\x02\u1D3A\u1D3B\x07\u0170\x02\x02\u1D3B\u1D3F\x05\u0562" + + "\u02B2\x02\u1D3C\u1D3D\x07\u0170\x02\x02\u1D3D\u1D3F\x07\v\x02\x02\u1D3E" + + "\u1D3A\x03\x02\x02\x02\u1D3E\u1D3C\x03\x02\x02\x02\u1D3F\u031F\x03\x02" + + "\x02\x02\u1D40\u1D42\x07\x83\x02\x02\u1D41\u1D43\x05\u0322\u0192\x02\u1D42" + + "\u1D41\x03\x02\x02\x02\u1D42\u1D43\x03\x02\x02\x02\u1D43\u1D45\x03\x02" + + "\x02\x02\u1D44\u1D46\x05\u032A\u0196\x02\u1D45\u1D44\x03\x02\x02\x02\u1D45" + + "\u1D46\x03\x02\x02\x02\u1D46\u1D86\x03\x02\x02\x02\u1D47\u1D49\x07\x94" + + "\x02\x02\u1D48\u1D4A\x05\u0322\u0192\x02\u1D49\u1D48\x03\x02\x02\x02\u1D49" + + "\u1D4A\x03\x02\x02\x02\u1D4A\u1D4C\x03\x02\x02\x02\u1D4B\u1D4D\x05\u0328" + + "\u0195\x02\u1D4C\u1D4B\x03\x02\x02\x02\u1D4C\u1D4D\x03\x02\x02\x02\u1D4D" + + "\u1D86\x03\x02\x02\x02\u1D4E\u1D4F\x07\u0156\x02\x02\u1D4F\u1D51\x07\u0166" + + "\x02\x02\u1D50\u1D52\x05\u0328\u0195\x02\u1D51\u1D50\x03\x02\x02\x02\u1D51" + + "\u1D52\x03\x02\x02\x02\u1D52\u1D86\x03\x02\x02\x02\u1D53\u1D55\x07\xA3" + + "\x02\x02\u1D54\u1D56\x05\u0322\u0192\x02\u1D55\u1D54\x03\x02\x02\x02\u1D55" + + "\u1D56\x03\x02\x02\x02\u1D56\u1D58\x03\x02\x02\x02\u1D57\u1D59\x05\u032A" + + "\u0196\x02\u1D58\u1D57\x03\x02\x02\x02\u1D58\u1D59\x03\x02\x02\x02\u1D59" + + "\u1D86\x03\x02\x02\x02\u1D5A\u1D5C\x07\u01C8\x02\x02\u1D5B\u1D5D\x05\u0322" + + "\u0192\x02\u1D5C\u1D5B\x03\x02\x02\x02\u1D5C\u1D5D\x03\x02\x02\x02\u1D5D" + + "\u1D5F\x03\x02\x02\x02\u1D5E\u1D60\x05\u032A\u0196\x02\u1D5F\u1D5E\x03" + + "\x02\x02\x02\u1D5F\u1D60\x03\x02\x02\x02\u1D60\u1D86\x03\x02\x02\x02\u1D61" + + "\u1D63\x07\u0141\x02\x02\u1D62\u1D64\x05\u0322\u0192\x02\u1D63\u1D62\x03" + + "\x02\x02\x02\u1D63\u1D64\x03\x02\x02\x02\u1D64\u1D66\x03\x02\x02\x02\u1D65" + + "\u1D67\x05\u032A\u0196\x02\u1D66\u1D65\x03\x02\x02\x02\u1D66\u1D67\x03" + + "\x02\x02\x02\u1D67\u1D86\x03\x02\x02\x02\u1D68\u1D69\x07\u0144\x02\x02" + + "\u1D69\u1D86\x05\u0562\u02B2\x02\u1D6A\u1D6B\x07\u0136\x02\x02\u1D6B\u1D6C" + + "\x07\u0144\x02\x02\u1D6C\u1D86\x05\u0562\u02B2\x02\u1D6D\u1D6E\x07\u0136" + + "\x02\x02\u1D6E\u1D86\x05\u0562\u02B2\x02\u1D6F\u1D71\x07\u0141\x02\x02" + + "\u1D70\u1D72\x05\u0322\u0192\x02\u1D71\u1D70\x03\x02\x02\x02\u1D71\u1D72" + + "\x03\x02\x02\x02\u1D72\u1D73\x03\x02\x02\x02\u1D73\u1D74\x07`\x02\x02" + + "\u1D74\u1D75\x07\u0144\x02\x02\u1D75\u1D86\x05\u0562\u02B2\x02\u1D76\u1D78" + + "\x07\u0141\x02\x02\u1D77\u1D79\x05\u0322\u0192\x02\u1D78\u1D77\x03\x02" + + "\x02\x02\u1D78\u1D79\x03\x02\x02\x02\u1D79\u1D7A\x03\x02\x02\x02\u1D7A" + + "\u1D7B\x07`\x02\x02\u1D7B\u1D86\x05\u0562\u02B2\x02\u1D7C\u1D7D\x07\u0124" + + "\x02\x02\u1D7D\u1D7E\x07\u0166\x02\x02\u1D7E\u1D86\x05\u0552\u02AA\x02" + + "\u1D7F\u1D80\x07\xA3\x02\x02\u1D80\u1D81\x07\u0125\x02\x02\u1D81\u1D86" + + "\x05\u0552\u02AA\x02\u1D82\u1D83\x07\u0141\x02\x02\u1D83\u1D84\x07\u0125" + + "\x02\x02\u1D84\u1D86\x05\u0552\u02AA\x02\u1D85\u1D40\x03\x02\x02\x02\u1D85" + + "\u1D47\x03\x02\x02\x02\u1D85\u1D4E\x03\x02\x02\x02\u1D85\u1D53\x03\x02" + + "\x02\x02\u1D85\u1D5A\x03\x02\x02\x02\u1D85\u1D61\x03\x02\x02\x02\u1D85" + + "\u1D68\x03\x02\x02\x02\u1D85\u1D6A\x03\x02\x02\x02\u1D85\u1D6D\x03\x02" + + "\x02\x02\u1D85\u1D6F\x03\x02\x02\x02\u1D85\u1D76\x03\x02\x02\x02\u1D85" + + "\u1D7C\x03\x02\x02\x02\u1D85\u1D7F\x03\x02\x02\x02\u1D85\u1D82\x03\x02" + + "\x02\x02\u1D86\u0321\x03\x02\x02\x02\u1D87\u1D88\t)\x02\x02\u1D88\u0323" + + "\x03\x02\x02\x02\u1D89\u1D8A\x07\xF6\x02\x02\u1D8A\u1D8B\x07\xFD\x02\x02" + + "\u1D8B\u1D94\x05@!\x02\u1D8C\u1D8D\x07\u012E\x02\x02\u1D8D\u1D94\x07S" + + "\x02\x02\u1D8E\u1D8F\x07\u012E\x02\x02\u1D8F\u1D94\x07\u0180\x02\x02\u1D90" + + "\u1D94\x078\x02\x02\u1D91\u1D92\x07O\x02\x02\u1D92\u1D94\x078\x02\x02" + + "\u1D93\u1D89\x03\x02\x02\x02\u1D93\u1D8C\x03\x02\x02\x02\u1D93\u1D8E\x03" + + "\x02\x02\x02\u1D93\u1D90\x03\x02\x02\x02\u1D93\u1D91\x03\x02\x02\x02\u1D94" + + "\u0325\x03\x02\x02\x02\u1D95\u1D9C\x05\u0324\u0193\x02\u1D96\u1D98\x07" + + "\b\x02\x02\u1D97\u1D96\x03\x02\x02\x02\u1D97\u1D98\x03\x02\x02\x02\u1D98" + + "\u1D99\x03\x02\x02\x02\u1D99\u1D9B\x05\u0324\u0193\x02\u1D9A\u1D97\x03" + + "\x02\x02\x02\u1D9B\u1D9E\x03\x02\x02\x02\u1D9C\u1D9A\x03\x02\x02\x02\u1D9C" + + "\u1D9D\x03\x02\x02\x02\u1D9D\u0327\x03\x02\x02\x02\u1D9E\u1D9C\x03\x02" + + "\x02\x02\u1D9F\u1DA0\x05\u0326\u0194\x02\u1DA0\u0329\x03\x02\x02\x02\u1DA1" + + "\u1DA3\x07#\x02\x02\u1DA2\u1DA4\x07\u010F\x02\x02\u1DA3\u1DA2\x03\x02" + + "\x02\x02\u1DA3\u1DA4\x03\x02\x02\x02\u1DA4\u1DA5\x03\x02\x02\x02\u1DA5" + + "\u1DA6\x07\x9B\x02\x02\u1DA6\u032B\x03\x02\x02\x02\u1DA7\u1DAA\x070\x02" + + "\x02\u1DA8\u1DA9\x07T\x02\x02\u1DA9\u1DAB\x07\u0139\x02\x02\u1DAA\u1DA8" + + "\x03\x02\x02\x02\u1DAA\u1DAB\x03\x02\x02\x02\u1DAB\u1DAD\x03\x02\x02\x02" + + "\u1DAC\u1DAE\x05\xAEX\x02\u1DAD\u1DAC\x03\x02\x02\x02\u1DAD\u1DAE\x03" + + "\x02\x02\x02\u1DAE\u1DC0\x03\x02\x02\x02\u1DAF\u1DB0\x07\u017A\x02\x02" + + "\u1DB0\u1DB2\x05\u053C\u029F\x02\u1DB1\u1DB3\x05\xDAn\x02\u1DB2\u1DB1" + + "\x03\x02\x02\x02\u1DB2\u1DB3\x03\x02\x02\x02\u1DB3\u1DB5\x03\x02\x02\x02" + + "\u1DB4\u1DB6\x05v<\x02\u1DB5\u1DB4\x03\x02\x02\x02\u1DB5\u1DB6\x03\x02" + + "\x02\x02\u1DB6\u1DC1\x03\x02\x02\x02\u1DB7\u1DB8\x07\u0131\x02\x02\u1DB8" + + "\u1DB9\x07\u017A\x02\x02\u1DB9\u1DBA\x05\u053C\u029F\x02\u1DBA\u1DBB\x07" + + "\x04\x02\x02\u1DBB\u1DBC\x05\xDCo\x02\u1DBC\u1DBE\x07\x05\x02\x02\u1DBD" + + "\u1DBF\x05v<\x02\u1DBE\u1DBD\x03\x02\x02\x02\u1DBE\u1DBF\x03\x02\x02\x02" + + "\u1DBF\u1DC1\x03\x02\x02\x02\u1DC0\u1DAF\x03\x02\x02\x02\u1DC0\u1DB7\x03" + + "\x02\x02\x02\u1DC1\u1DC2\x03\x02\x02\x02\u1DC2\u1DC3\x07&\x02\x02\u1DC3" + + "\u1DC5\x05\u03C6\u01E4\x02\u1DC4\u1DC6\x05\u032E\u0198\x02\u1DC5\u1DC4" + + "\x03\x02\x02\x02\u1DC5\u1DC6\x03\x02\x02\x02\u1DC6\u032D\x03\x02\x02\x02" + + "\u1DC7\u1DC9\x07k\x02\x02\u1DC8\u1DCA\t*\x02\x02\u1DC9\u1DC8\x03\x02\x02" + + "\x02\u1DC9\u1DCA\x03\x02\x02\x02\u1DCA\u1DCB\x03\x02\x02\x02\u1DCB\u1DCC" + + "\x07,\x02\x02\u1DCC\u1DCD\x07\u0119\x02\x02\u1DCD\u032F\x03\x02\x02\x02" + + "\u1DCE\u1DCF\x07\xFF\x02\x02\u1DCF\u1DD0\x05\u0544\u02A3\x02\u1DD0\u0331" + + "\x03\x02\x02\x02\u1DD1\u1DD2\x070\x02\x02\u1DD2\u1DD3\x07\xB1\x02\x02" + + "\u1DD3\u1DD5\x05\u0540\u02A1\x02\u1DD4\u1DD6\x05\x10\t\x02\u1DD5\u1DD4" + + "\x03\x02\x02\x02\u1DD5\u1DD6\x03\x02\x02\x02\u1DD6\u1DD8\x03\x02\x02\x02" + + "\u1DD7\u1DD9\x05\u0334\u019B\x02\u1DD8\u1DD7\x03\x02\x02\x02\u1DD8\u1DD9" + + "\x03\x02\x02\x02\u1DD9\u0333\x03\x02\x02\x02\u1DDA\u1DDB\x05\u0336\u019C" + + "\x02\u1DDB\u0335\x03\x02\x02\x02\u1DDC\u1DDE\x05\u0338\u019D\x02\u1DDD" + + "\u1DDC\x03\x02\x02\x02\u1DDE\u1DDF\x03\x02\x02\x02\u1DDF\u1DDD\x03\x02" + + "\x02\x02\u1DDF\u1DE0\x03\x02\x02\x02\u1DE0\u0337\x03\x02\x02\x02\u1DE1" + + "\u1DE3\x05\u033A\u019E\x02\u1DE2\u1DE4\x05\u033C\u019F\x02\u1DE3\u1DE2" + + "\x03\x02\x02\x02\u1DE3\u1DE4\x03\x02\x02\x02\u1DE4\u1DE8\x03\x02\x02\x02" + + "\u1DE5\u1DE9\x05\u0558\u02AD\x02\u1DE6\u1DE9\x05B\"\x02\u1DE7\u1DE9\x07" + + "7\x02\x02\u1DE8\u1DE5\x03\x02\x02\x02\u1DE8\u1DE6\x03\x02\x02\x02\u1DE8" + + "\u1DE7\x03\x02\x02\x02\u1DE9\u0339\x03\x02\x02\x02\u1DEA\u1DF3\x05\u0572" + + "\u02BA\x02\u1DEB\u1DEC\x07\xA6\x02\x02\u1DEC\u1DF3\x07L\x02\x02\u1DED" + + "\u1DF3\x07\xC4\x02\x02\u1DEE\u1DF3\x07\u0101\x02\x02\u1DEF\u1DF3\x07\u011C" + + "\x02\x02\u1DF0\u1DF3\x07\u0161\x02\x02\u1DF1\u1DF3\x07\u0163\x02\x02\u1DF2" + + "\u1DEA\x03\x02\x02\x02\u1DF2\u1DEB\x03\x02\x02\x02\u1DF2\u1DED\x03\x02" + + "\x02\x02\u1DF2\u1DEE\x03\x02\x02\x02\u1DF2\u1DEF\x03\x02\x02\x02\u1DF2" + + "\u1DF0\x03\x02\x02\x02\u1DF2\u1DF1\x03\x02\x02\x02\u1DF3\u033B\x03\x02" + + "\x02\x02\u1DF4\u1DF5\x07\f\x02\x02\u1DF5\u033D\x03\x02\x02\x02\u1DF6\u1DF7" + + "\x07\x8C\x02\x02\u1DF7\u1DF8\x07\xB1\x02\x02\u1DF8\u1E03\x05\u0540\u02A1" + + "\x02\u1DF9\u1DFB\x07k\x02\x02\u1DFA\u1DFC\x05\u0334\u019B\x02\u1DFB\u1DFA" + + "\x03\x02\x02\x02\u1DFB\u1DFC\x03\x02\x02\x02\u1DFC\u1E04\x03\x02\x02\x02" + + "\u1DFD\u1DFF\x05\u0334\u019B\x02\u1DFE\u1DFD\x03\x02\x02\x02\u1DFE\u1DFF" + + "\x03\x02\x02\x02\u1DFF\u1E04\x03\x02\x02\x02\u1E00\u1E01\x07\u014F\x02" + + "\x02\u1E01\u1E02\x07\u0161\x02\x02\u1E02\u1E04\x05\u0540\u02A1\x02\u1E03" + + "\u1DF9\x03\x02\x02\x02\u1E03\u1DFE\x03\x02\x02\x02\u1E03\u1E00\x03\x02" + + "\x02\x02\u1E04\u033F\x03\x02\x02\x02\u1E05\u1E06\x07\x8C\x02\x02\u1E06" + + "\u1E07\x07\xB1\x02\x02\u1E07\u1E08\x05\u0540\u02A1\x02\u1E08\u1E09\x05" + + "P)\x02\u1E09\u0341\x03\x02\x02\x02\u1E0A\u1E0B\x07\xC1\x02\x02\u1E0B\u1E0E" + + "\x07\xB1\x02\x02\u1E0C\u1E0D\x07\xDE\x02\x02\u1E0D\u1E0F\x07\u018E\x02" + + "\x02\u1E0E\u1E0C\x03\x02\x02\x02\u1E0E\u1E0F\x03\x02\x02\x02\u1E0F\u1E10" + + "\x03\x02\x02\x02\u1E10\u1E18\x05\u0540\u02A1\x02\u1E11\u1E13\x05\x10\t" + + "\x02\u1E12\u1E11\x03\x02\x02\x02\u1E12\u1E13\x03\x02\x02\x02\u1E13\u1E14" + + "\x03\x02\x02\x02\u1E14\u1E15\x07\x04\x02\x02\u1E15\u1E16\x05\u0344\u01A3" + + "\x02\u1E16\u1E17\x07\x05\x02\x02\u1E17\u1E19\x03\x02\x02\x02\u1E18\u1E12" + + "\x03\x02\x02\x02\u1E18\u1E19\x03\x02\x02\x02\u1E19\u0343\x03\x02\x02\x02" + + "\u1E1A\u1E1F\x05\u0346\u01A4\x02\u1E1B\u1E1C\x07\b\x02\x02\u1E1C\u1E1E" + + "\x05\u0346\u01A4\x02\u1E1D\u1E1B\x03\x02\x02\x02\u1E1E\u1E21\x03\x02\x02" + + "\x02\u1E1F\u1E1D\x03\x02\x02\x02\u1E1F\u1E20\x03\x02\x02\x02\u1E20\u0345" + + "\x03\x02\x02\x02\u1E21\u1E1F\x03\x02\x02\x02\u1E22\u1E23\x07\xD3\x02\x02" + + "\u1E23\u0347\x03\x02\x02\x02\u1E24\u1E25\x07\x8C\x02\x02\u1E25\u1E26\x07" + + "n\x02\x02\u1E26\u1E27\x05\u0214\u010B\x02\u1E27\u1E28\x07\u0133\x02\x02" + + "\u1E28\u1E29\x07\u0179\x02\x02\u1E29\u0349\x03\x02\x02\x02\u1E2A\u1E2B" + + "\x07\x8C\x02\x02\u1E2B\u1E2C\x07\u015F\x02\x02\u1E2C\u1E2D\t+\x02\x02" + + "\u1E2D\u1E2E\x056\x1C\x02\u1E2E\u034B\x03\x02\x02\x02\u1E2F\u1E30\x07" + + "0\x02\x02\u1E30\u1E31\x07\xBF\x02\x02\u1E31\u1E33\x05\u0214\u010B\x02" + + "\u1E32\u1E34\x05\u0350\u01A9\x02\u1E33\u1E32\x03\x02\x02\x02\u1E33\u1E34" + + "\x03\x02\x02\x02\u1E34\u1E35\x03\x02\x02\x02\u1E35\u1E36\x05\u0462\u0232" + + "\x02\u1E36\u1E37\x05\xC2b\x02\u1E37\u034D\x03\x02\x02\x02\u1E38\u1E39" + + "\x07\x8C\x02\x02\u1E39\u1E3A\x07\xBF\x02\x02\u1E3A\u1E51\x05\u0214\u010B" + + "\x02\u1E3B\u1E52\x05j6\x02\u1E3C\u1E3D\x07\xC1\x02\x02\u1E3D\u1E3E\x07" + + "O\x02\x02\u1E3E\u1E52\x07P\x02\x02\u1E3F\u1E40\x07\u014F\x02\x02\u1E40" + + "\u1E41\x07O\x02\x02\u1E41\u1E52\x07P\x02\x02\u1E42\u1E43\x07\x87\x02\x02" + + "\u1E43\u1E52\x05\xD4k\x02\u1E44\u1E45\x07\xC1\x02\x02\u1E45\u1E48\x07" + + "/\x02\x02\u1E46\u1E47\x07\xDE\x02\x02\u1E47\u1E49\x07\u018E\x02\x02\u1E48" + + "\u1E46\x03\x02\x02\x02\u1E48\u1E49\x03\x02\x02\x02\u1E49\u1E4A\x03\x02" + + "\x02\x02\u1E4A\u1E4C\x05\u0540\u02A1\x02\u1E4B\u1E4D\x05l7\x02\u1E4C\u1E4B" + + "\x03\x02\x02\x02\u1E4C\u1E4D\x03\x02\x02\x02\u1E4D\u1E52\x03\x02\x02\x02" + + "\u1E4E\u1E4F\x07\u0176\x02\x02\u1E4F\u1E50\x07/\x02\x02\u1E50\u1E52\x05" + + "\u0540\u02A1\x02\u1E51\u1E3B\x03\x02\x02\x02\u1E51\u1E3C\x03\x02\x02\x02" + + "\u1E51\u1E3F\x03\x02\x02\x02\u1E51\u1E42\x03\x02\x02\x02\u1E51\u1E44\x03" + + "\x02\x02\x02\u1E51\u1E4E\x03\x02\x02\x02\u1E52\u034F\x03\x02\x02\x02\u1E53" + + "\u1E54\x07&\x02\x02\u1E54\u0351\x03\x02\x02\x02\u1E55\u1E56\x07\x8C\x02" + + "\x02\u1E56\u1E57\x07\u0165\x02\x02\u1E57\u1E58\x07\u0147\x02\x02\u1E58" + + "\u1E59\x07\xBB\x02\x02\u1E59\u1E5A\x05\u0214\u010B\x02\u1E5A\u1E5B\x05" + + "\u01D4\xEB\x02\u1E5B\u0353\x03\x02\x02\x02\u1E5C\u1E5D\x07\x8C\x02\x02" + + "\u1E5D\u1E5E\x07\u0165\x02\x02\u1E5E\u1E5F\x07\u0147\x02\x02\u1E5F\u1E60" + + "\x07\xA5\x02\x02\u1E60\u1E61\x05\u0214\u010B\x02\u1E61\u1E62\x07\x87\x02" + + "\x02\u1E62\u1E63\x07\u0103\x02\x02\u1E63\u1E64\x07@\x02\x02\u1E64\u1E65" + + "\x05\u053E\u02A0\x02\u1E65\u1E66\x05\u0356\u01AC\x02\u1E66\u1E67\x05\u0212" + + "\u010A\x02\u1E67\u1EA5\x03\x02\x02\x02\u1E68\u1E69\x07\x8C\x02\x02\u1E69" + + "\u1E6A\x07\u0165\x02\x02\u1E6A\u1E6B\x07\u0147\x02\x02\u1E6B\u1E6C\x07" + + "\xA5\x02\x02\u1E6C\u1E6D\x05\u0214\u010B\x02\u1E6D\u1E6E\x07\x8C\x02\x02" + + "\u1E6E\u1E6F\x07\u0103\x02\x02\u1E6F\u1E70\x07@\x02\x02\u1E70\u1E71\x05" + + "\u053E\u02A0\x02\u1E71\u1E72\x05\u0356\u01AC\x02\u1E72\u1E73\x05\u0212" + + "\u010A\x02\u1E73\u1EA5\x03\x02\x02\x02\u1E74\u1E75\x07\x8C\x02\x02\u1E75" + + "\u1E76\x07\u0165\x02\x02\u1E76\u1E77\x07\u0147\x02\x02\u1E77\u1E78\x07" + + "\xA5\x02\x02\u1E78\u1E79\x05\u0214\u010B\x02\u1E79\u1E7A\x07\x8C\x02\x02" + + "\u1E7A\u1E7B\x07\u0103\x02\x02\u1E7B\u1E7C\x07\u0139\x02\x02\u1E7C\u1E7D" + + "\x05\u0214\u010B\x02\u1E7D\u1E7E\x05\u0356\u01AC\x02\u1E7E"; private static readonly _serializedATNSegment15: string = - "\u1EA2\x03\x02\x02\x02\u1EA2\u1EA4\x03\x02\x02\x02\u1EA3\u1E95\x03\x02" + - "\x02\x02\u1EA3\u1E9C\x03\x02\x02\x02\u1EA4\u0353\x03\x02\x02\x02\u1EA5" + - "\u1EAA\x05\u0358\u01AD\x02\u1EA6\u1EA7\x07\b\x02\x02\u1EA7\u1EA9\x05\u0358" + - "\u01AD\x02\u1EA8\u1EA6\x03\x02\x02\x02\u1EA9\u1EAC\x03\x02\x02\x02\u1EAA" + - "\u1EA8\x03\x02\x02\x02\u1EAA\u1EAB\x03\x02\x02\x02\u1EAB\u0355\x03\x02" + - "\x02\x02\u1EAC\u1EAA\x03\x02\x02\x02\u1EAD\u1EAE\t&\x02\x02\u1EAE\u0357" + - "\x03\x02\x02\x02\u1EAF\u1EB1\x05\u035A\u01AE\x02\u1EB0\u1EB2\x05\u035C" + - "\u01AF\x02\u1EB1\u1EB0\x03\x02\x02\x02\u1EB1\u1EB2\x03\x02\x02\x02\u1EB2" + - "\u0359\x03\x02\x02\x02\u1EB3\u1EB6\x05\u0554\u02AB\x02\u1EB4\u1EB6\x05" + - "\u0356\u01AC\x02\u1EB5\u1EB3\x03\x02\x02\x02\u1EB5\u1EB4\x03\x02\x02\x02" + - "\u1EB6\u035B\x03\x02\x02\x02\u1EB7\u1EBA\x05B\"\x02\u1EB8\u1EBA\x05\u0124" + - "\x93\x02\u1EB9\u1EB7\x03\x02\x02\x02\u1EB9\u1EB8\x03\x02\x02\x02\u1EBA" + - "\u035D\x03\x02\x02\x02\u1EBB\u1EBC\x05\u0356\u01AC\x02\u1EBC\u035F\x03" + - "\x02\x02\x02\u1EBD\u1EBE\x07\x82\x02\x02\u1EBE\u0361\x03\x02\x02\x02\u1EBF" + - "\u1EC0\x07s\x02\x02\u1EC0\u0363\x03\x02\x02\x02\u1EC1\u1EC2\x07r\x02\x02" + - "\u1EC2\u0365\x03\x02\x02\x02\u1EC3\u1EC4\x07\x04\x02\x02\u1EC4\u1EC5\x05" + - "\u052E\u0298\x02\u1EC5\u1EC6\x07\x05\x02\x02\u1EC6\u0367\x03\x02\x02\x02" + - "\u1EC7\u1EC9\x05\u052C\u0297\x02\u1EC8\u1ECA\x05\u0366\u01B4\x02\u1EC9" + - "\u1EC8\x03\x02\x02\x02\u1EC9\u1ECA\x03\x02\x02\x02\u1ECA\u0369\x03\x02" + - "\x02\x02\u1ECB\u1ED0\x05\u0368\u01B5\x02\u1ECC\u1ECD\x07\b\x02\x02\u1ECD" + - "\u1ECF\x05\u0368\u01B5\x02\u1ECE\u1ECC\x03\x02\x02\x02\u1ECF\u1ED2\x03" + - "\x02\x02\x02\u1ED0\u1ECE\x03\x02\x02\x02\u1ED0\u1ED1\x03\x02\x02\x02\u1ED1" + - "\u036B\x03\x02\x02\x02\u1ED2\u1ED0\x03\x02\x02\x02\u1ED3\u1ED4\x05\u036A" + - "\u01B6\x02\u1ED4\u036D\x03\x02\x02\x02\u1ED5\u1ED6\x07\xCD\x02\x02\u1ED6" + - "\u1EE8\x05\u0370\u01B9\x02\u1ED7\u1ED8\x07\xCD\x02\x02\u1ED8\u1EDA\x05" + - "\u0356\u01AC\x02\u1ED9\u1EDB\x05\u0360\u01B1\x02\u1EDA\u1ED9\x03\x02\x02" + - "\x02\u1EDA\u1EDB\x03\x02\x02\x02\u1EDB\u1EDC\x03\x02\x02\x02\u1EDC\u1EDD" + - "\x05\u0370\u01B9\x02\u1EDD\u1EE8\x03\x02\x02\x02\u1EDE\u1EDF\x07\xCD\x02" + - "\x02\u1EDF\u1EE0\x07\x82\x02\x02\u1EE0\u1EE8\x05\u0370\u01B9\x02\u1EE1" + - "\u1EE2\x07\xCD\x02\x02\u1EE2\u1EE3\x07\x04\x02\x02\u1EE3\u1EE4\x05\u0372" + - "\u01BA\x02\u1EE4\u1EE5\x07\x05\x02\x02\u1EE5\u1EE6\x05\u0370\u01B9\x02" + - "\u1EE6\u1EE8\x03\x02\x02\x02\u1EE7\u1ED5\x03\x02\x02\x02\u1EE7\u1ED7\x03" + - "\x02\x02\x02\u1EE7\u1EDE\x03\x02\x02\x02\u1EE7\u1EE1\x03\x02\x02\x02\u1EE8" + - "\u036F\x03\x02\x02\x02\u1EE9\u1EF3\x05\u03B8\u01DD\x02\u1EEA\u1EF3\x05" + - "\u0386\u01C4\x02\u1EEB\u1EF3\x05\u03A6\u01D4\x02\u1EEC\u1EF3\x05\u0398" + - "\u01CD\x02\u1EED\u1EF3\x05\u03B0\u01D9\x02\u1EEE\u1EF3\x05\u0108\x85\x02" + - "\u1EEF\u1EF3\x05\u010E\x88\x02\u1EF0\u1EF3\x05\u0114\x8B\x02\u1EF1\u1EF3" + - "\x05\u0380\u01C1\x02\u1EF2\u1EE9\x03\x02\x02\x02\u1EF2\u1EEA\x03\x02\x02" + - "\x02\u1EF2\u1EEB\x03\x02\x02\x02\u1EF2\u1EEC\x03\x02\x02\x02\u1EF2\u1EED" + - "\x03\x02\x02\x02\u1EF2\u1EEE\x03\x02\x02\x02\u1EF2\u1EEF\x03\x02\x02\x02" + - "\u1EF2\u1EF0\x03\x02\x02\x02\u1EF2\u1EF1\x03\x02\x02\x02\u1EF3\u0371\x03" + - "\x02\x02\x02\u1EF4\u1EF9\x05\u0374\u01BB\x02\u1EF5\u1EF6\x07\b\x02\x02" + - "\u1EF6\u1EF8\x05\u0374\u01BB\x02\u1EF7\u1EF5\x03\x02\x02\x02\u1EF8\u1EFB" + - "\x03\x02\x02\x02\u1EF9\u1EF7\x03\x02\x02\x02\u1EF9\u1EFA\x03\x02\x02\x02" + - "\u1EFA\u0373\x03\x02\x02\x02\u1EFB\u1EF9\x03\x02\x02\x02\u1EFC\u1EFE\x05" + - "\u0376\u01BC\x02\u1EFD\u1EFF\x05\u0378\u01BD\x02\u1EFE\u1EFD\x03\x02\x02" + - "\x02\u1EFE\u1EFF\x03\x02\x02\x02\u1EFF\u0375\x03\x02\x02\x02\u1F00\u1F03" + - "\x05\u0554\u02AB\x02\u1F01\u1F03\x05\u0356\u01AC\x02\u1F02\u1F00\x03\x02" + - "\x02\x02\u1F02\u1F01\x03\x02\x02\x02\u1F03\u0377\x03\x02\x02\x02\u1F04" + - "\u1F07\x05B\"\x02\u1F05\u1F07\x05\u0124\x93\x02\u1F06\u1F04\x03\x02\x02" + - "\x02\u1F06\u1F05\x03\x02\x02\x02\u1F07\u0379\x03\x02\x02\x02\u1F08\u1F09" + - "\x07\u011B\x02\x02\u1F09\u1F0B\x05\u0530\u0299\x02\u1F0A\u1F0C\x05\u037C" + - "\u01BF\x02\u1F0B\u1F0A\x03\x02\x02\x02\u1F0B\u1F0C\x03\x02\x02\x02\u1F0C" + - "\u1F0D\x03\x02\x02\x02\u1F0D\u1F0E\x07&\x02\x02\u1F0E\u1F0F\x05\u037E" + - "\u01C0\x02\u1F0F\u037B\x03\x02\x02\x02\u1F10\u1F11\x07\x04\x02\x02\u1F11" + - "\u1F12\x05\u04FA\u027E\x02\u1F12\u1F13\x07\x05\x02\x02\u1F13\u037D\x03" + - "\x02\x02\x02\u1F14\u1F19\x05\u03B8\u01DD\x02\u1F15\u1F19\x05\u0386\u01C4" + - "\x02\u1F16\u1F19\x05\u03A6\u01D4\x02\u1F17\u1F19\x05\u0398\u01CD\x02\u1F18" + - "\u1F14\x03\x02\x02\x02\u1F18\u1F15\x03\x02\x02\x02\u1F18\u1F16\x03\x02" + - "\x02\x02\u1F18\u1F17\x03\x02\x02\x02\u1F19\u037F\x03\x02\x02\x02\u1F1A" + - "\u1F1B\x07\xCC\x02\x02\u1F1B\u1F1D\x05\u0530\u0299\x02\u1F1C\u1F1E\x05" + - "\u0382\u01C2\x02\u1F1D\u1F1C\x03\x02\x02\x02\u1F1D\u1F1E\x03\x02\x02\x02" + - "\u1F1E\u1F41\x03\x02\x02\x02\u1F1F\u1F21\x070\x02\x02\u1F20\u1F22\x05" + - "\xAEX\x02\u1F21\u1F20\x03\x02\x02\x02\u1F21\u1F22\x03\x02\x02\x02\u1F22" + - "\u1F23\x03\x02\x02\x02\u1F23\u1F24\x07^\x02\x02\u1F24\u1F25\x05\u010A" + - "\x86\x02\u1F25\u1F26\x07&\x02\x02\u1F26\u1F27\x07\xCC\x02\x02\u1F27\u1F29" + - "\x05\u0530\u0299\x02\u1F28\u1F2A\x05\u0382\u01C2\x02\u1F29\u1F28\x03\x02" + - "\x02\x02\u1F29\u1F2A\x03\x02\x02\x02\u1F2A\u1F2C\x03\x02\x02\x02\u1F2B" + - "\u1F2D\x05\u010C\x87\x02\u1F2C\u1F2B\x03\x02\x02\x02\u1F2C\u1F2D\x03\x02" + - "\x02\x02\u1F2D\u1F41\x03\x02\x02\x02\u1F2E\u1F30\x070\x02\x02\u1F2F\u1F31" + - "\x05\xAEX\x02\u1F30\u1F2F\x03\x02\x02\x02\u1F30\u1F31\x03\x02\x02\x02" + - "\u1F31\u1F32\x03\x02\x02\x02\u1F32\u1F33\x07^\x02\x02\u1F33\u1F34\x07" + - "\xDE\x02\x02\u1F34\u1F35\x07O\x02\x02\u1F35\u1F36\x07\u0185\x02\x02\u1F36" + - "\u1F37\x05\u010A\x86\x02\u1F37\u1F38\x07&\x02\x02\u1F38\u1F39\x07\xCC" + - "\x02\x02\u1F39\u1F3B\x05\u0530\u0299\x02\u1F3A\u1F3C\x05\u0382\u01C2\x02" + - "\u1F3B\u1F3A\x03\x02\x02\x02\u1F3B\u1F3C\x03\x02\x02\x02\u1F3C\u1F3E\x03" + - "\x02\x02\x02\u1F3D\u1F3F\x05\u010C\x87\x02\u1F3E\u1F3D\x03\x02\x02\x02" + - "\u1F3E\u1F3F\x03\x02\x02\x02\u1F3F\u1F41\x03\x02\x02\x02\u1F40\u1F1A\x03" + - "\x02\x02\x02\u1F40\u1F1F\x03\x02\x02\x02\u1F40\u1F2E\x03\x02\x02\x02\u1F41" + - "\u0381\x03\x02\x02\x02\u1F42\u1F43\x07\x04\x02\x02\u1F43\u1F44\x05\u04F4" + - "\u027B\x02\u1F44\u1F45\x07\x05\x02\x02\u1F45\u0383\x03\x02\x02\x02\u1F46" + - "\u1F47\x07\xB3\x02\x02\u1F47\u1F51\x05\u0530\u0299\x02\u1F48\u1F49\x07" + - "\xB3\x02\x02\u1F49\u1F4A\x07\u011B\x02\x02\u1F4A\u1F51\x05\u0530\u0299" + - "\x02\u1F4B\u1F4C\x07\xB3\x02\x02\u1F4C\u1F51\x07 \x02\x02\u1F4D\u1F4E" + - "\x07\xB3\x02\x02\u1F4E\u1F4F\x07\u011B\x02\x02\u1F4F\u1F51\x07 \x02\x02" + - "\u1F50\u1F46\x03\x02\x02\x02\u1F50\u1F48\x03\x02\x02\x02\u1F50\u1F4B\x03" + - "\x02\x02\x02\u1F50\u1F4D\x03\x02\x02\x02\u1F51\u0385\x03\x02\x02\x02\u1F52" + - "\u1F54\x05\u03CE\u01E8\x02\u1F53\u1F52\x03\x02\x02\x02\u1F53\u1F54\x03" + - "\x02\x02\x02\u1F54\u1F55\x03\x02\x02\x02\u1F55\u1F56\x07\xEA\x02\x02\u1F56" + - "\u1F57\x07I\x02\x02\u1F57\u1F58\x05\u0388\u01C5\x02\u1F58\u1F5A\x05\u038A" + - "\u01C6\x02\u1F59\u1F5B\x05\u0392\u01CA\x02\u1F5A\u1F59\x03\x02\x02\x02" + - "\u1F5A\u1F5B\x03\x02\x02\x02\u1F5B\u1F5D\x03\x02\x02\x02\u1F5C\u1F5E\x05" + - "\u0396\u01CC\x02\u1F5D\u1F5C\x03\x02\x02\x02\u1F5D\u1F5E\x03\x02\x02\x02" + - "\u1F5E\u0387\x03\x02\x02\x02\u1F5F\u1F62\x05\u052C\u0297\x02\u1F60\u1F61" + - "\x07&\x02\x02\u1F61\u1F63\x05\u0550\u02A9\x02\u1F62\u1F60\x03\x02\x02" + - "\x02\u1F62\u1F63\x03\x02\x02\x02\u1F63\u0389\x03\x02\x02\x02\u1F64\u1F78" + - "\x05\u03B8\u01DD\x02\u1F65\u1F66\x07\u01C8\x02\x02\u1F66\u1F67\x05\u038C" + - "\u01C7\x02\u1F67\u1F68\x07\u01BB\x02\x02\u1F68\u1F69\x05\u03B8\u01DD\x02" + - "\u1F69\u1F78\x03\x02\x02\x02\u1F6A\u1F6B\x07\x04\x02\x02\u1F6B\u1F6C\x05" + - "\u038E\u01C8\x02\u1F6C\u1F71\x07\x05\x02\x02\u1F6D\u1F6E\x07\u01C8\x02" + - "\x02\u1F6E\u1F6F\x05\u038C\u01C7\x02\u1F6F\u1F70\x07\u01BB\x02\x02\u1F70" + - "\u1F72\x03\x02\x02\x02\u1F71\u1F6D\x03\x02\x02\x02\u1F71\u1F72\x03\x02" + - "\x02\x02\u1F72\u1F73\x03\x02\x02\x02\u1F73\u1F74\x05\u03B8\u01DD\x02\u1F74" + - "\u1F78\x03\x02\x02\x02\u1F75\u1F76\x077\x02\x02\u1F76\u1F78\x07\u019F" + - "\x02\x02\u1F77\u1F64\x03\x02\x02\x02\u1F77\u1F65\x03\x02\x02\x02\u1F77" + - "\u1F6A\x03\x02\x02\x02\u1F77\u1F75\x03\x02\x02\x02\u1F78\u038B\x03\x02" + - "\x02\x02\u1F79\u1F7A\t\'\x02\x02\u1F7A\u038D\x03\x02\x02\x02\u1F7B\u1F80" + - "\x05\u0390\u01C9\x02\u1F7C\u1F7D\x07\b\x02\x02\u1F7D\u1F7F\x05\u0390\u01C9" + - "\x02\u1F7E\u1F7C\x03\x02\x02\x02\u1F7F\u1F82\x03\x02\x02\x02\u1F80\u1F7E" + - "\x03\x02\x02\x02\u1F80\u1F81\x03\x02\x02\x02\u1F81\u038F\x03\x02\x02\x02" + - "\u1F82\u1F80\x03\x02\x02\x02\u1F83\u1F84\x05\u0550\u02A9\x02\u1F84\u1F85" + - "\x05\u0522\u0292\x02\u1F85\u0391\x03\x02\x02\x02\u1F86\u1F87\x07R\x02" + - "\x02\u1F87\u1F89\x07\u01C9\x02\x02\u1F88\u1F8A\x05\u0394\u01CB\x02\u1F89" + - "\u1F88\x03\x02\x02\x02\u1F89\u1F8A\x03\x02\x02\x02\u1F8A\u1F8B\x03\x02" + - "\x02\x02\u1F8B\u1F93\x07;\x02\x02\u1F8C\u1F8D\x07\u016A\x02\x02\u1F8D" + - "\u1F8E\x07\u0146\x02\x02\u1F8E\u1F90\x05\u03A8\u01D5\x02\u1F8F\u1F91\x05" + - "\u043C\u021F\x02\u1F90\u1F8F\x03\x02\x02\x02\u1F90\u1F91\x03\x02\x02\x02" + - "\u1F91\u1F94\x03\x02\x02\x02\u1F92\u1F94\x07\u0107\x02\x02\u1F93\u1F8C" + - "\x03\x02\x02\x02\u1F93\u1F92\x03\x02\x02\x02\u1F94\u0393\x03\x02\x02\x02" + - "\u1F95\u1F96\x07\x04\x02\x02\u1F96\u1F97\x05\u0256\u012C\x02\u1F97\u1F99" + - "\x07\x05\x02\x02\u1F98\u1F9A\x05\u043C\u021F\x02\u1F99\u1F98\x03\x02\x02" + - "\x02\u1F99\u1F9A\x03\x02\x02\x02\u1F9A\u1F9F\x03\x02\x02\x02\u1F9B\u1F9C" + - "\x07R\x02\x02\u1F9C\u1F9D\x07/\x02\x02\u1F9D\u1F9F\x05\u0530\u0299\x02" + - "\u1F9E\u1F95\x03\x02\x02\x02\u1F9E\u1F9B\x03\x02\x02\x02\u1F9F\u0395\x03" + - "\x02\x02\x02\u1FA0\u1FA1\x07Y\x02\x02\u1FA1\u1FA2\x05\u0526\u0294\x02" + - "\u1FA2\u0397\x03\x02\x02\x02\u1FA3\u1FA5\x05\u03CE\u01E8\x02\u1FA4\u1FA3" + - "\x03\x02\x02\x02\u1FA4\u1FA5\x03\x02\x02\x02\u1FA5\u1FA6\x03\x02\x02\x02" + - "\u1FA6\u1FA7\x07\xB8\x02\x02\u1FA7\u1FA8\x07B\x02\x02\u1FA8\u1FAA\x05" + - "\u042C\u0217\x02\u1FA9\u1FAB\x05\u039A\u01CE\x02\u1FAA\u1FA9\x03\x02\x02" + - "\x02\u1FAA\u1FAB\x03\x02\x02\x02\u1FAB\u1FAD\x03\x02\x02\x02\u1FAC\u1FAE" + - "\x05\u043E\u0220\x02\u1FAD\u1FAC\x03\x02\x02\x02\u1FAD\u1FAE\x03\x02\x02" + - "\x02\u1FAE\u1FB0\x03\x02\x02\x02\u1FAF\u1FB1\x05\u0396\u01CC\x02\u1FB0" + - "\u1FAF\x03\x02\x02\x02\u1FB0\u1FB1\x03\x02\x02\x02\u1FB1\u0399\x03\x02" + - "\x02\x02\u1FB2\u1FB3\x07f\x02\x02\u1FB3\u1FB4\x05\u041A\u020E\x02\u1FB4" + - "\u039B\x03\x02\x02\x02\u1FB5\u1FB7\x07\xF9\x02\x02\u1FB6\u1FB8\x05\u03D6" + - "\u01EC\x02\u1FB7\u1FB6\x03\x02\x02\x02\u1FB7\u1FB8\x03\x02\x02\x02\u1FB8" + - "\u1FB9\x03\x02\x02\x02\u1FB9\u1FBB\x05\u042A\u0216\x02\u1FBA\u1FBC\x05" + - "\u039E\u01D0\x02\u1FBB\u1FBA\x03\x02\x02\x02\u1FBB\u1FBC\x03\x02\x02\x02" + - "\u1FBC\u1FBE\x03\x02\x02\x02\u1FBD\u1FBF\x05\u03A2\u01D2\x02\u1FBE\u1FBD" + - "\x03\x02\x02\x02\u1FBE\u1FBF\x03\x02\x02\x02\u1FBF\u039D\x03\x02\x02\x02" + - "\u1FC0\u1FC1\x07F\x02\x02\u1FC1\u1FC2\x05\u03A0\u01D1\x02\u1FC2\u1FC3" + - "\x07\u0100\x02\x02\u1FC3\u039F\x03\x02\x02\x02\u1FC4\u1FC5\x07\x85\x02" + - "\x02\u1FC5\u1FD1\t(\x02\x02\u1FC6\u1FC7\x07\u0197\x02\x02\u1FC7\u1FD1" + - "\t(\x02\x02\u1FC8\u1FCD\x07\u0147\x02\x02\u1FC9\u1FCA\x07\u016A\x02\x02" + - "\u1FCA\u1FCE\x07\xCB\x02\x02\u1FCB\u1FCC\x07\u0197\x02\x02\u1FCC\u1FCE" + - "\x07\xCB\x02\x02\u1FCD\u1FC9\x03\x02\x02\x02\u1FCD\u1FCB\x03\x02\x02\x02" + - "\u1FCD\u1FCE\x03\x02\x02\x02\u1FCE\u1FD1\x03\x02\x02\x02\u1FCF\u1FD1\x07" + - "\xCB\x02\x02\u1FD0\u1FC4\x03\x02\x02\x02\u1FD0\u1FC6\x03\x02\x02\x02\u1FD0" + - "\u1FC8\x03\x02\x02\x02\u1FD0\u1FCF\x03\x02\x02\x02\u1FD1\u03A1\x03\x02" + - "\x02\x02\u1FD2\u1FD3\x07\u0109\x02\x02\u1FD3\u03A3\x03\x02\x02\x02\u1FD4" + - "\u1FD8\x07\u0109\x02\x02\u1FD5\u1FD6\x07\u01CA\x02\x02\u1FD6\u1FD8\x07" + - "\u01CB\x02\x02\u1FD7\u1FD4\x03\x02\x02\x02\u1FD7\u1FD5\x03\x02\x02\x02" + - "\u1FD8\u03A5\x03\x02\x02\x02\u1FD9\u1FDB\x05\u03CE\u01E8\x02\u1FDA\u1FD9" + - "\x03\x02\x02\x02\u1FDA\u1FDB\x03\x02\x02\x02\u1FDB\u1FDC\x03\x02\x02\x02" + - "\u1FDC\u1FDD\x07\u016A\x02\x02\u1FDD\u1FDE\x05\u042C\u0217\x02\u1FDE\u1FDF" + - "\x07\u0146\x02\x02\u1FDF\u1FE1\x05\u03A8\u01D5\x02\u1FE0\u1FE2\x05\u0418" + - "\u020D\x02\u1FE1\u1FE0\x03\x02\x02\x02\u1FE1\u1FE2\x03\x02\x02\x02\u1FE2" + - "\u1FE4\x03\x02\x02\x02\u1FE3\u1FE5\x05\u043E\u0220\x02\u1FE4\u1FE3\x03" + - "\x02\x02\x02\u1FE4\u1FE5\x03\x02\x02\x02\u1FE5\u1FE7\x03\x02\x02\x02\u1FE6" + - "\u1FE8\x05\u0396\u01CC\x02\u1FE7\u1FE6\x03\x02\x02\x02\u1FE7\u1FE8\x03" + - "\x02\x02\x02\u1FE8\u03A7\x03\x02\x02\x02\u1FE9\u1FEE\x05\u03AA\u01D6\x02" + - "\u1FEA\u1FEB\x07\b\x02\x02\u1FEB\u1FED\x05\u03AA\u01D6\x02\u1FEC\u1FEA" + - "\x03\x02\x02\x02\u1FED\u1FF0\x03\x02\x02\x02\u1FEE\u1FEC\x03\x02\x02\x02" + - "\u1FEE\u1FEF\x03\x02\x02\x02\u1FEF\u03A9\x03\x02\x02\x02\u1FF0\u1FEE\x03" + - "\x02\x02\x02\u1FF1\u1FF2\x05\u03AC\u01D7\x02\u1FF2\u1FF3\x07\f\x02\x02" + - "\u1FF3\u1FF4\x05\u0480\u0241\x02\u1FF4\u1FFC\x03\x02\x02\x02\u1FF5\u1FF6" + - "\x07\x04\x02\x02\u1FF6\u1FF7\x05\u03AE\u01D8\x02\u1FF7\u1FF8\x07\x05\x02" + - "\x02\u1FF8\u1FF9\x07\f\x02\x02\u1FF9\u1FFA\x05\u0480\u0241\x02\u1FFA\u1FFC" + - "\x03\x02\x02\x02\u1FFB\u1FF1\x03\x02\x02\x02\u1FFB\u1FF5\x03\x02\x02\x02" + - "\u1FFC\u03AB\x03\x02\x02\x02\u1FFD\u1FFE\x05\u0550\u02A9\x02\u1FFE\u1FFF" + - "\x05\u0522\u0292\x02\u1FFF\u03AD\x03\x02\x02\x02\u2000\u2005\x05\u03AC" + - "\u01D7\x02\u2001\u2002\x07\b\x02\x02\u2002\u2004\x05\u03AC\u01D7\x02\u2003" + - "\u2001\x03\x02\x02\x02\u2004\u2007\x03\x02\x02\x02\u2005\u2003\x03\x02" + - "\x02\x02\u2005\u2006\x03\x02\x02\x02\u2006\u03AF\x03\x02\x02\x02\u2007" + - "\u2005\x03\x02\x02\x02\u2008\u2009\x07\xB4\x02\x02\u2009\u200A\x05\u03B2" + - "\u01DA\x02\u200A\u200B\x05\u03B4\u01DB\x02\u200B\u200C\x07\xAE\x02\x02" + - "\u200C\u200D\x05\u03B6\u01DC\x02\u200D\u200E\x07@\x02\x02\u200E\u200F" + - "\x05\u03B8\u01DD\x02\u200F\u03B1\x03\x02\x02\x02\u2010\u2011\x05\u0530" + - "\u0299\x02\u2011\u03B3\x03\x02\x02\x02\u2012\u2013\x07\u0106\x02\x02\u2013" + - "\u2018\x07\u013D\x02\x02\u2014\u2018\x07\u013D\x02\x02\u2015\u2018\x07" + - "m\x02\x02\u2016\u2018\x07\xE9\x02\x02\u2017\u2012\x03\x02\x02\x02\u2017" + - "\u2014\x03\x02\x02\x02\u2017\u2015\x03\x02\x02\x02\u2017\u2016\x03\x02" + - "\x02\x02\u2018\u201B\x03\x02\x02\x02\u2019\u2017\x03\x02\x02\x02\u2019" + - "\u201A\x03\x02\x02\x02\u201A\u03B5\x03\x02\x02\x02\u201B\u2019\x03\x02" + - "\x02\x02\u201C\u2022\x03\x02\x02\x02\u201D\u201E\x07k\x02\x02\u201E\u2022" + - "\x07\xDB\x02\x02\u201F\u2020\x07\u0174\x02\x02\u2020\u2022\x07\xDB\x02" + - "\x02\u2021\u201C\x03\x02\x02\x02\u2021\u201D\x03\x02\x02\x02\u2021\u201F" + - "\x03\x02\x02\x02\u2022\u03B7\x03\x02\x02\x02\u2023\u2026\x05\u03BC\u01DF" + - "\x02\u2024\u2026\x05\u03BA\u01DE\x02\u2025\u2023\x03\x02\x02\x02\u2025" + - "\u2024\x03\x02\x02\x02\u2026\u03B9\x03\x02\x02\x02\u2027\u2028\x07\x04" + - "\x02\x02\u2028\u2029\x05\u03BC\u01DF\x02\u2029\u202A\x07\x05\x02\x02\u202A" + - "\u2030\x03\x02\x02\x02\u202B\u202C\x07\x04\x02\x02\u202C\u202D\x05\u03BA" + - "\u01DE\x02\u202D\u202E\x07\x05\x02\x02\u202E\u2030\x03\x02\x02\x02\u202F" + - "\u2027\x03\x02\x02\x02\u202F\u202B\x03\x02\x02\x02\u2030\u03BB\x03\x02" + - "\x02\x02\u2031\u2033\x05\u03BE\u01E0\x02\u2032\u2034\x05\u03DE\u01F0\x02" + - "\u2033\u2032\x03\x02\x02\x02\u2033\u2034\x03\x02\x02\x02\u2034\u203D\x03" + - "\x02\x02\x02\u2035\u2037\x05\u040A\u0206\x02\u2036\u2038\x05\u03E8\u01F5" + - "\x02\u2037\u2036\x03\x02\x02\x02\u2037\u2038\x03\x02\x02\x02\u2038\u203E" + - "\x03\x02\x02\x02\u2039\u203B\x05\u03E6\u01F4\x02\u203A\u203C\x05\u040C" + - "\u0207\x02\u203B\u203A\x03\x02\x02\x02\u203B\u203C\x03\x02\x02\x02\u203C" + - "\u203E\x03\x02\x02\x02\u203D\u2035\x03\x02\x02\x02\u203D\u2039\x03\x02" + - "\x02\x02\u203D\u203E\x03\x02\x02\x02\u203E\u204F\x03\x02\x02\x02\u203F" + - "\u2040\x05\u03C6\u01E4\x02\u2040\u2042\x05\u03BE\u01E0\x02\u2041\u2043" + - "\x05\u03DE\u01F0\x02\u2042\u2041\x03\x02\x02\x02\u2042\u2043\x03\x02\x02" + - "\x02\u2043\u204C\x03\x02\x02\x02\u2044\u2046\x05\u040A\u0206\x02\u2045" + - "\u2047\x05\u03E8\u01F5\x02\u2046\u2045\x03\x02\x02\x02\u2046\u2047\x03" + - "\x02\x02\x02\u2047\u204D\x03\x02\x02\x02\u2048\u204A\x05\u03E6\u01F4\x02" + - "\u2049\u204B\x05\u040C\u0207\x02\u204A\u2049\x03\x02\x02\x02\u204A\u204B" + - "\x03\x02\x02\x02\u204B\u204D\x03\x02\x02\x02\u204C\u2044\x03\x02\x02\x02" + - "\u204C\u2048\x03\x02\x02\x02\u204C\u204D\x03\x02\x02\x02\u204D\u204F\x03" + - "\x02\x02\x02\u204E\u2031\x03\x02\x02\x02\u204E\u203F\x03\x02\x02\x02\u204F" + - "\u03BD\x03\x02\x02\x02\u2050\u2053\x05\u03C0\u01E1\x02\u2051\u2053\x05" + - "\u03BA\u01DE\x02\u2052\u2050\x03\x02\x02\x02\u2052\u2051\x03\x02\x02\x02" + - "\u2053\u03BF\x03\x02\x02\x02\u2054\u2061\x07Z\x02\x02\u2055\u2057\x05" + - "\u03DC\u01EF\x02\u2056\u2055\x03\x02\x02\x02\u2056\u2057\x03\x02\x02\x02" + - "\u2057\u2059\x03\x02\x02\x02\u2058\u205A\x05\u03D0\u01E9\x02\u2059\u2058" + - "\x03\x02\x02\x02\u2059\u205A\x03\x02\x02\x02\u205A\u205C\x03\x02\x02\x02" + - "\u205B\u205D\x05\u0524\u0293\x02\u205C\u205B\x03\x02\x02\x02\u205C\u205D" + - "\x03\x02\x02\x02\u205D\u2062\x03\x02\x02\x02\u205E\u205F\x05\u03DA\u01EE" + - "\x02\u205F\u2060\x05\u0526\u0294\x02\u2060\u2062\x03\x02\x02\x02\u2061" + - "\u2056\x03\x02\x02\x02\u2061\u205E\x03\x02\x02\x02\u2062\u2064\x03\x02" + - "\x02\x02\u2063\u2065\x05\u03D0\u01E9\x02\u2064\u2063\x03\x02\x02\x02\u2064" + - "\u2065\x03\x02\x02\x02\u2065\u2067\x03\x02\x02\x02\u2066\u2068\x05\u0418" + - "\u020D\x02\u2067\u2066\x03\x02\x02\x02\u2067\u2068\x03\x02\x02\x02\u2068" + - "\u206A\x03\x02\x02\x02\u2069\u206B\x05\u043C\u021F\x02\u206A\u2069\x03" + - "\x02\x02\x02\u206A\u206B\x03\x02\x02\x02\u206B\u206D\x03\x02\x02\x02\u206C" + - "\u206E\x05\u03FA\u01FE\x02\u206D\u206C\x03\x02\x02\x02\u206D\u206E\x03" + - "\x02\x02\x02\u206E\u2070\x03\x02\x02\x02\u206F\u2071\x05\u0408\u0205\x02" + - "\u2070\u206F\x03\x02\x02\x02\u2070\u2071\x03\x02\x02\x02\u2071\u2073\x03" + - "\x02\x02\x02\u2072\u2074\x05\u04CC\u0267\x02\u2073\u2072\x03\x02\x02\x02" + - "\u2073\u2074\x03\x02\x02\x02\u2074\u207F\x03\x02\x02\x02\u2075\u207F\x05" + - "\u0416\u020C\x02\u2076\u2077\x07^\x02\x02\u2077\u207F\x05\u0428\u0215" + - "\x02\u2078\u2079\x05\u03BA\u01DE\x02\u2079\u207C\x05\u03C4\u01E3\x02\u207A" + - "\u207D\x05\u03C0\u01E1\x02\u207B\u207D\x05\u03BA\u01DE\x02\u207C\u207A" + - "\x03\x02\x02\x02\u207C\u207B\x03\x02\x02\x02\u207D\u207F\x03\x02\x02\x02" + - "\u207E\u2054\x03\x02\x02\x02\u207E\u2075\x03\x02\x02\x02\u207E\u2076\x03" + - "\x02\x02\x02\u207E\u2078\x03\x02\x02\x02\u207F\u2087\x03\x02\x02\x02\u2080" + - "\u2083\x05\u03C4\u01E3\x02\u2081\u2084\x05\u03C0\u01E1\x02\u2082\u2084" + - "\x05\u03BA\u01DE\x02\u2083\u2081\x03\x02\x02\x02\u2083\u2082\x03\x02\x02" + - "\x02\u2084\u2086\x03\x02\x02\x02\u2085\u2080\x03\x02\x02\x02\u2086\u2089" + - "\x03\x02\x02\x02\u2087\u2085\x03\x02\x02\x02\u2087\u2088\x03\x02\x02\x02" + - "\u2088\u03C1\x03\x02\x02\x02\u2089\u2087\x03\x02\x02\x02\u208A\u208E\x07" + - "c\x02\x02\u208B\u208E\x07H\x02\x02\u208C\u208E\x07=\x02\x02\u208D\u208A" + - "\x03\x02\x02\x02\u208D\u208B\x03\x02\x02\x02\u208D\u208C\x03\x02\x02\x02" + - "\u208E\u03C3\x03\x02\x02\x02\u208F\u2091\x05\u03C2\u01E2\x02\u2090\u2092" + - "\x05\u03D8\u01ED\x02\u2091\u2090\x03\x02\x02\x02\u2091\u2092\x03\x02\x02" + - "\x02\u2092\u03C5\x03\x02\x02\x02\u2093\u2095\x07k\x02\x02\u2094\u2096" + - "\x07\u0128\x02\x02\u2095\u2094\x03\x02\x02\x02\u2095\u2096\x03\x02\x02" + - "\x02\u2096\u2097\x03\x02\x02\x02\u2097\u2098\x05\u03C8\u01E5\x02\u2098" + - "\u03C7\x03\x02\x02\x02\u2099\u209E\x05\u03CA\u01E6\x02\u209A\u209B\x07" + - "\b\x02\x02\u209B\u209D\x05\u03CA\u01E6\x02\u209C\u209A\x03\x02\x02\x02" + - "\u209D\u20A0\x03\x02\x02\x02\u209E\u209C\x03\x02\x02\x02\u209E\u209F\x03" + - "\x02\x02\x02\u209F\u03C9\x03\x02\x02\x02\u20A0\u209E\x03\x02\x02\x02\u20A1" + - "\u20A3\x05\u0530\u0299\x02\u20A2\u20A4\x05\u0366\u01B4\x02\u20A3\u20A2" + - "\x03\x02\x02\x02\u20A3\u20A4\x03\x02\x02\x02\u20A4\u20A5\x03\x02\x02\x02" + - "\u20A5\u20A7\x07&\x02\x02\u20A6\u20A8\x05\u03CC\u01E7\x02\u20A7\u20A6" + - "\x03\x02\x02\x02\u20A7\u20A8\x03\x02\x02\x02\u20A8\u20A9\x03\x02\x02\x02" + - "\u20A9\u20AA\x07\x04\x02\x02\u20AA\u20AB\x05\u037E\u01C0\x02\u20AB\u20AC" + - "\x07\x05\x02\x02\u20AC\u03CB\x03\x02\x02\x02\u20AD\u20B1\x07\xFC\x02\x02" + - "\u20AE\u20AF\x07O\x02\x02\u20AF\u20B1\x07\xFC\x02\x02\u20B0\u20AD\x03" + - "\x02\x02\x02\u20B0\u20AE\x03\x02\x02\x02\u20B1\u03CD\x03\x02\x02\x02\u20B2" + - "\u20B3\x05\u03C6\u01E4\x02\u20B3\u03CF\x03\x02\x02\x02\u20B4\u20B9\x07" + - "I\x02\x02\u20B5\u20B6\x05\u03D2\u01EA\x02\u20B6\u20B7\x05\u03D4\u01EB" + - "\x02\u20B7\u20BA\x03\x02\x02\x02\u20B8\u20BA\x05\u060E\u0308\x02\u20B9" + - "\u20B5\x03\x02\x02\x02\u20B9\u20B8\x03\x02\x02\x02\u20BA\u03D1\x03\x02" + - "\x02\x02\u20BB\u20BE\x03\x02\x02\x02\u20BC\u20BE\x07\u0153\x02\x02\u20BD" + - "\u20BB\x03\x02\x02\x02\u20BD\u20BC\x03\x02\x02\x02\u20BE\u03D3\x03\x02" + - "\x02\x02\u20BF\u20C1\t)\x02\x02\u20C0\u20BF\x03\x02\x02\x02\u20C0\u20C1" + - "\x03\x02\x02\x02\u20C1\u20C2\x03\x02\x02\x02\u20C2\u20C4\t\x0E\x02\x02" + - "\u20C3\u20C5\x05\u03D6\u01EC\x02\u20C4\u20C3\x03\x02\x02\x02\u20C4\u20C5" + - "\x03\x02\x02\x02\u20C5\u20C6\x03\x02\x02\x02\u20C6\u20D0\x05\u052C\u0297" + - "\x02\u20C7\u20C9\x07\u0168\x02\x02\u20C8\u20CA\x05\u03D6\u01EC\x02\u20C9" + - "\u20C8\x03\x02\x02\x02\u20C9\u20CA\x03\x02\x02\x02\u20CA\u20CB\x03\x02" + - "\x02\x02\u20CB\u20D0\x05\u052C\u0297\x02\u20CC\u20CD\x07^\x02\x02\u20CD" + - "\u20D0\x05\u052C\u0297\x02\u20CE\u20D0\x05\u052C\u0297\x02\u20CF\u20C0" + - "\x03\x02\x02\x02\u20CF\u20C7\x03\x02\x02\x02\u20CF\u20CC\x03\x02\x02\x02" + - "\u20CF\u20CE\x03\x02\x02\x02\u20D0\u03D5\x03\x02\x02\x02\u20D1\u20D2\x07" + - "^\x02\x02\u20D2\u03D7\x03\x02\x02\x02\u20D3\u20D4\t*\x02\x02\u20D4\u03D9" + - "\x03\x02\x02\x02\u20D5\u20DB\x07:\x02\x02\u20D6\u20D7\x07R\x02\x02\u20D7" + - "\u20D8\x07\x04\x02\x02\u20D8\u20D9\x05\u04F4\u027B\x02\u20D9\u20DA\x07" + - "\x05\x02\x02\u20DA\u20DC\x03\x02\x02\x02\u20DB\u20D6\x03\x02\x02\x02\u20DB" + - "\u20DC\x03\x02\x02\x02\u20DC\u03DB\x03\x02\x02\x02\u20DD\u20DE\x07 \x02" + - "\x02\u20DE\u03DD\x03\x02\x02\x02\u20DF\u20E0\x05\u03E0\u01F1\x02\u20E0" + - "\u03DF\x03\x02\x02\x02\u20E1\u20E2\x07U\x02\x02\u20E2\u20E3\x07\x95\x02" + - "\x02\u20E3\u20E4\x05\u03E2\u01F2\x02\u20E4\u03E1\x03\x02\x02\x02\u20E5" + - "\u20EA\x05\u03E4\u01F3\x02\u20E6\u20E7\x07\b\x02\x02\u20E7\u20E9\x05\u03E4" + - "\u01F3\x02\u20E8\u20E6\x03\x02\x02\x02\u20E9\u20EC\x03\x02\x02\x02\u20EA" + - "\u20E8\x03\x02\x02\x02\u20EA\u20EB\x03\x02\x02\x02\u20EB\u03E3\x03\x02" + - "\x02\x02\u20EC\u20EA\x03\x02\x02\x02\u20ED\u20F3\x05\u0480\u0241\x02\u20EE" + - "\u20EF\x07f\x02\x02\u20EF\u20F4\x05\u04F0\u0279\x02\u20F0\u20F2\x05\u0264" + - "\u0133\x02\u20F1\u20F0\x03\x02\x02\x02\u20F1\u20F2\x03\x02\x02\x02\u20F2" + - "\u20F4\x03\x02\x02\x02\u20F3\u20EE\x03\x02\x02\x02\u20F3\u20F1\x03\x02" + - "\x02\x02\u20F4\u20F6\x03\x02\x02\x02\u20F5\u20F7\x05\u0266\u0134\x02\u20F6" + - "\u20F5\x03\x02\x02\x02\u20F6\u20F7\x03\x02\x02\x02\u20F7\u03E5\x03\x02" + - "\x02\x02\u20F8\u20FA\x05\u03EA\u01F6\x02\u20F9\u20FB\x05\u03EC\u01F7\x02" + - "\u20FA\u20F9\x03\x02\x02\x02\u20FA\u20FB\x03\x02\x02\x02\u20FB\u2101\x03" + - "\x02\x02\x02\u20FC\u20FE\x05\u03EC\u01F7\x02\u20FD\u20FF\x05\u03EA\u01F6" + - "\x02\u20FE\u20FD\x03\x02\x02\x02\u20FE\u20FF\x03\x02\x02\x02\u20FF\u2101" + - "\x03\x02\x02\x02\u2100\u20F8\x03\x02\x02\x02\u2100\u20FC\x03\x02\x02\x02" + - "\u2101\u03E7\x03\x02\x02\x02\u2102\u2103\x05\u03E6\u01F4\x02\u2103\u03E9" + - "\x03\x02\x02\x02\u2104\u2105\x07L\x02\x02\u2105\u2108\x05\u03EE\u01F8" + - "\x02\u2106\u2107\x07\b\x02\x02\u2107\u2109\x05\u03F0\u01F9\x02\u2108\u2106" + - "\x03\x02\x02\x02\u2108\u2109\x03\x02\x02\x02\u2109\u211C\x03\x02\x02\x02" + - "\u210A\u210B\x07?\x02\x02\u210B\u2119\x05\u03F8\u01FD\x02\u210C\u210D" + - "\x05\u03F2\u01FA\x02\u210D\u2111\x05\u03F6\u01FC\x02\u210E\u2112\x07S" + - "\x02\x02\u210F\u2110\x07k\x02\x02\u2110\u2112\x07\u01CC\x02\x02\u2111" + - "\u210E\x03\x02\x02\x02\u2111\u210F\x03\x02\x02\x02\u2112\u211A\x03\x02" + - "\x02\x02\u2113\u2117\x05\u03F6\u01FC\x02\u2114\u2118\x07S\x02\x02\u2115" + - "\u2116\x07k\x02\x02\u2116\u2118\x07\u01CC\x02\x02\u2117\u2114\x03\x02" + - "\x02\x02\u2117\u2115\x03\x02\x02\x02\u2118\u211A\x03\x02\x02\x02\u2119" + - "\u210C\x03\x02\x02\x02\u2119\u2113\x03\x02\x02\x02\u211A\u211C\x03\x02" + - "\x02\x02\u211B\u2104\x03\x02\x02\x02\u211B\u210A\x03\x02\x02\x02\u211C" + - "\u03EB\x03\x02\x02\x02\u211D\u2122\x07Q\x02\x02\u211E\u2123\x05\u03F0" + - "\u01F9\x02\u211F\u2120\x05\u03F2\u01FA\x02\u2120\u2121\x05\u03F6\u01FC" + - "\x02\u2121\u2123\x03\x02\x02\x02\u2122\u211E\x03\x02\x02\x02\u2122\u211F" + - "\x03\x02\x02\x02\u2123\u03ED\x03\x02\x02\x02\u2124\u2127\x05\u0480\u0241" + - "\x02\u2125\u2127\x07 \x02\x02\u2126\u2124\x03\x02\x02\x02\u2126\u2125" + - "\x03\x02\x02\x02\u2127\u03EF\x03\x02\x02\x02\u2128\u2129\x05\u0480\u0241" + - "\x02\u2129\u03F1\x03\x02\x02\x02\u212A\u2130\x05\u04AA\u0256\x02\u212B" + - "\u212C\x07\x0E\x02\x02\u212C\u2130\x05\u03F4\u01FB\x02\u212D\u212E\x07" + - "\x0F\x02\x02\u212E\u2130\x05\u03F4\u01FB\x02\u212F\u212A\x03\x02\x02\x02" + - "\u212F\u212B\x03\x02\x02\x02\u212F\u212D\x03\x02\x02\x02\u2130\u03F3\x03" + - "\x02\x02\x02\u2131\u2134\x05\u0540\u02A1\x02\u2132\u2134\x05\u053E\u02A0" + - "\x02\u2133\u2131\x03\x02\x02\x02\u2133\u2132\x03\x02\x02\x02\u2134\u03F5" + - "\x03\x02\x02\x02\u2135\u2136\t+\x02\x02\u2136\u03F7\x03\x02\x02\x02\u2137" + - "\u2138\t,\x02\x02\u2138\u03F9\x03\x02\x02\x02\u2139\u213A\x07D\x02\x02" + - "\u213A\u213B\x07\x95\x02\x02\u213B\u213C\x05\u03FC\u01FF\x02\u213C\u03FB" + - "\x03\x02\x02\x02\u213D\u2142\x05\u03FE\u0200\x02\u213E\u213F\x07\b\x02" + - "\x02\u213F\u2141\x05\u03FE\u0200\x02\u2140\u213E\x03\x02\x02\x02\u2141" + - "\u2144\x03\x02\x02\x02\u2142\u2140\x03\x02\x02\x02\u2142\u2143\x03\x02" + - "\x02\x02\u2143\u03FD\x03\x02\x02\x02\u2144\u2142\x03\x02\x02\x02\u2145" + - "\u214B\x05\u0480\u0241\x02\u2146\u214B\x05\u0400\u0201\x02\u2147\u214B" + - "\x05\u0404\u0203\x02\u2148\u214B\x05\u0402\u0202\x02\u2149\u214B\x05\u0406" + - "\u0204\x02\u214A\u2145\x03\x02\x02\x02\u214A\u2146\x03\x02\x02\x02\u214A" + - "\u2147\x03\x02\x02\x02\u214A\u2148\x03\x02\x02\x02\u214A\u2149\x03\x02" + - "\x02\x02\u214B\u03FF\x03\x02\x02\x02\u214C\u214D\x07\x04\x02\x02\u214D" + - "\u214E\x07\x05\x02\x02\u214E\u0401\x03"; + "\u1E7F\x05\u0214\u010B\x02\u1E7F\u1EA5\x03\x02\x02\x02\u1E80\u1E81\x07" + + "\x8C\x02\x02\u1E81\u1E82\x07\u0165\x02\x02\u1E82\u1E83\x07\u0147\x02\x02" + + "\u1E83\u1E84\x07\xA5\x02\x02\u1E84\u1E85\x05\u0214\u010B\x02\u1E85\u1E86" + + "\x07\x8C\x02\x02\u1E86\u1E87\x07\u0103\x02\x02\u1E87\u1E88\x07@\x02\x02" + + "\u1E88\u1E89\x05\u053E\u02A0\x02\u1E89\u1E8A\x07\u0139\x02\x02\u1E8A\u1E8B" + + "\x05\u0214\u010B\x02\u1E8B\u1E8C\x05\u0356\u01AC\x02\u1E8C\u1E8D\x05\u0214" + + "\u010B\x02\u1E8D\u1EA5\x03\x02\x02\x02\u1E8E\u1E8F\x07\x8C\x02\x02\u1E8F" + + "\u1E90\x07\u0165\x02\x02\u1E90\u1E91\x07\u0147\x02\x02\u1E91\u1E92\x07" + + "\xA5\x02\x02\u1E92\u1E93\x05\u0214\u010B\x02\u1E93\u1E94\x07\xC1\x02\x02" + + "\u1E94\u1E95\x07\u0103\x02\x02\u1E95\u1E96\x07@\x02\x02\u1E96\u1E97\x05" + + "\u053E\u02A0\x02\u1E97\u1EA5\x03\x02\x02\x02\u1E98\u1E99\x07\x8C\x02\x02" + + "\u1E99\u1E9A\x07\u0165\x02\x02\u1E9A\u1E9B\x07\u0147\x02\x02\u1E9B\u1E9C" + + "\x07\xA5\x02\x02\u1E9C\u1E9D\x05\u0214\u010B\x02\u1E9D\u1E9E\x07\xC1\x02" + + "\x02\u1E9E\u1E9F\x07\u0103\x02\x02\u1E9F\u1EA0\x07\xDE\x02\x02\u1EA0\u1EA1" + + "\x07\u018E\x02\x02\u1EA1\u1EA2\x07@\x02\x02\u1EA2\u1EA3\x05\u053E\u02A0" + + "\x02\u1EA3\u1EA5\x03\x02\x02\x02\u1EA4\u1E5C\x03\x02\x02\x02\u1EA4\u1E68" + + "\x03\x02\x02\x02\u1EA4\u1E74\x03\x02\x02\x02\u1EA4\u1E80\x03\x02\x02\x02" + + "\u1EA4\u1E8E\x03\x02\x02\x02\u1EA4\u1E98\x03\x02\x02\x02\u1EA5\u0355\x03" + + "\x02\x02\x02\u1EA6\u1EA7\x07k\x02\x02\u1EA7\u0357\x03\x02\x02\x02\u1EA8" + + "\u1EAA\x070\x02\x02\u1EA9\u1EAB\x05\u01F0\xF9\x02\u1EAA\u1EA9\x03\x02" + + "\x02\x02\u1EAA\u1EAB\x03\x02\x02\x02\u1EAB\u1EAC\x03\x02\x02\x02\u1EAC" + + "\u1EAD\x07\xAA\x02\x02\u1EAD\u1EAE\x05\u0214\u010B\x02\u1EAE\u1EAF\x07" + + "@\x02\x02\u1EAF\u1EB0\x05\u0552\u02AA\x02\u1EB0\u1EB1\x07`\x02\x02\u1EB1" + + "\u1EB2\x05\u0552\u02AA\x02\u1EB2\u1EB3\x07B\x02\x02\u1EB3\u1EB4\x05\u0214" + + "\u010B\x02\u1EB4\u0359\x03\x02\x02\x02\u1EB5\u1EB7\x07\xA0\x02\x02\u1EB6" + + "\u1EB8\x05\u036E\u01B8\x02\u1EB7\u1EB6\x03\x02\x02\x02\u1EB7\u1EB8\x03" + + "\x02\x02\x02\u1EB8\u1EB9\x03\x02\x02\x02\u1EB9\u1EBB\x05\u053C\u029F\x02" + + "\u1EBA\u1EBC\x05\u035C\u01AF\x02\u1EBB\u1EBA\x03\x02\x02\x02\u1EBB\u1EBC" + + "\x03\x02\x02\x02\u1EBC\u1ECA\x03\x02\x02\x02\u1EBD\u1EBF\x07\xA0\x02\x02" + + "\u1EBE\u1EC0\x05\u036E\u01B8\x02\u1EBF\u1EBE\x03\x02\x02\x02\u1EBF\u1EC0" + + "\x03\x02\x02\x02\u1EC0\u1ECA\x03\x02\x02\x02\u1EC1\u1EC3\x07\xA0\x02\x02" + + "\u1EC2\u1EC4\x05\u036E\u01B8\x02\u1EC3\u1EC2\x03\x02\x02\x02\u1EC3\u1EC4" + + "\x03\x02\x02\x02\u1EC4\u1EC5\x03\x02\x02\x02\u1EC5\u1EC6\x05\u0540\u02A1" + + "\x02\u1EC6\u1EC7\x07R\x02\x02\u1EC7\u1EC8\x05\u053C\u029F\x02\u1EC8\u1ECA" + + "\x03\x02\x02\x02\u1EC9\u1EB5\x03\x02\x02\x02\u1EC9\u1EBD\x03\x02\x02\x02" + + "\u1EC9\u1EC1\x03\x02\x02\x02\u1ECA\u035B\x03\x02\x02\x02\u1ECB\u1ECC\x07" + + "f\x02\x02\u1ECC\u1ECD\x05\u0540\u02A1\x02\u1ECD\u035D\x03\x02\x02\x02" + + "\u1ECE\u1ED0\x07\u0174\x02\x02\u1ECF\u1ED1\x05\u0370\u01B9\x02\u1ED0\u1ECF" + + "\x03\x02\x02\x02\u1ED0\u1ED1\x03\x02\x02\x02\u1ED1\u1ED3\x03\x02\x02\x02" + + "\u1ED2\u1ED4\x05\u0372\u01BA\x02\u1ED3\u1ED2\x03\x02\x02\x02\u1ED3\u1ED4" + + "\x03\x02\x02\x02\u1ED4\u1ED6\x03\x02\x02\x02\u1ED5\u1ED7\x05\u036E\u01B8" + + "\x02\u1ED6\u1ED5\x03\x02\x02\x02\u1ED6\u1ED7\x03\x02\x02\x02\u1ED7\u1ED9" + + "\x03\x02\x02\x02\u1ED8\u1EDA\x05\u036C\u01B7\x02\u1ED9\u1ED8\x03\x02\x02" + + "\x02\u1ED9\u1EDA\x03\x02\x02\x02\u1EDA\u1EDC\x03\x02\x02\x02\u1EDB\u1EDD" + + "\x05\u037A\u01BE\x02\u1EDC\u1EDB\x03\x02\x02\x02\u1EDC\u1EDD\x03\x02\x02" + + "\x02\u1EDD\u1EE6\x03\x02\x02\x02\u1EDE\u1EDF\x07\u0174\x02\x02\u1EDF\u1EE0" + + "\x07\x04\x02\x02\u1EE0\u1EE1\x05\u0362\u01B2\x02\u1EE1\u1EE3\x07\x05\x02" + + "\x02\u1EE2\u1EE4\x05\u037A\u01BE\x02\u1EE3\u1EE2\x03\x02\x02\x02\u1EE3" + + "\u1EE4\x03\x02\x02\x02\u1EE4\u1EE6\x03\x02\x02\x02\u1EE5\u1ECE\x03\x02" + + "\x02\x02\u1EE5\u1EDE\x03\x02\x02\x02\u1EE6\u035F\x03\x02\x02\x02\u1EE7" + + "\u1EE9\x05\u0364\u01B3\x02\u1EE8\u1EEA\x05\u036E\u01B8\x02\u1EE9\u1EE8" + + "\x03\x02\x02\x02\u1EE9\u1EEA\x03\x02\x02\x02\u1EEA\u1EEC\x03\x02\x02\x02" + + "\u1EEB\u1EED\x05\u037A\u01BE\x02\u1EEC\u1EEB\x03\x02\x02\x02\u1EEC\u1EED" + + "\x03\x02\x02\x02\u1EED\u1EF6\x03\x02\x02\x02\u1EEE\u1EEF\x05\u0364\u01B3" + + "\x02\u1EEF\u1EF0\x07\x04\x02\x02\u1EF0\u1EF1\x05\u0362\u01B2\x02\u1EF1" + + "\u1EF3\x07\x05\x02\x02\u1EF2\u1EF4\x05\u037A\u01BE\x02\u1EF3\u1EF2\x03" + + "\x02\x02\x02\u1EF3\u1EF4\x03\x02\x02\x02\u1EF4\u1EF6\x03\x02\x02\x02\u1EF5" + + "\u1EE7\x03\x02\x02\x02\u1EF5\u1EEE\x03\x02\x02\x02\u1EF6\u0361\x03\x02" + + "\x02\x02\u1EF7\u1EFC\x05\u0366\u01B4\x02\u1EF8\u1EF9\x07\b\x02\x02\u1EF9" + + "\u1EFB\x05\u0366\u01B4\x02\u1EFA\u1EF8\x03\x02\x02\x02\u1EFB\u1EFE\x03" + + "\x02\x02\x02\u1EFC\u1EFA\x03\x02\x02\x02\u1EFC\u1EFD\x03\x02\x02\x02\u1EFD" + + "\u0363\x03\x02\x02\x02\u1EFE\u1EFC\x03\x02\x02\x02\u1EFF\u1F00\t,\x02" + + "\x02\u1F00\u0365\x03\x02\x02\x02\u1F01\u1F03\x05\u0368\u01B5\x02\u1F02" + + "\u1F04\x05\u036A\u01B6\x02\u1F03\u1F02\x03\x02\x02\x02\u1F03\u1F04\x03" + + "\x02\x02\x02\u1F04\u0367\x03\x02\x02\x02\u1F05\u1F08\x05\u056E\u02B8\x02" + + "\u1F06\u1F08\x05\u0364\u01B3\x02\u1F07\u1F05\x03\x02\x02\x02\u1F07\u1F06" + + "\x03\x02\x02\x02\u1F08\u0369\x03\x02\x02\x02\u1F09\u1F0C\x05B\"\x02\u1F0A" + + "\u1F0C\x05\u0128\x95\x02\u1F0B\u1F09\x03\x02\x02\x02\u1F0B\u1F0A\x03\x02" + + "\x02\x02\u1F0C\u036B\x03\x02\x02\x02\u1F0D\u1F0E\x05\u0364\u01B3\x02\u1F0E" + + "\u036D\x03\x02\x02\x02\u1F0F\u1F10\x07\x82\x02\x02\u1F10\u036F\x03\x02" + + "\x02\x02\u1F11\u1F12\x07s\x02\x02\u1F12\u0371\x03\x02\x02\x02\u1F13\u1F14" + + "\x07r\x02\x02\u1F14\u0373\x03\x02\x02\x02\u1F15\u1F16\x07\x04\x02\x02" + + "\u1F16\u1F17\x05\u053E\u02A0\x02\u1F17\u1F18\x07\x05\x02\x02\u1F18\u0375" + + "\x03\x02\x02\x02\u1F19\u1F1B\x05\u053C\u029F\x02\u1F1A\u1F1C\x05\u0374" + + "\u01BB\x02\u1F1B\u1F1A\x03\x02\x02\x02\u1F1B\u1F1C\x03\x02\x02\x02\u1F1C" + + "\u0377\x03\x02\x02\x02\u1F1D\u1F22\x05\u0376\u01BC\x02\u1F1E\u1F1F\x07" + + "\b\x02\x02\u1F1F\u1F21\x05\u0376\u01BC\x02\u1F20\u1F1E\x03\x02\x02\x02" + + "\u1F21\u1F24\x03\x02\x02\x02\u1F22\u1F20\x03\x02\x02\x02\u1F22\u1F23\x03" + + "\x02\x02\x02\u1F23\u0379\x03\x02\x02\x02\u1F24\u1F22\x03\x02\x02\x02\u1F25" + + "\u1F26\x05\u0378\u01BD\x02\u1F26\u037B\x03\x02\x02\x02\u1F27\u1F28\x07" + + "\xCD\x02\x02\u1F28\u1F3A\x05\u037E\u01C0\x02\u1F29\u1F2A\x07\xCD\x02\x02" + + "\u1F2A\u1F2C\x05\u0364\u01B3\x02\u1F2B\u1F2D\x05\u036E\u01B8\x02\u1F2C" + + "\u1F2B\x03\x02\x02\x02\u1F2C\u1F2D\x03\x02\x02\x02\u1F2D\u1F2E\x03\x02" + + "\x02\x02\u1F2E\u1F2F\x05\u037E\u01C0\x02\u1F2F\u1F3A\x03\x02\x02\x02\u1F30" + + "\u1F31\x07\xCD\x02\x02\u1F31\u1F32\x07\x82\x02\x02\u1F32\u1F3A\x05\u037E" + + "\u01C0\x02\u1F33\u1F34\x07\xCD\x02\x02\u1F34\u1F35\x07\x04\x02\x02\u1F35" + + "\u1F36\x05\u0380\u01C1\x02\u1F36\u1F37\x07\x05\x02\x02\u1F37\u1F38\x05" + + "\u037E\u01C0\x02\u1F38\u1F3A\x03\x02\x02\x02\u1F39\u1F27\x03\x02\x02\x02" + + "\u1F39\u1F29\x03\x02\x02\x02\u1F39\u1F30\x03\x02\x02\x02\u1F39\u1F33\x03" + + "\x02\x02\x02\u1F3A\u037D\x03\x02\x02\x02\u1F3B\u1F45\x05\u03C6\u01E4\x02" + + "\u1F3C\u1F45\x05\u0394\u01CB\x02\u1F3D\u1F45\x05\u03B4\u01DB\x02\u1F3E" + + "\u1F45\x05\u03A6\u01D4\x02\u1F3F\u1F45\x05\u03BE\u01E0\x02\u1F40\u1F45" + + "\x05\u010C\x87\x02\u1F41\u1F45\x05\u0112\x8A\x02\u1F42\u1F45\x05\u0118" + + "\x8D\x02\u1F43\u1F45\x05\u038E\u01C8\x02\u1F44\u1F3B\x03\x02\x02\x02\u1F44" + + "\u1F3C\x03\x02\x02\x02\u1F44\u1F3D\x03\x02\x02\x02\u1F44\u1F3E\x03\x02" + + "\x02\x02\u1F44\u1F3F\x03\x02\x02\x02\u1F44\u1F40\x03\x02\x02\x02\u1F44" + + "\u1F41\x03\x02\x02\x02\u1F44\u1F42\x03\x02\x02\x02\u1F44\u1F43\x03\x02" + + "\x02\x02\u1F45\u037F\x03\x02\x02\x02\u1F46\u1F4B\x05\u0382\u01C2\x02\u1F47" + + "\u1F48\x07\b\x02\x02\u1F48\u1F4A\x05\u0382\u01C2\x02\u1F49\u1F47\x03\x02" + + "\x02\x02\u1F4A\u1F4D\x03\x02\x02\x02\u1F4B\u1F49\x03\x02\x02\x02\u1F4B" + + "\u1F4C\x03\x02\x02\x02\u1F4C\u0381\x03\x02\x02\x02\u1F4D\u1F4B\x03\x02" + + "\x02\x02\u1F4E\u1F50\x05\u0384\u01C3\x02\u1F4F\u1F51\x05\u0386\u01C4\x02" + + "\u1F50\u1F4F\x03\x02\x02\x02\u1F50\u1F51\x03\x02\x02\x02\u1F51\u0383\x03" + + "\x02\x02\x02\u1F52\u1F55\x05\u056E\u02B8\x02\u1F53\u1F55\x05\u0364\u01B3" + + "\x02\u1F54\u1F52\x03\x02\x02\x02\u1F54\u1F53\x03\x02\x02\x02\u1F55\u0385" + + "\x03\x02\x02\x02\u1F56\u1F59\x05B\"\x02\u1F57\u1F59\x05\u0128\x95\x02" + + "\u1F58\u1F56\x03\x02\x02\x02\u1F58\u1F57\x03\x02\x02\x02\u1F59\u0387\x03" + + "\x02\x02\x02\u1F5A\u1F5B\x07\u0124\x02\x02\u1F5B\u1F5D\x05\u0540\u02A1" + + "\x02\u1F5C\u1F5E\x05\u038A\u01C6\x02\u1F5D\u1F5C\x03\x02\x02\x02\u1F5D" + + "\u1F5E\x03\x02\x02\x02\u1F5E\u1F5F\x03\x02\x02\x02\u1F5F\u1F60\x07&\x02" + + "\x02\u1F60\u1F61\x05\u038C\u01C7\x02\u1F61\u0389\x03\x02\x02\x02\u1F62" + + "\u1F63\x07\x04\x02\x02\u1F63\u1F64\x05\u0508\u0285\x02\u1F64\u1F65\x07" + + "\x05\x02\x02\u1F65\u038B\x03\x02\x02\x02\u1F66\u1F6B\x05\u03C6\u01E4\x02" + + "\u1F67\u1F6B\x05\u0394\u01CB\x02\u1F68\u1F6B\x05\u03B4\u01DB\x02\u1F69" + + "\u1F6B\x05\u03A6\u01D4\x02\u1F6A\u1F66\x03\x02\x02\x02\u1F6A\u1F67\x03" + + "\x02\x02\x02\u1F6A\u1F68\x03\x02\x02\x02\u1F6A\u1F69\x03\x02\x02\x02\u1F6B" + + "\u038D\x03\x02\x02\x02\u1F6C\u1F6D\x07\xCC\x02\x02\u1F6D\u1F6F\x05\u0540" + + "\u02A1\x02\u1F6E\u1F70\x05\u0390\u01C9\x02\u1F6F\u1F6E\x03\x02\x02\x02" + + "\u1F6F\u1F70\x03\x02\x02\x02\u1F70\u1F93\x03\x02\x02\x02\u1F71\u1F73\x07" + + "0\x02\x02\u1F72\u1F74\x05\xAEX\x02\u1F73\u1F72\x03\x02\x02\x02\u1F73\u1F74" + + "\x03\x02\x02\x02\u1F74\u1F75\x03\x02\x02\x02\u1F75\u1F76\x07^\x02\x02" + + "\u1F76\u1F77\x05\u010E\x88\x02\u1F77\u1F78\x07&\x02\x02\u1F78\u1F79\x07" + + "\xCC\x02\x02\u1F79\u1F7B\x05\u0540\u02A1\x02\u1F7A\u1F7C\x05\u0390\u01C9" + + "\x02\u1F7B\u1F7A\x03\x02\x02\x02\u1F7B\u1F7C\x03\x02\x02\x02\u1F7C\u1F7E" + + "\x03\x02\x02\x02\u1F7D\u1F7F\x05\u0110\x89\x02\u1F7E\u1F7D\x03\x02\x02" + + "\x02\u1F7E\u1F7F\x03\x02\x02\x02\u1F7F\u1F93\x03\x02\x02\x02\u1F80\u1F82" + + "\x070\x02\x02\u1F81\u1F83\x05\xAEX\x02\u1F82\u1F81\x03\x02\x02\x02\u1F82" + + "\u1F83\x03\x02\x02\x02\u1F83\u1F84\x03\x02\x02\x02\u1F84\u1F85\x07^\x02" + + "\x02\u1F85\u1F86\x07\xDE\x02\x02\u1F86\u1F87\x07O\x02\x02\u1F87\u1F88" + + "\x07\u018E\x02\x02\u1F88\u1F89\x05\u010E\x88\x02\u1F89\u1F8A\x07&\x02" + + "\x02\u1F8A\u1F8B\x07\xCC\x02\x02\u1F8B\u1F8D\x05\u0540\u02A1\x02\u1F8C" + + "\u1F8E\x05\u0390\u01C9\x02\u1F8D\u1F8C\x03\x02\x02\x02\u1F8D\u1F8E\x03" + + "\x02\x02\x02\u1F8E\u1F90\x03\x02\x02\x02\u1F8F\u1F91\x05\u0110\x89\x02" + + "\u1F90\u1F8F\x03\x02\x02\x02\u1F90\u1F91\x03\x02\x02\x02\u1F91\u1F93\x03" + + "\x02\x02\x02\u1F92\u1F6C\x03\x02\x02\x02\u1F92\u1F71\x03\x02\x02\x02\u1F92" + + "\u1F80\x03\x02\x02\x02\u1F93\u038F\x03\x02\x02\x02\u1F94\u1F95\x07\x04" + + "\x02\x02\u1F95\u1F96\x05\u0502\u0282\x02\u1F96\u1F97\x07\x05\x02\x02\u1F97" + + "\u0391\x03\x02\x02\x02\u1F98\u1F99\x07\xB3\x02\x02\u1F99\u1FA3\x05\u0540" + + "\u02A1\x02\u1F9A\u1F9B\x07\xB3\x02\x02\u1F9B\u1F9C\x07\u0124\x02\x02\u1F9C" + + "\u1FA3\x05\u0540\u02A1\x02\u1F9D\u1F9E\x07\xB3\x02\x02\u1F9E\u1FA3\x07" + + " \x02\x02\u1F9F\u1FA0\x07\xB3\x02\x02\u1FA0\u1FA1\x07\u0124\x02\x02\u1FA1" + + "\u1FA3\x07 \x02\x02\u1FA2\u1F98\x03\x02\x02\x02\u1FA2\u1F9A\x03\x02\x02" + + "\x02\u1FA2\u1F9D\x03\x02\x02\x02\u1FA2\u1F9F\x03\x02\x02\x02\u1FA3\u0393" + + "\x03\x02\x02\x02\u1FA4\u1FA6\x05\u03DC\u01EF\x02\u1FA5\u1FA4\x03\x02\x02" + + "\x02\u1FA5\u1FA6\x03\x02\x02\x02\u1FA6\u1FA7\x03\x02\x02\x02\u1FA7\u1FA8" + + "\x07\xF3\x02\x02\u1FA8\u1FA9\x07I\x02\x02\u1FA9\u1FAA\x05\u0396\u01CC" + + "\x02\u1FAA\u1FAC\x05\u0398\u01CD\x02\u1FAB\u1FAD\x05\u03A0\u01D1\x02\u1FAC" + + "\u1FAB\x03\x02\x02\x02\u1FAC\u1FAD\x03\x02\x02\x02\u1FAD\u1FAF\x03\x02" + + "\x02\x02\u1FAE\u1FB0\x05\u03A4\u01D3\x02\u1FAF\u1FAE\x03\x02\x02\x02\u1FAF" + + "\u1FB0\x03\x02\x02\x02\u1FB0\u0395\x03\x02\x02\x02\u1FB1\u1FB4\x05\u053C" + + "\u029F\x02\u1FB2\u1FB3\x07&\x02\x02\u1FB3\u1FB5\x05\u0562\u02B2\x02\u1FB4" + + "\u1FB2\x03\x02\x02\x02\u1FB4\u1FB5\x03\x02\x02\x02\u1FB5\u0397\x03\x02" + + "\x02\x02\u1FB6\u1FCA\x05\u03C6\u01E4\x02\u1FB7\u1FB8\x07\u01D1\x02\x02" + + "\u1FB8\u1FB9\x05\u039A\u01CE\x02\u1FB9\u1FBA\x07\u01C4\x02\x02\u1FBA\u1FBB" + + "\x05\u03C6\u01E4\x02\u1FBB\u1FCA\x03\x02\x02\x02\u1FBC\u1FBD\x07\x04\x02" + + "\x02\u1FBD\u1FBE\x05\u039C\u01CF\x02\u1FBE\u1FC3\x07\x05\x02\x02\u1FBF" + + "\u1FC0\x07\u01D1\x02\x02\u1FC0\u1FC1\x05\u039A\u01CE\x02\u1FC1\u1FC2\x07" + + "\u01C4\x02\x02\u1FC2\u1FC4\x03\x02\x02\x02\u1FC3\u1FBF\x03\x02\x02\x02" + + "\u1FC3\u1FC4\x03\x02\x02\x02\u1FC4\u1FC5\x03\x02\x02\x02\u1FC5\u1FC6\x05" + + "\u03C6\u01E4\x02\u1FC6\u1FCA\x03\x02\x02\x02\u1FC7\u1FC8\x077\x02\x02" + + "\u1FC8\u1FCA\x07\u01A8\x02\x02\u1FC9\u1FB6\x03\x02\x02\x02\u1FC9\u1FB7" + + "\x03\x02\x02\x02\u1FC9\u1FBC\x03\x02\x02\x02\u1FC9\u1FC7\x03\x02\x02\x02" + + "\u1FCA\u0399\x03\x02\x02\x02\u1FCB\u1FCC\t-\x02\x02\u1FCC\u039B\x03\x02" + + "\x02\x02\u1FCD\u1FD2\x05\u039E\u01D0\x02\u1FCE\u1FCF\x07\b\x02\x02\u1FCF" + + "\u1FD1\x05\u039E\u01D0\x02\u1FD0\u1FCE\x03\x02\x02\x02\u1FD1\u1FD4\x03" + + "\x02\x02\x02\u1FD2\u1FD0\x03\x02\x02\x02\u1FD2\u1FD3\x03\x02\x02\x02\u1FD3" + + "\u039D\x03\x02\x02\x02\u1FD4\u1FD2\x03\x02\x02\x02\u1FD5\u1FD6\x05\u0562" + + "\u02B2\x02\u1FD6\u1FD7\x05\u0530\u0299\x02\u1FD7\u039F\x03\x02\x02\x02" + + "\u1FD8\u1FD9\x07R\x02\x02\u1FD9\u1FDB\x07\u01D2\x02\x02\u1FDA\u1FDC\x05" + + "\u03A2\u01D2\x02\u1FDB\u1FDA\x03\x02\x02\x02\u1FDB\u1FDC\x03\x02\x02\x02" + + "\u1FDC\u1FDD\x03\x02\x02\x02\u1FDD\u1FE5\x07;\x02\x02\u1FDE\u1FDF\x07" + + "\u0173\x02\x02\u1FDF\u1FE0\x07\u014F\x02\x02\u1FE0\u1FE2\x05\u03B6\u01DC" + + "\x02\u1FE1\u1FE3\x05\u044A\u0226\x02\u1FE2\u1FE1\x03\x02\x02\x02\u1FE2" + + "\u1FE3\x03\x02\x02\x02\u1FE3\u1FE6\x03\x02\x02\x02\u1FE4\u1FE6\x07\u0110" + + "\x02\x02\u1FE5\u1FDE\x03\x02\x02\x02\u1FE5\u1FE4\x03\x02\x02\x02\u1FE6" + + "\u03A1\x03\x02\x02\x02\u1FE7\u1FE8\x07\x04\x02\x02\u1FE8\u1FE9\x05\u0262" + + "\u0132\x02\u1FE9\u1FEB\x07\x05\x02\x02\u1FEA\u1FEC\x05\u044A\u0226\x02" + + "\u1FEB\u1FEA\x03\x02\x02\x02\u1FEB\u1FEC\x03\x02\x02\x02\u1FEC\u1FF1\x03" + + "\x02\x02\x02\u1FED\u1FEE\x07R\x02\x02\u1FEE\u1FEF\x07/\x02\x02\u1FEF\u1FF1" + + "\x05\u0540\u02A1\x02\u1FF0\u1FE7\x03\x02\x02\x02\u1FF0\u1FED\x03\x02\x02" + + "\x02\u1FF1\u03A3\x03\x02\x02\x02\u1FF2\u1FF3\x07Y\x02\x02\u1FF3\u1FF4" + + "\x05\u0534\u029B\x02\u1FF4\u03A5\x03\x02\x02\x02\u1FF5\u1FF7\x05\u03DC" + + "\u01EF\x02\u1FF6\u1FF5\x03\x02\x02\x02\u1FF6\u1FF7\x03\x02\x02\x02\u1FF7" + + "\u1FF8\x03\x02\x02\x02\u1FF8\u1FF9\x07\xB8\x02\x02\u1FF9\u1FFA\x07B\x02" + + "\x02\u1FFA\u1FFC\x05\u043A\u021E\x02\u1FFB\u1FFD\x05\u03A8\u01D5\x02\u1FFC" + + "\u1FFB\x03\x02\x02\x02\u1FFC\u1FFD\x03\x02\x02\x02\u1FFD\u1FFF\x03\x02" + + "\x02\x02\u1FFE\u2000\x05\u044C\u0227\x02\u1FFF\u1FFE\x03\x02\x02\x02\u1FFF" + + "\u2000\x03\x02\x02\x02\u2000\u2002\x03\x02\x02\x02\u2001\u2003\x05\u03A4" + + "\u01D3\x02\u2002\u2001\x03\x02\x02\x02\u2002\u2003\x03\x02\x02\x02\u2003" + + "\u03A7\x03\x02\x02\x02\u2004\u2005\x07f\x02\x02\u2005\u2006\x05\u0428" + + "\u0215\x02\u2006\u03A9\x03\x02\x02\x02\u2007\u2009\x07\u0102\x02\x02\u2008" + + "\u200A\x05\u03E4\u01F3\x02\u2009\u2008\x03\x02\x02\x02\u2009\u200A\x03" + + "\x02\x02\x02\u200A\u200B\x03\x02\x02\x02\u200B\u200D\x05\u0438\u021D\x02" + + "\u200C\u200E\x05\u03AC\u01D7\x02\u200D\u200C\x03\x02\x02\x02\u200D\u200E" + + "\x03\x02\x02\x02\u200E\u2010\x03\x02\x02\x02\u200F\u2011\x05\u03B0\u01D9" + + "\x02\u2010\u200F\x03\x02\x02\x02\u2010\u2011\x03\x02\x02\x02\u2011\u03AB" + + "\x03\x02\x02\x02\u2012\u2013\x07F\x02\x02\u2013\u2014\x05\u03AE\u01D8" + + "\x02\u2014\u2015\x07\u0109\x02\x02\u2015\u03AD\x03\x02\x02\x02\u2016\u2017" + + "\x07\x85\x02\x02\u2017\u2023\t.\x02\x02\u2018\u2019\x07\u01A0\x02\x02" + + "\u2019\u2023\t.\x02\x02\u201A\u201F\x07\u0150\x02\x02\u201B\u201C\x07" + + "\u0173\x02\x02\u201C\u2020\x07\xCB\x02\x02\u201D\u201E\x07\u01A0\x02\x02" + + "\u201E\u2020\x07\xCB\x02\x02\u201F\u201B\x03\x02\x02\x02\u201F\u201D\x03" + + "\x02\x02\x02\u201F\u2020\x03\x02\x02\x02\u2020\u2023\x03\x02\x02\x02\u2021" + + "\u2023\x07\xCB\x02\x02\u2022\u2016\x03\x02\x02\x02\u2022\u2018\x03\x02" + + "\x02\x02\u2022\u201A\x03\x02\x02\x02\u2022\u2021\x03\x02\x02\x02\u2023" + + "\u03AF\x03\x02\x02\x02\u2024\u2025\x07\u0112\x02\x02\u2025\u03B1\x03\x02" + + "\x02\x02\u2026\u202A\x07\u0112\x02\x02\u2027\u2028\x07\u01D3\x02\x02\u2028" + + "\u202A\x07\u01D4\x02\x02\u2029\u2026\x03\x02\x02\x02\u2029\u2027\x03\x02" + + "\x02\x02\u202A\u03B3\x03\x02\x02\x02\u202B\u202D\x05\u03DC\u01EF\x02\u202C" + + "\u202B\x03\x02\x02\x02\u202C\u202D\x03\x02\x02\x02\u202D\u202E\x03\x02" + + "\x02\x02\u202E\u202F\x07\u0173\x02\x02\u202F\u2030\x05\u043A\u021E\x02" + + "\u2030\u2031\x07\u014F\x02\x02\u2031\u2033\x05\u03B6\u01DC\x02\u2032\u2034" + + "\x05\u0426\u0214\x02\u2033\u2032\x03\x02\x02\x02\u2033\u2034\x03\x02\x02" + + "\x02\u2034\u2036\x03\x02\x02\x02\u2035\u2037\x05\u044C\u0227\x02\u2036" + + "\u2035\x03\x02\x02\x02\u2036\u2037\x03\x02\x02\x02\u2037\u2039\x03\x02" + + "\x02\x02\u2038\u203A\x05\u03A4\u01D3\x02\u2039\u2038\x03\x02\x02\x02\u2039" + + "\u203A\x03\x02\x02\x02\u203A\u03B5\x03\x02\x02\x02\u203B\u2040\x05\u03B8" + + "\u01DD\x02\u203C\u203D\x07\b\x02\x02\u203D\u203F\x05\u03B8\u01DD\x02\u203E" + + "\u203C\x03\x02\x02\x02\u203F\u2042\x03\x02\x02\x02\u2040\u203E\x03\x02" + + "\x02\x02\u2040\u2041\x03\x02\x02\x02\u2041\u03B7\x03\x02\x02\x02\u2042" + + "\u2040\x03\x02\x02\x02\u2043\u2044\x05\u03BA\u01DE\x02\u2044\u2045\x07" + + "\f\x02\x02\u2045\u2046\x05\u048E\u0248\x02\u2046\u204E\x03\x02\x02\x02" + + "\u2047\u2048\x07\x04\x02\x02\u2048\u2049\x05\u03BC\u01DF\x02\u2049\u204A" + + "\x07\x05\x02\x02\u204A\u204B\x07\f\x02\x02\u204B\u204C\x05\u048E\u0248" + + "\x02\u204C\u204E\x03\x02\x02\x02\u204D\u2043\x03\x02\x02\x02\u204D\u2047" + + "\x03\x02\x02\x02\u204E\u03B9\x03\x02\x02\x02\u204F\u2050\x05\u0562\u02B2" + + "\x02\u2050\u2051\x05\u0530\u0299\x02\u2051\u03BB\x03\x02\x02\x02\u2052" + + "\u2057\x05\u03BA\u01DE\x02\u2053\u2054\x07\b\x02\x02\u2054\u2056\x05\u03BA" + + "\u01DE\x02\u2055\u2053\x03\x02\x02\x02\u2056\u2059\x03\x02\x02\x02\u2057" + + "\u2055\x03\x02\x02\x02\u2057\u2058\x03\x02\x02\x02\u2058\u03BD\x03\x02" + + "\x02\x02\u2059\u2057\x03\x02\x02\x02\u205A\u205B\x07\xB4\x02\x02\u205B" + + "\u205C\x05\u03C0\u01E1\x02\u205C\u205D\x05\u03C2\u01E2\x02\u205D\u205E" + + "\x07\xAE\x02\x02\u205E\u205F\x05\u03C4\u01E3\x02\u205F\u2060\x07@\x02" + + "\x02\u2060\u2061\x05\u03C6\u01E4\x02\u2061\u03BF\x03\x02\x02\x02\u2062" + + "\u2063\x05\u0540\u02A1\x02\u2063\u03C1\x03\x02\x02\x02\u2064\u2065\x07" + + "\u010F\x02\x02\u2065\u206A\x07\u0146\x02\x02\u2066\u206A\x07\u0146\x02" + + "\x02\u2067\u206A\x07m\x02\x02\u2068\u206A\x07\xF2\x02\x02\u2069\u2064" + + "\x03\x02\x02\x02\u2069\u2066\x03\x02\x02\x02\u2069\u2067\x03\x02\x02\x02" + + "\u2069\u2068\x03\x02\x02\x02\u206A\u206D\x03\x02\x02\x02\u206B\u2069\x03" + + "\x02\x02\x02\u206B\u206C\x03\x02\x02\x02\u206C\u03C3\x03\x02\x02\x02\u206D" + + "\u206B\x03\x02\x02\x02\u206E\u2074\x03\x02\x02\x02\u206F\u2070\x07k\x02" + + "\x02\u2070\u2074\x07\xDB\x02\x02\u2071\u2072\x07\u017D\x02\x02\u2072\u2074" + + "\x07\xDB\x02\x02\u2073\u206E\x03\x02\x02\x02\u2073\u206F\x03\x02\x02\x02" + + "\u2073\u2071\x03\x02\x02\x02\u2074\u03C5\x03\x02\x02\x02\u2075\u2078\x05" + + "\u03CA\u01E6\x02\u2076\u2078\x05\u03C8\u01E5\x02\u2077\u2075\x03\x02\x02" + + "\x02\u2077\u2076\x03\x02\x02\x02\u2078\u03C7\x03\x02\x02\x02\u2079\u207A" + + "\x07\x04\x02\x02\u207A\u207B\x05\u03CA\u01E6\x02\u207B\u207C\x07\x05\x02" + + "\x02\u207C\u2082\x03\x02\x02\x02\u207D\u207E\x07\x04\x02\x02\u207E\u207F" + + "\x05\u03C8\u01E5\x02\u207F\u2080\x07\x05\x02\x02\u2080\u2082\x03\x02\x02" + + "\x02\u2081\u2079\x03\x02\x02\x02\u2081\u207D\x03\x02\x02\x02\u2082\u03C9" + + "\x03\x02\x02\x02\u2083\u2085\x05\u03CC\u01E7\x02\u2084\u2086\x05\u03EC" + + "\u01F7\x02\u2085\u2084\x03\x02\x02\x02\u2085\u2086\x03\x02\x02\x02\u2086" + + "\u208F\x03\x02\x02\x02\u2087\u2089\x05\u0418\u020D\x02\u2088\u208A\x05" + + "\u03F6\u01FC\x02\u2089\u2088\x03\x02\x02\x02\u2089\u208A\x03\x02\x02\x02" + + "\u208A\u2090\x03\x02\x02\x02\u208B\u208D\x05\u03F4\u01FB\x02\u208C\u208E" + + "\x05\u041A\u020E\x02\u208D\u208C\x03\x02\x02\x02\u208D\u208E\x03\x02\x02" + + "\x02\u208E\u2090\x03\x02\x02\x02\u208F\u2087\x03\x02\x02\x02\u208F\u208B" + + "\x03\x02\x02\x02\u208F\u2090\x03\x02\x02\x02\u2090\u20A1\x03\x02\x02\x02" + + "\u2091\u2092\x05\u03D4\u01EB\x02\u2092\u2094\x05\u03CC\u01E7\x02\u2093" + + "\u2095\x05\u03EC\u01F7\x02\u2094\u2093\x03\x02\x02\x02\u2094\u2095\x03" + + "\x02\x02\x02\u2095\u209E\x03\x02\x02\x02\u2096\u2098\x05\u0418\u020D\x02" + + "\u2097\u2099\x05\u03F6\u01FC\x02\u2098\u2097\x03\x02\x02\x02\u2098\u2099" + + "\x03\x02\x02\x02\u2099\u209F\x03\x02\x02\x02\u209A\u209C\x05\u03F4\u01FB" + + "\x02\u209B\u209D\x05\u041A\u020E\x02\u209C\u209B\x03\x02\x02\x02\u209C" + + "\u209D\x03\x02\x02\x02\u209D\u209F\x03\x02\x02\x02\u209E\u2096\x03\x02" + + "\x02\x02\u209E\u209A\x03\x02\x02\x02\u209E\u209F\x03\x02\x02\x02\u209F" + + "\u20A1\x03\x02\x02\x02\u20A0\u2083\x03\x02\x02\x02\u20A0\u2091\x03\x02" + + "\x02\x02\u20A1\u03CB\x03\x02\x02\x02\u20A2\u20A5\x05\u03CE\u01E8\x02\u20A3" + + "\u20A5\x05\u03C8\u01E5\x02\u20A4\u20A2\x03\x02\x02\x02\u20A4\u20A3\x03" + + "\x02\x02\x02\u20A5\u03CD\x03\x02\x02\x02\u20A6\u20B6\x07Z\x02\x02\u20A7" + + "\u20A9\x05\u03EA\u01F6\x02\u20A8\u20A7\x03\x02\x02\x02\u20A8\u20A9\x03" + + "\x02\x02\x02\u20A9\u20AB\x03\x02\x02\x02\u20AA\u20AC\x05\u03DE\u01F0\x02" + + "\u20AB\u20AA\x03\x02\x02\x02\u20AB\u20AC\x03\x02\x02\x02\u20AC\u20AE\x03" + + "\x02\x02\x02\u20AD\u20AF\x05\u0532\u029A\x02\u20AE\u20AD\x03\x02\x02\x02" + + "\u20AE\u20AF\x03\x02\x02\x02\u20AF\u20B7\x03\x02\x02\x02\u20B0\u20B2\x05" + + "\u03E8\u01F5\x02\u20B1\u20B0\x03\x02\x02\x02\u20B1\u20B2\x03\x02\x02\x02" + + "\u20B2\u20B4\x03\x02\x02\x02\u20B3\u20B5\x05\u0534\u029B\x02\u20B4\u20B3" + + "\x03\x02\x02\x02\u20B4\u20B5\x03\x02\x02\x02\u20B5\u20B7\x03\x02\x02\x02" + + "\u20B6\u20A8\x03\x02\x02\x02\u20B6\u20B1\x03\x02\x02\x02\u20B7\u20B9\x03" + + "\x02\x02\x02\u20B8\u20BA\x05\u03DE\u01F0\x02\u20B9\u20B8\x03\x02\x02\x02" + + "\u20B9\u20BA\x03\x02\x02\x02\u20BA\u20BC\x03\x02\x02\x02\u20BB\u20BD\x05" + + "\u0426\u0214\x02\u20BC\u20BB\x03\x02\x02\x02\u20BC\u20BD\x03\x02\x02\x02" + + "\u20BD\u20BF\x03\x02\x02\x02\u20BE\u20C0\x05\u044A\u0226\x02\u20BF\u20BE" + + "\x03\x02\x02\x02\u20BF\u20C0\x03\x02\x02\x02\u20C0\u20C2\x03\x02\x02\x02" + + "\u20C1\u20C3\x05\u0408\u0205\x02\u20C2\u20C1\x03\x02\x02\x02\u20C2\u20C3" + + "\x03\x02\x02\x02\u20C3\u20C5\x03\x02\x02\x02\u20C4\u20C6\x05\u0416\u020C" + + "\x02\u20C5\u20C4\x03\x02\x02\x02\u20C5\u20C6\x03\x02\x02\x02\u20C6\u20C8" + + "\x03\x02\x02\x02\u20C7\u20C9\x05\u04DA\u026E\x02\u20C8\u20C7\x03\x02\x02" + + "\x02\u20C8\u20C9\x03\x02\x02\x02\u20C9\u20D4\x03\x02\x02\x02\u20CA\u20D4" + + "\x05\u0424\u0213\x02\u20CB\u20CC\x07^\x02\x02\u20CC\u20D4\x05\u0436\u021C" + + "\x02\u20CD\u20CE\x05\u03C8\u01E5\x02\u20CE\u20D1\x05\u03D2\u01EA\x02\u20CF" + + "\u20D2\x05\u03CE\u01E8\x02\u20D0\u20D2\x05\u03C8\u01E5\x02\u20D1\u20CF" + + "\x03\x02\x02\x02\u20D1\u20D0\x03\x02\x02\x02\u20D2\u20D4\x03\x02\x02\x02" + + "\u20D3\u20A6\x03\x02\x02\x02\u20D3\u20CA\x03\x02\x02\x02\u20D3\u20CB\x03" + + "\x02\x02\x02\u20D3\u20CD\x03\x02\x02\x02\u20D4\u20DC\x03\x02\x02\x02\u20D5" + + "\u20D8\x05\u03D2\u01EA\x02\u20D6\u20D9\x05\u03CE\u01E8\x02\u20D7\u20D9" + + "\x05\u03C8\u01E5\x02\u20D8\u20D6\x03\x02\x02\x02\u20D8\u20D7\x03\x02\x02" + + "\x02\u20D9\u20DB\x03\x02\x02\x02\u20DA\u20D5\x03\x02\x02\x02\u20DB\u20DE" + + "\x03\x02\x02\x02\u20DC\u20DA\x03\x02\x02\x02\u20DC\u20DD\x03\x02\x02\x02" + + "\u20DD\u03CF\x03\x02\x02\x02\u20DE\u20DC\x03\x02\x02\x02\u20DF\u20E3\x07" + + "c\x02\x02\u20E0\u20E3\x07H\x02\x02\u20E1\u20E3\x07=\x02\x02\u20E2\u20DF" + + "\x03\x02\x02\x02\u20E2\u20E0\x03\x02\x02\x02\u20E2\u20E1\x03\x02\x02\x02" + + "\u20E3\u03D1\x03\x02\x02\x02\u20E4\u20E6\x05\u03D0\u01E9\x02\u20E5\u20E7" + + "\x05\u03E6\u01F4\x02\u20E6\u20E5\x03\x02\x02\x02\u20E6\u20E7\x03\x02\x02" + + "\x02\u20E7\u03D3\x03\x02\x02\x02\u20E8\u20EA\x07k\x02\x02\u20E9\u20EB" + + "\x07\u0131\x02\x02\u20EA\u20E9\x03\x02\x02\x02\u20EA\u20EB\x03\x02\x02" + + "\x02\u20EB\u20EC\x03\x02\x02\x02\u20EC\u20ED\x05\u03D6\u01EC\x02\u20ED" + + "\u03D5\x03\x02\x02\x02\u20EE\u20F3\x05\u03D8\u01ED\x02\u20EF\u20F0\x07" + + "\b\x02\x02\u20F0\u20F2\x05\u03D8\u01ED\x02\u20F1\u20EF\x03\x02\x02\x02" + + "\u20F2\u20F5\x03\x02\x02\x02\u20F3\u20F1\x03\x02\x02\x02\u20F3\u20F4\x03" + + "\x02\x02\x02\u20F4\u03D7\x03\x02\x02\x02\u20F5\u20F3\x03\x02\x02\x02\u20F6" + + "\u20F8\x05\u0540\u02A1\x02\u20F7\u20F9\x05\u0374\u01BB\x02\u20F8\u20F7" + + "\x03\x02\x02\x02\u20F8\u20F9\x03\x02\x02\x02\u20F9\u20FA\x03\x02\x02\x02" + + "\u20FA\u20FC\x07&\x02\x02\u20FB\u20FD\x05\u03DA\u01EE\x02\u20FC\u20FB" + + "\x03\x02\x02\x02\u20FC\u20FD\x03\x02\x02\x02\u20FD\u20FE\x03\x02\x02\x02" + + "\u20FE\u20FF\x07\x04\x02\x02\u20FF\u2100\x05\u038C\u01C7\x02\u2100\u2101" + + "\x07\x05\x02\x02\u2101\u03D9\x03\x02\x02\x02\u2102\u2106\x07\u0105\x02" + + "\x02\u2103\u2104\x07O\x02\x02\u2104\u2106\x07\u0105\x02\x02\u2105\u2102" + + "\x03\x02\x02\x02\u2105\u2103\x03\x02\x02\x02\u2106\u03DB\x03\x02\x02\x02" + + "\u2107\u2108\x05\u03D4\u01EB\x02\u2108\u03DD\x03\x02\x02\x02\u2109\u210E" + + "\x07I\x02\x02\u210A\u210B\x05\u03E0\u01F1\x02\u210B\u210C\x05\u03E2\u01F2" + + "\x02\u210C\u210F\x03\x02\x02\x02\u210D\u210F\x05\u0628\u0315\x02\u210E" + + "\u210A\x03\x02\x02\x02\u210E\u210D\x03\x02\x02\x02\u210F\u03DF\x03\x02" + + "\x02\x02\u2110\u2113\x03\x02\x02\x02\u2111\u2113\x07\u015C\x02\x02\u2112" + + "\u2110\x03\x02\x02\x02\u2112\u2111\x03\x02\x02\x02\u2113\u03E1\x03\x02" + + "\x02\x02\u2114\u2116\t/\x02\x02\u2115\u2114\x03\x02\x02\x02\u2115\u2116" + + "\x03\x02\x02\x02\u2116\u2117\x03\x02\x02\x02\u2117\u2119\t\x13\x02\x02" + + "\u2118\u211A\x05\u03E4\u01F3\x02\u2119\u2118\x03\x02\x02\x02\u2119\u211A" + + "\x03\x02\x02\x02\u211A\u211B\x03\x02\x02\x02\u211B\u2125\x05\u053C\u029F" + + "\x02\u211C\u211E\x07\u0171\x02\x02\u211D\u211F\x05\u03E4\u01F3\x02\u211E" + + "\u211D\x03\x02\x02\x02\u211E\u211F\x03\x02\x02\x02\u211F\u2120\x03\x02" + + "\x02\x02\u2120\u2125\x05\u053C\u029F\x02\u2121\u2122\x07^\x02\x02\u2122" + + "\u2125\x05\u053C\u029F\x02\u2123\u2125\x05\u053C\u029F\x02\u2124\u2115" + + "\x03\x02\x02\x02\u2124\u211C\x03\x02\x02\x02\u2124\u2121\x03\x02\x02\x02" + + "\u2124\u2123\x03\x02\x02\x02\u2125\u03E3\x03\x02\x02\x02\u2126\u2127\x07" + + "^\x02\x02\u2127\u03E5\x03\x02\x02\x02\u2128\u2129\t0\x02\x02\u2129\u03E7" + + "\x03\x02\x02\x02\u212A\u2130\x07"; private static readonly _serializedATNSegment16: string = - "\x02\x02\x02\u214F\u2150\x07\u01CD\x02\x02\u2150\u2151\x07\x04\x02\x02" + - "\u2151\u2152\x05\u04F4\u027B\x02\u2152\u2153\x07\x05\x02\x02\u2153\u0403" + - "\x03\x02\x02\x02\u2154\u2155\x07\u01CE\x02\x02\u2155\u2156\x07\x04\x02" + - "\x02\u2156\u2157\x05\u04F4\u027B\x02\u2157\u2158\x07\x05\x02\x02\u2158" + - "\u0405\x03\x02\x02\x02\u2159\u215A\x07\u01CF\x02\x02\u215A\u215B\x07\u01D0" + - "\x02\x02\u215B\u215C\x07\x04\x02\x02\u215C\u215D\x05\u03FC\u01FF\x02\u215D" + - "\u215E\x07\x05\x02\x02\u215E\u0407\x03\x02\x02\x02\u215F\u2160\x07E\x02" + - "\x02\u2160\u2161\x05\u0480\u0241\x02\u2161\u0409\x03\x02\x02\x02\u2162" + - "\u2167\x05\u040E\u0208\x02\u2163\u2164\x07@\x02\x02\u2164\u2165\x07\u0125" + - "\x02\x02\u2165\u2167\x07S\x02\x02\u2166\u2162\x03\x02\x02\x02\u2166\u2163" + - "\x03\x02\x02\x02\u2167\u040B\x03\x02\x02\x02\u2168\u2169\x05\u040A\u0206" + - "\x02\u2169\u040D\x03\x02\x02\x02\u216A\u216C\x05\u0410\u0209\x02\u216B" + - "\u216A\x03\x02\x02\x02\u216C\u216D\x03\x02\x02\x02\u216D\u216B\x03\x02" + - "\x02\x02\u216D\u216E\x03\x02\x02\x02\u216E\u040F\x03\x02\x02\x02\u216F" + - "\u2171\x05\u0412\u020A\x02\u2170\u2172\x05\u0414\u020B\x02\u2171\u2170" + - "\x03\x02\x02\x02\u2171\u2172\x03\x02\x02\x02\u2172\u2174\x03\x02\x02\x02" + - "\u2173\u2175\x05\u03A4\u01D3\x02\u2174\u2173\x03\x02\x02\x02\u2174\u2175" + - "\x03\x02\x02\x02\u2175\u0411\x03\x02\x02\x02\u2176\u2180\x07@\x02\x02" + - "\u2177\u2178\x07\u0106\x02\x02\u2178\u217A\x07\xEE\x02\x02\u2179\u2177" + - "\x03\x02\x02\x02\u2179\u217A\x03\x02\x02\x02\u217A\u217B\x03\x02\x02\x02" + - "\u217B\u2181\x07\u016A\x02\x02\u217C\u217E\x07\xEE\x02\x02\u217D\u217C" + - "\x03\x02\x02\x02\u217D\u217E\x03\x02\x02\x02\u217E\u217F\x03\x02\x02\x02" + - "\u217F\u2181\x07\u0147\x02\x02\u2180\u2179\x03\x02\x02\x02\u2180\u217D" + - "\x03\x02\x02\x02\u2181\u0413\x03\x02\x02\x02\u2182\u2183\x07\u010C\x02" + - "\x02\u2183\u2184\x05\u052A\u0296\x02\u2184\u0415\x03\x02\x02\x02\u2185" + - "\u2186\x07\u019F\x02\x02\u2186\u2187\x07\x04\x02\x02\u2187\u2188\x05\u04F4" + - "\u027B\x02\u2188\u2190\x07\x05\x02\x02\u2189\u218A\x07\b\x02\x02\u218A" + - "\u218B\x07\x04\x02\x02\u218B\u218C\x05\u04F4\u027B\x02\u218C\u218D\x07" + - "\x05\x02\x02\u218D\u218F\x03\x02\x02\x02\u218E\u2189\x03\x02\x02\x02\u218F" + - "\u2192\x03\x02\x02\x02\u2190\u218E\x03\x02\x02\x02\u2190\u2191\x03\x02" + - "\x02\x02\u2191\u0417\x03\x02\x02\x02\u2192\u2190\x03\x02\x02\x02\u2193" + - "\u2194\x07B\x02\x02\u2194\u2195\x05\u041A\u020E\x02\u2195\u0419\x03\x02" + - "\x02\x02\u2196\u219B\x05\u041C\u020F\x02\u2197\u2198\x07\b\x02\x02\u2198" + - "\u219A\x05\u041C\u020F\x02\u2199\u2197\x03\x02\x02\x02\u219A\u219D\x03" + - "\x02\x02\x02\u219B\u2199\x03\x02\x02\x02\u219B\u219C\x03\x02\x02\x02\u219C" + - "\u041B\x03\x02\x02\x02\u219D\u219B\x03\x02\x02\x02\u219E\u21A0\x05\u0428" + - "\u0215\x02\u219F\u21A1\x05\u0420\u0211\x02\u21A0\u219F\x03\x02\x02\x02" + - "\u21A0\u21A1\x03\x02\x02\x02\u21A1\u21A3\x03\x02\x02\x02\u21A2\u21A4\x05" + - "\u042E\u0218\x02\u21A3\u21A2\x03\x02\x02\x02\u21A3\u21A4\x03\x02\x02\x02" + - "\u21A4\u21D9\x03\x02\x02\x02\u21A5\u21A7\x05\u0432\u021A\x02\u21A6\u21A8" + - "\x05\u0422\u0212\x02\u21A7\u21A6\x03\x02\x02\x02\u21A7\u21A8\x03\x02\x02" + - "\x02\u21A8\u21D9\x03\x02\x02\x02\u21A9\u21AB\x05\u0446\u0224\x02\u21AA" + - "\u21AC\x05\u0420\u0211\x02\u21AB\u21AA\x03\x02\x02\x02\u21AB\u21AC\x03" + - "\x02\x02\x02\u21AC\u21D9\x03\x02\x02\x02\u21AD\u21AF\x05\u03BA\u01DE\x02" + - "\u21AE\u21B0\x05\u0420\u0211\x02\u21AF\u21AE\x03\x02\x02\x02\u21AF\u21B0" + - "\x03\x02\x02\x02\u21B0\u21D9\x03\x02\x02\x02\u21B1\u21BE\x07J\x02\x02" + - "\u21B2\u21B4\x05\u0446\u0224\x02\u21B3\u21B5\x05\u0420\u0211\x02\u21B4" + - "\u21B3\x03\x02\x02\x02\u21B4\u21B5\x03\x02\x02\x02\u21B5\u21BF\x03\x02" + - "\x02\x02\u21B6\u21B8\x05\u0432\u021A\x02\u21B7\u21B9\x05\u0422\u0212\x02" + - "\u21B8\u21B7\x03\x02\x02\x02\u21B8\u21B9\x03\x02\x02\x02\u21B9\u21BF\x03" + - "\x02\x02\x02\u21BA\u21BC\x05\u03BA\u01DE\x02\u21BB\u21BD\x05\u0420\u0211" + - "\x02\u21BC\u21BB\x03\x02\x02\x02\u21BC\u21BD\x03\x02\x02\x02\u21BD\u21BF" + - "\x03\x02\x02\x02\u21BE\u21B2\x03\x02\x02\x02\u21BE\u21B6\x03\x02\x02\x02" + - "\u21BE\u21BA\x03\x02\x02\x02\u21BF\u21D9\x03\x02\x02\x02\u21C0\u21C1\x07" + - "\x04\x02\x02\u21C1\u21D2\x05\u041C\u020F\x02\u21C2\u21C3\x07p\x02\x02" + - "\u21C3\u21C4\x07x\x02\x02\u21C4\u21D3\x05\u041C\u020F\x02\u21C5\u21C7" + - "\x07{\x02\x02\u21C6\u21C8\x05\u0424\u0213\x02\u21C7\u21C6\x03\x02\x02" + - "\x02\u21C7\u21C8\x03\x02\x02\x02\u21C8\u21C9\x03\x02\x02\x02\u21C9\u21CA" + - "\x07x\x02\x02\u21CA\u21D3\x05\u041C\u020F\x02\u21CB\u21CD\x05\u0424\u0213" + - "\x02\u21CC\u21CB\x03\x02\x02\x02\u21CC\u21CD\x03\x02\x02\x02\u21CD\u21CE" + - "\x03\x02\x02\x02\u21CE\u21CF\x07x\x02\x02\u21CF\u21D0\x05\u041C\u020F" + - "\x02\u21D0\u21D1\x05\u0426\u0214\x02\u21D1\u21D3\x03\x02\x02\x02\u21D2" + - "\u21C2\x03\x02\x02\x02\u21D2\u21C5\x03\x02\x02\x02\u21D2\u21CC\x03\x02" + - "\x02\x02\u21D2\u21D3\x03\x02\x02\x02\u21D3\u21D4\x03\x02\x02\x02\u21D4" + - "\u21D6\x07\x05\x02\x02\u21D5\u21D7\x05\u0420\u0211\x02\u21D6\u21D5\x03" + - "\x02\x02\x02\u21D6\u21D7\x03\x02\x02\x02\u21D7\u21D9\x03\x02\x02\x02\u21D8" + - "\u219E\x03\x02\x02\x02\u21D8\u21A5\x03\x02\x02\x02\u21D8\u21A9\x03\x02" + - "\x02\x02\u21D8\u21AD\x03\x02\x02\x02\u21D8\u21B1\x03\x02\x02\x02\u21D8" + - "\u21C0\x03\x02\x02\x02\u21D9\u21EC\x03\x02\x02\x02\u21DA\u21DB\x07p\x02" + - "\x02\u21DB\u21DC\x07x\x02\x02\u21DC\u21EB\x05\u041C\u020F\x02\u21DD\u21DF" + - "\x07{\x02\x02\u21DE\u21E0\x05\u0424\u0213\x02\u21DF\u21DE\x03\x02\x02" + - "\x02\u21DF\u21E0\x03\x02\x02\x02\u21E0\u21E1\x03\x02\x02\x02\u21E1\u21E2" + - "\x07x\x02\x02\u21E2\u21EB\x05\u041C\u020F\x02\u21E3\u21E5\x05\u0424\u0213" + - "\x02\u21E4\u21E3\x03\x02\x02\x02\u21E4\u21E5\x03\x02\x02\x02\u21E5\u21E6" + - "\x03\x02\x02\x02\u21E6\u21E7\x07x\x02\x02\u21E7\u21E8\x05\u041C\u020F" + - "\x02\u21E8\u21E9\x05\u0426\u0214\x02\u21E9\u21EB\x03\x02\x02\x02\u21EA" + - "\u21DA\x03\x02\x02\x02\u21EA\u21DD\x03\x02\x02\x02\u21EA\u21E4\x03\x02" + - "\x02\x02\u21EB\u21EE\x03\x02\x02\x02\u21EC\u21EA\x03\x02\x02\x02\u21EC" + - "\u21ED\x03\x02\x02\x02\u21ED\u041D\x03\x02\x02\x02\u21EE\u21EC\x03\x02" + - "\x02\x02\u21EF\u21F1\x07&\x02\x02\u21F0\u21EF\x03\x02\x02\x02\u21F0\u21F1" + - "\x03\x02\x02\x02\u21F1\u21F2\x03\x02\x02\x02\u21F2\u21F7\x05\u0550\u02A9" + - "\x02\u21F3\u21F4\x07\x04\x02\x02\u21F4\u21F5\x05\u052E\u0298\x02\u21F5" + - "\u21F6\x07\x05\x02\x02\u21F6\u21F8\x03\x02\x02\x02\u21F7\u21F3\x03\x02" + - "\x02\x02\u21F7\u21F8\x03\x02\x02\x02\u21F8\u041F\x03\x02\x02\x02\u21F9" + - "\u21FA\x05\u041E\u0210\x02\u21FA\u0421\x03\x02\x02\x02\u21FB\u2208\x05" + - "\u041E\u0210\x02\u21FC\u21FE\x07&\x02\x02\u21FD\u21FF\x05\u0550\u02A9" + - "\x02\u21FE\u21FD\x03\x02\x02\x02\u21FE\u21FF\x03\x02\x02\x02\u21FF\u2202" + - "\x03\x02\x02\x02\u2200\u2202\x05\u0550\u02A9\x02\u2201\u21FC\x03\x02\x02" + - "\x02\u2201\u2200\x03\x02\x02\x02\u2202\u2203\x03\x02\x02\x02\u2203\u2204" + - "\x07\x04\x02\x02\u2204\u2205\x05\u0442\u0222\x02\u2205\u2206\x07\x05\x02" + - "\x02\u2206\u2208\x03\x02\x02\x02\u2207\u21FB\x03\x02\x02\x02\u2207\u2201" + - "\x03\x02\x02\x02\u2208\u0423\x03\x02\x02\x02\u2209\u220B\t-\x02\x02\u220A" + - "\u220C\x07}\x02\x02\u220B\u220A\x03\x02\x02\x02\u220B\u220C\x03\x02\x02" + - "\x02\u220C\u0425\x03\x02\x02\x02\u220D\u220E\x07f\x02\x02\u220E\u220F" + - "\x07\x04\x02\x02\u220F\u2210\x05\u052E\u0298\x02\u2210\u2211\x07\x05\x02" + - "\x02\u2211\u2215\x03\x02\x02\x02\u2212\u2213\x07R\x02\x02\u2213\u2215" + - "\x05\u0480\u0241\x02\u2214\u220D\x03\x02\x02\x02\u2214\u2212\x03\x02\x02" + - "\x02\u2215\u0427\x03\x02\x02\x02\u2216\u2218\x05\u052C\u0297\x02\u2217" + - "\u2219\x07\v\x02\x02\u2218\u2217\x03\x02\x02\x02\u2218\u2219\x03\x02\x02" + - "\x02\u2219\u2223\x03\x02\x02\x02\u221A\u2220\x07S\x02\x02\u221B\u2221" + - "\x05\u052C\u0297\x02\u221C\u221D\x07\x04\x02\x02\u221D\u221E\x05\u052C" + - "\u0297\x02\u221E\u221F\x07\x05\x02\x02\u221F\u2221\x03\x02\x02\x02\u2220" + - "\u221B\x03\x02\x02\x02\u2220\u221C\x03\x02\x02\x02\u2221\u2223\x03\x02" + - "\x02\x02\u2222\u2216\x03\x02\x02\x02\u2222\u221A\x03\x02\x02\x02\u2223" + - "\u0429\x03\x02\x02\x02\u2224\u2229\x05\u0428\u0215\x02\u2225\u2226\x07" + - "\b\x02\x02\u2226\u2228\x05\u0428\u0215\x02\u2227\u2225\x03\x02\x02\x02" + - "\u2228\u222B\x03\x02\x02\x02\u2229\u2227\x03\x02\x02\x02\u2229\u222A\x03" + - "\x02\x02\x02\u222A\u042B\x03\x02\x02\x02\u222B\u2229\x03\x02\x02\x02\u222C" + - "\u2231\x05\u0428\u0215\x02\u222D\u222F\x07&\x02\x02\u222E\u222D\x03\x02" + - "\x02\x02\u222E\u222F\x03\x02\x02\x02\u222F\u2230\x03\x02\x02\x02\u2230" + - "\u2232\x05\u0550\u02A9\x02\u2231\u222E\x03\x02\x02\x02\u2231\u2232\x03" + - "\x02\x02\x02\u2232\u042D\x03\x02\x02\x02\u2233\u2234\x07\u01D1\x02\x02" + - "\u2234\u2235\x05\u0536\u029C\x02\u2235\u2236\x07\x04\x02\x02\u2236\u2237" + - "\x05\u04F4\u027B\x02\u2237\u2239\x07\x05\x02\x02\u2238\u223A\x05\u0430" + - "\u0219\x02\u2239\u2238\x03\x02\x02\x02\u2239\u223A\x03\x02\x02\x02\u223A" + - "\u042F\x03\x02\x02\x02\u223B\u223C\x07\u012F\x02\x02\u223C\u223D\x07\x04" + - "\x02\x02\u223D\u223E\x05\u0480\u0241\x02\u223E\u223F\x07\x05\x02\x02\u223F" + - "\u0431\x03\x02\x02\x02\u2240\u2242\x05\u04B2\u025A\x02\u2241\u2243\x05" + - "\u043A\u021E\x02\u2242\u2241\x03\x02\x02\x02\u2242\u2243\x03\x02\x02\x02" + - "\u2243\u224D\x03\x02\x02\x02\u2244\u2245\x07\u0139\x02\x02\u2245\u2246" + - "\x07B\x02\x02\u2246\u2247\x07\x04\x02\x02\u2247\u2248\x05\u0436\u021C" + - "\x02\u2248\u224A\x07\x05\x02\x02\u2249\u224B\x05\u043A\u021E\x02\u224A" + - "\u2249\x03\x02\x02\x02\u224A\u224B\x03\x02\x02\x02\u224B\u224D\x03\x02" + - "\x02\x02\u224C\u2240\x03\x02\x02\x02\u224C\u2244\x03\x02\x02\x02\u224D" + - "\u0433\x03\x02\x02\x02\u224E\u2250\x05\u04B2\u025A\x02\u224F\u2251\x05" + - "\u0438\u021D\x02\u2250\u224F\x03\x02\x02\x02\u2250\u2251\x03\x02\x02\x02" + - "\u2251\u0435\x03\x02\x02\x02\u2252\u2257\x05\u0434\u021B\x02\u2253\u2254" + - "\x07\b\x02\x02\u2254\u2256\x05\u0434\u021B\x02\u2255\u2253\x03\x02\x02" + - "\x02\u2256\u2259\x03\x02\x02\x02\u2257\u2255\x03\x02\x02\x02\u2257\u2258" + - "\x03\x02\x02\x02\u2258\u0437\x03\x02\x02\x02\u2259\u2257\x03\x02\x02\x02" + - "\u225A\u225B\x07&\x02\x02\u225B\u225C\x07\x04\x02\x02\u225C\u225D\x05" + - "\u0442\u0222\x02\u225D\u225E\x07\x05\x02\x02\u225E\u0439\x03\x02\x02\x02" + - "\u225F\u2260\x07k\x02\x02\u2260\u2261\x07\u01D2\x02\x02\u2261\u043B\x03" + - "\x02\x02\x02\u2262\u2263\x07i\x02\x02\u2263\u2264\x05\u0480\u0241\x02" + - "\u2264\u043D\x03\x02\x02\x02\u2265\u226A\x07i\x02\x02\u2266\u2267\x07" + - "\u01AB\x02\x02\u2267\u2268\x07\u010C\x02\x02\u2268\u226B\x05\u03B2\u01DA" + - "\x02\u2269\u226B\x05\u0480\u0241\x02\u226A\u2266\x03\x02\x02\x02\u226A" + - "\u2269\x03\x02\x02\x02\u226B\u043F\x03\x02\x02\x02\u226C\u226D\x05\u0442" + - "\u0222\x02\u226D\u0441\x03\x02\x02\x02\u226E\u2273\x05\u0444\u0223\x02" + - "\u226F\u2270\x07\b\x02\x02\u2270\u2272\x05\u0444\u0223\x02\u2271\u226F" + - "\x03\x02\x02\x02\u2272\u2275\x03\x02\x02\x02\u2273\u2271\x03\x02\x02\x02" + - "\u2273\u2274\x03\x02\x02\x02\u2274\u0443\x03\x02\x02\x02\u2275\u2273\x03" + - "\x02\x02\x02\u2276\u2277\x05\u0550\u02A9\x02\u2277\u2279\x05\u0454\u022B" + - "\x02\u2278\u227A\x05n8\x02\u2279\u2278\x03\x02\x02\x02\u2279\u227A\x03" + - "\x02\x02\x02\u227A\u0445\x03\x02\x02\x02\u227B\u227C\x07\u01D3\x02\x02" + - "\u227C\u228C\x07\x04\x02\x02\u227D\u227E\x05\u04AA\u0256\x02\u227E\u227F" + - "\x05\u04C4\u0263\x02\u227F\u2280\x07\u01D4\x02\x02\u2280\u2281\x05\u0448" + - "\u0225\x02\u2281\u228D\x03\x02\x02\x02\u2282\u2283\x07\u01D5\x02\x02\u2283" + - "\u2284\x07\x04\x02\x02\u2284\u2285\x05\u0450\u0229\x02\u2285\u2286\x07" + - "\x05\x02\x02\u2286\u2287\x07\b\x02\x02\u2287\u2288\x05\u04AA\u0256\x02" + - "\u2288\u2289\x05\u04C4\u0263\x02\u2289\u228A\x07\u01D4\x02\x02\u228A\u228B" + - "\x05\u0448\u0225\x02\u228B\u228D\x03\x02\x02\x02\u228C\u227D\x03\x02\x02" + - "\x02\u228C\u2282\x03\x02\x02\x02\u228D\u228E\x03\x02\x02\x02\u228E\u228F" + - "\x07\x05\x02\x02\u228F\u0447\x03\x02\x02\x02\u2290\u2295\x05\u044A\u0226" + - "\x02\u2291\u2292\x07\b\x02\x02\u2292\u2294\x05\u044A\u0226\x02\u2293\u2291" + - "\x03\x02\x02\x02\u2294\u2297\x03\x02\x02\x02\u2295\u2293\x03\x02\x02\x02" + - "\u2295\u2296\x03\x02\x02\x02\u2296\u0449\x03\x02\x02\x02\u2297\u2295\x03" + - "\x02\x02\x02\u2298\u229F\x05\u0550\u02A9\x02\u2299\u229B\x05\u0454\u022B" + - "\x02\u229A\u229C\x05\u044C\u0227\x02\u229B\u229A\x03\x02\x02\x02\u229B" + - "\u229C\x03\x02\x02\x02\u229C\u22A0\x03\x02\x02\x02\u229D\u229E\x07@\x02" + - "\x02\u229E\u22A0\x07\u01D2\x02\x02\u229F\u2299\x03\x02\x02\x02\u229F\u229D" + - "\x03\x02\x02\x02\u22A0\u044B\x03\x02\x02\x02\u22A1\u22A3\x05\u044E\u0228" + - "\x02\u22A2\u22A1\x03\x02\x02\x02\u22A3\u22A4\x03\x02\x02\x02\u22A4\u22A2" + - "\x03\x02\x02\x02\u22A4\u22A5\x03\x02\x02\x02\u22A5\u044D\x03\x02\x02\x02" + - "\u22A6\u22A7\x077\x02\x02\u22A7\u22AF\x05\u0480\u0241\x02\u22A8\u22A9" + - "\x05\u0558\u02AD\x02\u22A9\u22AA\x05\u0480\u0241\x02\u22AA\u22AF\x03\x02" + - "\x02\x02\u22AB\u22AC\x07O\x02\x02\u22AC\u22AF\x07P\x02\x02\u22AD\u22AF" + - "\x07P\x02\x02\u22AE\u22A6\x03\x02\x02\x02\u22AE\u22A8\x03\x02\x02\x02" + - "\u22AE\u22AB\x03\x02\x02\x02\u22AE\u22AD\x03\x02\x02\x02\u22AF\u044F\x03" + - "\x02\x02\x02\u22B0\u22B5\x05\u0452\u022A\x02\u22B1\u22B2\x07\b\x02\x02" + - "\u22B2\u22B4\x05\u0452\u022A\x02\u22B3\u22B1\x03\x02\x02\x02\u22B4\u22B7" + - "\x03\x02\x02\x02\u22B5\u22B3\x03\x02\x02\x02\u22B5\u22B6\x03\x02\x02\x02" + - "\u22B6\u0451\x03\x02\x02\x02\u22B7\u22B5\x03\x02\x02\x02\u22B8\u22B9\x05" + - "\u04A8\u0255\x02\u22B9\u22BA\x07&\x02\x02\u22BA\u22BB\x05\u0556\u02AC" + - "\x02\u22BB\u22BF\x03\x02\x02\x02\u22BC\u22BD\x077\x02\x02\u22BD\u22BF" + - "\x05\u04A8\u0255\x02\u22BE\u22B8\x03\x02\x02\x02\u22BE\u22BC\x03\x02\x02" + - "\x02\u22BF\u0453\x03\x02\x02\x02\u22C0\u22C2\x07\u0198\x02\x02\u22C1\u22C0" + - "\x03\x02\x02\x02\u22C1\u22C2\x03\x02\x02\x02\u22C2\u22C3\x03\x02\x02\x02" + - "\u22C3\u22CC\x05\u0458\u022D\x02\u22C4\u22CD\x05\u0456\u022C\x02\u22C5" + - "\u22CA\x07%\x02\x02\u22C6\u22C7\x07\x06\x02\x02\u22C7\u22C8\x05\u0540" + - "\u02A1\x02\u22C8\u22C9\x07\x07\x02\x02\u22C9\u22CB\x03\x02\x02\x02\u22CA" + - "\u22C6\x03\x02\x02\x02\u22CA\u22CB\x03\x02\x02\x02\u22CB\u22CD\x03\x02" + - "\x02\x02\u22CC\u22C4\x03\x02\x02\x02\u22CC\u22C5\x03\x02\x02\x02\u22CD" + - "\u22D3\x03\x02\x02\x02\u22CE\u22CF\x05\u052C\u0297\x02\u22CF\u22D0\x07" + - "\x1D\x02\x02\u22D0\u22D1\t.\x02\x02\u22D1\u22D3\x03\x02\x02\x02\u22D2" + - "\u22C1\x03\x02\x02\x02\u22D2\u22CE\x03\x02\x02\x02\u22D3\u0455\x03\x02" + - "\x02\x02\u22D4\u22D6\x07\x06\x02\x02\u22D5\u22D7\x05\u0540\u02A1\x02\u22D6" + - "\u22D5\x03\x02\x02\x02\u22D6\u22D7\x03\x02\x02\x02\u22D7\u22D8\x03\x02" + - "\x02\x02\u22D8\u22DA\x07\x07\x02\x02\u22D9\u22D4\x03\x02\x02\x02\u22DA" + - "\u22DD\x03\x02\x02\x02\u22DB\u22D9\x03\x02\x02\x02\u22DB\u22DC\x03\x02" + - "\x02\x02\u22DC\u0457\x03\x02\x02\x02\u22DD\u22DB\x03\x02\x02\x02\u22DE" + - "\u22EE\x05\u045C\u022F\x02\u22DF\u22EE\x05\u0460\u0231\x02\u22E0\u22EE" + - "\x05\u0464\u0233\x02\u22E1\u22EE\x05\u046C\u0237\x02\u22E2\u22EE\x05\u0474" + - "\u023B\x02\u22E3\u22EB\x05\u0476\u023C\x02\u22E4\u22E6\x05\u047A\u023E" + - "\x02\u22E5\u22E4\x03\x02\x02\x02\u22E5\u22E6\x03\x02\x02\x02\u22E6\u22EC" + - "\x03\x02\x02\x02\u22E7\u22E8\x07\x04\x02\x02\u22E8\u22E9\x05\u0540\u02A1" + - "\x02\u22E9\u22EA\x07\x05\x02\x02\u22EA\u22EC\x03\x02\x02\x02\u22EB\u22E5" + - "\x03\x02\x02\x02\u22EB\u22E7\x03\x02\x02\x02\u22EC\u22EE\x03\x02\x02\x02" + - "\u22ED\u22DE\x03\x02\x02\x02\u22ED\u22DF\x03\x02\x02\x02\u22ED\u22E0\x03" + - "\x02\x02\x02\u22ED\u22E1\x03\x02\x02\x02\u22ED\u22E2\x03\x02\x02\x02\u22ED" + - "\u22E3\x03\x02\x02\x02\u22EE\u0459\x03\x02\x02\x02\u22EF\u22F4\x05\u0460" + - "\u0231\x02\u22F0\u22F4\x05\u0466\u0234\x02\u22F1\u22F4\x05\u046E\u0238" + - "\x02\u22F2\u22F4\x05\u0474\u023B\x02\u22F3\u22EF\x03\x02\x02\x02\u22F3" + - "\u22F0\x03\x02\x02\x02\u22F3\u22F1\x03\x02\x02\x02\u22F3\u22F2\x03\x02" + - "\x02\x02\u22F4\u045B\x03\x02\x02\x02\u22F5\u22F7\x05\u0552\u02AA\x02\u22F6" + - "\u22F8\x05\u020E\u0108\x02\u22F7\u22F6\x03\x02\x02\x02\u22F7\u22F8\x03" + - "\x02\x02\x02\u22F8\u22FA\x03\x02\x02\x02\u22F9\u22FB\x05\u045E\u0230\x02" + - "\u22FA\u22F9\x03\x02\x02\x02\u22FA\u22FB\x03\x02\x02\x02\u22FB\u045D\x03" + - "\x02\x02\x02\u22FC\u22FD\x07\x04\x02\x02\u22FD\u22FE\x05\u04F4\u027B\x02" + - "\u22FE\u22FF\x07\x05\x02\x02\u22FF\u045F\x03\x02\x02\x02\u2300\u2319\x07" + - "\u018A\x02\x02\u2301\u2319\x07\u018B\x02\x02\u2302\u2319\x07\u0199\x02" + - "\x02\u2303\u2319\x07\u017D\x02\x02\u2304\u2319\x07\u0196\x02\x02\u2305" + - "\u2307\x07\u0187\x02\x02\u2306\u2308\x05\u0462\u0232\x02\u2307\u2306\x03" + - "\x02\x02\x02\u2307\u2308\x03\x02\x02\x02\u2308\u2319\x03\x02\x02\x02\u2309" + - "\u230A\x07\xC0\x02\x02\u230A\u2319\x07\u0195\x02\x02\u230B\u230D\x07\u0184" + - "\x02\x02\u230C\u230E\x05\u045E\u0230\x02\u230D\u230C\x03\x02\x02\x02\u230D" + - "\u230E\x03\x02\x02\x02\u230E\u2319\x03\x02\x02\x02\u230F\u2311\x07\u0183" + - "\x02\x02\u2310\u2312\x05\u045E\u0230\x02\u2311\u2310\x03\x02\x02\x02\u2311" + - "\u2312\x03\x02\x02\x02\u2312\u2319\x03\x02\x02\x02\u2313\u2315\x07\u0192" + - "\x02\x02\u2314\u2316\x05\u045E\u0230\x02\u2315\u2314\x03\x02\x02\x02\u2315" + - "\u2316\x03\x02\x02\x02\u2316\u2319\x03\x02\x02\x02\u2317\u2319\x07\u017F" + - "\x02\x02\u2318\u2300\x03\x02\x02\x02\u2318\u2301\x03\x02\x02\x02\u2318" + - "\u2302\x03\x02\x02\x02\u2318\u2303\x03\x02\x02\x02\u2318\u2304\x03\x02" + - "\x02\x02\u2318\u2305\x03\x02\x02\x02\u2318\u2309\x03\x02\x02\x02\u2318" + - "\u230B\x03\x02\x02\x02\u2318\u230F\x03\x02\x02\x02\u2318\u2313\x03\x02" + - "\x02\x02\u2318\u2317\x03\x02\x02\x02\u2319\u0461\x03\x02\x02\x02\u231A" + - "\u231B\x07\x04\x02\x02\u231B\u231C\x05\u0540\u02A1\x02\u231C\u231D\x07" + - "\x05\x02\x02\u231D\u0463\x03\x02\x02\x02\u231E\u2321\x05\u0468\u0235\x02" + - "\u231F\u2321\x05\u046A\u0236\x02\u2320\u231E\x03\x02\x02\x02\u2320\u231F" + - "\x03\x02\x02\x02\u2321\u0465\x03\x02\x02\x02\u2322\u2325\x05\u0468\u0235" + - "\x02\u2323\u2325\x05\u046A\u0236\x02\u2324\u2322\x03\x02\x02\x02\u2324" + - "\u2323\x03\x02\x02\x02\u2325\u0467\x03\x02\x02\x02\u2326\u2328\x07\u017E" + - "\x02\x02\u2327\u2329\x05\u0472\u023A\x02\u2328\u2327\x03\x02\x02\x02\u2328" + - "\u2329\x03\x02\x02\x02\u2329\u232A\x03\x02\x02\x02\u232A\u232B\x07\x04" + - "\x02\x02\u232B\u232C\x05\u04F4\u027B\x02\u232C\u232D\x07\x05\x02\x02\u232D" + - "\u0469\x03\x02\x02\x02\u232E\u2330\x07\u017E\x02\x02\u232F\u2331\x05\u0472" + - "\u023A\x02\u2330\u232F\x03\x02\x02\x02\u2330\u2331\x03\x02\x02\x02\u2331" + - "\u046B\x03\x02\x02\x02\u2332\u2337\x05\u0470\u0239\x02\u2333\u2334\x07" + - "\x04\x02\x02\u2334\u2335\x05\u0540\u02A1\x02\u2335\u2336\x07\x05\x02\x02" + - "\u2336\u2338\x03\x02\x02\x02\u2337\u2333\x03\x02\x02\x02\u2337\u2338\x03" + - "\x02\x02\x02\u2338\u046D\x03\x02\x02\x02\u2339\u233E\x05\u0470\u0239\x02" + - "\u233A\u233B\x07\x04\x02\x02\u233B\u233C\x05\u0540\u02A1\x02\u233C\u233D" + - "\x07\x05\x02\x02\u233D\u233F\x03\x02\x02\x02\u233E\u233A\x03\x02\x02\x02" + - "\u233E\u233F\x03\x02\x02\x02\u233F\u046F\x03\x02\x02\x02\u2340\u2342\t" + - "/\x02\x02\u2341\u2343\x05\u0472\u023A\x02\u2342\u2341\x03\x02\x02\x02" + - "\u2342\u2343\x03\x02\x02\x02\u2343\u234B\x03\x02\x02\x02\u2344\u234B\x07" + - "\u01A0\x02\x02\u2345\u2346\x07\u018E\x02\x02\u2346\u2348\t0\x02\x02\u2347" + - "\u2349\x05\u0472\u023A\x02\u2348\u2347\x03\x02\x02\x02\u2348\u2349\x03" + - "\x02\x02\x02\u2349\u234B\x03\x02\x02\x02\u234A\u2340\x03\x02\x02\x02\u234A" + - "\u2344\x03\x02\x02\x02\u234A\u2345\x03\x02\x02\x02\u234B\u0471\x03\x02" + - "\x02\x02\u234C\u234D\x07\u016F\x02\x02\u234D\u0473\x03\x02\x02\x02\u234E" + - "\u2353\t1\x02\x02\u234F\u2350\x07\x04\x02\x02\u2350\u2351\x05\u0540\u02A1" + - "\x02\u2351\u2352\x07\x05\x02\x02\u2352\u2354\x03\x02\x02\x02\u2353\u234F" + - "\x03\x02\x02\x02\u2353\u2354\x03\x02\x02\x02\u2354\u2356\x03\x02\x02\x02" + - "\u2355\u2357\x05\u0478\u023D\x02\u2356\u2355\x03\x02\x02\x02\u2356\u2357" + - "\x03\x02\x02\x02\u2357\u0475\x03\x02\x02\x02\u2358\u2359\x07\u018C\x02" + - "\x02\u2359\u0477\x03\x02\x02\x02\u235A\u235B\x07k\x02\x02\u235B\u235C" + - "\x07\u019B\x02\x02\u235C\u2361\x07\u017B\x02\x02\u235D\u235E\x07\u0174" + - "\x02\x02\u235E\u235F\x07\u019B\x02\x02\u235F\u2361\x07\u017B\x02\x02\u2360" + - "\u235A\x03\x02\x02\x02\u2360\u235D\x03\x02\x02\x02\u2361\u0479\x03\x02" + - "\x02\x02\u2362\u237C\x07\u0179\x02\x02\u2363\u237C\x07\u0101\x02\x02\u2364" + - "\u237C\x07\xB2\x02\x02\u2365\u237C\x07\xDC\x02\x02\u2366\u237C\x07\xFE" + - "\x02\x02\u2367\u237C\x05\u047C\u023F\x02\u2368\u2369\x07\u0179\x02\x02" + - "\u2369\u236A\x07`\x02\x02\u236A\u237C\x07\u0101\x02\x02\u236B\u236C\x07" + - "\xB2\x02\x02\u236C\u2370\x07`\x02\x02\u236D\u2371\x07\xDC\x02\x02\u236E" + - "\u2371\x07\xFE\x02\x02\u236F\u2371\x05\u047C\u023F\x02\u2370\u236D\x03" + - "\x02\x02\x02\u2370\u236E\x03\x02\x02\x02\u2370\u236F\x03\x02\x02\x02\u2371" + - "\u237C\x03\x02\x02\x02\u2372\u2373\x07\xDC\x02\x02\u2373\u2376\x07`\x02" + - "\x02\u2374\u2377\x07\xFE\x02\x02\u2375\u2377\x05\u047C\u023F\x02\u2376" + - "\u2374\x03\x02\x02\x02\u2376\u2375\x03\x02\x02\x02\u2377\u237C\x03\x02" + - "\x02\x02\u2378\u2379\x07\xFE\x02\x02\u2379\u237A\x07`\x02\x02\u237A\u237C" + - "\x05\u047C\u023F\x02\u237B\u2362\x03\x02\x02\x02\u237B\u2363\x03\x02\x02" + - "\x02\u237B\u2364\x03\x02\x02\x02\u237B\u2365\x03\x02\x02\x02\u237B\u2366" + - "\x03\x02\x02\x02\u237B\u2367\x03\x02\x02\x02\u237B\u2368\x03\x02\x02\x02" + - "\u237B\u236B\x03\x02\x02\x02\u237B\u2372\x03\x02\x02\x02\u237B\u2378\x03" + - "\x02\x02\x02\u237C\u047B\x03\x02\x02\x02\u237D\u2382\x07\u013F\x02\x02" + - "\u237E\u237F\x07\x04\x02\x02\u237F\u2380\x05\u0540\u02A1\x02\u2380\u2381" + - "\x07\x05\x02\x02\u2381\u2383\x03\x02\x02\x02\u2382\u237E\x03\x02\x02\x02" + - "\u2382\u2383\x03\x02\x02\x02\u2383\u047D\x03\x02\x02\x02\u2384\u2385\x07" + - "\xC7\x02\x02\u2385\u2386\x05\u0480\u0241\x02\u2386\u047F\x03\x02\x02\x02" + - "\u2387\u2388\x05\u0482\u0242\x02\u2388\u0481\x03\x02\x02\x02\u2389\u238B" + - "\x05\u0484\u0243\x02\u238A\u238C\x05\u04EE\u0278\x02\u238B\u238A\x03\x02" + - "\x02\x02\u238B\u238C\x03\x02\x02\x02\u238C\u0483\x03\x02\x02\x02\u238D" + - "\u2392\x05\u0486\u0244\x02\u238E\u238F\t2\x02\x02\u238F\u2391\x05\u0486" + - "\u0244\x02\u2390\u238E\x03\x02\x02\x02\u2391\u2394\x03\x02\x02\x02\u2392" + - "\u2390\x03\x02\x02\x02\u2392\u2393\x03\x02\x02\x02\u2393\u0485\x03\x02" + - "\x02\x02\u2394\u2392\x03\x02\x02\x02\u2395\u239A\x05\u0488\u0245\x02\u2396" + - "\u2397\x07T\x02\x02\u2397\u2399\x05\u0488\u0245\x02\u2398\u2396\x03\x02" + - "\x02\x02\u2399\u239C\x03\x02\x02\x02\u239A\u2398\x03\x02\x02\x02\u239A" + - "\u239B\x03\x02\x02\x02\u239B\u0487\x03\x02\x02\x02\u239C\u239A\x03\x02" + - "\x02\x02\u239D\u23A2\x05\u048A\u0246\x02\u239E\u239F\x07#\x02\x02\u239F" + - "\u23A1\x05\u048A\u0246\x02\u23A0\u239E\x03\x02\x02\x02\u23A1\u23A4\x03" + - "\x02\x02\x02\u23A2\u23A0\x03\x02\x02\x02\u23A2\u23A3\x03\x02\x02\x02\u23A3" + - "\u0489\x03\x02\x02\x02\u23A4\u23A2\x03\x02\x02\x02\u23A5\u23AB\x05\u048C" + - "\u0247\x02\u23A6\u23A8\x07O\x02\x02\u23A7\u23A6\x03\x02\x02\x02\u23A7" + - "\u23A8\x03\x02\x02\x02\u23A8\u23A9\x03\x02\x02\x02\u23A9\u23AA\x07F\x02" + - "\x02\u23AA\u23AC\x05\u050E\u0288\x02\u23AB\u23A7\x03\x02\x02\x02\u23AB" + - "\u23AC\x03\x02\x02\x02\u23AC\u048B\x03\x02\x02\x02\u23AD\u23AF\x07O\x02" + - "\x02\u23AE\u23AD\x03\x02\x02\x02\u23AE\u23AF\x03\x02\x02\x02\u23AF\u23B0" + - "\x03\x02\x02\x02\u23B0\u23B1\x05\u048E\u0248\x02\u23B1\u048D\x03\x02\x02" + - "\x02\u23B2\u23B4\x05\u0490\u0249\x02\u23B3\u23B5\t3\x02\x02\u23B4\u23B3" + - "\x03\x02\x02\x02\u23B4\u23B5\x03\x02\x02\x02\u23B5\u048F\x03\x02\x02\x02" + - "\u23B6\u23CE\x05\u0492\u024A\x02\u23B7\u23B9\x07v\x02\x02\u23B8\u23BA" + - "\x07O\x02\x02\u23B9\u23B8\x03\x02\x02\x02\u23B9\u23BA\x03\x02\x02\x02" + - "\u23BA\u23CC\x03\x02\x02\x02\u23BB\u23CD\x07P\x02\x02\u23BC\u23CD\x07" + - "b\x02\x02\u23BD\u23CD\x07>\x02\x02\u23BE\u23CD\x07\u0166\x02\x02\u23BF" + - "\u23C0\x07:\x02\x02\u23C0\u23C1\x07B\x02\x02\u23C1\u23CD\x05\u0480\u0241" + - "\x02\u23C2\u23C3\x07\u010C\x02\x02\u23C3\u23C4\x07\x04\x02\x02\u23C4\u23C5" + - "\x05\u04FA\u027E\x02\u23C5\u23C6\x07\x05\x02\x02\u23C6\u23CD\x03\x02\x02" + - "\x02\u23C7\u23CD\x07\xBE\x02\x02\u23C8\u23CA\x05\u0504\u0283\x02\u23C9" + - "\u23C8\x03\x02\x02\x02\u23C9\u23CA\x03\x02\x02\x02\u23CA\u23CB\x03\x02" + - "\x02\x02\u23CB\u23CD\x07\u01D7\x02\x02\u23CC\u23BB\x03\x02\x02\x02\u23CC" + - "\u23BC\x03\x02\x02\x02\u23CC\u23BD\x03\x02\x02\x02\u23CC\u23BE\x03\x02" + - "\x02\x02\u23CC\u23BF\x03\x02\x02\x02\u23CC\u23C2\x03\x02\x02\x02\u23CC" + - "\u23C7\x03\x02\x02\x02\u23CC\u23C9\x03\x02\x02\x02\u23CD\u23CF\x03\x02" + - "\x02\x02\u23CE\u23B7\x03\x02\x02\x02\u23CE\u23CF\x03\x02\x02\x02\u23CF" + - "\u0491\x03\x02\x02\x02\u23D0\u23DC\x05\u0494\u024B\x02\u23D1\u23D2\t4" + - "\x02\x02\u23D2\u23DD\x05\u0494\u024B\x02\u23D3\u23D4\x05\u04F2\u027A\x02" + - "\u23D4\u23DA\x05\u04E8\u0275\x02\u23D5\u23DB\x05\u03BA\u01DE\x02\u23D6" + - "\u23D7\x07\x04\x02\x02\u23D7\u23D8\x05\u0480\u0241\x02\u23D8\u23D9\x07" + - "\x05\x02\x02\u23D9\u23DB\x03\x02\x02\x02\u23DA\u23D5\x03\x02\x02\x02\u23DA" + - "\u23D6\x03\x02\x02\x02\u23DB\u23DD\x03\x02\x02\x02\u23DC\u23D1\x03\x02" + - "\x02\x02\u23DC\u23D3\x03\x02\x02\x02\u23DC\u23DD\x03\x02\x02\x02\u23DD" + - "\u0493\x03\x02\x02\x02\u23DE\u23F0\x05\u0496\u024C\x02\u23DF\u23E1\x07" + - "O\x02\x02\u23E0\u23DF\x03\x02\x02\x02\u23E0\u23E1\x03\x02\x02\x02\u23E1" + - "\u23EA\x03\x02\x02\x02\u23E2\u23EB\x07z\x02\x02\u23E3\u23EB\x07t\x02\x02" + - "\u23E4\u23E5\x07\x81\x02\x02\u23E5\u23EB\x07`\x02\x02\u23E6\u23E8\x07" + - "\u017C\x02\x02\u23E7\u23E9\x07]\x02\x02\u23E8\u23E7\x03\x02\x02\x02\u23E8" + - "\u23E9\x03\x02\x02\x02\u23E9\u23EB\x03\x02\x02\x02\u23EA\u23E2\x03\x02" + - "\x02\x02\u23EA\u23E3\x03\x02\x02\x02\u23EA\u23E4\x03\x02\x02\x02\u23EA" + - "\u23E6\x03\x02\x02\x02\u23EB\u23EC\x03\x02\x02\x02\u23EC\u23EE\x05\u0496" + - "\u024C\x02\u23ED\u23EF\x05\u047E\u0240\x02\u23EE\u23ED\x03\x02\x02\x02" + - "\u23EE\u23EF\x03\x02\x02\x02\u23EF\u23F1\x03\x02\x02\x02\u23F0\u23E0\x03" + - "\x02\x02\x02\u23F0\u23F1\x03\x02\x02\x02\u23F1\u0495\x03\x02\x02\x02\u23F2" + - "\u23F8\x05\u0498\u024D\x02\u23F3\u23F4\x05\u04EE\u0278\x02\u23F4\u23F5" + - "\x05\u0498\u024D\x02\u23F5\u23F7\x03\x02\x02\x02\u23F6\u23F3\x03\x02\x02"; + ":\x02\x02\u212B\u212C\x07R\x02\x02\u212C\u212D\x07\x04\x02\x02\u212D\u212E" + + "\x05\u0502\u0282\x02\u212E\u212F\x07\x05\x02\x02\u212F\u2131\x03\x02\x02" + + "\x02\u2130\u212B\x03\x02\x02\x02\u2130\u2131\x03\x02\x02\x02\u2131\u03E9" + + "\x03\x02\x02\x02\u2132\u2133\x07 \x02\x02\u2133\u03EB\x03\x02\x02\x02" + + "\u2134\u2135\x05\u03EE\u01F8\x02\u2135\u03ED\x03\x02\x02\x02\u2136\u2137" + + "\x07U\x02\x02\u2137\u2138\x07\x95\x02\x02\u2138\u2139\x05\u03F0\u01F9" + + "\x02\u2139\u03EF\x03\x02\x02\x02\u213A\u213F\x05\u03F2\u01FA\x02\u213B" + + "\u213C\x07\b\x02\x02\u213C\u213E\x05\u03F2\u01FA\x02\u213D\u213B\x03\x02" + + "\x02\x02\u213E\u2141\x03\x02\x02\x02\u213F\u213D\x03\x02\x02\x02\u213F" + + "\u2140\x03\x02\x02\x02\u2140\u03F1\x03\x02\x02\x02\u2141\u213F\x03\x02" + + "\x02\x02\u2142\u2146\x05\u048E\u0248\x02\u2143\u2144\x07f\x02\x02\u2144" + + "\u2147\x05\u04FE\u0280\x02\u2145\u2147\x05\u0270\u0139\x02\u2146\u2143" + + "\x03\x02\x02\x02\u2146\u2145\x03\x02\x02\x02\u2146\u2147\x03\x02\x02\x02" + + "\u2147\u2149\x03\x02\x02\x02\u2148\u214A\x05\u0272\u013A\x02\u2149\u2148" + + "\x03\x02\x02\x02\u2149\u214A\x03\x02\x02\x02\u214A\u03F3\x03\x02\x02\x02" + + "\u214B\u214D\x05\u03F8\u01FD\x02\u214C\u214E\x05\u03FA\u01FE\x02\u214D" + + "\u214C\x03\x02\x02\x02\u214D\u214E\x03\x02\x02\x02\u214E\u2154\x03\x02" + + "\x02\x02\u214F\u2151\x05\u03FA\u01FE\x02\u2150\u2152\x05\u03F8\u01FD\x02" + + "\u2151\u2150\x03\x02\x02\x02\u2151\u2152\x03\x02\x02\x02\u2152\u2154\x03" + + "\x02\x02\x02\u2153\u214B\x03\x02\x02\x02\u2153\u214F\x03\x02\x02\x02\u2154" + + "\u03F5\x03\x02\x02\x02\u2155\u2156\x05\u03F4\u01FB\x02\u2156\u03F7\x03" + + "\x02\x02\x02\u2157\u2158\x07L\x02\x02\u2158\u215B\x05\u03FC\u01FF\x02" + + "\u2159\u215A\x07\b\x02\x02\u215A\u215C\x05\u03FE\u0200\x02\u215B\u2159" + + "\x03\x02\x02\x02\u215B\u215C\x03\x02\x02\x02\u215C\u216F\x03\x02\x02\x02" + + "\u215D\u215E\x07?\x02\x02\u215E\u216C\x05\u0406\u0204\x02\u215F\u2160" + + "\x05\u0400\u0201\x02\u2160\u2164\x05\u0404\u0203\x02\u2161\u2165\x07S" + + "\x02\x02\u2162\u2163\x07k\x02\x02\u2163\u2165\x07\u01D5\x02\x02\u2164" + + "\u2161\x03\x02\x02\x02\u2164\u2162\x03\x02\x02\x02\u2165\u216D\x03\x02" + + "\x02\x02\u2166\u216A\x05\u0404\u0203\x02\u2167\u216B\x07S\x02\x02\u2168" + + "\u2169\x07k\x02\x02\u2169\u216B\x07\u01D5\x02\x02\u216A\u2167\x03\x02" + + "\x02\x02\u216A\u2168\x03\x02\x02\x02\u216B\u216D\x03\x02\x02\x02\u216C" + + "\u215F\x03\x02\x02\x02\u216C\u2166\x03\x02\x02\x02\u216D\u216F\x03\x02" + + "\x02\x02\u216E\u2157\x03\x02\x02\x02\u216E\u215D\x03\x02\x02\x02\u216F" + + "\u03F9\x03\x02\x02\x02\u2170\u2175\x07Q\x02\x02\u2171\u2176\x05\u03FE" + + "\u0200\x02\u2172\u2173\x05\u0400\u0201\x02\u2173\u2174\x05\u0404\u0203" + + "\x02\u2174\u2176\x03\x02\x02\x02\u2175\u2171\x03\x02\x02\x02\u2175\u2172" + + "\x03\x02\x02\x02\u2176\u03FB\x03\x02\x02\x02\u2177\u217A\x05\u048E\u0248" + + "\x02\u2178\u217A\x07 \x02\x02\u2179\u2177\x03\x02\x02\x02\u2179\u2178" + + "\x03\x02\x02\x02\u217A\u03FD\x03\x02\x02\x02\u217B\u217C\x05\u048E\u0248" + + "\x02\u217C\u03FF\x03\x02\x02\x02\u217D\u2183\x05\u04B8\u025D\x02\u217E" + + "\u217F\x07\x0E\x02\x02\u217F\u2183\x05\u0402\u0202\x02\u2180\u2181\x07" + + "\x0F\x02\x02\u2181\u2183\x05\u0402\u0202\x02\u2182\u217D\x03\x02\x02\x02" + + "\u2182\u217E\x03\x02\x02\x02\u2182\u2180\x03\x02\x02\x02\u2183\u0401\x03" + + "\x02\x02\x02\u2184\u2187\x05\u0550\u02A9\x02\u2185\u2187\x05\u054E\u02A8" + + "\x02\u2186\u2184\x03\x02\x02\x02\u2186\u2185\x03\x02\x02\x02\u2187\u0403" + + "\x03\x02\x02\x02\u2188\u2189\t1\x02\x02\u2189\u0405\x03\x02\x02\x02\u218A" + + "\u218B\t2\x02\x02\u218B\u0407\x03\x02\x02\x02\u218C\u218D\x07D\x02\x02" + + "\u218D\u218E\x07\x95\x02\x02\u218E\u218F\x05\u040A\u0206\x02\u218F\u0409" + + "\x03\x02\x02\x02\u2190\u2195\x05\u040C\u0207\x02\u2191\u2192\x07\b\x02" + + "\x02\u2192\u2194\x05\u040C\u0207\x02\u2193\u2191\x03\x02\x02\x02\u2194" + + "\u2197\x03\x02\x02\x02\u2195\u2193\x03\x02\x02\x02\u2195\u2196\x03\x02" + + "\x02\x02\u2196\u040B\x03\x02\x02\x02\u2197\u2195\x03\x02\x02\x02\u2198" + + "\u219E\x05\u048E\u0248\x02\u2199\u219E\x05\u040E\u0208\x02\u219A\u219E" + + "\x05\u0412\u020A\x02\u219B\u219E\x05\u0410\u0209\x02\u219C\u219E\x05\u0414" + + "\u020B\x02\u219D\u2198\x03\x02\x02\x02\u219D\u2199\x03\x02\x02\x02\u219D" + + "\u219A\x03\x02\x02\x02\u219D\u219B\x03\x02\x02\x02\u219D\u219C\x03\x02" + + "\x02\x02\u219E\u040D\x03\x02\x02\x02\u219F\u21A0\x07\x04\x02\x02\u21A0" + + "\u21A1\x07\x05\x02\x02\u21A1\u040F\x03\x02\x02\x02\u21A2\u21A3\x07\u01D6" + + "\x02\x02\u21A3\u21A4\x07\x04\x02\x02\u21A4\u21A5\x05\u0502\u0282\x02\u21A5" + + "\u21A6\x07\x05\x02\x02\u21A6\u0411\x03\x02\x02\x02\u21A7\u21A8\x07\u01D7" + + "\x02\x02\u21A8\u21A9\x07\x04\x02\x02\u21A9\u21AA\x05\u0502\u0282\x02\u21AA" + + "\u21AB\x07\x05\x02\x02\u21AB\u0413\x03\x02\x02\x02\u21AC\u21AD\x07\u01D8" + + "\x02\x02\u21AD\u21AE\x07\u01D9\x02\x02\u21AE\u21AF\x07\x04\x02\x02\u21AF" + + "\u21B0\x05\u040A\u0206\x02\u21B0\u21B1\x07\x05\x02\x02\u21B1\u0415\x03" + + "\x02\x02\x02\u21B2\u21B3\x07E\x02\x02\u21B3\u21B4\x05\u048E\u0248\x02" + + "\u21B4\u0417\x03\x02\x02\x02\u21B5\u21BA\x05\u041C\u020F\x02\u21B6\u21B7" + + "\x07@\x02\x02\u21B7\u21B8\x07\u012E\x02\x02\u21B8\u21BA\x07S\x02\x02\u21B9" + + "\u21B5\x03\x02\x02\x02\u21B9\u21B6\x03\x02\x02\x02\u21BA\u0419\x03\x02" + + "\x02\x02\u21BB\u21BC\x05\u0418\u020D\x02\u21BC\u041B\x03\x02\x02\x02\u21BD" + + "\u21BF\x05\u041E\u0210\x02\u21BE\u21BD\x03\x02\x02\x02\u21BF\u21C0\x03" + + "\x02\x02\x02\u21C0\u21BE\x03\x02\x02\x02\u21C0\u21C1\x03\x02\x02\x02\u21C1" + + "\u041D\x03\x02\x02\x02\u21C2\u21C4\x05\u0420\u0211\x02\u21C3\u21C5\x05" + + "\u0422\u0212\x02\u21C4\u21C3\x03\x02\x02\x02\u21C4\u21C5\x03\x02\x02\x02" + + "\u21C5\u21C7\x03\x02\x02\x02\u21C6\u21C8\x05\u03B2\u01DA\x02\u21C7\u21C6" + + "\x03\x02\x02\x02\u21C7\u21C8\x03\x02\x02\x02\u21C8\u041F\x03\x02\x02\x02" + + "\u21C9\u21D3\x07@\x02\x02\u21CA\u21CB\x07\u010F\x02\x02\u21CB\u21CD\x07" + + "\xF7\x02\x02\u21CC\u21CA\x03\x02\x02\x02\u21CC\u21CD\x03\x02\x02\x02\u21CD" + + "\u21CE\x03\x02\x02\x02\u21CE\u21D4\x07\u0173\x02\x02\u21CF\u21D1\x07\xF7" + + "\x02\x02\u21D0\u21CF\x03\x02\x02\x02\u21D0\u21D1\x03\x02\x02\x02\u21D1" + + "\u21D2\x03\x02\x02\x02\u21D2\u21D4\x07\u0150\x02\x02\u21D3\u21CC\x03\x02" + + "\x02\x02\u21D3\u21D0\x03\x02\x02\x02\u21D4\u0421\x03\x02\x02\x02\u21D5" + + "\u21D6\x07\u0115\x02\x02\u21D6\u21D7\x05\u0538\u029D\x02\u21D7\u0423\x03" + + "\x02\x02\x02\u21D8\u21D9\x07\u01A8\x02\x02\u21D9\u21DA\x07\x04\x02\x02" + + "\u21DA\u21DB\x05\u0502\u0282\x02\u21DB\u21E3\x07\x05\x02\x02\u21DC\u21DD" + + "\x07\b\x02\x02\u21DD\u21DE\x07\x04\x02\x02\u21DE\u21DF\x05\u0502\u0282" + + "\x02\u21DF\u21E0\x07\x05\x02\x02\u21E0\u21E2\x03\x02\x02\x02\u21E1\u21DC" + + "\x03\x02\x02\x02\u21E2\u21E5\x03\x02\x02\x02\u21E3\u21E1\x03\x02\x02\x02" + + "\u21E3\u21E4\x03\x02\x02\x02\u21E4\u0425\x03\x02\x02\x02\u21E5\u21E3\x03" + + "\x02\x02\x02\u21E6\u21E7\x07B\x02\x02\u21E7\u21E8\x05\u0428\u0215\x02" + + "\u21E8\u0427\x03\x02\x02\x02\u21E9\u21EE\x05\u042A\u0216\x02\u21EA\u21EB" + + "\x07\b\x02\x02\u21EB\u21ED\x05\u042A\u0216\x02\u21EC\u21EA\x03\x02\x02" + + "\x02\u21ED\u21F0\x03\x02\x02\x02\u21EE\u21EC\x03\x02\x02\x02\u21EE\u21EF" + + "\x03\x02\x02\x02\u21EF\u0429\x03\x02\x02\x02\u21F0\u21EE\x03\x02\x02\x02" + + "\u21F1\u21F3\x05\u0436\u021C\x02\u21F2\u21F4\x05\u042E\u0218\x02\u21F3" + + "\u21F2\x03\x02\x02\x02\u21F3\u21F4\x03\x02\x02\x02\u21F4\u21F6\x03\x02" + + "\x02\x02\u21F5\u21F7\x05\u043C\u021F\x02\u21F6\u21F5\x03\x02\x02\x02\u21F6" + + "\u21F7\x03\x02\x02\x02\u21F7\u222C\x03\x02\x02\x02\u21F8\u21FA\x05\u0440" + + "\u0221\x02\u21F9\u21FB\x05\u0430\u0219\x02\u21FA\u21F9\x03\x02\x02\x02" + + "\u21FA\u21FB\x03\x02\x02\x02\u21FB\u222C\x03\x02\x02\x02\u21FC\u21FE\x05" + + "\u0454\u022B\x02\u21FD\u21FF\x05\u042E\u0218\x02\u21FE\u21FD\x03\x02\x02" + + "\x02\u21FE\u21FF\x03\x02\x02\x02\u21FF\u222C\x03\x02\x02\x02\u2200\u2202" + + "\x05\u03C8\u01E5\x02\u2201\u2203\x05\u042E\u0218\x02\u2202\u2201\x03\x02" + + "\x02\x02\u2202\u2203\x03\x02\x02\x02\u2203\u222C\x03\x02\x02\x02\u2204" + + "\u2211\x07J\x02\x02\u2205\u2207\x05\u0454\u022B\x02\u2206\u2208\x05\u042E" + + "\u0218\x02\u2207\u2206\x03\x02\x02\x02\u2207\u2208\x03\x02\x02\x02\u2208" + + "\u2212\x03\x02\x02\x02\u2209\u220B\x05\u0440\u0221\x02\u220A\u220C\x05" + + "\u0430\u0219\x02\u220B\u220A\x03\x02\x02\x02\u220B\u220C\x03\x02\x02\x02" + + "\u220C\u2212\x03\x02\x02\x02\u220D\u220F\x05\u03C8\u01E5\x02\u220E\u2210" + + "\x05\u042E\u0218\x02\u220F\u220E\x03\x02\x02\x02\u220F\u2210\x03\x02\x02" + + "\x02\u2210\u2212\x03\x02\x02\x02\u2211\u2205\x03\x02\x02\x02\u2211\u2209" + + "\x03\x02\x02\x02\u2211\u220D\x03\x02\x02\x02\u2212\u222C\x03\x02\x02\x02" + + "\u2213\u2214\x07\x04\x02\x02\u2214\u2225\x05\u042A\u0216\x02\u2215\u2216" + + "\x07p\x02\x02\u2216\u2217\x07x\x02\x02\u2217\u2226\x05\u042A\u0216\x02" + + "\u2218\u221A\x07{\x02\x02\u2219\u221B\x05\u0432\u021A\x02\u221A\u2219" + + "\x03\x02\x02\x02\u221A\u221B\x03\x02\x02\x02\u221B\u221C\x03\x02\x02\x02" + + "\u221C\u221D\x07x\x02\x02\u221D\u2226\x05\u042A\u0216\x02\u221E\u2220" + + "\x05\u0432\u021A\x02\u221F\u221E\x03\x02\x02\x02\u221F\u2220\x03\x02\x02" + + "\x02\u2220\u2221\x03\x02\x02\x02\u2221\u2222\x07x\x02\x02\u2222\u2223" + + "\x05\u042A\u0216\x02\u2223\u2224\x05\u0434\u021B\x02\u2224\u2226\x03\x02" + + "\x02\x02\u2225\u2215\x03\x02\x02\x02\u2225\u2218\x03\x02\x02\x02\u2225" + + "\u221F\x03\x02\x02\x02\u2225\u2226\x03\x02\x02\x02\u2226\u2227\x03\x02" + + "\x02\x02\u2227\u2229\x07\x05\x02\x02\u2228\u222A\x05\u042E\u0218\x02\u2229" + + "\u2228\x03\x02\x02\x02\u2229\u222A\x03\x02\x02\x02\u222A\u222C\x03\x02" + + "\x02\x02\u222B\u21F1\x03\x02\x02\x02\u222B\u21F8\x03\x02\x02\x02\u222B" + + "\u21FC\x03\x02\x02\x02\u222B\u2200\x03\x02\x02\x02\u222B\u2204\x03\x02" + + "\x02\x02\u222B\u2213\x03\x02\x02\x02\u222C\u223F\x03\x02\x02\x02\u222D" + + "\u222E\x07p\x02\x02\u222E\u222F\x07x\x02\x02\u222F\u223E\x05\u042A\u0216" + + "\x02\u2230\u2232\x07{\x02\x02\u2231\u2233\x05\u0432\u021A\x02\u2232\u2231" + + "\x03\x02\x02\x02\u2232\u2233\x03\x02\x02\x02\u2233\u2234\x03\x02\x02\x02" + + "\u2234\u2235\x07x\x02\x02\u2235\u223E\x05\u042A\u0216\x02\u2236\u2238" + + "\x05\u0432\u021A\x02\u2237\u2236\x03\x02\x02\x02\u2237\u2238\x03\x02\x02" + + "\x02\u2238\u2239\x03\x02\x02\x02\u2239\u223A\x07x\x02\x02\u223A\u223B" + + "\x05\u042A\u0216\x02\u223B\u223C\x05\u0434\u021B\x02\u223C\u223E\x03\x02" + + "\x02\x02\u223D\u222D\x03\x02\x02\x02\u223D\u2230\x03\x02\x02\x02\u223D" + + "\u2237\x03\x02\x02\x02\u223E\u2241\x03\x02\x02\x02\u223F\u223D\x03\x02" + + "\x02\x02\u223F\u2240\x03\x02\x02\x02\u2240\u042B\x03\x02\x02\x02\u2241" + + "\u223F\x03\x02\x02\x02\u2242\u2244\x07&\x02\x02\u2243\u2242\x03\x02\x02" + + "\x02\u2243\u2244\x03\x02\x02\x02\u2244\u2245\x03\x02\x02\x02\u2245\u224A" + + "\x05\u0562\u02B2\x02\u2246\u2247\x07\x04\x02\x02\u2247\u2248\x05\u053E" + + "\u02A0\x02\u2248\u2249\x07\x05\x02\x02\u2249\u224B\x03\x02\x02\x02\u224A" + + "\u2246\x03\x02\x02\x02\u224A\u224B\x03\x02\x02\x02\u224B\u042D\x03\x02" + + "\x02\x02\u224C\u224D\x05\u042C\u0217\x02\u224D\u042F\x03\x02\x02\x02\u224E" + + "\u225B\x05\u042C\u0217\x02\u224F\u2251\x07&\x02\x02\u2250\u2252\x05\u0562" + + "\u02B2\x02\u2251\u2250\x03\x02\x02\x02\u2251\u2252\x03\x02\x02\x02\u2252" + + "\u2255\x03\x02\x02\x02\u2253\u2255\x05\u0562\u02B2\x02\u2254\u224F\x03" + + "\x02\x02\x02\u2254\u2253\x03\x02\x02\x02\u2255\u2256\x03\x02\x02\x02\u2256" + + "\u2257\x07\x04\x02\x02\u2257\u2258\x05\u0450\u0229\x02\u2258\u2259\x07" + + "\x05\x02\x02\u2259\u225B\x03\x02\x02\x02\u225A\u224E\x03\x02\x02\x02\u225A" + + "\u2254\x03\x02\x02\x02\u225B\u0431\x03\x02\x02\x02\u225C\u225E\t3\x02" + + "\x02\u225D\u225F\x07}\x02\x02\u225E\u225D\x03\x02\x02\x02\u225E\u225F" + + "\x03\x02\x02\x02\u225F\u0433\x03\x02\x02\x02\u2260\u2261\x07f\x02\x02" + + "\u2261\u2262\x07\x04\x02\x02\u2262\u2263\x05\u053E\u02A0\x02\u2263\u2264" + + "\x07\x05\x02\x02\u2264\u2268\x03\x02\x02\x02\u2265\u2266\x07R\x02\x02" + + "\u2266\u2268\x05\u048E\u0248\x02\u2267\u2260\x03\x02\x02\x02\u2267\u2265" + + "\x03\x02\x02\x02\u2268\u0435\x03\x02\x02\x02\u2269\u226B\x07S\x02\x02" + + "\u226A\u2269\x03\x02\x02\x02\u226A\u226B\x03\x02\x02\x02\u226B\u226C\x03" + + "\x02\x02\x02\u226C\u226E\x05\u053C\u029F\x02\u226D\u226F\x07\v\x02\x02" + + "\u226E\u226D\x03\x02\x02\x02\u226E\u226F\x03\x02\x02\x02\u226F\u2279\x03" + + "\x02\x02\x02\u2270\u2276\x07S\x02\x02\u2271\u2277\x05\u053C\u029F\x02" + + "\u2272\u2273\x07\x04\x02\x02\u2273\u2274\x05\u053C\u029F\x02\u2274\u2275" + + "\x07\x05\x02\x02\u2275\u2277\x03\x02\x02\x02\u2276\u2271\x03\x02\x02\x02" + + "\u2276\u2272\x03\x02\x02\x02\u2277\u2279\x03\x02\x02\x02\u2278\u226A\x03" + + "\x02\x02\x02\u2278\u2270\x03\x02\x02\x02\u2279\u0437\x03\x02\x02\x02\u227A" + + "\u227F\x05\u0436\u021C\x02\u227B\u227C\x07\b\x02\x02\u227C\u227E\x05\u0436" + + "\u021C\x02\u227D\u227B\x03\x02\x02\x02\u227E\u2281\x03\x02\x02\x02\u227F" + + "\u227D\x03\x02\x02\x02\u227F\u2280\x03\x02\x02\x02\u2280\u0439\x03\x02" + + "\x02\x02\u2281\u227F\x03\x02\x02\x02\u2282\u2287\x05\u0436\u021C\x02\u2283" + + "\u2285\x07&\x02\x02\u2284\u2283\x03\x02\x02\x02\u2284\u2285\x03\x02\x02" + + "\x02\u2285\u2286\x03\x02\x02\x02\u2286\u2288\x05\u0562\u02B2\x02\u2287" + + "\u2284\x03\x02\x02\x02\u2287\u2288\x03\x02\x02\x02\u2288\u043B\x03\x02" + + "\x02\x02\u2289\u228A\x07\u01DA\x02\x02\u228A\u228B\x05\u0546\u02A4\x02" + + "\u228B\u228C\x07\x04\x02\x02\u228C\u228D\x05\u0502\u0282\x02\u228D\u228F" + + "\x07\x05\x02\x02\u228E\u2290\x05\u043E\u0220\x02\u228F\u228E\x03\x02\x02" + + "\x02\u228F\u2290\x03\x02\x02\x02\u2290\u043D\x03\x02\x02\x02\u2291\u2292" + + "\x07\u0138\x02\x02\u2292\u2293\x07\x04\x02\x02\u2293\u2294\x05\u048E\u0248" + + "\x02\u2294\u2295\x07\x05\x02\x02\u2295\u043F\x03\x02\x02\x02\u2296\u2298" + + "\x05\u04C0\u0261\x02\u2297\u2299\x05\u0448\u0225\x02\u2298\u2297\x03\x02" + + "\x02\x02\u2298\u2299\x03\x02\x02\x02\u2299\u22A3\x03\x02\x02\x02\u229A" + + "\u229B\x07\u0142\x02\x02\u229B\u229C\x07B\x02\x02\u229C\u229D\x07\x04" + + "\x02\x02\u229D\u229E\x05\u0444\u0223\x02\u229E\u22A0\x07\x05\x02\x02\u229F" + + "\u22A1\x05\u0448\u0225\x02\u22A0\u229F\x03\x02\x02\x02\u22A0\u22A1\x03" + + "\x02\x02\x02\u22A1\u22A3\x03\x02\x02\x02\u22A2\u2296\x03\x02\x02\x02\u22A2" + + "\u229A\x03\x02\x02\x02\u22A3\u0441\x03\x02\x02\x02\u22A4\u22A6\x05\u04C0" + + "\u0261\x02\u22A5\u22A7\x05\u0446\u0224\x02\u22A6\u22A5\x03\x02\x02\x02" + + "\u22A6\u22A7\x03\x02\x02\x02\u22A7\u0443\x03\x02\x02\x02\u22A8\u22AD\x05" + + "\u0442\u0222\x02\u22A9\u22AA\x07\b\x02\x02\u22AA\u22AC\x05\u0442\u0222" + + "\x02\u22AB\u22A9\x03\x02\x02\x02\u22AC\u22AF\x03\x02\x02\x02\u22AD\u22AB" + + "\x03\x02\x02\x02\u22AD\u22AE\x03\x02\x02\x02\u22AE\u0445\x03\x02\x02\x02" + + "\u22AF\u22AD\x03\x02\x02\x02\u22B0\u22B1\x07&\x02\x02\u22B1\u22B2\x07" + + "\x04\x02\x02\u22B2\u22B3\x05\u0450\u0229\x02\u22B3\u22B4\x07\x05\x02\x02" + + "\u22B4\u0447\x03\x02\x02\x02\u22B5\u22B6\x07k\x02\x02\u22B6\u22B7\x07" + + "\u01DB\x02\x02\u22B7\u0449\x03\x02\x02\x02\u22B8\u22B9\x07i\x02\x02\u22B9" + + "\u22BA\x05\u048E\u0248\x02\u22BA\u044B\x03\x02\x02\x02\u22BB\u22C0\x07" + + "i\x02\x02\u22BC\u22BD\x07\u01B4\x02\x02\u22BD\u22BE\x07\u0115\x02\x02" + + "\u22BE\u22C1\x05\u03C0\u01E1\x02\u22BF\u22C1\x05\u048E\u0248\x02\u22C0" + + "\u22BC\x03\x02\x02\x02\u22C0\u22BF\x03\x02\x02\x02\u22C1\u044D\x03\x02" + + "\x02\x02\u22C2\u22C3\x05\u0450\u0229\x02\u22C3\u044F\x03\x02\x02\x02\u22C4" + + "\u22C9\x05\u0452\u022A\x02\u22C5\u22C6\x07\b\x02\x02\u22C6\u22C8\x05\u0452" + + "\u022A\x02\u22C7\u22C5\x03\x02\x02\x02\u22C8\u22CB\x03\x02\x02\x02\u22C9" + + "\u22C7\x03\x02\x02\x02\u22C9\u22CA\x03\x02\x02\x02\u22CA\u0451\x03\x02" + + "\x02\x02\u22CB\u22C9\x03\x02\x02\x02\u22CC\u22CD\x05\u0562\u02B2\x02\u22CD" + + "\u22CF\x05\u0462\u0232\x02\u22CE\u22D0\x05n8\x02\u22CF\u22CE\x03\x02\x02" + + "\x02\u22CF\u22D0\x03\x02\x02\x02\u22D0\u0453\x03\x02\x02\x02\u22D1\u22D2" + + "\x07\u01DC\x02\x02\u22D2\u22E2\x07\x04\x02\x02\u22D3\u22D4\x05\u04B8\u025D" + + "\x02\u22D4\u22D5\x05\u04D2\u026A\x02\u22D5\u22D6\x07\u01DD\x02\x02\u22D6" + + "\u22D7\x05\u0456\u022C\x02\u22D7\u22E3\x03\x02\x02\x02\u22D8\u22D9\x07" + + "\u01DE\x02\x02\u22D9\u22DA\x07\x04\x02\x02\u22DA\u22DB\x05\u045E\u0230" + + "\x02\u22DB\u22DC\x07\x05\x02\x02\u22DC\u22DD\x07\b\x02\x02\u22DD\u22DE" + + "\x05\u04B8\u025D\x02\u22DE\u22DF\x05\u04D2\u026A\x02\u22DF\u22E0\x07\u01DD" + + "\x02\x02\u22E0\u22E1\x05\u0456\u022C\x02\u22E1\u22E3\x03\x02\x02\x02\u22E2" + + "\u22D3\x03\x02\x02\x02\u22E2\u22D8\x03\x02\x02\x02\u22E3\u22E4\x03\x02" + + "\x02\x02\u22E4\u22E5\x07\x05\x02\x02\u22E5\u0455\x03\x02\x02\x02\u22E6" + + "\u22EB\x05\u0458\u022D\x02\u22E7\u22E8\x07\b\x02\x02\u22E8\u22EA\x05\u0458" + + "\u022D\x02\u22E9\u22E7\x03\x02\x02\x02\u22EA\u22ED\x03\x02\x02\x02\u22EB" + + "\u22E9\x03\x02\x02\x02\u22EB\u22EC\x03\x02\x02\x02\u22EC\u0457\x03\x02" + + "\x02\x02\u22ED\u22EB\x03\x02\x02\x02\u22EE\u22F5\x05\u0562\u02B2\x02\u22EF" + + "\u22F1\x05\u0462\u0232\x02\u22F0\u22F2\x05\u045A\u022E\x02\u22F1\u22F0" + + "\x03\x02\x02\x02\u22F1\u22F2\x03\x02\x02\x02\u22F2\u22F6\x03\x02\x02\x02" + + "\u22F3\u22F4\x07@\x02\x02\u22F4\u22F6\x07\u01DB\x02\x02\u22F5\u22EF\x03" + + "\x02\x02\x02\u22F5\u22F3\x03\x02\x02\x02\u22F6\u0459\x03\x02\x02\x02\u22F7" + + "\u22F9\x05\u045C\u022F\x02\u22F8\u22F7\x03\x02\x02\x02\u22F9\u22FA\x03" + + "\x02\x02\x02\u22FA\u22F8\x03\x02\x02\x02\u22FA\u22FB\x03\x02\x02\x02\u22FB" + + "\u045B\x03\x02\x02\x02\u22FC\u22FD\x077\x02\x02\u22FD\u2305\x05\u048E" + + "\u0248\x02\u22FE\u22FF\x05\u0572\u02BA\x02\u22FF\u2300\x05\u048E\u0248" + + "\x02\u2300\u2305\x03\x02\x02\x02\u2301\u2302\x07O\x02\x02\u2302\u2305" + + "\x07P\x02\x02\u2303\u2305\x07P\x02\x02\u2304\u22FC\x03\x02\x02\x02\u2304" + + "\u22FE\x03\x02\x02\x02\u2304\u2301\x03\x02\x02\x02\u2304\u2303\x03\x02" + + "\x02\x02\u2305\u045D\x03\x02\x02\x02\u2306\u230B\x05\u0460\u0231\x02\u2307" + + "\u2308\x07\b\x02\x02\u2308\u230A\x05\u0460\u0231\x02\u2309\u2307\x03\x02" + + "\x02\x02\u230A\u230D\x03\x02\x02\x02\u230B\u2309\x03\x02\x02\x02\u230B" + + "\u230C\x03\x02\x02\x02\u230C\u045F\x03\x02\x02\x02\u230D\u230B\x03\x02" + + "\x02\x02\u230E\u230F\x05\u04B6\u025C\x02\u230F\u2310\x07&\x02\x02\u2310" + + "\u2311\x05\u0570\u02B9\x02\u2311\u2315\x03\x02\x02\x02\u2312\u2313\x07" + + "7\x02\x02\u2313\u2315\x05\u04B6\u025C\x02\u2314\u230E\x03\x02\x02\x02" + + "\u2314\u2312\x03\x02\x02\x02\u2315\u0461\x03\x02\x02\x02\u2316\u2318\x07" + + "\u01A1\x02\x02\u2317\u2316\x03\x02\x02\x02\u2317\u2318\x03\x02\x02\x02" + + "\u2318\u2319\x03\x02\x02\x02\u2319\u2322\x05\u0466\u0234\x02\u231A\u2323" + + "\x05\u0464\u0233\x02\u231B\u2320\x07%\x02\x02\u231C\u231D\x07\x06\x02" + + "\x02\u231D\u231E\x05\u0550\u02A9\x02\u231E\u231F\x07\x07\x02\x02\u231F" + + "\u2321\x03\x02\x02\x02\u2320\u231C\x03\x02\x02\x02\u2320\u2321\x03\x02" + + "\x02\x02\u2321\u2323\x03\x02\x02\x02\u2322\u231A\x03\x02\x02\x02\u2322" + + "\u231B\x03\x02\x02\x02\u2323\u2329\x03\x02\x02\x02\u2324\u2325\x05\u053C" + + "\u029F\x02\u2325\u2326\x07\x1D\x02\x02\u2326\u2327\t4\x02\x02\u2327\u2329" + + "\x03\x02\x02\x02\u2328\u2317\x03\x02\x02\x02\u2328\u2324\x03\x02\x02\x02" + + "\u2329\u0463\x03\x02\x02\x02\u232A\u232C\x07\x06\x02\x02\u232B\u232D\x05" + + "\u0550\u02A9\x02\u232C\u232B\x03\x02\x02\x02\u232C\u232D\x03\x02\x02\x02" + + "\u232D\u232E\x03\x02\x02\x02\u232E\u2330\x07\x07\x02\x02\u232F\u232A\x03" + + "\x02\x02\x02\u2330\u2333\x03\x02\x02\x02\u2331\u232F\x03\x02\x02\x02\u2331" + + "\u2332\x03\x02\x02\x02\u2332\u0465\x03\x02\x02\x02\u2333\u2331\x03\x02" + + "\x02\x02\u2334\u2344\x05\u046A\u0236\x02\u2335\u2344\x05\u046E\u0238\x02" + + "\u2336\u2344\x05\u0472\u023A\x02\u2337\u2344\x05\u047A\u023E\x02\u2338" + + "\u2344\x05\u0482\u0242\x02\u2339\u2341\x05\u0484\u0243\x02\u233A\u233C" + + "\x05\u0488\u0245\x02\u233B\u233A\x03\x02\x02\x02\u233B\u233C\x03\x02\x02" + + "\x02\u233C\u2342\x03\x02\x02\x02\u233D\u233E\x07\x04\x02\x02\u233E\u233F" + + "\x05\u0550\u02A9\x02\u233F\u2340\x07\x05\x02\x02\u2340\u2342\x03\x02\x02" + + "\x02\u2341\u233B\x03\x02\x02\x02\u2341\u233D\x03\x02\x02\x02\u2342\u2344" + + "\x03\x02\x02\x02\u2343\u2334\x03\x02\x02\x02\u2343\u2335\x03\x02\x02\x02" + + "\u2343\u2336\x03\x02\x02\x02\u2343\u2337\x03\x02\x02\x02\u2343\u2338\x03" + + "\x02\x02\x02\u2343\u2339\x03\x02\x02\x02\u2344\u0467\x03\x02\x02\x02\u2345" + + "\u234A\x05\u046E\u0238\x02\u2346\u234A\x05\u0474\u023B\x02\u2347\u234A" + + "\x05\u047C\u023F\x02\u2348\u234A\x05\u0482\u0242\x02\u2349\u2345\x03\x02" + + "\x02\x02\u2349\u2346\x03\x02\x02\x02\u2349\u2347\x03\x02\x02\x02\u2349" + + "\u2348\x03\x02\x02\x02\u234A\u0469\x03\x02\x02\x02\u234B\u234D\x05\u056C" + + "\u02B7\x02\u234C\u234E\x05\u0216\u010C\x02\u234D\u234C\x03\x02\x02\x02" + + "\u234D\u234E\x03\x02\x02\x02\u234E\u2350\x03\x02\x02\x02\u234F\u2351\x05" + + "\u046C\u0237\x02\u2350\u234F\x03\x02\x02\x02\u2350\u2351\x03\x02\x02\x02" + + "\u2351\u046B\x03\x02\x02\x02\u2352\u2353\x07\x04\x02\x02\u2353\u2354\x05" + + "\u0502\u0282\x02\u2354\u2355\x07\x05\x02\x02\u2355\u046D\x03\x02\x02\x02" + + "\u2356\u236F\x07\u0193\x02\x02\u2357\u236F\x07\u0194\x02\x02\u2358\u236F" + + "\x07\u01A2\x02\x02\u2359\u236F\x07\u0186\x02\x02\u235A\u236F\x07\u019F" + + "\x02\x02\u235B\u235D\x07\u0190\x02\x02\u235C\u235E\x05\u0470\u0239\x02" + + "\u235D\u235C\x03\x02\x02\x02\u235D\u235E\x03\x02\x02\x02\u235E\u236F\x03" + + "\x02\x02\x02\u235F\u2360\x07\xC0\x02\x02\u2360\u236F\x07\u019E\x02\x02" + + "\u2361\u2363\x07\u018D\x02\x02\u2362\u2364\x05\u046C\u0237\x02\u2363\u2362" + + "\x03\x02\x02\x02\u2363\u2364\x03\x02\x02\x02\u2364\u236F\x03\x02\x02\x02" + + "\u2365\u2367\x07\u018C\x02\x02\u2366\u2368\x05\u046C\u0237\x02\u2367\u2366" + + "\x03\x02\x02\x02\u2367\u2368\x03\x02\x02\x02\u2368\u236F\x03\x02\x02\x02" + + "\u2369\u236B\x07\u019B\x02\x02\u236A\u236C\x05\u046C\u0237\x02\u236B\u236A" + + "\x03\x02\x02\x02\u236B\u236C\x03\x02\x02\x02\u236C\u236F\x03\x02\x02\x02" + + "\u236D\u236F\x07\u0188\x02\x02\u236E\u2356\x03\x02\x02\x02\u236E\u2357" + + "\x03\x02\x02\x02\u236E\u2358\x03\x02\x02\x02\u236E\u2359\x03\x02\x02\x02" + + "\u236E\u235A\x03\x02\x02\x02\u236E\u235B\x03\x02\x02\x02\u236E\u235F\x03" + + "\x02\x02\x02\u236E\u2361\x03\x02\x02\x02\u236E\u2365\x03\x02\x02\x02\u236E" + + "\u2369\x03\x02\x02\x02\u236E\u236D\x03\x02\x02\x02\u236F\u046F\x03\x02" + + "\x02\x02\u2370\u2371\x07\x04\x02\x02\u2371\u2372\x05\u0550\u02A9\x02\u2372" + + "\u2373\x07\x05\x02\x02\u2373\u0471\x03\x02\x02\x02\u2374\u2377\x05\u0476" + + "\u023C\x02\u2375\u2377\x05\u0478\u023D\x02\u2376\u2374\x03\x02\x02\x02" + + "\u2376\u2375\x03\x02\x02\x02\u2377\u0473\x03\x02\x02\x02\u2378\u237B\x05" + + "\u0476\u023C\x02\u2379\u237B\x05\u0478\u023D\x02\u237A\u2378\x03\x02\x02" + + "\x02\u237A\u2379\x03\x02\x02\x02\u237B\u0475\x03\x02\x02\x02\u237C\u237E" + + "\x07\u0187\x02\x02\u237D\u237F\x05\u0480\u0241\x02\u237E\u237D\x03\x02" + + "\x02\x02\u237E\u237F\x03\x02\x02\x02\u237F\u2380\x03\x02\x02\x02\u2380" + + "\u2381\x07\x04\x02\x02\u2381\u2382\x05\u0502\u0282\x02\u2382\u2383\x07" + + "\x05\x02\x02\u2383\u0477\x03\x02\x02\x02\u2384\u2386\x07\u0187\x02\x02" + + "\u2385\u2387\x05\u0480\u0241\x02\u2386\u2385\x03\x02\x02\x02\u2386\u2387" + + "\x03\x02\x02\x02\u2387\u0479\x03\x02\x02\x02\u2388\u238D\x05\u047E\u0240" + + "\x02\u2389\u238A\x07\x04\x02\x02\u238A\u238B\x05\u0550\u02A9\x02\u238B" + + "\u238C\x07\x05\x02\x02\u238C\u238E\x03\x02\x02\x02\u238D\u2389\x03\x02" + + "\x02\x02\u238D\u238E\x03\x02\x02\x02\u238E\u047B\x03\x02\x02\x02\u238F" + + "\u2394\x05\u047E\u0240\x02\u2390\u2391\x07\x04\x02\x02\u2391\u2392\x05" + + "\u0550\u02A9\x02\u2392\u2393\x07\x05\x02\x02\u2393\u2395\x03\x02\x02\x02" + + "\u2394\u2390\x03\x02\x02\x02\u2394\u2395\x03\x02\x02\x02\u2395\u047D\x03" + + "\x02\x02\x02\u2396\u2398\t5\x02\x02\u2397\u2399\x05\u0480\u0241\x02\u2398" + + "\u2397\x03\x02\x02\x02\u2398\u2399\x03\x02\x02\x02\u2399\u23A1\x03\x02" + + "\x02\x02\u239A\u23A1\x07\u01A9\x02\x02\u239B\u239C\x07\u0197\x02\x02\u239C" + + "\u239E\t6\x02\x02\u239D\u239F\x05\u0480\u0241\x02\u239E\u239D\x03\x02" + + "\x02\x02\u239E\u239F\x03\x02\x02\x02\u239F\u23A1\x03\x02\x02\x02\u23A0" + + "\u2396\x03\x02\x02\x02\u23A0\u239A\x03\x02\x02\x02\u23A0\u239B\x03\x02" + + "\x02\x02\u23A1\u047F\x03\x02\x02\x02\u23A2\u23A3\x07\u0178\x02\x02\u23A3" + + "\u0481\x03\x02\x02\x02\u23A4\u23A9\t7\x02\x02\u23A5\u23A6\x07\x04\x02" + + "\x02\u23A6\u23A7\x05\u0550\u02A9\x02\u23A7\u23A8\x07\x05\x02\x02\u23A8" + + "\u23AA\x03\x02\x02\x02\u23A9\u23A5\x03\x02\x02\x02\u23A9\u23AA\x03\x02" + + "\x02\x02\u23AA\u23AC\x03\x02\x02\x02\u23AB\u23AD\x05\u0486\u0244\x02\u23AC" + + "\u23AB\x03\x02\x02\x02\u23AC\u23AD\x03\x02\x02\x02\u23AD\u0483\x03\x02" + + "\x02\x02\u23AE\u23AF\x07\u0195\x02\x02\u23AF\u0485\x03\x02\x02\x02\u23B0" + + "\u23B1\x07k\x02\x02\u23B1\u23B2\x07\u01A4\x02\x02\u23B2\u23B7\x07\u0184" + + "\x02\x02\u23B3\u23B4\x07\u017D\x02\x02\u23B4\u23B5\x07\u01A4\x02\x02\u23B5" + + "\u23B7\x07\u0184\x02\x02\u23B6\u23B0\x03\x02\x02\x02\u23B6\u23B3\x03\x02" + + "\x02\x02\u23B7\u0487\x03\x02\x02\x02\u23B8\u23D2\x07\u0182\x02\x02\u23B9" + + "\u23D2\x07\u010A\x02\x02\u23BA\u23D2\x07\xB2\x02\x02\u23BB\u23D2\x07\xDC" + + "\x02\x02\u23BC\u23D2\x07\u0107\x02\x02\u23BD\u23D2\x05\u048A\u0246\x02" + + "\u23BE\u23BF\x07\u0182\x02\x02\u23BF\u23C0\x07`\x02\x02\u23C0\u23D2\x07" + + "\u010A\x02\x02\u23C1\u23C2\x07\xB2\x02\x02\u23C2\u23C6\x07`\x02\x02\u23C3" + + "\u23C7\x07\xDC\x02\x02\u23C4\u23C7\x07\u0107\x02\x02\u23C5\u23C7\x05\u048A" + + "\u0246\x02\u23C6\u23C3\x03\x02\x02\x02\u23C6\u23C4\x03\x02\x02\x02\u23C6" + + "\u23C5\x03\x02\x02\x02\u23C7\u23D2\x03\x02\x02\x02\u23C8\u23C9\x07\xDC" + + "\x02\x02\u23C9\u23CC\x07`\x02\x02\u23CA\u23CD\x07\u0107\x02\x02\u23CB" + + "\u23CD\x05\u048A\u0246\x02\u23CC\u23CA\x03\x02\x02\x02\u23CC\u23CB\x03" + + "\x02\x02\x02\u23CD\u23D2\x03\x02\x02\x02\u23CE\u23CF\x07\u0107\x02\x02" + + "\u23CF\u23D0\x07`\x02\x02\u23D0\u23D2\x05\u048A\u0246\x02\u23D1\u23B8" + + "\x03\x02\x02\x02\u23D1\u23B9\x03\x02\x02\x02\u23D1\u23BA\x03\x02\x02\x02" + + "\u23D1\u23BB\x03\x02\x02\x02\u23D1\u23BC\x03\x02\x02\x02\u23D1\u23BD\x03" + + "\x02\x02\x02\u23D1\u23BE\x03\x02\x02\x02\u23D1\u23C1\x03\x02\x02\x02\u23D1" + + "\u23C8\x03\x02\x02\x02\u23D1\u23CE\x03\x02\x02\x02\u23D2\u0489\x03\x02" + + "\x02\x02\u23D3\u23D8\x07\u0148\x02\x02\u23D4\u23D5\x07\x04\x02\x02\u23D5" + + "\u23D6\x05\u0550\u02A9\x02\u23D6\u23D7\x07\x05\x02\x02\u23D7\u23D9\x03" + + "\x02\x02"; private static readonly _serializedATNSegment17: string = - "\x02\u23F7\u23FA\x03\x02\x02\x02\u23F8\u23F6\x03\x02\x02\x02\u23F8\u23F9" + - "\x03\x02\x02\x02\u23F9\u0497\x03\x02\x02\x02\u23FA\u23F8\x03\x02\x02\x02" + - "\u23FB\u23FD\x05\u04EE\u0278\x02\u23FC\u23FB\x03\x02\x02\x02\u23FC\u23FD" + - "\x03\x02\x02\x02\u23FD\u23FE\x03\x02\x02\x02\u23FE\u23FF\x05\u049A\u024E" + - "\x02\u23FF\u0499\x03\x02\x02\x02\u2400\u2405\x05\u049C\u024F\x02\u2401" + - "\u2402\t5\x02\x02\u2402\u2404\x05\u049C\u024F\x02\u2403\u2401\x03\x02" + - "\x02\x02\u2404\u2407\x03\x02\x02\x02\u2405\u2403\x03\x02\x02\x02\u2405" + - "\u2406\x03\x02\x02\x02\u2406\u049B\x03\x02\x02\x02\u2407\u2405\x03\x02" + - "\x02\x02\u2408\u240D\x05\u049E\u0250\x02\u2409\u240A\t6\x02\x02\u240A" + - "\u240C\x05\u049E\u0250\x02\u240B\u2409\x03\x02\x02\x02\u240C\u240F\x03" + - "\x02\x02\x02\u240D\u240B\x03\x02\x02\x02\u240D\u240E\x03\x02\x02\x02\u240E" + - "\u049D\x03\x02\x02\x02\u240F\u240D\x03\x02\x02\x02\u2410\u2413\x05\u04A0" + - "\u0251\x02\u2411\u2412\x07\x11\x02\x02\u2412\u2414\x05\u0480\u0241\x02" + - "\u2413\u2411\x03\x02\x02\x02\u2413\u2414\x03\x02\x02\x02\u2414\u049F\x03" + - "\x02\x02\x02\u2415\u2417\t5\x02\x02\u2416\u2415\x03\x02\x02\x02\u2416" + - "\u2417\x03\x02\x02\x02\u2417\u2418\x03\x02\x02\x02\u2418\u2419\x05\u04A2" + - "\u0252\x02\u2419\u04A1\x03\x02\x02\x02\u241A\u241F\x05\u04A4\u0253\x02" + - "\u241B\u241C\x07\x90\x02\x02\u241C\u241D\x07\u019B\x02\x02\u241D\u241E" + - "\x07\u017B\x02\x02\u241E\u2420\x05\u0480\u0241\x02\u241F\u241B\x03\x02" + - "\x02\x02\u241F\u2420\x03\x02\x02\x02\u2420\u04A3\x03\x02\x02\x02\u2421" + - "\u2424\x05\u04A6\u0254\x02\u2422\u2423\x07-\x02\x02\u2423\u2425\x05\u020C" + - "\u0107\x02\u2424\u2422\x03\x02\x02\x02\u2424\u2425\x03\x02\x02\x02\u2425" + - "\u04A5\x03\x02\x02\x02\u2426\u242B\x05\u04AA\u0256\x02\u2427\u2428\x07" + - "\x1C\x02\x02\u2428\u242A\x05\u0454\u022B\x02\u2429\u2427\x03\x02\x02\x02" + - "\u242A\u242D\x03\x02\x02\x02\u242B\u2429\x03\x02\x02\x02\u242B\u242C\x03" + - "\x02\x02\x02\u242C\u04A7\x03\x02\x02\x02\u242D\u242B\x03\x02\x02\x02\u242E" + - "\u242F\b\u0255\x01\x02\u242F\u2436\x05\u04AA\u0256\x02\u2430\u2431\t5" + - "\x02\x02\u2431\u2436\x05\u04A8\u0255\v\u2432\u2433\x05\u04EE\u0278\x02" + - "\u2433\u2434\x05\u04A8\u0255\x05\u2434\u2436\x03\x02\x02\x02\u2435\u242E" + - "\x03\x02\x02\x02\u2435\u2430\x03\x02\x02\x02\u2435\u2432\x03\x02\x02\x02" + - "\u2436\u245E\x03\x02\x02\x02\u2437\u2438\f\n\x02\x02\u2438\u2439\x07\x11" + - "\x02\x02\u2439\u245D\x05\u04A8\u0255\v\u243A\u243B\f\t\x02\x02\u243B\u243C" + - "\t6\x02\x02\u243C\u245D\x05\u04A8\u0255\n\u243D\u243E\f\b\x02\x02\u243E" + - "\u243F\t5\x02\x02\u243F\u245D\x05\u04A8\u0255\t\u2440\u2441\f\x07\x02" + - "\x02\u2441\u2442\x05\u04EE\u0278\x02\u2442\u2443\x05\u04A8\u0255\b\u2443" + - "\u245D\x03\x02\x02\x02\u2444\u2445\f\x06\x02\x02\u2445\u2446\t4\x02\x02" + - "\u2446\u245D\x05\u04A8\u0255\x07\u2447\u2448\f\f\x02\x02\u2448\u2449\x07" + - "\x1C\x02\x02\u2449\u245D\x05\u0454\u022B\x02\u244A\u244B\f\x04\x02\x02" + - "\u244B\u245D\x05\u04EE\u0278\x02\u244C\u244D\f\x03\x02\x02\u244D\u244F" + - "\x07v\x02\x02\u244E\u2450\x07O\x02\x02\u244F\u244E\x03\x02\x02\x02\u244F" + - "\u2450\x03\x02\x02\x02\u2450\u245A\x03\x02\x02\x02\u2451\u2452\x07:\x02" + - "\x02\u2452\u2453\x07B\x02\x02\u2453\u245B\x05\u04A8\u0255\x02\u2454\u2455" + - "\x07\u010C\x02\x02\u2455\u2456\x07\x04\x02\x02\u2456\u2457\x05\u04FA\u027E" + - "\x02\u2457\u2458\x07\x05\x02\x02\u2458\u245B\x03\x02\x02\x02\u2459\u245B" + - "\x07\xBE\x02\x02\u245A\u2451\x03\x02\x02\x02\u245A\u2454\x03\x02\x02\x02" + - "\u245A\u2459\x03\x02\x02\x02\u245B\u245D\x03\x02\x02\x02\u245C\u2437\x03" + - "\x02\x02\x02\u245C\u243A\x03\x02\x02\x02\u245C\u243D\x03\x02\x02\x02\u245C" + - "\u2440\x03\x02\x02\x02\u245C\u2444\x03\x02\x02\x02\u245C\u2447\x03\x02" + - "\x02\x02\u245C\u244A\x03\x02\x02\x02\u245C\u244C\x03\x02\x02\x02\u245D" + - "\u2460\x03\x02\x02\x02\u245E\u245C\x03\x02\x02\x02\u245E\u245F\x03\x02" + - "\x02\x02\u245F\u04A9\x03\x02\x02\x02\u2460\u245E\x03\x02\x02\x02\u2461" + - "\u2462\x07\u0185\x02\x02\u2462\u2486\x05\u03BA\u01DE\x02\u2463\u2466\x07" + - "%\x02\x02\u2464\u2467\x05\u03BA\u01DE\x02\u2465\u2467\x05\u04FC\u027F" + - "\x02\u2466\u2464\x03\x02\x02\x02\u2466\u2465\x03\x02\x02\x02\u2467\u2486" + - "\x03\x02\x02\x02\u2468\u2469\x07\x1E\x02\x02\u2469\u2486\x05\u0522\u0292" + - "\x02\u246A\u246B\x07\u01CF\x02\x02\u246B\u246C\x07\x04\x02\x02\u246C\u246D" + - "\x05\u04F4\u027B\x02\u246D\u246E\x07\x05\x02\x02\u246E\u2486\x03\x02\x02" + - "\x02\u246F\u2470\x07d\x02\x02\u2470\u2486\x05\u03BA\u01DE\x02\u2471\u2486" + - "\x05\u051A\u028E\x02\u2472\u2486\x05\u0538\u029D\x02\u2473\u2486\x05\u04AC" + - "\u0257\x02\u2474\u2475\x07\x04\x02\x02\u2475\u2476\x05\u0480\u0241\x02" + - "\u2476\u2477\x07\x05\x02\x02\u2477\u2478\x05\u0522\u0292\x02\u2478\u2486" + - "\x03\x02\x02\x02\u2479\u2486\x05\u0510\u0289\x02\u247A\u2486\x05\u04B0" + - "\u0259\x02\u247B\u247D\x05\u03BA\u01DE\x02\u247C\u247E\x05\u0520\u0291" + - "\x02\u247D\u247C\x03\x02\x02\x02\u247D\u247E\x03\x02\x02\x02\u247E\u2486" + - "\x03\x02\x02\x02\u247F\u2486\x05\u04E4\u0273\x02\u2480\u2486\x05\u04E6" + - "\u0274\x02\u2481\u2482\x05\u04E2\u0272\x02\u2482\u2483\x07\x7F\x02\x02" + - "\u2483\u2484\x05\u04E2\u0272\x02\u2484\u2486\x03\x02\x02\x02\u2485\u2461" + - "\x03\x02\x02\x02\u2485\u2463\x03\x02\x02\x02\u2485\u2468\x03\x02\x02\x02" + - "\u2485\u246A\x03\x02\x02\x02\u2485\u246F\x03\x02\x02\x02\u2485\u2471\x03" + - "\x02\x02\x02\u2485\u2472\x03\x02\x02\x02\u2485\u2473\x03\x02\x02\x02\u2485" + - "\u2474\x03\x02\x02\x02\u2485\u2479\x03\x02\x02\x02\u2485\u247A\x03\x02" + - "\x02\x02\u2485\u247B\x03\x02\x02\x02\u2485\u247F\x03\x02\x02\x02\u2485" + - "\u2480\x03\x02\x02\x02\u2485\u2481\x03\x02\x02\x02\u2486\u04AB\x03\x02" + - "\x02\x02\u2487\u2488\x07\u021B\x02\x02\u2488\u04AD\x03\x02\x02\x02\u2489" + - "\u248A\x05\u0536\u029C\x02\u248A\u24A0\x07\x04\x02\x02\u248B\u248F\x05" + - "\u04F6\u027C\x02\u248C\u248D\x07\b\x02\x02\u248D\u248E\x07g\x02\x02\u248E" + - "\u2490\x05\u04F8\u027D\x02\u248F\u248C\x03\x02\x02\x02\u248F\u2490\x03" + - "\x02\x02\x02\u2490\u2492\x03\x02\x02\x02\u2491\u2493\x05\u03DE\u01F0\x02" + - "\u2492\u2491\x03\x02\x02\x02\u2492\u2493\x03\x02\x02\x02\u2493\u24A1\x03" + - "\x02\x02\x02\u2494\u2495\x07g\x02\x02\u2495\u2497\x05\u04F8\u027D\x02" + - "\u2496\u2498\x05\u03DE\u01F0\x02\u2497\u2496\x03\x02\x02\x02\u2497\u2498" + - "\x03\x02\x02\x02\u2498\u24A1\x03\x02\x02\x02\u2499\u249A\t*\x02\x02\u249A" + - "\u249C\x05\u04F6\u027C\x02\u249B\u249D\x05\u03DE\u01F0\x02\u249C\u249B" + - "\x03\x02\x02\x02\u249C\u249D\x03\x02\x02\x02\u249D\u24A1\x03\x02\x02\x02" + - "\u249E\u24A1\x07\v\x02\x02\u249F\u24A1\x03\x02\x02\x02\u24A0\u248B\x03" + - "\x02\x02\x02\u24A0\u2494\x03\x02\x02\x02\u24A0\u2499\x03\x02\x02\x02\u24A0" + - "\u249E\x03\x02\x02\x02\u24A0\u249F\x03\x02\x02\x02\u24A1\u24A2\x03\x02" + - "\x02\x02\u24A2\u24A3\x07\x05\x02\x02\u24A3\u04AF\x03\x02\x02\x02\u24A4" + - "\u24A6\x05\u04AE\u0258\x02\u24A5\u24A7\x05\u04C8\u0265\x02\u24A6\u24A5" + - "\x03\x02\x02\x02\u24A6\u24A7\x03\x02\x02\x02\u24A7\u24A9\x03\x02\x02\x02" + - "\u24A8\u24AA\x05\u04CA\u0266\x02\u24A9\u24A8\x03\x02\x02\x02\u24A9\u24AA" + - "\x03\x02\x02\x02\u24AA\u24AC\x03\x02\x02\x02\u24AB\u24AD\x05\u04D2\u026A" + - "\x02\u24AC\u24AB\x03\x02\x02\x02\u24AC\u24AD\x03\x02\x02\x02\u24AD\u24B0" + - "\x03\x02\x02\x02\u24AE\u24B0\x05\u04B4\u025B\x02\u24AF\u24A4\x03\x02\x02" + - "\x02\u24AF\u24AE\x03\x02\x02\x02\u24B0\u04B1\x03\x02\x02\x02\u24B1\u24B4" + - "\x05\u04AE\u0258\x02\u24B2\u24B4\x05\u04B4\u025B\x02\u24B3\u24B1\x03\x02" + - "\x02\x02\u24B3\u24B2\x03\x02\x02\x02\u24B4\u04B3\x03\x02\x02\x02\u24B5" + - "\u24B6\x07n\x02\x02\u24B6\u24B7\x07@\x02\x02\u24B7\u24B8\x07\x04\x02\x02" + - "\u24B8\u24B9\x05\u0480\u0241\x02\u24B9\u24BA\x07\x05\x02\x02\u24BA\u256E" + - "\x03\x02\x02\x02\u24BB\u256E\x072\x02\x02\u24BC\u24C1\x074\x02\x02\u24BD" + - "\u24BE\x07\x04\x02\x02\u24BE\u24BF\x05\u0540\u02A1\x02\u24BF\u24C0\x07" + - "\x05\x02\x02\u24C0\u24C2\x03\x02\x02\x02\u24C1\u24BD\x03\x02\x02\x02\u24C1" + - "\u24C2\x03\x02\x02\x02\u24C2\u256E\x03\x02\x02\x02\u24C3\u24C8\x075\x02" + - "\x02\u24C4\u24C5\x07\x04\x02\x02\u24C5\u24C6\x05\u0540\u02A1\x02\u24C6" + - "\u24C7\x07\x05\x02\x02\u24C7\u24C9\x03\x02\x02\x02\u24C8\u24C4\x03\x02" + - "\x02\x02\u24C8\u24C9\x03\x02\x02\x02\u24C9\u256E\x03\x02\x02\x02\u24CA" + - "\u24CF\x07M\x02\x02\u24CB\u24CC\x07\x04\x02\x02\u24CC\u24CD\x05\u0540" + - "\u02A1\x02\u24CD\u24CE\x07\x05\x02\x02\u24CE\u24D0\x03\x02\x02\x02\u24CF" + - "\u24CB\x03\x02\x02\x02\u24CF\u24D0\x03\x02\x02\x02\u24D0\u256E\x03\x02" + - "\x02\x02\u24D1\u24D6\x07N\x02\x02\u24D2\u24D3\x07\x04\x02\x02\u24D3\u24D4" + - "\x05\u0540\u02A1\x02\u24D4\u24D5\x07\x05\x02\x02\u24D5\u24D7\x03\x02\x02" + - "\x02\u24D6\u24D2\x03\x02\x02\x02\u24D6\u24D7\x03\x02\x02\x02\u24D7\u256E" + - "\x03\x02\x02\x02\u24D8\u256E\x073\x02\x02\u24D9\u256E\x076\x02\x02\u24DA" + - "\u256E\x07[\x02\x02\u24DB\u256E\x07e\x02\x02\u24DC\u256E\x071\x02\x02" + - "\u24DD\u256E\x07q\x02\x02\u24DE\u24DF\x07+\x02\x02\u24DF\u24E0\x07\x04" + - "\x02\x02\u24E0\u24E1\x05\u0480\u0241\x02\u24E1\u24E2\x07&\x02\x02\u24E2" + - "\u24E3\x05\u0454\u022B\x02\u24E3\u24E4\x07\x05\x02\x02\u24E4\u256E\x03" + - "\x02\x02\x02\u24E5\u24E6\x07\u0186\x02\x02\u24E6\u24E8\x07\x04\x02\x02" + - "\u24E7\u24E9\x05\u0500\u0281\x02\u24E8\u24E7\x03\x02\x02\x02\u24E8\u24E9" + - "\x03\x02\x02\x02\u24E9\u24EA\x03\x02\x02\x02\u24EA\u256E\x07\x05\x02\x02" + - "\u24EB\u24EC\x07\u01E2\x02\x02\u24EC\u24ED\x07\x04\x02\x02\u24ED\u24F0" + - "\x05\u0480\u0241\x02\u24EE\u24EF\x07\b\x02\x02\u24EF\u24F1\x05\u0504\u0283" + - "\x02\u24F0\u24EE\x03\x02\x02\x02\u24F0\u24F1\x03\x02\x02\x02\u24F1\u24F2" + - "\x03\x02\x02\x02\u24F2\u24F3\x07\x05\x02\x02\u24F3\u256E\x03\x02\x02\x02" + - "\u24F4\u24F5\x07\u0193\x02\x02\u24F5\u24F6\x07\x04\x02\x02\u24F6\u24F7" + - "\x05\u0506\u0284\x02\u24F7\u24F8\x07\x05\x02\x02\u24F8\u256E\x03\x02\x02" + - "\x02\u24F9\u24FA\x07\u0194\x02\x02\u24FA\u24FC\x07\x04\x02\x02\u24FB\u24FD" + - "\x05\u0508\u0285\x02\u24FC\u24FB\x03\x02\x02\x02\u24FC\u24FD\x03\x02\x02" + - "\x02\u24FD\u24FE\x03\x02\x02\x02\u24FE\u256E\x07\x05\x02\x02\u24FF\u2500" + - "\x07\u019A\x02\x02\u2500\u2502\x07\x04\x02\x02\u2501\u2503\x05\u050A\u0286" + - "\x02\u2502\u2501\x03\x02\x02\x02\u2502\u2503\x03\x02\x02\x02\u2503\u2504" + - "\x03\x02\x02\x02\u2504\u256E\x07\x05\x02\x02\u2505\u2506\x07\u019D\x02" + - "\x02\u2506\u2507\x07\x04\x02\x02\u2507\u2508\x05\u0480\u0241\x02\u2508" + - "\u2509\x07&\x02\x02\u2509\u250A\x05\u0454\u022B\x02\u250A\u250B\x07\x05" + - "\x02\x02\u250B\u256E\x03\x02\x02\x02\u250C\u250D\x07\u019E\x02\x02\u250D" + - "\u250F\x07\x04\x02\x02\u250E\u2510\t7\x02\x02\u250F\u250E\x03\x02\x02" + - "\x02\u250F\u2510\x03\x02\x02\x02\u2510\u2511\x03\x02\x02\x02\u2511\u2512" + - "\x05\u050C\u0287\x02\u2512\u2513\x07\x05\x02\x02\u2513\u256E\x03\x02\x02" + - "\x02\u2514\u2515\x07\u0191\x02\x02\u2515\u2516\x07\x04\x02\x02\u2516\u2517" + - "\x05\u0480\u0241\x02\u2517\u2518\x07\b\x02\x02\u2518\u2519\x05\u0480\u0241" + - "\x02\u2519\u251A\x07\x05\x02\x02\u251A\u256E\x03\x02\x02\x02\u251B\u251C" + - "\x07\u0182\x02\x02\u251C\u251D\x07\x04\x02\x02\u251D\u251E\x05\u04F4\u027B" + - "\x02\u251E\u251F\x07\x05\x02\x02\u251F\u256E\x03\x02\x02\x02\u2520\u2521" + - "\x07\u0188\x02\x02\u2521\u2522\x07\x04\x02\x02\u2522\u2523\x05\u04F4\u027B" + - "\x02\u2523\u2524\x07\x05\x02\x02\u2524\u256E\x03\x02\x02\x02\u2525\u2526" + - "\x07\u018D\x02\x02\u2526\u2527\x07\x04\x02\x02\u2527\u2528\x05\u04F4\u027B" + - "\x02\u2528\u2529\x07\x05\x02\x02\u2529\u256E\x03\x02\x02\x02\u252A\u252B" + - "\x07\u01A2\x02\x02\u252B\u252C\x07\x04\x02\x02\u252C\u252D\x05\u04F4\u027B" + - "\x02\u252D\u252E\x07\x05\x02\x02\u252E\u256E\x03\x02\x02\x02\u252F\u2530" + - "\x07\u01A3\x02\x02\u2530\u2531\x07\x04\x02\x02\u2531\u2532\x07\u0103\x02" + - "\x02\u2532\u2538\x05\u0556\u02AC\x02\u2533\u2536\x07\b\x02\x02\u2534\u2537" + - "\x05\u04BA\u025E\x02\u2535\u2537\x05\u04F4\u027B\x02\u2536\u2534\x03\x02" + - "\x02\x02\u2536\u2535\x03\x02\x02\x02\u2537\u2539\x03\x02\x02\x02\u2538" + - "\u2533\x03\x02\x02\x02\u2538\u2539\x03\x02\x02\x02\u2539\u253A\x03\x02" + - "\x02\x02\u253A\u253B\x07\x05\x02\x02\u253B\u256E\x03\x02\x02\x02\u253C" + - "\u253D\x07\u01A4\x02\x02\u253D\u253E\x07\x04\x02\x02\u253E\u253F\x05\u04AA" + - "\u0256\x02\u253F\u2540\x05\u04C4\u0263\x02\u2540\u2541\x07\x05\x02\x02" + - "\u2541\u256E\x03\x02\x02\x02\u2542\u2543\x07\u01A5\x02\x02\u2543\u2544" + - "\x07\x04\x02\x02\u2544\u2545\x05\u04BC\u025F\x02\u2545\u2546\x07\x05\x02" + - "\x02\u2546\u256E\x03\x02\x02\x02\u2547\u2548\x07\u01A6\x02\x02\u2548\u2549" + - "\x07\x04\x02\x02\u2549\u254A\x05\u04C0\u0261\x02\u254A\u254C\x05\u0480" + - "\u0241\x02\u254B\u254D\x05\u04C2\u0262\x02\u254C\u254B\x03\x02\x02\x02" + - "\u254C\u254D\x03\x02\x02\x02\u254D\u254E\x03\x02\x02\x02\u254E\u254F\x07" + - "\x05\x02\x02\u254F\u256E\x03\x02\x02\x02\u2550\u2551\x07\u01A7\x02\x02" + - "\u2551\u2552\x07\x04\x02\x02\u2552\u2553\x07\u0103\x02\x02\u2553\u2556" + - "\x05\u0556\u02AC\x02\u2554\u2555\x07\b\x02\x02\u2555\u2557\x05\u0480\u0241" + - "\x02\u2556\u2554\x03\x02\x02\x02\u2556\u2557\x03\x02\x02\x02\u2557\u2558" + - "\x03\x02\x02\x02\u2558\u2559\x07\x05\x02\x02\u2559\u256E\x03\x02\x02\x02" + - "\u255A\u255B\x07\u01A8\x02\x02\u255B\u255C\x07\x04\x02\x02\u255C\u255D" + - "\x07\u0178\x02\x02\u255D\u255E\x05\u0480\u0241\x02\u255E\u255F\x07\b\x02" + - "\x02\u255F\u2561\x05\u04B6\u025C\x02\u2560\u2562\x05\u04B8\u025D\x02\u2561" + - "\u2560\x03\x02\x02\x02\u2561\u2562\x03\x02\x02\x02\u2562\u2563\x03\x02" + - "\x02\x02\u2563\u2564\x07\x05\x02\x02\u2564\u256E\x03\x02\x02\x02\u2565" + - "\u2566\x07\u01A9\x02\x02\u2566\u2567\x07\x04\x02\x02\u2567\u2568\x05\u04C0" + - "\u0261\x02\u2568\u2569\x05\u0480\u0241\x02\u2569\u256A\x07&\x02\x02\u256A" + - "\u256B\x05\u0458\u022D\x02\u256B\u256C\x07\x05\x02\x02\u256C\u256E\x03" + - "\x02\x02\x02\u256D\u24B5\x03\x02\x02\x02\u256D\u24BB\x03\x02\x02\x02\u256D" + - "\u24BC\x03\x02\x02\x02\u256D\u24C3\x03\x02\x02\x02\u256D\u24CA\x03\x02" + - "\x02\x02\u256D\u24D1\x03\x02\x02\x02\u256D\u24D8\x03\x02\x02\x02\u256D" + - "\u24D9\x03\x02\x02\x02\u256D\u24DA\x03\x02\x02\x02\u256D\u24DB\x03\x02" + - "\x02\x02\u256D\u24DC\x03\x02\x02\x02\u256D\u24DD\x03\x02\x02\x02\u256D" + - "\u24DE\x03\x02\x02\x02\u256D\u24E5\x03\x02\x02\x02\u256D\u24EB\x03\x02" + - "\x02\x02\u256D\u24F4\x03\x02\x02\x02\u256D\u24F9\x03\x02\x02\x02\u256D" + - "\u24FF\x03\x02\x02\x02\u256D\u2505\x03\x02\x02\x02\u256D\u250C\x03\x02" + - "\x02\x02\u256D\u2514\x03\x02\x02\x02\u256D\u251B\x03\x02\x02\x02\u256D" + - "\u2520\x03\x02\x02\x02\u256D\u2525\x03\x02\x02\x02\u256D\u252A\x03\x02" + - "\x02\x02\u256D\u252F\x03\x02\x02\x02\u256D\u253C\x03\x02\x02\x02\u256D" + - "\u2542\x03\x02\x02\x02\u256D\u2547\x03\x02\x02\x02\u256D\u2550\x03\x02" + - "\x02\x02\u256D\u255A\x03\x02\x02\x02\u256D\u2565\x03\x02\x02\x02\u256E" + - "\u04B5\x03\x02\x02\x02\u256F\u2570\x07\u0170\x02\x02\u2570\u2575\x05\u0480" + - "\u0241\x02\u2571\u2572\x07\u0170\x02\x02\u2572\u2573\x07\u0106\x02\x02" + - "\u2573\u2575\x07\u01BB\x02\x02\u2574\u256F\x03\x02\x02\x02\u2574\u2571" + - "\x03\x02\x02\x02\u2575\u04B7\x03\x02\x02\x02\u2576\u2577\x07\b\x02\x02" + - "\u2577\u2578\x07\u014C\x02\x02\u2578\u2581\x07\u017A\x02\x02\u2579\u257A" + - "\x07\b\x02\x02\u257A\u257B\x07\u014C\x02\x02\u257B\u2581\x07\u0106\x02" + - "\x02\u257C\u257D\x07\b\x02\x02\u257D\u257E\x07\u014C\x02\x02\u257E\u257F" + - "\x07\u0106\x02\x02\u257F\u2581\x07\u01BB\x02\x02\u2580\u2576\x03\x02\x02" + - "\x02\u2580\u2579\x03\x02\x02\x02\u2580\u257C\x03\x02\x02\x02\u2581\u04B9" + - "\x03\x02\x02\x02\u2582\u2583\x07\u01A1\x02\x02\u2583\u2584\x07\x04\x02" + - "\x02\u2584\u2585\x05\u04BC\u025F\x02\u2585\u2586\x07\x05\x02\x02\u2586" + - "\u04BB\x03\x02\x02\x02\u2587\u258C\x05\u04BE\u0260\x02\u2588\u2589\x07" + - "\b\x02\x02\u2589\u258B\x05\u04BE\u0260\x02\u258A\u2588\x03\x02\x02\x02" + - "\u258B\u258E\x03\x02\x02\x02\u258C\u258A\x03\x02\x02\x02\u258C\u258D\x03" + - "\x02\x02\x02\u258D\u04BD\x03\x02\x02\x02\u258E\u258C\x03\x02\x02\x02\u258F" + - "\u2592\x05\u0480\u0241\x02\u2590\u2591\x07&\x02\x02\u2591\u2593\x05\u0556" + - "\u02AC\x02\u2592\u2590\x03\x02\x02\x02\u2592\u2593\x03\x02\x02\x02\u2593" + - "\u04BF\x03\x02\x02\x02\u2594\u2595\t8\x02\x02\u2595\u04C1\x03\x02\x02" + - "\x02\u2596\u2597\x07\u011D\x02\x02\u2597\u259B\x07\u0173\x02\x02\u2598" + - "\u2599\x07\u0154\x02\x02\u2599\u259B\x07\u0173\x02\x02\u259A\u2596\x03" + - "\x02\x02\x02\u259A\u2598\x03\x02\x02\x02\u259B\u04C3\x03\x02\x02\x02\u259C" + - "\u259D\x07\u0117\x02\x02\u259D\u25AC\x05\u04AA\u0256\x02\u259E\u259F\x07" + - "\u0117\x02\x02\u259F\u25A0\x05\u04AA\u0256\x02\u25A0\u25A1\x05\u04C6\u0264" + - "\x02\u25A1\u25AC\x03\x02\x02\x02\u25A2\u25A3\x07\u0117\x02\x02\u25A3\u25A4" + - "\x05\u04C6\u0264\x02\u25A4\u25A5\x05\u04AA\u0256\x02\u25A5\u25AC\x03\x02" + - "\x02\x02\u25A6\u25A7\x07\u0117\x02\x02\u25A7\u25A8\x05\u04C6\u0264\x02" + - "\u25A8\u25A9\x05\u04AA\u0256\x02\u25A9\u25AA\x05\u04C6\u0264\x02\u25AA" + - "\u25AC\x03\x02\x02\x02\u25AB\u259C\x03\x02\x02\x02\u25AB\u259E\x03\x02" + - "\x02\x02\u25AB\u25A2\x03\x02\x02\x02\u25AB\u25A6\x03\x02\x02\x02\u25AC" + - "\u04C5\x03\x02\x02\x02\u25AD\u25AE\x07\x95\x02\x02\u25AE\u25AF\t9\x02" + - "\x02\u25AF\u04C7\x03\x02\x02\x02\u25B0\u25B1\x07\u01D8\x02\x02\u25B1\u25B2" + - "\x07D\x02\x02\u25B2\u25B3\x07\x04\x02\x02\u25B3\u25B4\x05\u03E0\u01F1" + - "\x02\u25B4\u25B5\x07\x05\x02\x02\u25B5\u04C9\x03\x02\x02\x02\u25B6\u25B7" + - "\x07\u01D9\x02\x02\u25B7\u25B8\x07\x04\x02\x02\u25B8\u25B9\x07i\x02\x02" + - "\u25B9\u25BA\x05\u0480\u0241\x02\u25BA\u25BB\x07\x05\x02\x02\u25BB\u04CB" + - "\x03\x02\x02\x02\u25BC\u25BD\x07j\x02\x02\u25BD\u25BE\x05\u04CE\u0268" + - "\x02\u25BE\u04CD\x03\x02\x02\x02\u25BF\u25C4\x05\u04D0\u0269\x02\u25C0" + - "\u25C1\x07\b\x02\x02\u25C1\u25C3\x05\u04D0\u0269\x02\u25C2\u25C0\x03\x02" + - "\x02\x02\u25C3\u25C6\x03\x02\x02\x02\u25C4\u25C2\x03\x02\x02\x02\u25C4" + - "\u25C5\x03\x02\x02\x02\u25C5\u04CF\x03\x02\x02\x02\u25C6\u25C4\x03\x02" + - "\x02\x02\u25C7\u25C8\x05\u0550\u02A9\x02\u25C8\u25C9\x07&\x02\x02\u25C9" + - "\u25CA\x05\u04D4\u026B\x02\u25CA\u04D1\x03\x02\x02\x02\u25CB\u25CE\x07" + - "~\x02\x02\u25CC\u25CF\x05\u04D4\u026B\x02\u25CD\u25CF\x05\u0550\u02A9" + - "\x02\u25CE\u25CC\x03\x02\x02\x02\u25CE\u25CD\x03\x02\x02\x02\u25CF\u04D3" + - "\x03\x02\x02\x02\u25D0\u25D2\x07\x04\x02\x02\u25D1\u25D3\x05\u04D6\u026C" + - "\x02\u25D2\u25D1\x03\x02\x02\x02\u25D2\u25D3\x03\x02\x02\x02\u25D3\u25D5" + - "\x03\x02\x02\x02\u25D4\u25D6\x05\u04D8\u026D\x02\u25D5\u25D4\x03\x02\x02" + - "\x02\u25D5\u25D6\x03\x02\x02\x02\u25D6\u25D8\x03\x02\x02\x02\u25D7\u25D9" + - "\x05\u03DE\u01F0\x02\u25D8\u25D7\x03\x02\x02\x02\u25D8\u25D9\x03\x02\x02" + - "\x02\u25D9\u25DB\x03\x02\x02\x02\u25DA\u25DC\x05\u04DA\u026E\x02\u25DB" + - "\u25DA\x03\x02\x02\x02\u25DB\u25DC\x03\x02\x02\x02\u25DC\u25DD\x03\x02" + - "\x02\x02\u25DD\u25DE\x07\x05\x02\x02\u25DE\u04D5\x03\x02\x02\x02\u25DF" + - "\u25E0\x05\u0550\u02A9\x02\u25E0\u04D7\x03\x02\x02\x02\u25E1\u25E2\x07" + - "\u0116\x02\x02\u25E2\u25E3\x07\x95\x02\x02\u25E3\u25E4\x05\u04F4\u027B" + - "\x02\u25E4\u04D9\x03\x02\x02\x02\u25E5\u25E6\x07\u0124\x02\x02\u25E6\u25E8" + - "\x05\u04DC\u026F\x02\u25E7\u25E9\x05\u04E0\u0271\x02\u25E8\u25E7\x03\x02" + - "\x02\x02\u25E8\u25E9\x03\x02\x02\x02\u25E9\u25F5\x03\x02\x02\x02\u25EA" + - "\u25EB\x07\u0139\x02\x02\u25EB\u25ED\x05\u04DC\u026F\x02\u25EC\u25EE\x05" + - "\u04E0\u0271\x02\u25ED\u25EC\x03\x02\x02\x02\u25ED\u25EE\x03\x02\x02\x02" + - "\u25EE\u25F5\x03\x02\x02\x02\u25EF\u25F0\x07\u01DA\x02\x02\u25F0\u25F2" + - "\x05\u04DC\u026F\x02\u25F1\u25F3\x05\u04E0\u0271\x02\u25F2\u25F1\x03\x02" + - "\x02\x02\u25F2\u25F3\x03\x02\x02\x02\u25F3\u25F5\x03\x02\x02\x02\u25F4" + - "\u25E5\x03\x02\x02\x02\u25F4\u25EA\x03\x02\x02\x02\u25F4\u25EF\x03\x02" + - "\x02\x02\u25F5\u04DB\x03\x02\x02\x02\u25F6\u25FD\x05\u04DE\u0270\x02\u25F7" + - "\u25F8\x07\u017C\x02\x02\u25F8\u25F9\x05\u04DE\u0270\x02\u25F9\u25FA\x07" + - "#\x02\x02\u25FA\u25FB\x05\u04DE\u0270\x02\u25FB\u25FD\x03\x02\x02\x02" + - "\u25FC\u25F6\x03\x02\x02\x02\u25FC\u25F7\x03\x02\x02\x02\u25FD\u04DD\x03" + - "\x02\x02\x02\u25FE\u25FF\x07\u0163\x02\x02\u25FF\u2606\t:\x02\x02\u2600" + - "\u2601\x07\u01AB\x02\x02\u2601\u2606\x07\u0197\x02\x02\u2602\u2603\x05" + - "\u0480\u0241\x02\u2603\u2604\t:\x02\x02\u2604\u2606\x03\x02\x02\x02\u2605" + - "\u25FE\x03\x02\x02\x02\u2605\u2600\x03\x02\x02\x02\u2605\u2602\x03\x02" + - "\x02\x02\u2606\u04DF\x03\x02\x02\x02\u2607\u260E\x07\xC9\x02\x02\u2608" + - "\u2609\x07\u01AB\x02\x02\u2609\u260F\x07\u0197\x02\x02\u260A\u260F\x07" + - "D\x02\x02\u260B\u260F\x07\u01CC\x02\x02\u260C\u260D\x07\u0106\x02\x02" + - "\u260D\u260F\x07\u01DB\x02\x02\u260E\u2608\x03\x02\x02\x02\u260E\u260A" + - "\x03\x02\x02\x02\u260E\u260B\x03\x02\x02\x02\u260E\u260C\x03\x02\x02\x02" + - "\u260F\u04E1\x03\x02\x02\x02\u2610\u2611\x07\u0197\x02\x02\u2611\u2613" + - "\x07\x04\x02\x02\u2612\u2614\x05\u04F4\u027B\x02\u2613\u2612\x03\x02\x02" + - "\x02\u2613\u2614\x03\x02\x02\x02\u2614\u2615\x03\x02\x02\x02\u2615\u261D" + - "\x07\x05\x02\x02\u2616\u2617\x07\x04\x02\x02\u2617\u2618\x05\u04F4\u027B" + - "\x02\u2618\u2619\x07\b\x02\x02\u2619\u261A\x05\u0480\u0241\x02\u261A\u261B" + - "\x07\x05\x02\x02\u261B\u261D\x03\x02\x02\x02\u261C\u2610\x03\x02\x02\x02" + - "\u261C\u2616\x03\x02\x02\x02\u261D\u04E3\x03\x02\x02\x02\u261E\u261F\x07" + - "\u0197\x02\x02\u261F\u2621\x07\x04\x02\x02\u2620\u2622\x05\u04F4\u027B" + - "\x02\u2621\u2620\x03\x02\x02\x02\u2621\u2622\x03\x02\x02\x02\u2622\u2623" + - "\x03\x02\x02\x02\u2623\u2624\x07\x05\x02\x02\u2624\u04E5\x03\x02\x02\x02" + - "\u2625\u2626\x07\x04\x02\x02\u2626\u2627\x05\u04F4\u027B\x02\u2627\u2628" + - "\x07\b\x02\x02\u2628\u2629\x05\u0480\u0241\x02\u2629\u262A\x07\x05\x02" + - "\x02\u262A\u04E7\x03\x02\x02\x02\u262B\u262C\t;\x02\x02\u262C\u04E9\x03" + - "\x02\x02\x02\u262D\u2630\x07\x1F\x02\x02\u262E\u2630\x05\u04EC\u0277\x02" + - "\u262F\u262D\x03\x02\x02\x02\u262F\u262E\x03\x02\x02\x02\u2630\u04EB\x03" + - "\x02\x02\x02\u2631\u2632\t<\x02\x02\u2632\u04ED\x03\x02\x02\x02\u2633" + - "\u263A\x07\x1F\x02\x02\u2634\u2635\x07\u010F\x02\x02\u2635\u2636\x07\x04" + - "\x02\x02\u2636\u2637\x05\u02AC\u0157\x02\u2637\u2638\x07\x05\x02\x02\u2638" + - "\u263A\x03\x02\x02\x02\u2639\u2633\x03\x02\x02\x02\u2639\u2634\x03\x02" + - "\x02\x02\u263A\u04EF\x03\x02\x02\x02\u263B\u2642\x05\u04EA\u0276\x02\u263C" + - "\u263D\x07\u010F\x02\x02\u263D\u263E\x07\x04\x02\x02\u263E\u263F\x05\u02AC" + - "\u0157\x02\u263F\u2640\x07\x05\x02\x02\u2640\u2642\x03\x02\x02\x02\u2641" + - "\u263B\x03\x02\x02\x02\u2641\u263C\x03\x02\x02\x02\u2642\u04F1\x03\x02" + - "\x02\x02\u2643\u2650\x05\u04EA\u0276\x02\u2644\u2645\x07\u010F\x02\x02" + - "\u2645\u2646\x07\x04\x02\x02\u2646\u2647\x05\u02AC\u0157\x02\u2647\u2648" + - "\x07\x05\x02\x02\u2648\u2650\x03\x02\x02\x02\u2649\u2650\x07z\x02\x02" + - "\u264A\u264B\x07O\x02\x02\u264B\u2650\x07z\x02\x02\u264C\u2650\x07t\x02" + - "\x02\u264D\u264E\x07O\x02\x02\u264E\u2650\x07t\x02\x02\u264F\u2643\x03" + - "\x02\x02\x02\u264F\u2644\x03\x02\x02\x02\u264F\u2649\x03\x02\x02\x02\u264F" + - "\u264A\x03\x02\x02\x02\u264F\u264C\x03\x02\x02\x02\u264F\u264D\x03\x02" + - "\x02\x02\u2650\u04F3\x03\x02\x02\x02\u2651\u2656\x05\u0480\u0241\x02\u2652" + - "\u2653\x07\b\x02\x02\u2653\u2655\x05\u0480\u0241\x02\u2654\u2652\x03\x02" + - "\x02\x02\u2655\u2658\x03\x02\x02\x02\u2656\u2654\x03\x02\x02\x02\u2656" + - "\u2657\x03\x02\x02\x02\u2657\u04F5\x03\x02\x02\x02\u2658\u2656\x03\x02" + - "\x02\x02\u2659\u265E\x05\u04F8\u027D\x02\u265A\u265B\x07\b\x02\x02\u265B" + - "\u265D\x05\u04F8\u027D\x02\u265C\u265A\x03\x02\x02\x02\u265D\u2660\x03" + - "\x02\x02\x02\u265E\u265C\x03\x02\x02\x02\u265E\u265F\x03\x02\x02\x02\u265F" + - "\u04F7\x03\x02\x02\x02\u2660\u265E\x03\x02\x02\x02\u2661\u2667\x05\u0480" + - "\u0241\x02\u2662\u2663\x05\u027C\u013F\x02\u2663\u2664\t=\x02\x02\u2664" + - "\u2665\x05\u0480\u0241\x02\u2665\u2667\x03\x02\x02\x02\u2666\u2661\x03" + - "\x02\x02\x02\u2666\u2662\x03\x02\x02\x02\u2667\u04F9\x03\x02\x02\x02\u2668" + - "\u266D\x05\u0454\u022B\x02\u2669\u266A\x07\b\x02\x02\u266A\u266C\x05\u0454" + - "\u022B\x02\u266B\u2669\x03\x02\x02\x02\u266C\u266F\x03\x02\x02\x02\u266D" + - "\u266B\x03\x02\x02\x02\u266D\u266E\x03\x02\x02\x02\u266E\u04FB\x03\x02" + - "\x02\x02\u266F\u266D\x03\x02\x02\x02\u2670\u2673\x07\x06\x02\x02\u2671" + - "\u2674\x05\u04F4\u027B\x02\u2672\u2674\x05\u04FE\u0280\x02\u2673\u2671" + - "\x03\x02\x02\x02\u2673\u2672\x03\x02\x02\x02\u2673\u2674\x03\x02\x02\x02" + - "\u2674\u2675\x03\x02\x02\x02\u2675\u2676\x07\x07\x02\x02\u2676\u04FD\x03" + - "\x02\x02\x02\u2677\u267C\x05\u04FC\u027F\x02\u2678\u2679\x07\b\x02\x02" + - "\u2679\u267B\x05\u04FC\u027F\x02\u267A\u2678\x03\x02\x02\x02\u267B\u267E" + - "\x03\x02\x02\x02\u267C\u267A\x03\x02\x02\x02\u267C\u267D\x03\x02\x02\x02" + - "\u267D\u04FF\x03\x02\x02\x02\u267E\u267C\x03\x02\x02\x02\u267F\u2680\x05" + - "\u0502\u0282\x02\u2680\u2681\x07B\x02\x02\u2681\u2682\x05\u0480\u0241" + - "\x02\u2682\u0501\x03\x02\x02\x02\u2683\u268C\x05\u0558\u02AD\x02\u2684" + - "\u268C\x07\u0179\x02\x02\u2685\u268C\x07\u0101\x02\x02\u2686\u268C\x07" + - "\xB2\x02\x02\u2687\u268C\x07\xDC\x02\x02\u2688\u268C\x07\xFE\x02\x02\u2689" + - "\u268C\x07\u013F\x02\x02\u268A\u268C\x05\u0542\u02A2\x02\u268B\u2683\x03" + - "\x02\x02\x02\u268B\u2684\x03\x02\x02\x02\u268B\u2685\x03\x02\x02\x02\u268B" + - "\u2686\x03\x02\x02\x02\u268B\u2687\x03\x02\x02\x02\u268B\u2688\x03\x02" + - "\x02\x02\u268B\u2689\x03\x02\x02\x02\u268B\u268A\x03\x02\x02\x02\u268C" + - "\u0503\x03\x02\x02\x02\u268D\u268E\t>\x02\x02\u268E\u0505\x03\x02\x02" + - "\x02\u268F\u2690\x05\u0480\u0241\x02\u2690\u2691\x07V\x02\x02\u2691\u2692" + - "\x05\u0480\u0241\x02\u2692\u2693\x07B\x02\x02\u2693\u2696\x05\u0480\u0241" + - "\x02\u2694\u2695\x07@\x02\x02\u2695\u2697\x05\u0480\u0241\x02\u2696\u2694" + - "\x03\x02\x02\x02\u2696\u2697\x03\x02\x02\x02\u2697\u0507\x03\x02\x02\x02" + - "\u2698\u2699\x05\u04A8\u0255\x02\u2699\u269A\x07F\x02\x02\u269A\u269B" + - "\x05\u04A8\u0255\x02\u269B\u0509\x03\x02\x02\x02\u269C\u269D\x05\u0480" + - "\u0241\x02\u269D\u269E\x07B\x02\x02\u269E\u269F\x05\u0480\u0241\x02\u269F" + - "\u26A0\x07@\x02\x02\u26A0\u26A1\x05\u0480\u0241\x02\u26A1\u26B8\x03\x02" + - "\x02\x02\u26A2\u26A3\x05\u0480\u0241\x02\u26A3\u26A4\x07@\x02\x02\u26A4"; + "\x02\u23D8\u23D4\x03\x02\x02\x02\u23D8\u23D9\x03\x02\x02\x02\u23D9\u048B" + + "\x03\x02\x02\x02\u23DA\u23DB\x07\xC7\x02\x02\u23DB\u23DC\x05\u048E\u0248" + + "\x02\u23DC\u048D\x03\x02\x02\x02\u23DD\u23DE\x05\u0490\u0249\x02\u23DE" + + "\u048F\x03\x02\x02\x02\u23DF\u23E1\x05\u0492\u024A\x02\u23E0\u23E2\x05" + + "\u04FC\u027F\x02\u23E1\u23E0\x03\x02\x02\x02\u23E1\u23E2\x03\x02\x02\x02" + + "\u23E2\u0491\x03\x02\x02\x02\u23E3\u23E8\x05\u0494\u024B\x02\u23E4\u23E5" + + "\t8\x02\x02\u23E5\u23E7\x05\u0494\u024B\x02\u23E6\u23E4\x03\x02\x02\x02" + + "\u23E7\u23EA\x03\x02\x02\x02\u23E8\u23E6\x03\x02\x02\x02\u23E8\u23E9\x03" + + "\x02\x02\x02\u23E9\u0493\x03\x02\x02\x02\u23EA\u23E8\x03\x02\x02\x02\u23EB" + + "\u23F0\x05\u0496\u024C\x02\u23EC\u23ED\x07T\x02\x02\u23ED\u23EF\x05\u0496" + + "\u024C\x02\u23EE\u23EC\x03\x02\x02\x02\u23EF\u23F2\x03\x02\x02\x02\u23F0" + + "\u23EE\x03\x02\x02\x02\u23F0\u23F1\x03\x02\x02\x02\u23F1\u0495\x03\x02" + + "\x02\x02\u23F2\u23F0\x03\x02\x02\x02\u23F3\u23F8\x05\u0498\u024D\x02\u23F4" + + "\u23F5\x07#\x02\x02\u23F5\u23F7\x05\u0498\u024D\x02\u23F6\u23F4\x03\x02" + + "\x02\x02\u23F7\u23FA\x03\x02\x02\x02\u23F8\u23F6\x03\x02\x02\x02\u23F8" + + "\u23F9\x03\x02\x02\x02\u23F9\u0497\x03\x02\x02\x02\u23FA\u23F8\x03\x02" + + "\x02\x02\u23FB\u2401\x05\u049A\u024E\x02\u23FC\u23FE\x07O\x02\x02\u23FD" + + "\u23FC\x03\x02\x02\x02\u23FD\u23FE\x03\x02\x02\x02\u23FE\u23FF\x03\x02" + + "\x02\x02\u23FF\u2400\x07F\x02\x02\u2400\u2402\x05\u051C\u028F\x02\u2401" + + "\u23FD\x03\x02\x02\x02\u2401\u2402\x03\x02\x02\x02\u2402\u0499\x03\x02" + + "\x02\x02\u2403\u2405\x07O\x02\x02\u2404\u2403\x03\x02\x02\x02\u2404\u2405" + + "\x03\x02\x02\x02\u2405\u2406\x03\x02\x02\x02\u2406\u2407\x05\u049C\u024F" + + "\x02\u2407\u049B\x03\x02\x02\x02\u2408\u240A\x05\u049E\u0250\x02\u2409" + + "\u240B\t9\x02\x02\u240A\u2409\x03\x02\x02\x02\u240A\u240B\x03\x02\x02" + + "\x02\u240B\u049D\x03\x02\x02\x02\u240C\u2424\x05\u04A0\u0251\x02\u240D" + + "\u240F\x07v\x02\x02\u240E\u2410\x07O\x02\x02\u240F\u240E\x03\x02\x02\x02" + + "\u240F\u2410\x03\x02\x02\x02\u2410\u2422\x03\x02\x02\x02\u2411\u2423\x07" + + "P\x02\x02\u2412\u2423\x07b\x02\x02\u2413\u2423\x07>\x02\x02\u2414\u2423" + + "\x07\u016F\x02\x02\u2415\u2416\x07:\x02\x02\u2416\u2417\x07B\x02\x02\u2417" + + "\u2423\x05\u048E\u0248\x02\u2418\u2419\x07\u0115\x02\x02\u2419\u241A\x07" + + "\x04\x02\x02\u241A\u241B\x05\u0508\u0285\x02\u241B\u241C\x07\x05\x02\x02" + + "\u241C\u2423\x03\x02\x02\x02\u241D\u2423\x07\xBE\x02\x02\u241E\u2420\x05" + + "\u0512\u028A\x02\u241F\u241E\x03\x02\x02\x02\u241F\u2420\x03\x02\x02\x02" + + "\u2420\u2421\x03\x02\x02\x02\u2421\u2423\x07\u01E0\x02\x02\u2422\u2411" + + "\x03\x02\x02\x02\u2422\u2412\x03\x02\x02\x02\u2422\u2413\x03\x02\x02\x02" + + "\u2422\u2414\x03\x02\x02\x02\u2422\u2415\x03\x02\x02\x02\u2422\u2418\x03" + + "\x02\x02\x02\u2422\u241D\x03\x02\x02\x02\u2422\u241F\x03\x02\x02\x02\u2423" + + "\u2425\x03\x02\x02\x02\u2424\u240D\x03\x02\x02\x02\u2424\u2425\x03\x02" + + "\x02\x02\u2425\u049F\x03\x02\x02\x02\u2426\u2432\x05\u04A2\u0252\x02\u2427" + + "\u2428\t:\x02\x02\u2428\u2433\x05\u04A2\u0252\x02\u2429\u242A\x05\u0500" + + "\u0281\x02\u242A\u2430\x05\u04F6\u027C\x02\u242B\u2431\x05\u03C8\u01E5" + + "\x02\u242C\u242D\x07\x04\x02\x02\u242D\u242E\x05\u048E\u0248\x02\u242E" + + "\u242F\x07\x05\x02\x02\u242F\u2431\x03\x02\x02\x02\u2430\u242B\x03\x02" + + "\x02\x02\u2430\u242C\x03\x02\x02\x02\u2431\u2433\x03\x02\x02\x02\u2432" + + "\u2427\x03\x02\x02\x02\u2432\u2429\x03\x02\x02\x02\u2432\u2433\x03\x02" + + "\x02\x02\u2433\u04A1\x03\x02\x02\x02\u2434\u2446\x05\u04A4\u0253\x02\u2435" + + "\u2437\x07O\x02\x02\u2436\u2435\x03\x02\x02\x02\u2436\u2437\x03\x02\x02" + + "\x02\u2437\u2440\x03\x02\x02\x02\u2438\u2441\x07z\x02\x02\u2439\u2441" + + "\x07t\x02\x02\u243A\u243B\x07\x81\x02\x02\u243B\u2441\x07`\x02\x02\u243C" + + "\u243E\x07\u0185\x02\x02\u243D\u243F\x07]\x02\x02\u243E\u243D\x03\x02" + + "\x02\x02\u243E\u243F\x03\x02\x02\x02\u243F\u2441\x03\x02\x02\x02\u2440" + + "\u2438\x03\x02\x02\x02\u2440\u2439\x03\x02\x02\x02\u2440\u243A\x03\x02" + + "\x02\x02\u2440\u243C\x03\x02\x02\x02\u2441\u2442\x03\x02\x02\x02\u2442" + + "\u2444\x05\u04A4\u0253\x02\u2443\u2445\x05\u048C\u0247\x02\u2444\u2443" + + "\x03\x02\x02\x02\u2444\u2445\x03\x02\x02\x02\u2445\u2447\x03\x02\x02\x02" + + "\u2446\u2436\x03\x02\x02\x02\u2446\u2447\x03\x02\x02\x02\u2447\u04A3\x03" + + "\x02\x02\x02\u2448\u244E\x05\u04A6\u0254\x02\u2449\u244A\x05\u04FC\u027F" + + "\x02\u244A\u244B\x05\u04A6\u0254\x02\u244B\u244D\x03\x02\x02\x02\u244C" + + "\u2449\x03\x02\x02\x02\u244D\u2450\x03\x02\x02\x02\u244E\u244C\x03\x02" + + "\x02\x02\u244E\u244F\x03\x02\x02\x02\u244F\u04A5\x03\x02\x02\x02\u2450" + + "\u244E\x03\x02\x02\x02\u2451\u2453\x05\u04FC\u027F\x02\u2452\u2451\x03" + + "\x02\x02\x02\u2452\u2453\x03\x02\x02\x02\u2453\u2454\x03\x02\x02\x02\u2454" + + "\u2455\x05\u04A8\u0255\x02\u2455\u04A7\x03\x02\x02\x02\u2456\u245B\x05" + + "\u04AA\u0256\x02\u2457\u2458\t;\x02\x02\u2458\u245A\x05\u04AA\u0256\x02" + + "\u2459\u2457\x03\x02\x02\x02\u245A\u245D\x03\x02\x02\x02\u245B\u2459\x03" + + "\x02\x02\x02\u245B\u245C\x03\x02\x02\x02\u245C\u04A9\x03\x02\x02\x02\u245D" + + "\u245B\x03\x02\x02\x02\u245E\u2463\x05\u04AC\u0257\x02\u245F\u2460\t<" + + "\x02\x02\u2460\u2462\x05\u04AC\u0257\x02\u2461\u245F\x03\x02\x02\x02\u2462" + + "\u2465\x03\x02\x02\x02\u2463\u2461\x03\x02\x02\x02\u2463\u2464\x03\x02" + + "\x02\x02\u2464\u04AB\x03\x02\x02\x02\u2465\u2463\x03\x02\x02\x02\u2466" + + "\u2469\x05\u04AE\u0258\x02\u2467\u2468\x07\x11\x02\x02\u2468\u246A\x05" + + "\u048E\u0248\x02\u2469\u2467\x03\x02\x02\x02\u2469\u246A\x03\x02\x02\x02" + + "\u246A\u04AD\x03\x02\x02\x02\u246B\u246D\t;\x02\x02\u246C\u246B\x03\x02" + + "\x02\x02\u246C\u246D\x03\x02\x02\x02\u246D\u246E\x03\x02\x02\x02\u246E" + + "\u246F\x05\u04B0\u0259\x02\u246F\u04AF\x03\x02\x02\x02\u2470\u2475\x05" + + "\u04B2\u025A\x02\u2471\u2472\x07\x90\x02\x02\u2472\u2473\x07\u01A4\x02" + + "\x02\u2473\u2474\x07\u0184\x02\x02\u2474\u2476\x05\u048E\u0248\x02\u2475" + + "\u2471\x03\x02\x02\x02\u2475\u2476\x03\x02\x02\x02\u2476\u04B1\x03\x02" + + "\x02\x02\u2477\u247A\x05\u04B4\u025B\x02\u2478\u2479\x07-\x02\x02\u2479" + + "\u247B\x05\u0214\u010B\x02\u247A\u2478\x03\x02\x02\x02\u247A\u247B\x03" + + "\x02\x02\x02\u247B\u04B3\x03\x02\x02\x02\u247C\u2481\x05\u04B8\u025D\x02" + + "\u247D\u247E\x07\x1C\x02\x02\u247E\u2480\x05\u0462\u0232\x02\u247F\u247D" + + "\x03\x02\x02\x02\u2480\u2483\x03\x02\x02\x02\u2481\u247F\x03\x02\x02\x02" + + "\u2481\u2482\x03\x02\x02\x02\u2482\u04B5\x03\x02\x02\x02\u2483\u2481\x03" + + "\x02\x02\x02\u2484\u2485\b\u025C\x01\x02\u2485\u248C\x05\u04B8\u025D\x02" + + "\u2486\u2487\t;\x02\x02\u2487\u248C\x05\u04B6\u025C\v\u2488\u2489\x05" + + "\u04FC\u027F\x02\u2489\u248A\x05\u04B6\u025C\x05\u248A\u248C\x03\x02\x02" + + "\x02\u248B\u2484\x03\x02\x02\x02\u248B\u2486\x03\x02\x02\x02\u248B\u2488" + + "\x03\x02\x02\x02\u248C\u24B4\x03\x02\x02\x02\u248D\u248E\f\n\x02\x02\u248E" + + "\u248F\x07\x11\x02\x02\u248F\u24B3\x05\u04B6\u025C\v\u2490\u2491\f\t\x02" + + "\x02\u2491\u2492\t<\x02\x02\u2492\u24B3\x05\u04B6\u025C\n\u2493\u2494" + + "\f\b\x02\x02\u2494\u2495\t;\x02\x02\u2495\u24B3\x05\u04B6\u025C\t\u2496" + + "\u2497\f\x07\x02\x02\u2497\u2498\x05\u04FC\u027F\x02\u2498\u2499\x05\u04B6" + + "\u025C\b\u2499\u24B3\x03\x02\x02\x02\u249A\u249B\f\x06\x02\x02\u249B\u249C" + + "\t:\x02\x02\u249C\u24B3\x05\u04B6\u025C\x07\u249D\u249E\f\f\x02\x02\u249E" + + "\u249F\x07\x1C\x02\x02\u249F\u24B3\x05\u0462\u0232\x02\u24A0\u24A1\f\x04" + + "\x02\x02\u24A1\u24B3\x05\u04FC\u027F\x02\u24A2\u24A3\f\x03\x02\x02\u24A3" + + "\u24A5\x07v\x02\x02\u24A4\u24A6\x07O\x02\x02\u24A5\u24A4\x03\x02\x02\x02" + + "\u24A5\u24A6\x03\x02\x02\x02\u24A6\u24B0\x03\x02\x02\x02\u24A7\u24A8\x07" + + ":\x02\x02\u24A8\u24A9\x07B\x02\x02\u24A9\u24B1\x05\u04B6\u025C\x02\u24AA" + + "\u24AB\x07\u0115\x02\x02\u24AB\u24AC\x07\x04\x02\x02\u24AC\u24AD\x05\u0508" + + "\u0285\x02\u24AD\u24AE\x07\x05\x02\x02\u24AE\u24B1\x03\x02\x02\x02\u24AF" + + "\u24B1\x07\xBE\x02\x02\u24B0\u24A7\x03\x02\x02\x02\u24B0\u24AA\x03\x02" + + "\x02\x02\u24B0\u24AF\x03\x02\x02\x02\u24B1\u24B3\x03\x02\x02\x02\u24B2" + + "\u248D\x03\x02\x02\x02\u24B2\u2490\x03\x02\x02\x02\u24B2\u2493\x03\x02" + + "\x02\x02\u24B2\u2496\x03\x02\x02\x02\u24B2\u249A\x03\x02\x02\x02\u24B2" + + "\u249D\x03\x02\x02\x02\u24B2\u24A0\x03\x02\x02\x02\u24B2\u24A2\x03\x02" + + "\x02\x02\u24B3\u24B6\x03\x02\x02\x02\u24B4\u24B2\x03\x02\x02\x02\u24B4" + + "\u24B5\x03\x02\x02\x02\u24B5\u04B7\x03\x02\x02\x02\u24B6\u24B4\x03\x02" + + "\x02\x02\u24B7\u24B8\x07\u018E\x02\x02\u24B8\u24DC\x05\u03C8\u01E5\x02" + + "\u24B9\u24BC\x07%\x02\x02\u24BA\u24BD\x05\u03C8\u01E5\x02\u24BB\u24BD" + + "\x05\u050A\u0286\x02\u24BC\u24BA\x03\x02\x02\x02\u24BC\u24BB\x03\x02\x02" + + "\x02\u24BD\u24DC\x03\x02\x02\x02\u24BE\u24BF\x07\x1E\x02\x02\u24BF\u24DC" + + "\x05\u0530\u0299\x02\u24C0\u24C1\x07\u01D8\x02\x02\u24C1\u24C2\x07\x04" + + "\x02\x02\u24C2\u24C3\x05\u0502\u0282\x02\u24C3\u24C4\x07\x05\x02\x02\u24C4" + + "\u24DC\x03\x02\x02\x02\u24C5\u24C6\x07d\x02\x02\u24C6\u24DC\x05\u03C8" + + "\u01E5\x02\u24C7\u24DC\x05\u0528\u0295\x02\u24C8\u24DC\x05\u0548\u02A5" + + "\x02\u24C9\u24DC\x05\u04BA\u025E\x02\u24CA\u24CB\x07\x04\x02\x02\u24CB" + + "\u24CC\x05\u048E\u0248\x02\u24CC\u24CD\x07\x05\x02\x02\u24CD\u24CE\x05" + + "\u0530\u0299\x02\u24CE\u24DC\x03\x02\x02\x02\u24CF\u24DC\x05\u051E\u0290" + + "\x02\u24D0\u24DC\x05\u04BE\u0260\x02\u24D1\u24D3\x05\u03C8\u01E5\x02\u24D2" + + "\u24D4\x05\u052E\u0298\x02\u24D3\u24D2\x03\x02\x02\x02\u24D3\u24D4\x03" + + "\x02\x02\x02\u24D4\u24DC\x03\x02\x02\x02\u24D5\u24DC\x05\u04F2\u027A\x02" + + "\u24D6\u24DC\x05\u04F4\u027B\x02\u24D7\u24D8\x05\u04F0\u0279\x02\u24D8" + + "\u24D9\x07\x7F\x02\x02\u24D9\u24DA\x05\u04F0\u0279\x02\u24DA\u24DC\x03" + + "\x02\x02\x02\u24DB\u24B7\x03\x02\x02\x02\u24DB\u24B9\x03\x02\x02\x02\u24DB" + + "\u24BE\x03\x02\x02\x02\u24DB\u24C0\x03\x02\x02\x02\u24DB\u24C5\x03\x02" + + "\x02\x02\u24DB\u24C7\x03\x02\x02\x02\u24DB\u24C8\x03\x02\x02\x02\u24DB" + + "\u24C9\x03\x02\x02\x02\u24DB\u24CA\x03\x02\x02\x02\u24DB\u24CF\x03\x02" + + "\x02\x02\u24DB\u24D0\x03\x02\x02\x02\u24DB\u24D1\x03\x02\x02\x02\u24DB" + + "\u24D5\x03\x02\x02\x02\u24DB\u24D6\x03\x02\x02\x02\u24DB\u24D7\x03\x02" + + "\x02\x02\u24DC\u04B9\x03\x02\x02\x02\u24DD\u24DE\x07\u0228\x02\x02\u24DE" + + "\u04BB\x03\x02\x02\x02\u24DF\u24E0\x05\u0546\u02A4\x02\u24E0\u24F6\x07" + + "\x04\x02\x02\u24E1\u24E5\x05\u0504\u0283\x02\u24E2\u24E3\x07\b\x02\x02" + + "\u24E3\u24E4\x07g\x02\x02\u24E4\u24E6\x05\u0506\u0284\x02\u24E5\u24E2" + + "\x03\x02\x02\x02\u24E5\u24E6\x03\x02\x02\x02\u24E6\u24E8\x03\x02\x02\x02" + + "\u24E7\u24E9\x05\u03EC\u01F7\x02\u24E8\u24E7\x03\x02\x02\x02\u24E8\u24E9" + + "\x03\x02\x02\x02\u24E9\u24F7\x03\x02\x02\x02\u24EA\u24EB\x07g\x02\x02" + + "\u24EB\u24ED\x05\u0506\u0284\x02\u24EC\u24EE\x05\u03EC\u01F7\x02\u24ED" + + "\u24EC\x03\x02\x02\x02\u24ED\u24EE\x03\x02\x02\x02\u24EE\u24F7\x03\x02" + + "\x02\x02\u24EF\u24F0\t0\x02\x02\u24F0\u24F2\x05\u0504\u0283\x02\u24F1" + + "\u24F3\x05\u03EC\u01F7\x02\u24F2\u24F1\x03\x02\x02\x02\u24F2\u24F3\x03" + + "\x02\x02\x02\u24F3\u24F7\x03\x02\x02\x02\u24F4\u24F7\x07\v\x02\x02\u24F5" + + "\u24F7\x03\x02\x02\x02\u24F6\u24E1\x03\x02\x02\x02\u24F6\u24EA\x03\x02" + + "\x02\x02\u24F6\u24EF\x03\x02\x02\x02\u24F6\u24F4\x03\x02\x02\x02\u24F6" + + "\u24F5\x03\x02\x02\x02\u24F7\u24F8\x03\x02\x02\x02\u24F8\u24F9\x07\x05" + + "\x02\x02\u24F9\u04BD\x03\x02\x02\x02\u24FA\u24FC\x05\u04BC\u025F\x02\u24FB" + + "\u24FD\x05\u04D6\u026C\x02\u24FC\u24FB\x03\x02\x02\x02\u24FC\u24FD\x03" + + "\x02\x02\x02\u24FD\u24FF\x03\x02\x02\x02\u24FE\u2500\x05\u04D8\u026D\x02" + + "\u24FF\u24FE\x03\x02\x02\x02\u24FF\u2500\x03\x02\x02\x02\u2500\u2502\x03" + + "\x02\x02\x02\u2501\u2503\x05\u04E0\u0271\x02\u2502\u2501\x03\x02\x02\x02" + + "\u2502\u2503\x03\x02\x02\x02\u2503\u2506\x03\x02\x02\x02\u2504\u2506\x05" + + "\u04C2\u0262\x02\u2505\u24FA\x03\x02\x02\x02\u2505\u2504\x03\x02\x02\x02" + + "\u2506\u04BF\x03\x02\x02\x02\u2507\u250A\x05\u04BC\u025F\x02\u2508\u250A" + + "\x05\u04C2\u0262\x02\u2509\u2507\x03\x02\x02\x02\u2509\u2508\x03\x02\x02" + + "\x02\u250A\u04C1\x03\x02\x02\x02\u250B\u250C\x07n\x02\x02\u250C\u250D" + + "\x07@\x02\x02\u250D\u250E\x07\x04\x02\x02\u250E\u250F\x05\u048E\u0248" + + "\x02\u250F\u2510\x07\x05\x02\x02\u2510\u25C4\x03\x02\x02\x02\u2511\u25C4" + + "\x072\x02\x02\u2512\u2517\x074\x02\x02\u2513\u2514\x07\x04\x02\x02\u2514" + + "\u2515\x05\u0550\u02A9\x02\u2515\u2516\x07\x05\x02\x02\u2516\u2518\x03" + + "\x02\x02\x02\u2517\u2513\x03\x02\x02\x02\u2517\u2518\x03\x02\x02\x02\u2518" + + "\u25C4\x03\x02\x02\x02\u2519\u251E\x075\x02\x02\u251A\u251B\x07\x04\x02" + + "\x02\u251B\u251C\x05\u0550\u02A9\x02\u251C\u251D\x07\x05\x02\x02\u251D" + + "\u251F\x03\x02\x02\x02\u251E\u251A\x03\x02\x02\x02\u251E\u251F\x03\x02" + + "\x02\x02\u251F\u25C4\x03\x02\x02\x02\u2520\u2525\x07M\x02\x02\u2521\u2522" + + "\x07\x04\x02\x02\u2522\u2523\x05\u0550\u02A9\x02\u2523\u2524\x07\x05\x02" + + "\x02\u2524\u2526\x03\x02\x02\x02\u2525\u2521\x03\x02\x02\x02\u2525\u2526" + + "\x03\x02\x02\x02\u2526\u25C4\x03\x02\x02\x02\u2527\u252C\x07N\x02\x02" + + "\u2528\u2529\x07\x04\x02\x02\u2529\u252A\x05\u0550\u02A9\x02\u252A\u252B" + + "\x07\x05\x02\x02\u252B\u252D\x03\x02\x02\x02\u252C\u2528\x03\x02\x02\x02" + + "\u252C\u252D\x03\x02\x02\x02\u252D\u25C4\x03\x02\x02\x02\u252E\u25C4\x07" + + "3\x02\x02\u252F\u25C4\x076\x02\x02\u2530\u25C4\x07[\x02\x02\u2531\u25C4" + + "\x07e\x02\x02\u2532\u25C4\x071\x02\x02\u2533\u25C4\x07q\x02\x02\u2534" + + "\u2535\x07+\x02\x02\u2535\u2536\x07\x04\x02\x02\u2536\u2537\x05\u048E" + + "\u0248\x02\u2537\u2538\x07&\x02\x02\u2538\u2539\x05\u0462\u0232\x02\u2539" + + "\u253A\x07\x05\x02\x02\u253A\u25C4\x03\x02\x02\x02\u253B\u253C\x07\u018F" + + "\x02\x02\u253C\u253E\x07\x04\x02\x02\u253D\u253F\x05\u050E\u0288\x02\u253E" + + "\u253D\x03\x02\x02\x02\u253E\u253F\x03\x02\x02\x02\u253F\u2540\x03\x02" + + "\x02\x02\u2540\u25C4\x07\x05\x02\x02\u2541\u2542\x07\u01EB\x02\x02\u2542" + + "\u2543\x07\x04\x02\x02\u2543\u2546\x05\u048E\u0248\x02\u2544\u2545\x07" + + "\b\x02\x02\u2545\u2547\x05\u0512\u028A\x02\u2546\u2544\x03\x02\x02\x02" + + "\u2546\u2547\x03\x02\x02\x02\u2547\u2548\x03\x02\x02\x02\u2548\u2549\x07" + + "\x05\x02\x02\u2549\u25C4\x03\x02\x02\x02\u254A\u254B\x07\u019C\x02\x02" + + "\u254B\u254C\x07\x04\x02\x02\u254C\u254D\x05\u0514\u028B\x02\u254D\u254E" + + "\x07\x05\x02\x02\u254E\u25C4\x03\x02\x02\x02\u254F\u2550\x07\u019D\x02" + + "\x02\u2550\u2552\x07\x04\x02\x02\u2551\u2553\x05\u0516\u028C\x02\u2552" + + "\u2551\x03\x02\x02\x02\u2552\u2553\x03\x02\x02\x02\u2553\u2554\x03\x02" + + "\x02\x02\u2554\u25C4\x07\x05\x02\x02\u2555\u2556\x07\u01A3\x02\x02\u2556" + + "\u2558\x07\x04\x02\x02\u2557\u2559\x05\u0518\u028D\x02\u2558\u2557\x03" + + "\x02\x02\x02\u2558\u2559\x03\x02\x02\x02\u2559\u255A\x03\x02\x02\x02\u255A" + + "\u25C4\x07\x05\x02\x02\u255B\u255C\x07\u01A6\x02\x02\u255C\u255D\x07\x04" + + "\x02\x02\u255D\u255E\x05\u048E\u0248\x02\u255E\u255F\x07&\x02\x02\u255F" + + "\u2560\x05\u0462\u0232\x02\u2560\u2561\x07\x05\x02\x02\u2561\u25C4\x03" + + "\x02\x02\x02\u2562\u2563\x07\u01A7\x02\x02\u2563\u2565\x07\x04\x02\x02" + + "\u2564\u2566\t=\x02\x02\u2565\u2564\x03\x02\x02\x02\u2565\u2566\x03\x02" + + "\x02\x02\u2566\u2567\x03\x02\x02\x02\u2567\u2568\x05\u051A\u028E\x02\u2568" + + "\u2569\x07\x05\x02\x02\u2569\u25C4\x03\x02\x02\x02\u256A\u256B\x07\u019A" + + "\x02\x02\u256B\u256C\x07\x04\x02\x02\u256C\u256D\x05\u048E\u0248\x02\u256D" + + "\u256E\x07\b\x02\x02\u256E\u256F\x05\u048E\u0248\x02\u256F\u2570\x07\x05" + + "\x02\x02\u2570\u25C4\x03\x02\x02\x02\u2571\u2572\x07\u018B\x02\x02\u2572" + + "\u2573\x07\x04\x02\x02\u2573\u2574\x05\u0502\u0282\x02\u2574\u2575\x07" + + "\x05\x02\x02\u2575\u25C4\x03\x02\x02\x02\u2576\u2577\x07\u0191\x02\x02" + + "\u2577\u2578\x07\x04\x02\x02\u2578\u2579\x05\u0502\u0282\x02\u2579\u257A" + + "\x07\x05\x02\x02\u257A\u25C4\x03\x02\x02\x02\u257B\u257C\x07\u0196\x02" + + "\x02\u257C\u257D\x07\x04\x02\x02\u257D\u257E\x05\u0502\u0282\x02\u257E" + + "\u257F\x07\x05\x02\x02\u257F\u25C4\x03\x02\x02\x02\u2580\u2581\x07\u01AB" + + "\x02\x02\u2581\u2582\x07\x04\x02\x02\u2582\u2583\x05\u0502\u0282\x02\u2583" + + "\u2584\x07\x05\x02\x02\u2584\u25C4\x03\x02\x02\x02\u2585\u2586\x07\u01AC" + + "\x02\x02\u2586\u2587\x07\x04\x02\x02\u2587\u2588\x07\u010C\x02\x02\u2588" + + "\u258E\x05\u0570\u02B9\x02\u2589\u258C\x07\b\x02\x02\u258A\u258D\x05\u04C8" + + "\u0265\x02\u258B\u258D\x05\u0502\u0282\x02\u258C\u258A\x03\x02\x02\x02" + + "\u258C\u258B\x03\x02\x02\x02\u258D\u258F\x03\x02\x02\x02\u258E\u2589\x03" + + "\x02\x02\x02\u258E\u258F\x03\x02\x02\x02\u258F\u2590\x03\x02\x02\x02\u2590" + + "\u2591\x07\x05\x02\x02\u2591\u25C4\x03\x02\x02\x02\u2592\u2593\x07\u01AD" + + "\x02\x02\u2593\u2594\x07\x04\x02\x02\u2594\u2595\x05\u04B8\u025D\x02\u2595" + + "\u2596\x05\u04D2\u026A\x02\u2596\u2597\x07\x05\x02\x02\u2597\u25C4\x03" + + "\x02\x02\x02\u2598\u2599\x07\u01AE\x02\x02\u2599\u259A\x07\x04\x02\x02" + + "\u259A\u259B\x05\u04CA\u0266\x02\u259B\u259C\x07\x05\x02\x02\u259C\u25C4" + + "\x03\x02\x02\x02\u259D\u259E\x07\u01AF\x02\x02\u259E\u259F\x07\x04\x02" + + "\x02\u259F\u25A0\x05\u04CE\u0268\x02\u25A0\u25A2\x05\u048E\u0248\x02\u25A1" + + "\u25A3\x05\u04D0\u0269\x02\u25A2\u25A1\x03\x02\x02\x02\u25A2\u25A3\x03" + + "\x02\x02\x02\u25A3\u25A4\x03\x02\x02\x02\u25A4\u25A5\x07\x05\x02\x02\u25A5" + + "\u25C4\x03\x02\x02\x02\u25A6\u25A7\x07\u01B0\x02\x02\u25A7\u25A8\x07\x04" + + "\x02\x02\u25A8\u25A9\x07\u010C\x02\x02\u25A9\u25AC\x05\u0570\u02B9\x02" + + "\u25AA\u25AB\x07\b\x02\x02\u25AB\u25AD\x05\u048E\u0248\x02\u25AC\u25AA" + + "\x03\x02\x02\x02\u25AC\u25AD\x03\x02\x02\x02\u25AD\u25AE\x03\x02\x02\x02" + + "\u25AE\u25AF\x07\x05\x02\x02\u25AF\u25C4\x03\x02\x02\x02\u25B0\u25B1\x07" + + "\u01B1\x02\x02\u25B1\u25B2\x07\x04\x02\x02\u25B2\u25B3\x07\u0181\x02\x02" + + "\u25B3\u25B4\x05\u048E\u0248\x02\u25B4\u25B5\x07\b\x02\x02\u25B5\u25B7" + + "\x05\u04C4\u0263\x02\u25B6\u25B8\x05\u04C6\u0264\x02\u25B7\u25B6\x03\x02" + + "\x02\x02\u25B7\u25B8\x03\x02\x02\x02\u25B8\u25B9\x03\x02\x02\x02\u25B9" + + "\u25BA\x07\x05\x02\x02\u25BA\u25C4\x03\x02\x02\x02\u25BB\u25BC\x07\u01B2" + + "\x02\x02\u25BC\u25BD\x07\x04\x02\x02\u25BD\u25BE\x05\u04CE\u0268\x02\u25BE" + + "\u25BF\x05\u048E\u0248\x02\u25BF\u25C0\x07&\x02\x02\u25C0\u25C1\x05\u0466" + + "\u0234\x02\u25C1\u25C2\x07\x05\x02\x02\u25C2\u25C4\x03\x02\x02\x02\u25C3" + + "\u250B\x03\x02\x02\x02\u25C3\u2511\x03\x02\x02\x02\u25C3\u2512\x03\x02" + + "\x02\x02\u25C3\u2519\x03\x02\x02\x02\u25C3\u2520\x03\x02\x02\x02\u25C3" + + "\u2527\x03\x02\x02\x02\u25C3\u252E\x03\x02\x02\x02\u25C3\u252F\x03\x02" + + "\x02\x02\u25C3\u2530\x03\x02\x02\x02\u25C3\u2531\x03\x02\x02\x02\u25C3" + + "\u2532\x03\x02\x02\x02\u25C3\u2533\x03\x02\x02\x02\u25C3\u2534\x03\x02" + + "\x02\x02\u25C3\u253B\x03\x02\x02\x02\u25C3\u2541\x03\x02\x02\x02\u25C3" + + "\u254A\x03\x02\x02\x02\u25C3\u254F\x03\x02\x02\x02\u25C3\u2555\x03\x02" + + "\x02\x02\u25C3\u255B\x03\x02\x02\x02\u25C3\u2562\x03\x02\x02\x02\u25C3" + + "\u256A\x03\x02\x02\x02\u25C3\u2571\x03\x02\x02\x02\u25C3\u2576\x03\x02" + + "\x02\x02\u25C3\u257B\x03\x02\x02\x02\u25C3\u2580\x03\x02\x02\x02\u25C3" + + "\u2585\x03\x02\x02\x02\u25C3\u2592\x03\x02\x02\x02\u25C3\u2598\x03\x02" + + "\x02\x02\u25C3\u259D\x03\x02\x02\x02\u25C3\u25A6\x03\x02\x02\x02\u25C3" + + "\u25B0\x03\x02\x02\x02\u25C3\u25BB\x03\x02\x02\x02\u25C4\u04C3\x03\x02" + + "\x02\x02\u25C5\u25C6\x07\u0179\x02\x02\u25C6\u25CB\x05\u048E\u0248\x02" + + "\u25C7\u25C8\x07\u0179\x02\x02\u25C8\u25C9\x07\u010F\x02\x02\u25C9\u25CB" + + "\x07\u01C4\x02\x02\u25CA\u25C5\x03\x02\x02\x02\u25CA\u25C7\x03\x02\x02" + + "\x02\u25CB\u04C5\x03\x02\x02\x02\u25CC\u25CD\x07\b\x02\x02\u25CD\u25CE" + + "\x07\u0155\x02\x02\u25CE\u25D7\x07\u0183\x02\x02\u25CF\u25D0\x07\b\x02" + + "\x02\u25D0\u25D1\x07\u0155\x02\x02\u25D1\u25D7\x07\u010F\x02\x02\u25D2" + + "\u25D3\x07\b\x02\x02\u25D3\u25D4\x07\u0155\x02\x02\u25D4\u25D5\x07\u010F" + + "\x02\x02\u25D5\u25D7\x07\u01C4\x02\x02\u25D6\u25CC\x03\x02\x02\x02\u25D6" + + "\u25CF\x03\x02\x02\x02\u25D6\u25D2\x03\x02\x02\x02\u25D7\u04C7\x03\x02" + + "\x02\x02\u25D8\u25D9\x07\u01AA\x02\x02\u25D9\u25DA\x07\x04\x02\x02\u25DA" + + "\u25DB\x05\u04CA\u0266\x02\u25DB\u25DC\x07\x05\x02\x02\u25DC\u04C9\x03" + + "\x02\x02\x02\u25DD\u25E2\x05\u04CC\u0267\x02\u25DE\u25DF\x07\b\x02\x02" + + "\u25DF\u25E1\x05\u04CC\u0267\x02\u25E0\u25DE\x03\x02\x02\x02\u25E1\u25E4" + + "\x03\x02\x02\x02\u25E2\u25E0\x03\x02\x02\x02\u25E2\u25E3\x03\x02\x02\x02" + + "\u25E3\u04CB\x03\x02\x02\x02\u25E4\u25E2\x03\x02\x02\x02\u25E5\u25E8\x05" + + "\u048E\u0248\x02\u25E6\u25E7\x07&\x02\x02\u25E7\u25E9\x05\u0570\u02B9" + + "\x02\u25E8\u25E6\x03\x02\x02\x02\u25E8\u25E9\x03\x02\x02\x02\u25E9\u04CD" + + "\x03\x02\x02\x02\u25EA\u25EB\t>\x02\x02\u25EB\u04CF\x03\x02\x02\x02\u25EC" + + "\u25ED\x07\u0126\x02\x02\u25ED\u25F1\x07\u017C\x02\x02\u25EE\u25EF\x07" + + "\u015D\x02\x02\u25EF\u25F1\x07\u017C\x02\x02\u25F0\u25EC\x03\x02\x02\x02" + + "\u25F0\u25EE\x03\x02\x02\x02\u25F1\u04D1\x03\x02\x02\x02\u25F2\u25F3\x07" + + "\u0120\x02\x02\u25F3\u2602\x05\u04B8\u025D\x02\u25F4\u25F5\x07\u0120\x02" + + "\x02\u25F5\u25F6\x05\u04B8\u025D\x02\u25F6\u25F7\x05\u04D4\u026B\x02\u25F7" + + "\u2602\x03\x02\x02\x02\u25F8\u25F9\x07\u0120\x02\x02\u25F9\u25FA\x05\u04D4" + + "\u026B\x02\u25FA\u25FB\x05\u04B8\u025D\x02\u25FB\u2602\x03\x02\x02\x02" + + "\u25FC\u25FD\x07\u0120\x02\x02\u25FD\u25FE\x05\u04D4\u026B\x02\u25FE\u25FF" + + "\x05\u04B8\u025D\x02\u25FF\u2600\x05\u04D4\u026B\x02\u2600\u2602\x03\x02" + + "\x02\x02\u2601\u25F2\x03\x02\x02\x02\u2601\u25F4\x03\x02\x02\x02\u2601" + + "\u25F8\x03\x02\x02\x02\u2601\u25FC\x03\x02\x02\x02\u2602\u04D3\x03\x02" + + "\x02\x02\u2603\u2604\x07\x95\x02\x02\u2604\u2605\t?\x02\x02\u2605\u04D5" + + "\x03\x02\x02\x02\u2606\u2607\x07\u01E1\x02\x02\u2607\u2608\x07D\x02\x02" + + "\u2608\u2609\x07\x04\x02\x02\u2609\u260A\x05\u03EE\u01F8\x02\u260A\u260B" + + "\x07\x05\x02\x02\u260B\u04D7\x03\x02\x02\x02\u260C\u260D\x07\u01E2\x02" + + "\x02\u260D\u260E\x07\x04\x02\x02\u260E\u260F\x07i\x02\x02\u260F\u2610" + + "\x05\u048E\u0248\x02\u2610\u2611\x07\x05\x02\x02\u2611\u04D9\x03\x02\x02" + + "\x02\u2612\u2613\x07j\x02\x02\u2613\u2614\x05\u04DC\u026F\x02\u2614\u04DB" + + "\x03\x02\x02\x02\u2615\u261A\x05\u04DE\u0270\x02\u2616\u2617\x07\b\x02" + + "\x02\u2617\u2619\x05\u04DE\u0270\x02\u2618\u2616\x03\x02\x02\x02\u2619" + + "\u261C\x03\x02\x02\x02\u261A\u2618\x03\x02\x02\x02\u261A\u261B\x03\x02" + + "\x02\x02\u261B\u04DD\x03\x02\x02\x02\u261C\u261A\x03\x02\x02\x02\u261D" + + "\u261E\x05\u0562\u02B2\x02\u261E\u261F\x07&\x02\x02\u261F\u2620\x05\u04E2" + + "\u0272\x02\u2620\u04DF\x03\x02\x02\x02\u2621\u2624\x07~\x02\x02\u2622" + + "\u2625\x05\u04E2\u0272\x02\u2623\u2625\x05\u0562\u02B2\x02\u2624\u2622" + + "\x03\x02\x02\x02\u2624\u2623\x03\x02\x02\x02\u2625\u04E1\x03\x02\x02\x02" + + "\u2626\u2628\x07\x04\x02\x02\u2627\u2629\x05\u04E4\u0273\x02\u2628\u2627" + + "\x03\x02\x02\x02\u2628\u2629\x03\x02\x02\x02\u2629\u262B\x03\x02\x02\x02" + + "\u262A\u262C\x05\u04E6\u0274\x02\u262B\u262A\x03\x02\x02\x02\u262B\u262C" + + "\x03\x02\x02\x02\u262C\u262E\x03\x02\x02\x02\u262D\u262F\x05\u03EC\u01F7" + + "\x02\u262E\u262D\x03\x02\x02\x02\u262E\u262F\x03\x02\x02\x02\u262F\u2631" + + "\x03\x02\x02\x02\u2630\u2632\x05\u04E8\u0275\x02\u2631\u2630\x03\x02\x02" + + "\x02\u2631\u2632\x03\x02\x02\x02\u2632\u2633\x03\x02\x02\x02\u2633\u2634" + + "\x07\x05\x02\x02\u2634\u04E3\x03\x02\x02\x02\u2635\u2636\x05\u0562\u02B2" + + "\x02\u2636\u04E5\x03\x02\x02\x02\u2637\u2638\x07\u011F\x02\x02\u2638\u2639" + + "\x07\x95\x02\x02\u2639\u263A\x05\u0502\u0282\x02\u263A\u04E7\x03\x02\x02" + + "\x02\u263B\u263C\x07\u012D\x02\x02\u263C\u263E\x05\u04EA\u0276\x02\u263D" + + "\u263F\x05\u04EE\u0278\x02\u263E\u263D\x03\x02\x02\x02\u263E\u263F\x03" + + "\x02\x02\x02\u263F\u264B\x03\x02\x02\x02\u2640\u2641\x07\u0142\x02\x02" + + "\u2641\u2643\x05\u04EA\u0276\x02\u2642\u2644\x05\u04EE\u0278\x02\u2643" + + "\u2642\x03\x02\x02\x02\u2643\u2644\x03\x02\x02\x02\u2644\u264B\x03\x02" + + "\x02\x02\u2645\u2646\x07\u01E3\x02\x02\u2646\u2648\x05\u04EA\u0276\x02" + + "\u2647\u2649\x05\u04EE\u0278\x02\u2648\u2647\x03\x02\x02\x02\u2648\u2649" + + "\x03\x02\x02\x02\u2649\u264B\x03\x02\x02\x02\u264A\u263B\x03\x02\x02\x02" + + "\u264A\u2640\x03\x02\x02\x02\u264A\u2645\x03\x02\x02\x02\u264B\u04E9\x03" + + "\x02\x02\x02\u264C\u2653\x05\u04EC\u0277\x02\u264D\u264E\x07\u0185\x02" + + "\x02\u264E\u264F\x05\u04EC\u0277\x02\u264F\u2650\x07#\x02\x02\u2650\u2651" + + "\x05\u04EC\u0277\x02\u2651\u2653\x03\x02\x02\x02\u2652\u264C\x03\x02\x02" + + "\x02\u2652\u264D\x03\x02\x02\x02\u2653\u04EB\x03\x02\x02\x02\u2654\u2655" + + "\x07\u016C\x02\x02\u2655\u265C\t@\x02\x02\u2656\u2657\x07\u01B4\x02\x02" + + "\u2657\u265C\x07\u01A0\x02\x02\u2658\u2659\x05\u048E\u0248\x02\u2659\u265A" + + "\t@\x02\x02\u265A\u265C\x03\x02\x02\x02\u265B\u2654\x03\x02\x02\x02\u265B" + + "\u2656\x03\x02\x02\x02\u265B\u2658\x03\x02\x02\x02\u265C\u04ED\x03\x02" + + "\x02\x02\u265D\u2664\x07\xC9\x02\x02\u265E\u265F\x07\u01B4\x02\x02\u265F" + + "\u2665\x07\u01A0\x02\x02\u2660\u2665\x07D\x02\x02\u2661\u2665\x07\u01D5" + + "\x02\x02\u2662\u2663\x07\u010F\x02\x02\u2663\u2665\x07\u01E4\x02\x02\u2664" + + "\u265E\x03\x02\x02\x02\u2664\u2660\x03\x02\x02\x02\u2664\u2661\x03\x02" + + "\x02\x02\u2664\u2662\x03\x02\x02\x02\u2665\u04EF\x03\x02\x02\x02\u2666" + + "\u2667\x07\u01A0\x02\x02\u2667\u2669\x07\x04\x02\x02\u2668\u266A\x05\u0502" + + "\u0282\x02\u2669\u2668\x03\x02\x02\x02\u2669\u266A\x03\x02\x02\x02\u266A" + + "\u266B\x03\x02\x02\x02\u266B\u2673\x07\x05\x02\x02\u266C\u266D\x07\x04" + + "\x02\x02\u266D\u266E\x05\u0502\u0282\x02\u266E\u266F\x07\b\x02\x02\u266F" + + "\u2670\x05\u048E\u0248\x02\u2670\u2671\x07\x05\x02\x02\u2671\u2673\x03" + + "\x02\x02\x02\u2672\u2666\x03\x02\x02\x02\u2672\u266C\x03\x02\x02\x02\u2673" + + "\u04F1\x03\x02\x02\x02\u2674\u2675\x07\u01A0\x02\x02\u2675\u2677\x07\x04" + + "\x02\x02\u2676\u2678\x05\u0502\u0282\x02\u2677\u2676\x03\x02\x02\x02\u2677" + + "\u2678\x03\x02\x02\x02\u2678\u2679\x03\x02\x02\x02\u2679\u267A\x07\x05" + + "\x02\x02\u267A\u04F3\x03\x02\x02\x02\u267B\u267C\x07\x04\x02\x02\u267C" + + "\u267D\x05\u0502\u0282\x02\u267D\u267E\x07\b\x02\x02\u267E\u267F\x05\u048E" + + "\u0248\x02\u267F"; private static readonly _serializedATNSegment18: string = - "\u26A5\x05\u0480\u0241\x02\u26A5\u26A6\x07B\x02\x02\u26A6\u26A7\x05\u0480" + - "\u0241\x02\u26A7\u26B8\x03\x02\x02\x02\u26A8\u26A9\x05\u0480\u0241\x02" + - "\u26A9\u26AA\x07B\x02\x02\u26AA\u26AB\x05\u0480\u0241\x02\u26AB\u26B8" + - "\x03\x02\x02\x02\u26AC\u26AD\x05\u0480\u0241\x02\u26AD\u26AE\x07@\x02" + - "\x02\u26AE\u26AF\x05\u0480\u0241\x02\u26AF\u26B8\x03\x02\x02\x02\u26B0" + - "\u26B1\x05\u0480\u0241\x02\u26B1\u26B2\x07\x81\x02\x02\u26B2\u26B3\x05" + - "\u0480\u0241\x02\u26B3\u26B4\x07\xC7\x02\x02\u26B4\u26B5\x05\u0480\u0241" + - "\x02\u26B5\u26B8\x03\x02\x02\x02\u26B6\u26B8\x05\u04F4\u027B\x02\u26B7" + - "\u269C\x03\x02\x02\x02\u26B7\u26A2\x03\x02\x02\x02\u26B7\u26A8\x03\x02" + - "\x02\x02\u26B7\u26AC\x03\x02\x02\x02\u26B7\u26B0\x03\x02\x02\x02\u26B7" + - "\u26B6\x03\x02\x02\x02\u26B8\u050B\x03\x02\x02\x02\u26B9\u26BA\x05\u0480" + - "\u0241\x02\u26BA\u26BB\x07B\x02\x02\u26BB\u26BC\x05\u04F4\u027B\x02\u26BC" + - "\u26C1\x03\x02\x02\x02\u26BD\u26BE\x07B\x02\x02\u26BE\u26C1\x05\u04F4" + - "\u027B\x02\u26BF\u26C1\x05\u04F4\u027B\x02\u26C0\u26B9\x03\x02\x02\x02" + - "\u26C0\u26BD\x03\x02\x02\x02\u26C0\u26BF\x03\x02\x02\x02\u26C1\u050D\x03" + - "\x02\x02\x02\u26C2\u26C8\x05\u03BA\u01DE\x02\u26C3\u26C4\x07\x04\x02\x02" + - "\u26C4\u26C5\x05\u04F4\u027B\x02\u26C5\u26C6\x07\x05\x02\x02\u26C6\u26C8" + - "\x03\x02\x02\x02\u26C7\u26C2\x03\x02\x02\x02\u26C7\u26C3\x03\x02\x02\x02" + - "\u26C8\u050F\x03\x02\x02\x02\u26C9\u26CB\x07*\x02\x02\u26CA\u26CC\x05" + - "\u0518\u028D\x02\u26CB\u26CA\x03\x02\x02\x02\u26CB\u26CC\x03\x02\x02\x02" + - "\u26CC\u26CD\x03\x02\x02\x02\u26CD\u26CF\x05\u0512\u028A\x02\u26CE\u26D0" + - "\x05\u0516\u028C\x02\u26CF\u26CE\x03\x02\x02\x02\u26CF\u26D0\x03\x02\x02" + - "\x02\u26D0\u26D1\x03\x02\x02\x02\u26D1\u26D2\x07\u01BF\x02\x02\u26D2\u0511" + - "\x03\x02\x02\x02\u26D3\u26D5\x05\u0514\u028B\x02\u26D4\u26D3\x03\x02\x02" + - "\x02\u26D5\u26D6\x03\x02\x02\x02\u26D6\u26D4\x03\x02\x02\x02\u26D6\u26D7" + - "\x03\x02\x02\x02\u26D7\u0513\x03\x02\x02\x02\u26D8\u26D9\x07h\x02\x02" + - "\u26D9\u26DA\x05\u0480\u0241\x02\u26DA\u26DB\x07_\x02\x02\u26DB\u26DC" + - "\x05\u0480\u0241\x02\u26DC\u0515\x03\x02\x02\x02\u26DD\u26DE\x07<\x02" + - "\x02\u26DE\u26DF\x05\u0480\u0241\x02\u26DF\u0517\x03\x02\x02\x02\u26E0" + - "\u26E1\x05\u0480\u0241\x02\u26E1\u0519\x03\x02\x02\x02\u26E2\u26E4\x05" + - "\u0550\u02A9\x02\u26E3\u26E5\x05\u0520\u0291\x02\u26E4\u26E3\x03\x02\x02" + - "\x02\u26E4\u26E5\x03\x02\x02\x02\u26E5\u051B\x03\x02\x02\x02\u26E6\u26E9" + - "\x07\r\x02\x02\u26E7\u26EA\x05\u0532\u029A\x02\u26E8\u26EA\x07\v\x02\x02" + - "\u26E9\u26E7\x03\x02\x02\x02\u26E9\u26E8\x03\x02\x02\x02\u26EA\u26F8\x03" + - "\x02\x02\x02\u26EB\u26F4\x07\x06\x02\x02\u26EC\u26F5\x05\u0480\u0241\x02" + - "\u26ED\u26EF\x05\u051E\u0290\x02\u26EE\u26ED\x03\x02\x02\x02\u26EE\u26EF" + - "\x03\x02\x02\x02\u26EF\u26F0\x03\x02\x02\x02\u26F0\u26F2\x07\n\x02\x02" + - "\u26F1\u26F3\x05\u051E\u0290\x02\u26F2\u26F1\x03\x02\x02\x02\u26F2\u26F3" + - "\x03\x02\x02\x02\u26F3\u26F5\x03\x02\x02\x02\u26F4\u26EC\x03\x02\x02\x02" + - "\u26F4\u26EE\x03\x02\x02\x02\u26F5\u26F6\x03\x02\x02\x02\u26F6\u26F8\x07" + - "\x07\x02\x02\u26F7\u26E6\x03\x02\x02\x02\u26F7\u26EB\x03\x02\x02\x02\u26F8" + - "\u051D\x03\x02\x02\x02\u26F9\u26FA\x05\u0480\u0241\x02\u26FA\u051F\x03" + - "\x02\x02\x02\u26FB\u26FD\x05\u051C\u028F\x02\u26FC\u26FB\x03\x02\x02\x02" + - "\u26FD\u26FE\x03\x02\x02\x02\u26FE\u26FC\x03\x02\x02\x02\u26FE\u26FF\x03" + - "\x02\x02\x02\u26FF\u0521\x03\x02\x02\x02\u2700\u2702\x05\u051C\u028F\x02" + - "\u2701\u2700\x03\x02\x02\x02\u2702\u2705\x03\x02\x02\x02\u2703\u2701\x03" + - "\x02\x02\x02\u2703\u2704\x03\x02\x02\x02\u2704\u0523\x03\x02\x02\x02\u2705" + - "\u2703\x03\x02\x02\x02\u2706\u2707\x05\u0526\u0294\x02\u2707\u0525\x03" + - "\x02\x02\x02\u2708\u270D\x05\u0528\u0295\x02\u2709\u270A\x07\b\x02\x02" + - "\u270A\u270C\x05\u0528\u0295\x02\u270B\u2709\x03\x02\x02\x02\u270C\u270F" + - "\x03\x02\x02\x02\u270D\u270B\x03\x02\x02\x02\u270D\u270E\x03\x02\x02\x02" + - "\u270E\u0527\x03\x02\x02\x02\u270F\u270D\x03\x02\x02\x02\u2710\u2715\x05" + - "\u0480\u0241\x02\u2711\u2712\x07&\x02\x02\u2712\u2716\x05\u0556\u02AC" + - "\x02\u2713\u2716\x05\u0558\u02AD\x02\u2714\u2716\x03\x02\x02\x02\u2715" + - "\u2711\x03\x02\x02\x02\u2715\u2713\x03\x02\x02\x02\u2715\u2714\x03\x02" + - "\x02\x02\u2716\u2719\x03\x02\x02\x02\u2717\u2719\x07\v\x02\x02\u2718\u2710" + - "\x03\x02\x02\x02\u2718\u2717\x03\x02\x02\x02\u2719\u0529\x03\x02\x02\x02" + - "\u271A\u271F\x05\u052C\u0297\x02\u271B\u271C\x07\b\x02\x02\u271C\u271E" + - "\x05\u052C\u0297\x02\u271D\u271B\x03\x02\x02\x02\u271E\u2721\x03\x02\x02" + - "\x02\u271F\u271D\x03\x02\x02\x02\u271F\u2720\x03\x02\x02\x02\u2720\u052B" + - "\x03\x02\x02\x02\u2721\u271F\x03\x02\x02\x02\u2722\u2724\x05\u0550\u02A9" + - "\x02\u2723\u2725\x05\u0520\u0291\x02\u2724\u2723\x03\x02\x02\x02\u2724" + - "\u2725\x03\x02\x02\x02\u2725\u052D\x03\x02\x02\x02\u2726\u272B\x05\u0530" + - "\u0299\x02\u2727\u2728\x07\b\x02\x02\u2728\u272A\x05\u0530\u0299\x02\u2729" + - "\u2727\x03\x02\x02\x02\u272A\u272D\x03\x02\x02\x02\u272B\u2729\x03\x02" + - "\x02\x02\u272B\u272C\x03\x02\x02\x02\u272C\u052F\x03\x02\x02\x02\u272D" + - "\u272B\x03\x02\x02\x02\u272E\u272F\x05\u0550\u02A9\x02\u272F\u0531\x03" + - "\x02\x02\x02\u2730\u2731\x05\u0556\u02AC\x02\u2731\u0533\x03\x02\x02\x02" + - "\u2732\u2733\x05\u0542\u02A2\x02\u2733\u0535\x03\x02\x02\x02\u2734\u2739" + - "\x05\u0552\u02AA\x02\u2735\u2736\x05\u0550\u02A9\x02\u2736\u2737\x05\u0520" + - "\u0291\x02\u2737\u2739\x03\x02\x02\x02\u2738\u2734\x03\x02\x02\x02\u2738" + - "\u2735\x03\x02\x02\x02\u2739\u0537\x03\x02\x02\x02\u273A\u275E\x05\u0540" + - "\u02A1\x02\u273B\u275E\x05\u053E\u02A0\x02\u273C\u275E\x05\u0542\u02A2" + - "\x02\u273D\u275E\x05\u053C\u029F\x02\u273E\u275E\x05\u053A\u029E\x02\u273F" + - "\u2749\x05\u0536\u029C\x02\u2740\u274A\x05\u0542\u02A2\x02\u2741\u2742" + - "\x07\x04\x02\x02\u2742\u2744\x05\u04F6\u027C\x02\u2743\u2745\x05\u03DE" + - "\u01F0\x02\u2744\u2743\x03\x02\x02\x02\u2744\u2745\x03\x02\x02\x02\u2745" + - "\u2746\x03\x02\x02\x02\u2746\u2747\x07\x05\x02\x02\u2747\u2748\x05\u0542" + - "\u02A2\x02\u2748\u274A\x03\x02\x02\x02\u2749\u2740\x03\x02\x02\x02\u2749" + - "\u2741\x03\x02\x02\x02\u274A\u275E\x03\x02\x02\x02\u274B\u274C\x05\u045A" + - "\u022E\x02\u274C\u274D\x05\u0542\u02A2\x02\u274D\u275E\x03\x02\x02\x02" + - "\u274E\u2758\x05\u0476\u023C\x02\u274F\u2751\x05\u0542\u02A2\x02\u2750" + - "\u2752\x05\u047A\u023E\x02\u2751\u2750\x03\x02\x02\x02\u2751\u2752\x03" + - "\x02\x02\x02\u2752\u2759\x03\x02\x02\x02\u2753\u2754\x07\x04\x02\x02\u2754" + - "\u2755\x05\u0540\u02A1\x02\u2755\u2756\x07\x05\x02\x02\u2756\u2757\x05" + - "\u0542\u02A2\x02\u2757\u2759\x03\x02\x02\x02\u2758\u274F\x03\x02\x02\x02" + - "\u2758\u2753\x03\x02\x02\x02\u2759\u275E\x03\x02\x02\x02\u275A\u275E\x07" + - "b\x02\x02\u275B\u275E\x07>\x02\x02\u275C\u275E\x07P\x02\x02\u275D\u273A" + - "\x03\x02\x02\x02\u275D\u273B\x03\x02\x02\x02\u275D\u273C\x03\x02\x02\x02" + - "\u275D\u273D\x03\x02\x02\x02\u275D\u273E\x03\x02\x02\x02\u275D\u273F\x03" + - "\x02\x02\x02\u275D\u274B\x03\x02\x02\x02\u275D\u274E\x03\x02\x02\x02\u275D" + - "\u275A\x03\x02\x02\x02\u275D\u275B\x03\x02\x02\x02\u275D\u275C\x03\x02" + - "\x02\x02\u275E\u0539\x03\x02\x02\x02\u275F\u2760\x07\u0214\x02\x02\u2760" + - "\u053B\x03\x02\x02\x02\u2761\u2762\x07\u0210\x02\x02\u2762\u053D\x03\x02" + - "\x02\x02\u2763\u2764\x07\u021A\x02\x02\u2764\u053F\x03\x02\x02\x02\u2765" + - "\u2766\x07\u0218\x02\x02\u2766\u0541\x03\x02\x02\x02\u2767\u2769\x05\u0544" + - "\u02A3\x02\u2768\u276A\x05\u0546\u02A4\x02\u2769\u2768\x03\x02\x02\x02" + - "\u2769\u276A\x03\x02\x02\x02\u276A\u0543\x03\x02\x02\x02\u276B\u2777\x07" + - "\u020B\x02\x02\u276C\u2777\x07\u020D\x02\x02\u276D\u2771\x07\u020F\x02" + - "\x02\u276E\u2770\x07\u0229\x02\x02\u276F\u276E\x03\x02\x02\x02\u2770\u2773" + - "\x03\x02\x02\x02\u2771\u276F\x03\x02\x02\x02\u2771\u2772\x03\x02\x02\x02" + - "\u2772\u2774\x03\x02\x02\x02\u2773\u2771\x03\x02\x02\x02\u2774\u2777\x07" + - "\u022A\x02\x02\u2775\u2777\x07\u0225\x02\x02\u2776\u276B\x03\x02\x02\x02" + - "\u2776\u276C\x03\x02\x02\x02\u2776\u276D\x03\x02\x02\x02\u2776\u2775\x03" + - "\x02\x02\x02\u2777\u0545\x03\x02\x02\x02\u2778\u2779\x07\u01E0\x02\x02" + - "\u2779\u277A\x05\u0544\u02A3\x02\u277A\u0547\x03\x02\x02\x02\u277B\u2781" + - "\x05\u0540\u02A1\x02\u277C\u277D\x07\x0E\x02\x02\u277D\u2781\x05\u0540" + - "\u02A1\x02\u277E\u277F\x07\x0F\x02\x02\u277F\u2781\x05\u0540\u02A1\x02" + - "\u2780\u277B\x03\x02\x02\x02\u2780\u277C\x03\x02\x02\x02\u2780\u277E\x03" + - "\x02\x02\x02\u2781\u0549\x03\x02\x02\x02\u2782\u2783\x05\u054C\u02A7\x02" + - "\u2783\u054B\x03\x02\x02\x02\u2784\u2788\x05\u0554\u02AB\x02\u2785\u2788" + - "\x076\x02\x02\u2786\u2788\x07[\x02\x02\u2787\u2784\x03\x02\x02\x02\u2787" + - "\u2785\x03\x02\x02\x02\u2787\u2786\x03\x02\x02\x02\u2788\u054D\x03\x02" + - "\x02\x02\u2789\u278E\x05\u054C\u02A7\x02\u278A\u278B\x07\b\x02\x02\u278B" + - "\u278D\x05\u054C\u02A7\x02\u278C\u278A\x03\x02\x02\x02\u278D\u2790\x03" + - "\x02\x02\x02\u278E\u278C\x03\x02\x02\x02\u278E\u278F\x03\x02\x02\x02\u278F" + - "\u054F\x03\x02\x02\x02\u2790\u278E\x03\x02\x02\x02\u2791\u2796\x05\u0558" + - "\u02AD\x02\u2792\u2796\x05\u055C\u02AF\x02\u2793\u2796\x05\u055E\u02B0" + - "\x02\u2794\u2796\x05\u0638\u031D\x02\u2795\u2791\x03\x02\x02\x02\u2795" + - "\u2792\x03\x02\x02\x02\u2795\u2793\x03\x02\x02\x02\u2795\u2794\x03\x02" + - "\x02\x02\u2796\u0551\x03\x02\x02\x02\u2797\u279C\x05\u0558\u02AD\x02\u2798" + - "\u279C\x05\u055C\u02AF\x02\u2799\u279C\x05\u0638\u031D\x02\u279A\u279C" + - "\x05\u0560\u02B1\x02\u279B\u2797\x03\x02\x02\x02\u279B\u2798\x03\x02\x02" + - "\x02\u279B\u2799\x03\x02\x02\x02\u279B\u279A\x03\x02\x02\x02\u279C\u0553" + - "\x03\x02\x02\x02\u279D\u27A2\x05\u0558\u02AD\x02\u279E\u27A2\x05\u055C" + - "\u02AF\x02\u279F\u27A2\x05\u055E\u02B0\x02\u27A0\u27A2\x05\u0560\u02B1" + - "\x02\u27A1\u279D\x03\x02\x02\x02\u27A1\u279E\x03\x02\x02\x02\u27A1\u279F" + - "\x03\x02\x02\x02\u27A1\u27A0\x03\x02\x02\x02\u27A2\u0555\x03\x02\x02\x02" + - "\u27A3\u27AA\x05\u0558\u02AD\x02\u27A4\u27AA\x05\u0638\u031D\x02\u27A5" + - "\u27AA\x05\u055C\u02AF\x02\u27A6\u27AA\x05\u055E\u02B0\x02\u27A7\u27AA" + - "\x05\u0560\u02B1\x02\u27A8\u27AA\x05\u0562\u02B2\x02\u27A9\u27A3\x03\x02" + - "\x02\x02\u27A9\u27A4\x03\x02\x02\x02\u27A9\u27A5\x03\x02\x02\x02\u27A9" + - "\u27A6\x03\x02\x02\x02\u27A9\u27A7\x03\x02\x02\x02\u27A9\u27A8\x03\x02" + - "\x02\x02\u27AA\u0557\x03\x02\x02\x02\u27AB\u27AD\x07\u0202\x02\x02\u27AC" + - "\u27AE\x05\u0546\u02A4\x02\u27AD\u27AC\x03\x02\x02\x02\u27AD\u27AE\x03" + - "\x02\x02\x02\u27AE\u27B5\x03\x02\x02\x02\u27AF\u27B5\x07\u0203\x02\x02" + - "\u27B0\u27B5\x07\u0207\x02\x02\u27B1\u27B5\x05\u04AC\u0257\x02\u27B2\u27B5" + - "\x05\u055A\u02AE\x02\u27B3\u27B5\x05\u0638\u031D\x02\u27B4\u27AB\x03\x02" + - "\x02\x02\u27B4\u27AF\x03\x02\x02\x02\u27B4\u27B0\x03\x02\x02\x02\u27B4" + - "\u27B1\x03\x02\x02\x02\u27B4\u27B2\x03\x02\x02\x02\u27B4\u27B3\x03\x02" + - "\x02\x02\u27B5\u0559\x03\x02\x02\x02\u27B6\u27B7\x07\u021C\x02\x02\u27B7" + - "\u055B\x03\x02\x02\x02\u27B8\u27B9\t?\x02\x02\u27B9\u055D\x03\x02\x02" + - "\x02\u27BA\u27EE\x07\u017C\x02\x02\u27BB\u27EE\x07\u017D\x02\x02\u27BC" + - "\u27EE\x05\u0464\u0233\x02\u27BD\u27EE\x07\u017F\x02\x02\u27BE\u27EE\x07" + - "\u0180\x02\x02\u27BF\u27EE\x05\u046C\u0237\x02\u27C0\u27EE\x07\u0182\x02" + - "\x02\u27C1\u27EE\x07\u0183\x02\x02\u27C2\u27EE\x07\u0184\x02\x02\u27C3" + - "\u27EE\x07\u0185\x02\x02\u27C4\u27EE\x07\u0186\x02\x02\u27C5\u27EE\x07" + - "\u0187\x02\x02\u27C6\u27EE\x07\u0188\x02\x02\u27C7\u27EE\x07\u01CF\x02" + - "\x02\u27C8\u27EE\x07\u0189\x02\x02\u27C9\u27EE\x07\u018A\x02\x02\u27CA" + - "\u27EE\x07\u018B\x02\x02\u27CB\u27EE\x07\u018C\x02\x02\u27CC\u27EE\x07" + - "\u018D\x02\x02\u27CD\u27EE\x07\u018E\x02\x02\u27CE\u27EE\x07\u018F\x02" + - "\x02\u27CF\u27EE\x07\u0190\x02\x02\u27D0\u27EE\x07\u01E2\x02\x02\u27D1" + - "\u27EE\x07\u0191\x02\x02\u27D2\u27EE\x05\u0460\u0231\x02\u27D3\u27EE\x07" + - "\u01BE\x02\x02\u27D4\u27EE\x07\u0193\x02\x02\u27D5\u27EE\x07\u0194\x02" + - "\x02\u27D6\u27EE\x07\u0195\x02\x02\u27D7\u27EE\x07\u0196\x02\x02\u27D8" + - "\u27EE\x07\u0197\x02\x02\u27D9\u27EE\x07\u0198\x02\x02\u27DA\u27EE\x07" + - "\u0199\x02\x02\u27DB\u27EE\x07\u019A\x02\x02\u27DC\u27EE\x07\u019B\x02" + - "\x02\u27DD\u27EE\x07\u019C\x02\x02\u27DE\u27EE\x07\u019D\x02\x02\u27DF" + - "\u27EE\x07\u019E\x02\x02\u27E0\u27EE\x07\u019F\x02\x02\u27E1\u27EE\x07" + - "\u01A0\x02\x02\u27E2\u27EE\x07\u01A1\x02\x02\u27E3\u27EE\x07\u01A2\x02" + - "\x02\u27E4\u27EE\x07\u01A3\x02\x02\u27E5\u27EE\x07\u01A4\x02\x02\u27E6" + - "\u27EE\x07\u01A5\x02\x02\u27E7\u27EE\x07\u01D5\x02\x02\u27E8\u27EE\x07" + - "\u01A6\x02\x02\u27E9\u27EE\x07\u01A7\x02\x02\u27EA\u27EE\x07\u01A8\x02" + - "\x02\u27EB\u27EE\x07\u01A9\x02\x02\u27EC\u27EE\x07\u01D3\x02\x02\u27ED" + - "\u27BA\x03\x02\x02\x02\u27ED\u27BB\x03\x02\x02\x02\u27ED\u27BC\x03\x02" + - "\x02\x02\u27ED\u27BD\x03\x02\x02\x02\u27ED\u27BE\x03\x02\x02\x02\u27ED" + - "\u27BF\x03\x02\x02\x02\u27ED\u27C0\x03\x02\x02\x02\u27ED\u27C1\x03\x02" + - "\x02\x02\u27ED\u27C2\x03\x02\x02\x02\u27ED\u27C3\x03\x02\x02\x02\u27ED" + - "\u27C4\x03\x02\x02\x02\u27ED\u27C5\x03\x02\x02\x02\u27ED\u27C6\x03\x02" + - "\x02\x02\u27ED\u27C7\x03\x02\x02\x02\u27ED\u27C8\x03\x02\x02\x02\u27ED" + - "\u27C9\x03\x02\x02\x02\u27ED\u27CA\x03\x02\x02\x02\u27ED\u27CB\x03\x02" + - "\x02\x02\u27ED\u27CC\x03\x02\x02\x02\u27ED\u27CD\x03\x02\x02\x02\u27ED" + - "\u27CE\x03\x02\x02\x02\u27ED\u27CF\x03\x02\x02\x02\u27ED\u27D0\x03\x02" + - "\x02\x02\u27ED\u27D1\x03\x02\x02\x02\u27ED\u27D2\x03\x02\x02\x02\u27ED" + - "\u27D3\x03\x02\x02\x02\u27ED\u27D4\x03\x02\x02\x02\u27ED\u27D5\x03\x02" + - "\x02\x02\u27ED\u27D6\x03\x02\x02\x02\u27ED\u27D7\x03\x02\x02\x02\u27ED" + - "\u27D8\x03\x02\x02\x02\u27ED\u27D9\x03\x02\x02\x02\u27ED\u27DA\x03\x02" + - "\x02\x02\u27ED\u27DB\x03\x02\x02\x02\u27ED\u27DC\x03\x02\x02\x02\u27ED" + - "\u27DD\x03\x02\x02\x02\u27ED\u27DE\x03\x02\x02\x02\u27ED\u27DF\x03\x02" + - "\x02\x02\u27ED\u27E0\x03\x02\x02\x02\u27ED\u27E1\x03\x02\x02\x02\u27ED" + - "\u27E2\x03\x02\x02\x02\u27ED\u27E3\x03\x02\x02\x02\u27ED\u27E4\x03\x02" + - "\x02\x02\u27ED\u27E5\x03\x02\x02\x02\u27ED\u27E6\x03\x02\x02\x02\u27ED" + - "\u27E7\x03\x02\x02\x02\u27ED\u27E8\x03\x02\x02\x02\u27ED\u27E9\x03\x02" + - "\x02\x02\u27ED\u27EA\x03\x02\x02\x02\u27ED\u27EB\x03\x02\x02\x02\u27ED" + - "\u27EC\x03\x02\x02\x02\u27EE\u055F\x03\x02\x02\x02\u27EF\u27F0\t@\x02" + - "\x02\u27F0\u0561\x03\x02\x02\x02\u27F1\u27F2\tA\x02\x02\u27F2\u0563\x03" + - "\x02\x02\x02\u27F3\u27F4\x05\u0566\u02B4\x02\u27F4\u27F5\x05\u0570\u02B9" + - "\x02\u27F5\u27F6\x05\u056E\u02B8\x02\u27F6\u0565\x03\x02\x02\x02\u27F7" + - "\u27F9\x05\u0568\u02B5\x02\u27F8\u27F7\x03\x02\x02\x02\u27F9\u27FC\x03" + - "\x02\x02\x02\u27FA\u27F8\x03\x02\x02\x02\u27FA\u27FB\x03\x02\x02\x02\u27FB" + - "\u0567\x03\x02\x02\x02\u27FC\u27FA\x03\x02\x02\x02\u27FD\u27FE\x05\u056A" + - "\u02B6\x02\u27FE\u27FF\x07\u0110\x02\x02\u27FF\u2800\x07\u01E3\x02\x02" + - "\u2800\u2812\x03\x02\x02\x02\u2801\u2802\x05\u056A\u02B6\x02\u2802\u2803" + - "\x07\u01E4\x02\x02\u2803\u2804\x05\u056C\u02B7\x02\u2804\u2812\x03\x02" + - "\x02\x02\u2805\u2806\x05\u056A\u02B6\x02\u2806\u2807\x07\u01E5\x02\x02" + - "\u2807\u2808\x07\u01E6\x02\x02\u2808\u2812\x03\x02\x02\x02\u2809\u280A" + - "\x05\u056A\u02B6\x02\u280A\u280B\x07\u01E5\x02\x02\u280B\u280C\x07\u01E7" + - "\x02\x02\u280C\u2812\x03\x02\x02\x02\u280D\u280E\x05\u056A\u02B6\x02\u280E" + - "\u280F\x07\u01E5\x02\x02\u280F\u2810\x07\u01E8\x02\x02\u2810\u2812\x03" + - "\x02\x02\x02\u2811\u27FD\x03\x02\x02\x02\u2811\u2801\x03\x02\x02\x02\u2811" + - "\u2805\x03\x02\x02\x02\u2811\u2809\x03\x02\x02\x02\u2811\u280D\x03\x02" + - "\x02\x02\u2812\u0569\x03\x02\x02\x02\u2813\u2814\x07\x1F\x02\x02\u2814" + - "\u056B\x03\x02\x02\x02\u2815\u281A\x05\u0542\u02A2\x02\u2816\u281A\x05" + - "\u0562\u02B2\x02\u2817\u281A\x05\u0638\u031D\x02\u2818\u281A\x05\u055C" + - "\u02AF\x02\u2819\u2815\x03\x02\x02\x02\u2819\u2816\x03\x02\x02\x02\u2819" + - "\u2817\x03\x02\x02\x02\u2819\u2818\x03\x02\x02\x02\u281A\u056D\x03\x02" + - "\x02\x02\u281B\u281E\x03\x02\x02\x02\u281C\u281E\x07\t\x02\x02\u281D\u281B" + - "\x03\x02\x02\x02\u281D\u281C\x03\x02\x02\x02\u281E\u056F\x03\x02\x02\x02" + - "\u281F\u2820\x05\u0572\u02BA\x02\u2820\u2821\x07\x94\x02\x02\u2821\u2822" + - "\x05\u059C\u02CF\x02\u2822\u2823\x05\u0624\u0313\x02\u2823\u2824\x07\u01BF" + - "\x02\x02\u2824\u2825\x05\u0632\u031A\x02\u2825\u0571\x03\x02\x02\x02\u2826" + - "\u282B\x05\u062E\u0318\x02\u2827\u2829\x05\u0574\u02BB\x02\u2828\u282A" + - "\x05\u0576\u02BC\x02\u2829\u2828\x03\x02\x02\x02\u2829\u282A\x03\x02\x02" + - "\x02\u282A\u282C\x03\x02\x02\x02\u282B\u2827\x03\x02\x02\x02\u282B\u282C" + - "\x03\x02\x02\x02\u282C\u0573\x03\x02\x02\x02\u282D\u282E\x07\xB4\x02\x02" + - "\u282E\u0575\x03\x02\x02\x02\u282F\u2831\x05\u057A\u02BE\x02\u2830\u282F" + - "\x03\x02\x02\x02\u2831\u2832\x03\x02\x02\x02\u2832\u2830\x03\x02\x02\x02" + - "\u2832\u2833\x03\x02\x02\x02\u2833\u0577\x03\x02\x02\x02\u2834\u2835\x07" + - "\x14\x02\x02\u2835\u2836\x05\u0636\u031C\x02\u2836\u2837\x07\x15\x02\x02" + - "\u2837\u0579\x03\x02\x02\x02\u2838\u283C\x05\u057C\u02BF\x02\u2839\u283C" + - "\x07\xB4\x02\x02\u283A\u283C\x05\u0578\u02BD\x02\u283B\u2838\x03\x02\x02" + - "\x02\u283B\u2839\x03\x02\x02\x02\u283B\u283A\x03\x02\x02\x02\u283C\u057B" + - "\x03\x02\x02\x02\u283D\u284D\x05\u058C\u02C7\x02\u283E\u283F\x07\u01E9" + - "\x02\x02\u283F\u2840\x07@\x02\x02\u2840\u284E\x05\u058A\u02C6\x02\u2841" + - "\u2842\x05\u058E\u02C8\x02\u2842\u2843\x05\u0590\u02C9\x02\u2843\u2844" + - "\x05\u0592\u02CA\x02\u2844\u2845\x05\u0594\u02CB\x02\u2845\u2846\x05\u0596" + - "\u02CC\x02\u2846\u284E\x03\x02\x02\x02\u2847\u2848\x05\u057E\u02C0\x02" + - "\u2848\u2849\x07\xAE\x02\x02\u2849\u284A\x05\u0582\u02C2\x02\u284A\u284B" + - "\x05\u0588\u02C5\x02\u284B\u284C\x05\u0580\u02C1\x02\u284C\u284E\x03\x02" + - "\x02\x02\u284D\u283E\x03\x02\x02\x02\u284D\u2841\x03\x02\x02\x02\u284D" + - "\u2847\x03\x02\x02\x02\u284E\u284F\x03\x02\x02\x02\u284F\u2850\x07\t\x02" + - "\x02\u2850\u057D\x03\x02\x02\x02\u2851\u2856\x03\x02\x02\x02\u2852\u2853" + - "\x07\u0106\x02\x02\u2853\u2856\x07\u013D\x02\x02\u2854\u2856\x07\u013D" + - "\x02\x02\u2855\u2851\x03\x02\x02\x02\u2855\u2852\x03\x02\x02\x02\u2855" + - "\u2854\x03\x02\x02\x02\u2856\u057F\x03\x02\x02\x02\u2857\u2858\x05\u03B8" + - "\u01DD\x02\u2858\u0581\x03\x02\x02\x02\u2859\u285F\x03\x02\x02\x02\u285A" + - "\u285B\x07\x04\x02\x02\u285B\u285C\x05\u0584\u02C3\x02\u285C\u285D\x07" + - "\x05\x02\x02\u285D\u285F\x03\x02\x02\x02\u285E\u2859\x03\x02\x02\x02\u285E" + - "\u285A\x03\x02\x02\x02\u285F\u0583\x03\x02\x02\x02\u2860\u2865\x05\u0586" + - "\u02C4\x02\u2861\u2862\x07\b\x02\x02\u2862\u2864\x05\u0586\u02C4\x02\u2863" + - "\u2861\x03\x02\x02\x02\u2864\u2867\x03\x02\x02\x02\u2865\u2863\x03\x02" + - "\x02\x02\u2865\u2866\x03\x02\x02\x02\u2866\u0585\x03\x02\x02\x02\u2867" + - "\u2865\x03\x02\x02\x02\u2868\u2869\x05\u058C\u02C7\x02\u2869\u286A\x05" + - "\u0590\u02C9\x02\u286A\u0587\x03\x02\x02\x02\u286B\u286C\tB\x02\x02\u286C" + - "\u0589\x03\x02\x02\x02\u286D\u2870\x07\x1E\x02\x02\u286E\u2870\x05\u0550" + - "\u02A9\x02\u286F\u286D\x03\x02\x02\x02\u286F\u286E\x03\x02\x02\x02\u2870" + - "\u058B\x03\x02\x02\x02\u2871\u2872\x05\u0636\u031C\x02\u2872\u058D\x03" + - "\x02\x02\x02\u2873\u2876\x03\x02\x02\x02\u2874\u2876\x07\u01EA\x02\x02" + - "\u2875\u2873\x03\x02\x02\x02\u2875\u2874\x03\x02\x02\x02\u2876\u058F\x03" + - "\x02\x02\x02\u2877\u2878\x05\u0454\u022B\x02\u2878\u0591\x03\x02\x02\x02" + - "\u2879\u287D\x03\x02\x02\x02\u287A\u287B\x07-\x02\x02\u287B\u287D\x05" + - "\u020C\u0107\x02\u287C\u2879\x03\x02\x02\x02\u287C\u287A\x03\x02\x02\x02" + - "\u287D\u0593\x03\x02\x02\x02\u287E\u2882\x03\x02\x02\x02\u287F\u2880\x07" + - "O\x02\x02\u2880\u2882\x07P\x02\x02\u2881\u287E\x03\x02\x02\x02\u2881\u287F" + - "\x03\x02\x02\x02\u2882\u0595\x03\x02\x02\x02\u2883\u2888\x03\x02\x02\x02" + - "\u2884\u2885\x05\u0598\u02CD\x02\u2885\u2886\x05\u063A\u031E\x02\u2886" + - "\u2888\x03\x02\x02\x02\u2887\u2883\x03\x02\x02\x02\u2887\u2884\x03\x02" + - "\x02\x02\u2888\u0597\x03\x02\x02\x02\u2889\u288C\x05\u059A\u02CE\x02\u288A" + - "\u288C\x077\x02\x02\u288B\u2889\x03\x02\x02\x02\u288B\u288A\x03\x02\x02" + - "\x02\u288C\u0599\x03\x02\x02\x02\u288D\u288E\tC\x02\x02\u288E\u059B\x03" + - "\x02\x02\x02\u288F\u2891\x05\u059E\u02D0\x02\u2890\u288F\x03\x02\x02\x02" + - "\u2891\u2894\x03\x02\x02\x02\u2892\u2890\x03\x02\x02\x02\u2892\u2893\x03" + - "\x02\x02\x02\u2893\u059D\x03\x02\x02\x02\u2894\u2892\x03\x02\x02\x02\u2895" + - "\u2896\x05\u0570\u02B9\x02\u2896\u2897\x07\t\x02\x02\u2897\u28B1\x03\x02" + - "\x02\x02\u2898\u28B1\x05\u05E0\u02F1\x02\u2899\u28B1\x05\u05E4\u02F3\x02" + - "\u289A\u28B1\x05\u05A6\u02D4\x02\u289B\u28B1\x05\u05B6\u02DC\x02\u289C" + - "\u28B1\x05\u05BC\u02DF\x02\u289D\u28B1\x05\u05C6\u02E4\x02\u289E\u28B1" + - "\x05\u05C8\u02E5\x02\u289F\u28B1\x05\u05CA\u02E6\x02\u28A0\u28B1\x05\u05D8" + - "\u02ED\x02\u28A1\u28B1\x05\u05DC\u02EF\x02\u28A2\u28B1\x05\u05F0\u02F9" + - "\x02\u28A3\u28B1\x05\u05F6\u02FC\x02\u28A4\u28B1\x05\u05F8\u02FD\x02\u28A5" + - "\u28B1\x05\u05A0\u02D1\x02\u28A6\u28B1\x05\u05A2\u02D2\x02\u28A7\u28B1" + - "\x05\u05A8\u02D5\x02\u28A8\u28B1\x05\u0600\u0301\x02\u28A9\u28B1\x05\u060C" + - "\u0307\x02\u28AA\u28B1\x05\u0614\u030B\x02\u28AB\u28B1\x05\u0616\u030C" + - "\x02\u28AC\u28B1\x05\u0618\u030D\x02\u28AD\u28B1\x05\u061A\u030E\x02\u28AE" + - "\u28B1\x05\u061C\u030F\x02\u28AF\u28B1\x05\u0620\u0311\x02\u28B0\u2895" + - "\x03\x02\x02\x02\u28B0\u2898\x03\x02\x02\x02\u28B0\u2899\x03\x02\x02\x02" + - "\u28B0\u289A\x03\x02\x02\x02\u28B0\u289B\x03\x02\x02\x02\u28B0\u289C\x03" + - "\x02\x02\x02\u28B0\u289D\x03\x02\x02\x02\u28B0\u289E\x03\x02\x02\x02\u28B0" + - "\u289F\x03\x02\x02\x02\u28B0\u28A0\x03\x02\x02\x02\u28B0\u28A1\x03\x02" + - "\x02\x02\u28B0\u28A2\x03\x02\x02\x02\u28B0\u28A3\x03\x02\x02\x02\u28B0" + - "\u28A4\x03\x02\x02\x02\u28B0\u28A5\x03\x02\x02\x02\u28B0\u28A6\x03\x02" + - "\x02\x02\u28B0\u28A7\x03\x02\x02\x02\u28B0\u28A8\x03\x02\x02\x02\u28B0" + - "\u28A9\x03\x02\x02\x02\u28B0\u28AA\x03\x02\x02\x02\u28B0\u28AB\x03\x02" + - "\x02\x02\u28B0\u28AC\x03\x02\x02\x02\u28B0\u28AD\x03\x02\x02\x02\u28B0" + - "\u28AE\x03\x02\x02\x02\u28B0\u28AF\x03\x02\x02\x02\u28B1\u059F\x03\x02" + - "\x02\x02\u28B2\u28B3\x07\u01EB\x02\x02\u28B3\u28B4\x05\u063E\u0320\x02" + - "\u28B4\u28B5\x07\t\x02\x02\u28B5\u05A1\x03\x02\x02\x02\u28B6\u28B7\x07" + - "\u01AA\x02\x02\u28B7\u28B8\x05\u0636\u031C\x02\u28B8\u28B9\x07\x04\x02" + - "\x02\u28B9\u28BA\x05\u05A4\u02D3\x02\u28BA\u28BB\x07\x05\x02\x02\u28BB" + - "\u28BC\x07\t\x02\x02\u28BC\u28C5\x03\x02\x02\x02\u28BD\u28BE\x07;\x02" + - "\x02\u28BE\u28BF\x05\u0636\u031C\x02\u28BF\u28C0\x07\x04\x02\x02\u28C0" + - "\u28C1\x05\u05A4\u02D3\x02\u28C1\u28C2\x07\x05\x02\x02\u28C2\u28C3\x07" + - "\t\x02\x02\u28C3\u28C5\x03\x02\x02\x02\u28C4\u28B6\x03\x02\x02\x02\u28C4" + - "\u28BD\x03\x02\x02\x02\u28C5\u05A3\x03\x02\x02\x02\u28C6\u28C9\x03\x02" + - "\x02\x02\u28C7\u28C9\x05\u04F4\u027B\x02\u28C8\u28C6\x03\x02\x02\x02\u28C8" + - "\u28C7\x03\x02\x02\x02\u28C9\u05A5\x03\x02\x02\x02\u28CA\u28CB\x05\u05B4" + - "\u02DB\x02\u28CB\u28CC\x05\u059A\u02CE\x02\u28CC\u28CD\x05\u063A\u031E" + - "\x02\u28CD\u28CE\x07\t\x02\x02\u28CE\u05A7\x03\x02\x02\x02\u28CF\u28D0" + - "\x07\u01EC\x02\x02\u28D0\u28D1\x05\u05AA\u02D6\x02\u28D1\u28D2\x07\u01ED" + - "\x02\x02\u28D2\u28D3\x05\u05AC\u02D7\x02\u28D3\u28D4\x07\t\x02\x02\u28D4" + - "\u05A9\x03\x02\x02\x02\u28D5\u28D9\x03\x02\x02\x02\u28D6\u28D9\x07\u01AB" + - "\x02\x02\u28D7\u28D9\x07\u01EE\x02\x02\u28D8\u28D5\x03\x02\x02\x02\u28D8" + - "\u28D6\x03\x02\x02\x02\u28D8\u28D7\x03\x02\x02\x02\u28D9\u05AB\x03\x02" + - "\x02\x02\u28DA\u28DF\x05\u05AE\u02D8\x02\u28DB\u28DC\x07\b\x02\x02\u28DC" + - "\u28DE\x05\u05AE\u02D8\x02\u28DD\u28DB\x03\x02\x02\x02\u28DE\u28E1\x03" + - "\x02\x02\x02\u28DF\u28DD\x03\x02\x02\x02\u28DF\u28E0\x03\x02\x02\x02\u28E0" + - "\u05AD\x03\x02\x02\x02\u28E1\u28DF\x03\x02\x02\x02\u28E2\u28E3\x05\u05B2" + - "\u02DA\x02\u28E3\u28E4\x05\u059A\u02CE\x02\u28E4\u28E5\x05\u05B0\u02D9" + - "\x02\u28E5\u05AF\x03\x02\x02\x02\u28E6\u28E7\x05\u0550\u02A9\x02\u28E7" + - "\u05B1\x03\x02\x02\x02\u28E8\u28E9\x05\u05B4\u02DB\x02\u28E9\u05B3\x03" + - "\x02\x02\x02\u28EA\u28ED\x05\u020C\u0107\x02\u28EB\u28ED\x07\x1E\x02\x02" + - "\u28EC\u28EA\x03\x02\x02\x02\u28EC\u28EB\x03\x02\x02\x02\u28ED\u28F4\x03" + - "\x02\x02\x02\u28EE\u28EF\x07\x06\x02\x02\u28EF\u28F0\x05\u0640\u0321\x02" + - "\u28F0\u28F1\x07\x07\x02\x02\u28F1\u28F3\x03\x02\x02\x02\u28F2\u28EE\x03" + - "\x02\x02\x02\u28F3\u28F6\x03\x02\x02\x02\u28F4\u28F2\x03\x02\x02\x02\u28F4" + - "\u28F5\x03\x02\x02\x02\u28F5\u05B5\x03\x02\x02\x02\u28F6\u28F4\x03\x02" + - "\x02\x02\u28F7\u28F8\x07\xDE\x02\x02\u28F8\u28F9\x05\u063C\u031F\x02\u28F9" + - "\u28FA\x07_\x02\x02\u28FA\u28FB\x05\u059C\u02CF\x02\u28FB\u28FC\x05\u05B8" + - "\u02DD\x02\u28FC\u28FD\x05\u05BA\u02DE\x02\u28FD\u28FE\x07\u01BF\x02\x02" + - "\u28FE\u28FF\x07\xDE\x02\x02\u28FF\u2900\x07\t\x02\x02\u2900\u05B7\x03" + - "\x02\x02\x02\u2901\u2902\x07\u01EF\x02\x02\u2902\u2903\x05\u0480\u0241" + - "\x02\u2903\u2904\x07_\x02\x02\u2904\u2905\x05\u059C\u02CF\x02\u2905\u2907" + - "\x03\x02\x02\x02\u2906\u2901\x03\x02\x02\x02\u2907\u290A\x03\x02\x02\x02" + - "\u2908\u2906\x03\x02\x02\x02\u2908\u2909\x03\x02\x02\x02\u2909\u05B9\x03" + - "\x02\x02\x02\u290A\u2908\x03\x02\x02\x02\u290B\u290F\x03\x02\x02\x02\u290C" + - "\u290D\x07<\x02\x02\u290D\u290F\x05\u059C\u02CF\x02\u290E\u290B\x03\x02" + - "\x02\x02\u290E\u290C\x03\x02\x02\x02\u290F\u05BB\x03\x02\x02\x02\u2910" + - "\u2911\x07*\x02\x02\u2911\u2912\x05\u05BE\u02E0\x02\u2912\u2913\x05\u05C0" + - "\u02E1\x02\u2913\u2914\x05\u05C4\u02E3\x02\u2914\u2915\x07\u01BF\x02\x02" + - "\u2915\u2916\x07*\x02\x02\u2916\u2917\x07\t\x02\x02\u2917\u05BD\x03\x02" + - "\x02\x02\u2918\u291B\x03\x02\x02\x02\u2919\u291B\x05\u063A\u031E\x02\u291A" + - "\u2918\x03\x02\x02\x02\u291A\u2919\x03\x02\x02\x02\u291B\u05BF\x03\x02" + - "\x02\x02\u291C\u291E\x05\u05C2\u02E2\x02\u291D\u291C\x03\x02\x02\x02\u291E" + - "\u291F\x03\x02\x02\x02\u291F\u291D\x03\x02\x02\x02\u291F\u2920\x03\x02" + - "\x02\x02\u2920\u05C1\x03\x02\x02\x02\u2921\u2922\x07h\x02\x02\u2922\u2923" + - "\x05\u04F4\u027B\x02\u2923\u2924\x07_\x02\x02\u2924\u2925\x05\u059C\u02CF" + - "\x02\u2925\u05C3\x03\x02\x02\x02\u2926\u292A\x03\x02\x02\x02\u2927\u2928" + - "\x07<\x02\x02\u2928\u292A\x05\u059C\u02CF\x02\u2929\u2926\x03\x02\x02" + - "\x02\u2929\u2927\x03\x02\x02\x02\u292A\u05C5\x03\x02\x02\x02\u292B\u292C" + - "\x05\u0630\u0319\x02\u292C\u292D\x05\u05F4\u02FB\x02\u292D\u05C7\x03"; + "\u2680\x07\x05\x02\x02\u2680\u04F5\x03\x02\x02\x02\u2681\u2682\tA\x02" + + "\x02\u2682\u04F7\x03\x02\x02\x02\u2683\u2686\x07\x1F\x02\x02\u2684\u2686" + + "\x05\u04FA\u027E\x02\u2685\u2683\x03\x02\x02\x02\u2685\u2684\x03\x02\x02" + + "\x02\u2686\u04F9\x03\x02\x02\x02\u2687\u2688\tB\x02\x02\u2688\u04FB\x03" + + "\x02\x02\x02\u2689\u2690\x07\x1F\x02\x02\u268A\u268B\x07\u0118\x02\x02" + + "\u268B\u268C\x07\x04\x02\x02\u268C\u268D\x05\u02BA\u015E\x02\u268D\u268E" + + "\x07\x05\x02\x02\u268E\u2690\x03\x02\x02\x02\u268F\u2689\x03\x02\x02\x02" + + "\u268F\u268A\x03\x02\x02\x02\u2690\u04FD\x03\x02\x02\x02\u2691\u2698\x05" + + "\u04F8\u027D\x02\u2692\u2693\x07\u0118\x02\x02\u2693\u2694\x07\x04\x02" + + "\x02\u2694\u2695\x05\u02BA\u015E\x02\u2695\u2696\x07\x05\x02\x02\u2696" + + "\u2698\x03\x02\x02\x02\u2697\u2691\x03\x02\x02\x02\u2697\u2692\x03\x02" + + "\x02\x02\u2698\u04FF\x03\x02\x02\x02\u2699\u26A6\x05\u04F8\u027D\x02\u269A" + + "\u269B\x07\u0118\x02\x02\u269B\u269C\x07\x04\x02\x02\u269C\u269D\x05\u02BA" + + "\u015E\x02\u269D\u269E\x07\x05\x02\x02\u269E\u26A6\x03\x02\x02\x02\u269F" + + "\u26A6\x07z\x02\x02\u26A0\u26A1\x07O\x02\x02\u26A1\u26A6\x07z\x02\x02" + + "\u26A2\u26A6\x07t\x02\x02\u26A3\u26A4\x07O\x02\x02\u26A4\u26A6\x07t\x02" + + "\x02\u26A5\u2699\x03\x02\x02\x02\u26A5\u269A\x03\x02\x02\x02\u26A5\u269F" + + "\x03\x02\x02\x02\u26A5\u26A0\x03\x02\x02\x02\u26A5\u26A2\x03\x02\x02\x02" + + "\u26A5\u26A3\x03\x02\x02\x02\u26A6\u0501\x03\x02\x02\x02\u26A7\u26AC\x05" + + "\u048E\u0248\x02\u26A8\u26A9\x07\b\x02\x02\u26A9\u26AB\x05\u048E\u0248" + + "\x02\u26AA\u26A8\x03\x02\x02\x02\u26AB\u26AE\x03\x02\x02\x02\u26AC\u26AA" + + "\x03\x02\x02\x02\u26AC\u26AD\x03\x02\x02\x02\u26AD\u0503\x03\x02\x02\x02" + + "\u26AE\u26AC\x03\x02\x02\x02\u26AF\u26B4\x05\u0506\u0284\x02\u26B0\u26B1" + + "\x07\b\x02\x02\u26B1\u26B3\x05\u0506\u0284\x02\u26B2\u26B0\x03\x02\x02" + + "\x02\u26B3\u26B6\x03\x02\x02\x02\u26B4\u26B2\x03\x02\x02\x02\u26B4\u26B5" + + "\x03\x02\x02\x02\u26B5\u0505\x03\x02\x02\x02\u26B6\u26B4\x03\x02\x02\x02" + + "\u26B7\u26BD\x05\u048E\u0248\x02\u26B8\u26B9\x05\u028A\u0146\x02\u26B9" + + "\u26BA\tC\x02\x02\u26BA\u26BB\x05\u048E\u0248\x02\u26BB\u26BD\x03\x02" + + "\x02\x02\u26BC\u26B7\x03\x02\x02\x02\u26BC\u26B8\x03\x02\x02\x02\u26BD" + + "\u0507\x03\x02\x02\x02\u26BE\u26C3\x05\u0462\u0232\x02\u26BF\u26C0\x07" + + "\b\x02\x02\u26C0\u26C2\x05\u0462\u0232\x02\u26C1\u26BF\x03\x02\x02\x02" + + "\u26C2\u26C5\x03\x02\x02\x02\u26C3\u26C1\x03\x02\x02\x02\u26C3\u26C4\x03" + + "\x02\x02\x02\u26C4\u0509\x03\x02\x02\x02\u26C5\u26C3\x03\x02\x02\x02\u26C6" + + "\u26C9\x07\x06\x02\x02\u26C7\u26CA\x05\u0502\u0282\x02\u26C8\u26CA\x05" + + "\u050C\u0287\x02\u26C9\u26C7\x03\x02\x02\x02\u26C9\u26C8\x03\x02\x02\x02" + + "\u26C9\u26CA\x03\x02\x02\x02\u26CA\u26CB\x03\x02\x02\x02\u26CB\u26CC\x07" + + "\x07\x02\x02\u26CC\u050B\x03\x02\x02\x02\u26CD\u26D2\x05\u050A\u0286\x02" + + "\u26CE\u26CF\x07\b\x02\x02\u26CF\u26D1\x05\u050A\u0286\x02\u26D0\u26CE" + + "\x03\x02\x02\x02\u26D1\u26D4\x03\x02\x02\x02\u26D2\u26D0\x03\x02\x02\x02" + + "\u26D2\u26D3\x03\x02\x02\x02\u26D3\u050D\x03\x02\x02\x02\u26D4\u26D2\x03" + + "\x02\x02\x02\u26D5\u26D6\x05\u0510\u0289\x02\u26D6\u26D7\x07B\x02\x02" + + "\u26D7\u26D8\x05\u048E\u0248\x02\u26D8\u050F\x03\x02\x02\x02\u26D9\u26E2" + + "\x05\u0572\u02BA\x02\u26DA\u26E2\x07\u0182\x02\x02\u26DB\u26E2\x07\u010A" + + "\x02\x02\u26DC\u26E2\x07\xB2\x02\x02\u26DD\u26E2\x07\xDC\x02\x02\u26DE" + + "\u26E2\x07\u0107\x02\x02\u26DF\u26E2\x07\u0148\x02\x02\u26E0\u26E2\x05" + + "\u0552\u02AA\x02\u26E1\u26D9\x03\x02\x02\x02\u26E1\u26DA\x03\x02\x02\x02" + + "\u26E1\u26DB\x03\x02\x02\x02\u26E1\u26DC\x03\x02\x02\x02\u26E1\u26DD\x03" + + "\x02\x02\x02\u26E1\u26DE\x03\x02\x02\x02\u26E1\u26DF\x03\x02\x02\x02\u26E1" + + "\u26E0\x03\x02\x02\x02\u26E2\u0511\x03\x02\x02\x02\u26E3\u26E4\tD\x02" + + "\x02\u26E4\u0513\x03\x02\x02\x02\u26E5\u26E6\x05\u048E\u0248\x02\u26E6" + + "\u26E7\x07V\x02\x02\u26E7\u26E8\x05\u048E\u0248\x02\u26E8\u26E9\x07B\x02" + + "\x02\u26E9\u26EC\x05\u048E\u0248\x02\u26EA\u26EB\x07@\x02\x02\u26EB\u26ED" + + "\x05\u048E\u0248\x02\u26EC\u26EA\x03\x02\x02\x02\u26EC\u26ED\x03\x02\x02" + + "\x02\u26ED\u0515\x03\x02\x02\x02\u26EE\u26EF\x05\u04B6\u025C\x02\u26EF" + + "\u26F0\x07F\x02\x02\u26F0\u26F1\x05\u04B6\u025C\x02\u26F1\u0517\x03\x02" + + "\x02\x02\u26F2\u26F3\x05\u048E\u0248\x02\u26F3\u26F4\x07B\x02\x02\u26F4" + + "\u26F5\x05\u048E\u0248\x02\u26F5\u26F6\x07@\x02\x02\u26F6\u26F7\x05\u048E" + + "\u0248\x02\u26F7\u270E\x03\x02\x02\x02\u26F8\u26F9\x05\u048E\u0248\x02" + + "\u26F9\u26FA\x07@\x02\x02\u26FA\u26FB\x05\u048E\u0248\x02\u26FB\u26FC" + + "\x07B\x02\x02\u26FC\u26FD\x05\u048E\u0248\x02\u26FD\u270E\x03\x02\x02" + + "\x02\u26FE\u26FF\x05\u048E\u0248\x02\u26FF\u2700\x07B\x02\x02\u2700\u2701" + + "\x05\u048E\u0248\x02\u2701\u270E\x03\x02\x02\x02\u2702\u2703\x05\u048E" + + "\u0248\x02\u2703\u2704\x07@\x02\x02\u2704\u2705\x05\u048E\u0248\x02\u2705" + + "\u270E\x03\x02\x02\x02\u2706\u2707\x05\u048E\u0248\x02\u2707\u2708\x07" + + "\x81\x02\x02\u2708\u2709\x05\u048E\u0248\x02\u2709\u270A\x07\xC7\x02\x02" + + "\u270A\u270B\x05\u048E\u0248\x02\u270B\u270E\x03\x02\x02\x02\u270C\u270E" + + "\x05\u0502\u0282\x02\u270D\u26F2\x03\x02\x02\x02\u270D\u26F8\x03\x02\x02" + + "\x02\u270D\u26FE\x03\x02\x02\x02\u270D\u2702\x03\x02\x02\x02\u270D\u2706" + + "\x03\x02\x02\x02\u270D\u270C\x03\x02\x02\x02\u270E\u0519\x03\x02\x02\x02" + + "\u270F\u2710\x05\u048E\u0248\x02\u2710\u2711\x07B\x02\x02\u2711\u2712" + + "\x05\u0502\u0282\x02\u2712\u2717\x03\x02\x02\x02\u2713\u2714\x07B\x02" + + "\x02\u2714\u2717\x05\u0502\u0282\x02\u2715\u2717\x05\u0502\u0282\x02\u2716" + + "\u270F\x03\x02\x02\x02\u2716\u2713\x03\x02\x02\x02\u2716\u2715\x03\x02" + + "\x02\x02\u2717\u051B\x03\x02\x02\x02\u2718\u271E\x05\u03C8\u01E5\x02\u2719" + + "\u271A\x07\x04\x02\x02\u271A\u271B\x05\u0502\u0282\x02\u271B\u271C\x07" + + "\x05\x02\x02\u271C\u271E\x03\x02\x02\x02\u271D\u2718\x03\x02\x02\x02\u271D" + + "\u2719\x03\x02\x02\x02\u271E\u051D\x03\x02\x02\x02\u271F\u2721\x07*\x02" + + "\x02\u2720\u2722\x05\u0526\u0294\x02\u2721\u2720\x03\x02\x02\x02\u2721" + + "\u2722\x03\x02\x02\x02\u2722\u2723\x03\x02\x02\x02\u2723\u2725\x05\u0520" + + "\u0291\x02\u2724\u2726\x05\u0524\u0293\x02\u2725\u2724\x03\x02\x02\x02" + + "\u2725\u2726\x03\x02\x02\x02\u2726\u2727\x03\x02\x02\x02\u2727\u2728\x07" + + "\u01C8\x02\x02\u2728\u051F\x03\x02\x02\x02\u2729\u272B\x05\u0522\u0292" + + "\x02\u272A\u2729\x03\x02\x02\x02\u272B\u272C\x03\x02\x02\x02\u272C\u272A" + + "\x03\x02\x02\x02\u272C\u272D\x03\x02\x02\x02\u272D\u0521\x03\x02\x02\x02" + + "\u272E\u272F\x07h\x02\x02\u272F\u2730\x05\u048E\u0248\x02\u2730\u2731" + + "\x07_\x02\x02\u2731\u2732\x05\u048E\u0248\x02\u2732\u0523\x03\x02\x02" + + "\x02\u2733\u2734\x07<\x02\x02\u2734\u2735\x05\u048E\u0248\x02\u2735\u0525" + + "\x03\x02\x02\x02\u2736\u2737\x05\u048E\u0248\x02\u2737\u0527\x03\x02\x02" + + "\x02\u2738\u273A\x05\u0562\u02B2\x02\u2739\u273B\x05\u052E\u0298\x02\u273A" + + "\u2739\x03\x02\x02\x02\u273A\u273B\x03\x02\x02\x02\u273B\u0529\x03\x02" + + "\x02\x02\u273C\u273F\x07\r\x02\x02\u273D\u2740\x05\u0542\u02A2\x02\u273E" + + "\u2740\x07\v\x02\x02\u273F\u273D\x03\x02\x02\x02\u273F\u273E\x03\x02\x02" + + "\x02\u2740\u274E\x03\x02\x02\x02\u2741\u274A\x07\x06\x02\x02\u2742\u274B" + + "\x05\u048E\u0248\x02\u2743\u2745\x05\u052C\u0297\x02\u2744\u2743\x03\x02" + + "\x02\x02\u2744\u2745\x03\x02\x02\x02\u2745\u2746\x03\x02\x02\x02\u2746" + + "\u2748\x07\n\x02\x02\u2747\u2749\x05\u052C\u0297\x02\u2748\u2747\x03\x02" + + "\x02\x02\u2748\u2749\x03\x02\x02\x02\u2749\u274B\x03\x02\x02\x02\u274A" + + "\u2742\x03\x02\x02\x02\u274A\u2744\x03\x02\x02\x02\u274B\u274C\x03\x02" + + "\x02\x02\u274C\u274E\x07\x07\x02\x02\u274D\u273C\x03\x02\x02\x02\u274D" + + "\u2741\x03\x02\x02\x02\u274E\u052B\x03\x02\x02\x02\u274F\u2750\x05\u048E" + + "\u0248\x02\u2750\u052D\x03\x02\x02\x02\u2751\u2753\x05\u052A\u0296\x02" + + "\u2752\u2751\x03\x02\x02\x02\u2753\u2754\x03\x02\x02\x02\u2754\u2752\x03" + + "\x02\x02\x02\u2754\u2755\x03\x02\x02\x02\u2755\u052F\x03\x02\x02\x02\u2756" + + "\u2758\x05\u052A\u0296\x02\u2757\u2756\x03\x02\x02\x02\u2758\u275B\x03" + + "\x02\x02\x02\u2759\u2757\x03\x02\x02\x02\u2759\u275A\x03\x02\x02\x02\u275A" + + "\u0531\x03\x02\x02\x02\u275B\u2759\x03\x02\x02\x02\u275C\u275D\x05\u0534" + + "\u029B\x02\u275D\u0533\x03\x02\x02\x02\u275E\u2763\x05\u0536\u029C\x02" + + "\u275F\u2760\x07\b\x02\x02\u2760\u2762\x05\u0536\u029C\x02\u2761\u275F" + + "\x03\x02\x02\x02\u2762\u2765\x03\x02\x02\x02\u2763\u2761\x03\x02\x02\x02" + + "\u2763\u2764\x03\x02\x02\x02\u2764\u0535\x03\x02\x02\x02\u2765\u2763\x03" + + "\x02\x02\x02\u2766\u276B\x05\u048E\u0248\x02\u2767\u2768\x07&\x02\x02" + + "\u2768\u276C\x05\u0570\u02B9\x02\u2769\u276C\x05\u0572\u02BA\x02\u276A" + + "\u276C\x03\x02\x02\x02\u276B\u2767\x03\x02\x02\x02\u276B\u2769\x03\x02" + + "\x02\x02\u276B\u276A\x03\x02\x02\x02\u276C\u276F\x03\x02\x02\x02\u276D" + + "\u276F\x07\v\x02\x02\u276E\u2766\x03\x02\x02\x02\u276E\u276D\x03\x02\x02" + + "\x02\u276F\u0537\x03\x02\x02\x02\u2770\u2775\x05\u053C\u029F\x02\u2771" + + "\u2772\x07\b\x02\x02\u2772\u2774\x05\u053C\u029F\x02\u2773\u2771\x03\x02" + + "\x02\x02\u2774\u2777\x03\x02\x02\x02\u2775\u2773\x03\x02\x02\x02\u2775" + + "\u2776\x03\x02\x02\x02\u2776\u0539\x03\x02\x02\x02\u2777\u2775\x03\x02" + + "\x02\x02\u2778\u277A\x05\u0562\u02B2\x02\u2779\u277B\x05\u052E\u0298\x02" + + "\u277A\u2779\x03\x02\x02\x02\u277A\u277B\x03\x02\x02\x02\u277B\u053B\x03" + + "\x02\x02\x02\u277C\u277E\x05\u0562\u02B2\x02\u277D\u277F\x05\u052E\u0298" + + "\x02\u277E\u277D\x03\x02\x02\x02\u277E\u277F\x03\x02\x02\x02\u277F\u053D" + + "\x03\x02\x02\x02\u2780\u2785\x05\u0540\u02A1\x02\u2781\u2782\x07\b\x02" + + "\x02\u2782\u2784\x05\u0540\u02A1\x02\u2783\u2781\x03\x02\x02\x02\u2784" + + "\u2787\x03\x02\x02\x02\u2785\u2783\x03\x02\x02\x02\u2785\u2786\x03\x02" + + "\x02\x02\u2786\u053F\x03\x02\x02\x02\u2787\u2785\x03\x02\x02\x02\u2788" + + "\u2789\x05\u0562\u02B2\x02\u2789\u0541\x03\x02\x02\x02\u278A\u278B\x05" + + "\u0570\u02B9\x02\u278B\u0543\x03\x02\x02\x02\u278C\u278D\x05\u0552\u02AA" + + "\x02\u278D\u0545\x03\x02\x02\x02\u278E\u2793\x05\u056C\u02B7\x02\u278F" + + "\u2790\x05\u0562\u02B2\x02\u2790\u2791\x05\u052E\u0298\x02\u2791\u2793" + + "\x03\x02\x02\x02\u2792\u278E\x03\x02\x02\x02\u2792\u278F\x03\x02\x02\x02" + + "\u2793\u0547\x03\x02\x02\x02\u2794\u27B8\x05\u0550\u02A9\x02\u2795\u27B8" + + "\x05\u054E\u02A8\x02\u2796\u27B8\x05\u0552\u02AA\x02\u2797\u27B8\x05\u054C" + + "\u02A7\x02\u2798\u27B8\x05\u054A\u02A6\x02\u2799\u27A3\x05\u0546\u02A4" + + "\x02\u279A\u27A4\x05\u0552\u02AA\x02\u279B\u279C\x07\x04\x02\x02\u279C" + + "\u279E\x05\u0504\u0283\x02\u279D\u279F\x05\u03EC\u01F7\x02\u279E\u279D" + + "\x03\x02\x02\x02\u279E\u279F\x03\x02\x02\x02\u279F\u27A0\x03\x02\x02\x02" + + "\u27A0\u27A1\x07\x05\x02\x02\u27A1\u27A2\x05\u0552\u02AA\x02\u27A2\u27A4" + + "\x03\x02\x02\x02\u27A3\u279A\x03\x02\x02\x02\u27A3\u279B\x03\x02\x02\x02" + + "\u27A4\u27B8\x03\x02\x02\x02\u27A5\u27A6\x05\u0468\u0235\x02\u27A6\u27A7" + + "\x05\u0552\u02AA\x02\u27A7\u27B8\x03\x02\x02\x02\u27A8\u27B2\x05\u0484" + + "\u0243\x02\u27A9\u27AB\x05\u0552\u02AA\x02\u27AA\u27AC\x05\u0488\u0245" + + "\x02\u27AB\u27AA\x03\x02\x02\x02\u27AB\u27AC\x03\x02\x02\x02\u27AC\u27B3" + + "\x03\x02\x02\x02\u27AD\u27AE\x07\x04\x02\x02\u27AE\u27AF\x05\u0550\u02A9" + + "\x02\u27AF\u27B0\x07\x05\x02\x02\u27B0\u27B1\x05\u0552\u02AA\x02\u27B1" + + "\u27B3\x03\x02\x02\x02\u27B2\u27A9\x03\x02\x02\x02\u27B2\u27AD\x03\x02" + + "\x02\x02\u27B3\u27B8\x03\x02\x02\x02\u27B4\u27B8\x07b\x02\x02\u27B5\u27B8" + + "\x07>\x02\x02\u27B6\u27B8\x07P\x02\x02\u27B7\u2794\x03\x02\x02\x02\u27B7" + + "\u2795\x03\x02\x02\x02\u27B7\u2796\x03\x02\x02\x02\u27B7\u2797\x03\x02" + + "\x02\x02\u27B7\u2798\x03\x02\x02\x02\u27B7\u2799\x03\x02\x02\x02\u27B7" + + "\u27A5\x03\x02\x02\x02\u27B7\u27A8\x03\x02\x02\x02\u27B7\u27B4\x03\x02" + + "\x02\x02\u27B7\u27B5\x03\x02\x02\x02\u27B7\u27B6\x03\x02\x02\x02\u27B8" + + "\u0549\x03\x02\x02\x02\u27B9\u27BA\x07\u0221\x02\x02\u27BA\u054B\x03\x02" + + "\x02\x02\u27BB\u27BC\x07\u021D\x02\x02\u27BC\u054D\x03\x02\x02\x02\u27BD" + + "\u27BE\x07\u0227\x02\x02\u27BE\u054F\x03\x02\x02\x02\u27BF\u27C0\x07\u0225" + + "\x02\x02\u27C0\u0551\x03\x02\x02\x02\u27C1\u27C3\x05\u0554\u02AB\x02\u27C2" + + "\u27C4\x05\u0556\u02AC\x02\u27C3\u27C2\x03\x02\x02\x02\u27C3\u27C4\x03" + + "\x02\x02\x02\u27C4\u0553\x03\x02\x02\x02\u27C5\u27D1\x07\u0218\x02\x02" + + "\u27C6\u27D1\x07\u021A\x02\x02\u27C7\u27CB\x07\u021C\x02\x02\u27C8\u27CA" + + "\x07\u0236\x02\x02\u27C9\u27C8\x03\x02\x02\x02\u27CA\u27CD\x03\x02\x02" + + "\x02\u27CB\u27C9\x03\x02\x02\x02\u27CB\u27CC\x03\x02\x02\x02\u27CC\u27CE" + + "\x03\x02\x02\x02\u27CD\u27CB\x03\x02\x02\x02\u27CE\u27D1\x07\u0237\x02" + + "\x02\u27CF\u27D1\x07\u0232\x02\x02\u27D0\u27C5\x03\x02\x02\x02\u27D0\u27C6" + + "\x03\x02\x02\x02\u27D0\u27C7\x03\x02\x02\x02\u27D0\u27CF\x03\x02\x02\x02" + + "\u27D1\u0555\x03\x02\x02\x02\u27D2\u27D3\x07\u01E9\x02\x02\u27D3\u27D4" + + "\x05\u0554\u02AB\x02\u27D4\u0557\x03\x02\x02\x02\u27D5\u27DB\x05\u0550" + + "\u02A9\x02\u27D6\u27D7\x07\x0E\x02\x02\u27D7\u27DB\x05\u0550\u02A9\x02" + + "\u27D8\u27D9\x07\x0F\x02\x02\u27D9\u27DB\x05\u0550\u02A9\x02\u27DA\u27D5" + + "\x03\x02\x02\x02\u27DA\u27D6\x03\x02\x02\x02\u27DA\u27D8\x03\x02\x02\x02" + + "\u27DB\u0559\x03\x02\x02\x02\u27DC\u27DD\x05\u055E\u02B0\x02\u27DD\u055B" + + "\x03\x02\x02\x02\u27DE\u27DF\x05\u055E\u02B0\x02\u27DF\u055D\x03\x02\x02" + + "\x02\u27E0\u27E5\x05\u056E\u02B8\x02\u27E1\u27E5\x076\x02\x02\u27E2\u27E5" + + "\x07[\x02\x02\u27E3\u27E5\x07\u020E\x02\x02\u27E4\u27E0\x03\x02\x02\x02" + + "\u27E4\u27E1\x03\x02\x02\x02\u27E4\u27E2\x03\x02\x02\x02\u27E4\u27E3\x03" + + "\x02\x02\x02\u27E5\u055F\x03\x02\x02\x02\u27E6\u27EB\x05\u055E\u02B0\x02" + + "\u27E7\u27E8\x07\b\x02\x02\u27E8\u27EA\x05\u055E\u02B0\x02\u27E9\u27E7" + + "\x03\x02\x02\x02\u27EA\u27ED\x03\x02\x02\x02\u27EB\u27E9\x03\x02\x02\x02" + + "\u27EB\u27EC\x03\x02\x02\x02\u27EC\u0561\x03\x02\x02\x02\u27ED\u27EB\x03" + + "\x02\x02\x02\u27EE\u27F3\x05\u0572\u02BA\x02\u27EF\u27F3\x05\u0576\u02BC" + + "\x02\u27F0\u27F3\x05\u0578\u02BD\x02\u27F1\u27F3\x05\u0652\u032A\x02\u27F2" + + "\u27EE\x03\x02\x02\x02\u27F2\u27EF\x03\x02\x02\x02\u27F2\u27F0\x03\x02" + + "\x02\x02\u27F2\u27F1\x03\x02\x02\x02\u27F3\u0563\x03\x02\x02\x02\u27F4" + + "\u27F5\x05\u0572\u02BA\x02\u27F5\u0565\x03\x02\x02\x02\u27F6\u2803\x05" + + "\u02A6\u0154\x02\u27F7\u27F8\x07\x04\x02\x02\u27F8\u27F9\x05\u048E\u0248" + + "\x02\u27F9\u27FA\x07\x05\x02\x02\u27FA\u27FB\x03\x02\x02\x02\u27FB\u27FD" + + "\x05\u0572\u02BA\x02\u27FC\u27FE\x05\u0270\u0139\x02\u27FD\u27FC\x03\x02" + + "\x02\x02\u27FD\u27FE\x03\x02\x02\x02\u27FE\u2800\x03\x02\x02\x02\u27FF" + + "\u2801\x05\u0272\u013A\x02\u2800\u27FF\x03\x02\x02\x02\u2800\u2801\x03" + + "\x02\x02\x02\u2801\u2803\x03\x02\x02\x02\u2802\u27F6\x03\x02\x02\x02\u2802" + + "\u27F7\x03\x02\x02\x02\u2803\u0567\x03\x02\x02\x02\u2804\u2805\x07k\x02" + + "\x02\u2805\u2807\x05t;\x02\u2806\u2804\x03\x02\x02\x02\u2806\u2807\x03" + + "\x02\x02\x02\u2807\u2809\x03\x02\x02\x02\u2808\u280A\x05\u0104\x83\x02" + + "\u2809\u2808\x03\x02\x02\x02\u2809\u280A\x03\x02\x02\x02\u280A\u0569\x03" + + "\x02\x02\x02\u280B\u280C\x07i\x02\x02\u280C\u280D\x05\u0572\u02BA\x02" + + "\u280D\u056B\x03\x02\x02\x02\u280E\u2813\x05\u0572\u02BA\x02\u280F\u2813" + + "\x05\u0576\u02BC\x02\u2810\u2813\x05\u0652\u032A\x02\u2811\u2813\x05\u057A" + + "\u02BE\x02\u2812\u280E\x03\x02\x02\x02\u2812\u280F\x03\x02\x02\x02\u2812" + + "\u2810\x03\x02\x02\x02\u2812\u2811\x03\x02\x02\x02\u2813\u056D\x03\x02" + + "\x02\x02\u2814\u2819\x05\u0572\u02BA\x02\u2815\u2819\x05\u0576\u02BC\x02" + + "\u2816\u2819\x05\u0578\u02BD\x02\u2817\u2819\x05\u057A\u02BE\x02\u2818" + + "\u2814\x03\x02\x02\x02\u2818\u2815\x03\x02\x02\x02\u2818\u2816\x03\x02" + + "\x02\x02\u2818\u2817\x03\x02\x02\x02\u2819\u056F\x03\x02\x02\x02\u281A" + + "\u2821\x05\u0572\u02BA\x02\u281B\u2821\x05\u0652\u032A\x02\u281C\u2821" + + "\x05\u0576\u02BC\x02\u281D\u2821\x05\u0578\u02BD\x02\u281E\u2821\x05\u057A" + + "\u02BE\x02\u281F\u2821\x05\u057C\u02BF\x02\u2820\u281A\x03\x02\x02\x02" + + "\u2820\u281B\x03\x02\x02\x02\u2820\u281C\x03\x02\x02\x02\u2820\u281D\x03" + + "\x02\x02\x02\u2820\u281E\x03\x02\x02\x02\u2820\u281F\x03\x02\x02\x02\u2821" + + "\u0571\x03\x02\x02\x02\u2822\u2824\x07\u020F\x02\x02\u2823\u2825\x05\u0556" + + "\u02AC\x02\u2824\u2823\x03\x02\x02\x02\u2824\u2825\x03\x02\x02\x02\u2825" + + "\u282C\x03\x02\x02\x02\u2826\u282C\x07\u0210\x02\x02\u2827\u282C\x07\u0214" + + "\x02\x02\u2828\u282C\x05\u04BA\u025E\x02\u2829\u282C\x05\u0574\u02BB\x02" + + "\u282A\u282C\x05\u0652\u032A\x02\u282B\u2822\x03\x02\x02\x02\u282B\u2826" + + "\x03\x02\x02\x02\u282B\u2827\x03\x02\x02\x02\u282B\u2828\x03\x02\x02\x02" + + "\u282B\u2829\x03\x02\x02\x02\u282B\u282A\x03\x02\x02\x02\u282C\u0573\x03" + + "\x02\x02\x02\u282D\u282E\x07\u0229\x02\x02\u282E\u0575\x03\x02\x02\x02" + + "\u282F\u2830\tE\x02\x02\u2830\u0577\x03\x02\x02\x02\u2831\u2865\x07\u0185" + + "\x02\x02\u2832\u2865\x07\u0186\x02\x02\u2833\u2865\x05\u0472\u023A\x02" + + "\u2834\u2865\x07\u0188\x02\x02\u2835\u2865\x07\u0189\x02\x02\u2836\u2865" + + "\x05\u047A\u023E\x02\u2837\u2865\x07\u018B\x02\x02\u2838\u2865\x07\u018C" + + "\x02\x02\u2839\u2865\x07\u018D\x02\x02\u283A\u2865\x07\u018E\x02\x02\u283B" + + "\u2865\x07\u018F\x02\x02\u283C\u2865\x07\u0190\x02\x02\u283D\u2865\x07" + + "\u0191\x02\x02\u283E\u2865\x07\u01D8\x02\x02\u283F\u2865\x07\u0192\x02" + + "\x02\u2840\u2865\x07\u0193\x02\x02\u2841\u2865\x07\u0194\x02\x02\u2842" + + "\u2865\x07\u0195\x02\x02\u2843\u2865\x07\u0196\x02\x02\u2844\u2865\x07" + + "\u0197\x02\x02\u2845\u2865\x07\u0198\x02\x02\u2846\u2865\x07\u0199\x02" + + "\x02\u2847\u2865\x07\u01EB\x02\x02\u2848\u2865\x07\u019A\x02\x02\u2849" + + "\u2865\x05\u046E\u0238\x02\u284A\u2865\x07\u01C7\x02\x02\u284B\u2865\x07" + + "\u019C\x02\x02\u284C\u2865\x07\u019D\x02\x02\u284D\u2865\x07\u019E\x02" + + "\x02\u284E\u2865\x07\u019F\x02\x02\u284F\u2865\x07\u01A0\x02\x02\u2850" + + "\u2865\x07\u01A1\x02\x02\u2851\u2865\x07\u01A2\x02\x02\u2852\u2865\x07" + + "\u01A3\x02\x02\u2853\u2865\x07\u01A4\x02\x02\u2854\u2865\x07\u01A5\x02" + + "\x02\u2855\u2865\x07\u01A6\x02\x02\u2856\u2865\x07\u01A7\x02\x02\u2857" + + "\u2865\x07\u01A8\x02\x02\u2858\u2865\x07\u01A9\x02\x02\u2859\u2865\x07" + + "\u01AA\x02\x02\u285A\u2865\x07\u01AB\x02\x02\u285B\u2865\x07\u01AC\x02" + + "\x02\u285C\u2865\x07\u01AD\x02\x02\u285D\u2865\x07\u01AE\x02\x02\u285E" + + "\u2865\x07\u01DE\x02\x02\u285F\u2865\x07\u01AF\x02\x02\u2860\u2865\x07" + + "\u01B0\x02\x02\u2861\u2865\x07\u01B1\x02\x02\u2862\u2865\x07\u01B2\x02" + + "\x02\u2863\u2865\x07\u01DC\x02\x02\u2864\u2831\x03\x02\x02\x02\u2864\u2832" + + "\x03\x02\x02\x02\u2864\u2833\x03\x02\x02\x02\u2864\u2834\x03\x02\x02\x02" + + "\u2864\u2835\x03\x02\x02\x02\u2864\u2836\x03\x02\x02\x02\u2864\u2837\x03" + + "\x02\x02\x02\u2864\u2838\x03\x02\x02\x02\u2864\u2839\x03\x02\x02\x02\u2864" + + "\u283A\x03\x02\x02\x02\u2864\u283B\x03\x02\x02\x02\u2864\u283C\x03\x02" + + "\x02\x02\u2864\u283D\x03\x02\x02\x02\u2864\u283E\x03\x02\x02\x02\u2864" + + "\u283F\x03\x02\x02\x02\u2864\u2840\x03\x02\x02\x02\u2864\u2841\x03\x02" + + "\x02\x02\u2864\u2842\x03\x02\x02\x02\u2864\u2843\x03\x02\x02\x02\u2864" + + "\u2844\x03\x02\x02\x02\u2864\u2845\x03\x02\x02\x02\u2864\u2846\x03\x02" + + "\x02\x02\u2864\u2847\x03\x02\x02\x02\u2864\u2848\x03\x02\x02\x02\u2864" + + "\u2849\x03\x02\x02\x02\u2864\u284A\x03\x02\x02\x02\u2864\u284B\x03\x02" + + "\x02\x02\u2864\u284C\x03\x02\x02\x02\u2864\u284D\x03\x02\x02\x02\u2864" + + "\u284E\x03\x02\x02\x02\u2864\u284F\x03\x02\x02\x02\u2864\u2850\x03\x02" + + "\x02\x02\u2864\u2851\x03\x02\x02\x02\u2864\u2852\x03\x02\x02\x02\u2864" + + "\u2853\x03\x02\x02\x02\u2864\u2854\x03\x02\x02\x02\u2864\u2855\x03\x02" + + "\x02\x02\u2864\u2856\x03\x02\x02\x02\u2864\u2857\x03\x02\x02\x02\u2864" + + "\u2858\x03\x02\x02\x02\u2864\u2859\x03\x02\x02\x02\u2864\u285A\x03\x02" + + "\x02\x02\u2864\u285B\x03\x02\x02\x02\u2864\u285C\x03\x02\x02\x02\u2864" + + "\u285D\x03\x02\x02\x02\u2864\u285E\x03\x02\x02\x02\u2864\u285F\x03\x02" + + "\x02\x02\u2864\u2860\x03\x02\x02\x02\u2864\u2861\x03\x02\x02\x02\u2864" + + "\u2862\x03\x02\x02\x02\u2864\u2863\x03\x02\x02\x02\u2865\u0579\x03\x02" + + "\x02\x02\u2866\u2867\tF\x02\x02\u2867\u057B\x03\x02\x02\x02\u2868\u2869" + + "\tG\x02\x02\u2869\u057D\x03\x02\x02\x02\u286A\u286B\x05\u0580\u02C1\x02" + + "\u286B\u286C\x05\u058A\u02C6\x02\u286C\u286D\x05\u0588\u02C5\x02\u286D" + + "\u057F\x03\x02\x02\x02\u286E\u2870\x05\u0582\u02C2\x02\u286F\u286E\x03" + + "\x02\x02\x02\u2870\u2873\x03\x02\x02\x02\u2871\u286F\x03\x02\x02\x02\u2871" + + "\u2872\x03\x02\x02\x02\u2872\u0581\x03\x02\x02\x02\u2873\u2871\x03\x02" + + "\x02\x02\u2874\u2875\x05\u0584\u02C3\x02\u2875\u2876\x07\u0119\x02\x02" + + "\u2876\u2877\x07\u01EC\x02\x02\u2877\u2889\x03\x02\x02\x02\u2878\u2879" + + "\x05\u0584\u02C3\x02\u2879\u287A\x07\u01ED\x02\x02\u287A\u287B\x05\u0586" + + "\u02C4\x02\u287B\u2889\x03\x02\x02\x02\u287C\u287D\x05\u0584\u02C3\x02" + + "\u287D\u287E\x07\u01EE\x02\x02\u287E\u287F\x07\u01EF\x02\x02\u287F\u2889" + + "\x03\x02\x02\x02\u2880\u2881\x05\u0584\u02C3\x02\u2881\u2882\x07\u01EE" + + "\x02\x02\u2882\u2883\x07\u01F0\x02\x02\u2883\u2889\x03\x02\x02\x02\u2884" + + "\u2885\x05\u0584\u02C3\x02\u2885\u2886\x07\u01EE\x02\x02\u2886\u2887\x07" + + "\u01F1\x02\x02\u2887\u2889\x03\x02\x02\x02\u2888\u2874\x03\x02\x02\x02" + + "\u2888\u2878\x03\x02\x02\x02\u2888\u287C\x03\x02\x02\x02\u2888\u2880\x03" + + "\x02\x02\x02\u2888\u2884\x03\x02\x02\x02\u2889\u0583\x03\x02\x02\x02\u288A" + + "\u288B\x07\x1F\x02\x02\u288B\u0585\x03\x02\x02\x02\u288C\u2891\x05\u0552" + + "\u02AA\x02\u288D\u2891\x05\u057C\u02BF\x02\u288E\u2891\x05\u0652\u032A" + + "\x02\u288F\u2891\x05\u0576\u02BC\x02\u2890\u288C\x03\x02\x02\x02\u2890" + + "\u288D\x03\x02\x02\x02\u2890\u288E\x03\x02\x02\x02\u2890\u288F\x03\x02" + + "\x02\x02\u2891\u0587\x03\x02\x02\x02\u2892\u2895\x03\x02\x02\x02\u2893" + + "\u2895\x07\t\x02\x02\u2894\u2892\x03\x02\x02\x02\u2894\u2893\x03\x02\x02" + + "\x02\u2895\u0589\x03\x02\x02\x02\u2896\u2897\x05\u058C\u02C7\x02\u2897" + + "\u2898\x07\x94\x02\x02\u2898\u2899\x05\u05B6\u02DC\x02\u2899\u289A\x05" + + "\u063E\u0320\x02\u289A\u289B\x07\u01C8\x02\x02\u289B\u289C\x05\u064C\u0327" + + "\x02\u289C\u058B\x03\x02\x02\x02\u289D\u28A2\x05\u0648\u0325\x02\u289E" + + "\u28A0\x05\u058E\u02C8\x02\u289F\u28A1\x05\u0590\u02C9\x02\u28A0\u289F" + + "\x03\x02\x02\x02\u28A0\u28A1\x03\x02\x02\x02\u28A1\u28A3\x03\x02\x02\x02" + + "\u28A2\u289E\x03\x02\x02\x02\u28A2\u28A3\x03\x02\x02\x02\u28A3\u058D\x03" + + "\x02\x02\x02\u28A4\u28A5\x07\xB4\x02\x02\u28A5\u058F\x03\x02\x02\x02\u28A6" + + "\u28A8\x05\u0594\u02CB\x02\u28A7\u28A6\x03\x02\x02\x02\u28A8\u28A9\x03" + + "\x02\x02\x02\u28A9\u28A7\x03\x02\x02\x02\u28A9\u28AA\x03\x02\x02\x02\u28AA" + + "\u0591\x03\x02\x02\x02\u28AB\u28AC\x07\x14\x02\x02\u28AC\u28AD\x05\u0650" + + "\u0329\x02\u28AD\u28AE\x07\x15\x02\x02\u28AE\u0593\x03\x02\x02\x02\u28AF" + + "\u28B3\x05\u0596\u02CC\x02\u28B0\u28B3\x07\xB4\x02\x02\u28B1\u28B3\x05" + + "\u0592\u02CA\x02\u28B2\u28AF\x03\x02\x02\x02\u28B2\u28B0\x03\x02\x02\x02" + + "\u28B2\u28B1\x03\x02\x02\x02\u28B3\u0595\x03\x02\x02\x02\u28B4\u28C4\x05" + + "\u05A6\u02D4\x02\u28B5\u28B6\x07\u01F2\x02\x02\u28B6\u28B7\x07@\x02\x02" + + "\u28B7\u28C5\x05\u05A4\u02D3\x02\u28B8\u28B9\x05\u05A8\u02D5\x02\u28B9" + + "\u28BA\x05\u05AA\u02D6\x02\u28BA\u28BB\x05\u05AC\u02D7\x02\u28BB\u28BC" + + "\x05\u05AE\u02D8\x02\u28BC\u28BD\x05\u05B0\u02D9\x02\u28BD\u28C5\x03\x02" + + "\x02\x02\u28BE\u28BF\x05\u0598\u02CD\x02\u28BF\u28C0\x07\xAE\x02\x02\u28C0" + + "\u28C1\x05\u059C\u02CF\x02\u28C1\u28C2\x05\u05A2\u02D2\x02\u28C2\u28C3" + + "\x05\u059A\u02CE\x02\u28C3\u28C5\x03\x02\x02\x02\u28C4\u28B5\x03\x02\x02" + + "\x02\u28C4\u28B8\x03\x02\x02\x02\u28C4\u28BE\x03\x02\x02\x02\u28C5\u28C6" + + "\x03\x02\x02\x02\u28C6\u28C7\x07\t\x02\x02\u28C7\u0597\x03\x02\x02\x02" + + "\u28C8\u28CD\x03\x02\x02\x02\u28C9\u28CA\x07\u010F\x02\x02\u28CA\u28CD" + + "\x07\u0146\x02\x02\u28CB\u28CD\x07\u0146\x02\x02\u28CC\u28C8\x03\x02\x02" + + "\x02\u28CC\u28C9\x03\x02\x02\x02\u28CC\u28CB\x03\x02\x02\x02\u28CD\u0599" + + "\x03\x02\x02\x02\u28CE\u28CF\x05\u03C6\u01E4\x02\u28CF\u059B\x03\x02\x02" + + "\x02\u28D0\u28D6\x03\x02\x02\x02\u28D1\u28D2\x07\x04\x02\x02\u28D2\u28D3" + + "\x05\u059E\u02D0\x02\u28D3\u28D4\x07\x05\x02\x02\u28D4\u28D6\x03\x02\x02" + + "\x02\u28D5\u28D0\x03\x02\x02\x02\u28D5\u28D1\x03\x02\x02\x02\u28D6\u059D" + + "\x03\x02\x02\x02\u28D7\u28DC\x05\u05A0\u02D1\x02\u28D8\u28D9\x07\b\x02" + + "\x02\u28D9\u28DB\x05\u05A0\u02D1\x02\u28DA\u28D8\x03\x02\x02\x02\u28DB" + + "\u28DE\x03\x02\x02\x02\u28DC\u28DA\x03\x02\x02\x02\u28DC\u28DD\x03\x02" + + "\x02\x02\u28DD\u059F\x03\x02\x02\x02\u28DE\u28DC\x03\x02\x02\x02\u28DF" + + "\u28E0\x05\u05A6\u02D4\x02\u28E0\u28E1\x05\u05AA\u02D6\x02\u28E1\u05A1" + + "\x03\x02\x02\x02\u28E2\u28E3\tH\x02\x02\u28E3\u05A3\x03\x02\x02\x02\u28E4" + + "\u28E7\x07\x1E\x02\x02\u28E5\u28E7\x05\u0562\u02B2\x02\u28E6\u28E4\x03" + + "\x02\x02\x02\u28E6\u28E5\x03\x02\x02\x02\u28E7\u05A5\x03\x02\x02\x02\u28E8" + + "\u28E9\x05\u0650\u0329\x02\u28E9\u05A7\x03\x02\x02\x02\u28EA\u28ED\x03" + + "\x02\x02\x02\u28EB\u28ED\x07\u01F3\x02\x02\u28EC\u28EA\x03\x02\x02\x02" + + "\u28EC\u28EB\x03\x02\x02\x02\u28ED\u05A9\x03\x02\x02\x02\u28EE\u28EF\x05" + + "\u0462\u0232\x02\u28EF\u05AB\x03\x02\x02\x02\u28F0\u28F4\x03\x02\x02\x02" + + "\u28F1\u28F2\x07-\x02\x02\u28F2\u28F4\x05\u0214\u010B\x02\u28F3\u28F0" + + "\x03\x02\x02\x02\u28F3\u28F1\x03\x02\x02\x02\u28F4\u05AD\x03\x02\x02\x02" + + "\u28F5\u28F9\x03\x02\x02\x02\u28F6\u28F7\x07O\x02\x02\u28F7\u28F9\x07" + + "P\x02\x02\u28F8\u28F5\x03\x02\x02\x02\u28F8\u28F6\x03\x02\x02\x02\u28F9" + + "\u05AF\x03\x02\x02\x02\u28FA\u28FF\x03\x02\x02\x02\u28FB\u28FC\x05\u05B2" + + "\u02DA\x02\u28FC\u28FD\x05\u0654\u032B\x02\u28FD\u28FF\x03\x02\x02\x02" + + "\u28FE\u28FA\x03\x02\x02\x02\u28FE\u28FB\x03\x02\x02\x02\u28FF\u05B1\x03" + + "\x02\x02\x02\u2900\u2903\x05\u05B4\u02DB\x02\u2901\u2903\x077\x02\x02" + + "\u2902\u2900\x03\x02\x02\x02\u2902\u2901\x03\x02\x02\x02\u2903\u05B3\x03" + + "\x02\x02\x02\u2904\u2905\tI\x02\x02\u2905\u05B5\x03\x02\x02\x02\u2906" + + "\u2908\x05\u05B8\u02DD\x02\u2907\u2906\x03\x02\x02\x02\u2908\u290B\x03" + + "\x02\x02\x02\u2909\u2907\x03\x02\x02\x02\u2909\u290A\x03\x02\x02\x02\u290A" + + "\u05B7\x03\x02\x02\x02\u290B\u2909\x03\x02\x02\x02\u290C\u290D\x05\u058A" + + "\u02C6\x02\u290D\u290E\x07\t\x02\x02\u290E\u2928\x03"; private static readonly _serializedATNSegment19: string = - "\x02\x02\x02\u292E\u292F\x05\u0630\u0319\x02\u292F\u2930\x07\u01F0\x02" + - "\x02\u2930\u2931\x05\u0642\u0322\x02\u2931\u2932\x05\u05F4\u02FB\x02\u2932" + - "\u05C9\x03\x02\x02\x02\u2933\u2934\x05\u0630\u0319\x02\u2934\u2935\x07" + - "@\x02\x02\u2935\u2936\x05\u05CC\u02E7\x02\u2936\u2937\x05\u05F4\u02FB" + - "\x02\u2937\u05CB\x03\x02\x02\x02\u2938\u2939\x05\u05D6\u02EC\x02\u2939" + - "\u2949\x07F\x02\x02\u293A\u293B\x05\u03B2\u01DA\x02\u293B\u293C\x05\u05D0" + - "\u02E9\x02\u293C\u294A\x03\x02\x02\x02\u293D\u294A\x05\u03B8\u01DD\x02" + - "\u293E\u294A\x05\u036E\u01B8\x02\u293F\u2940\x07\xCC\x02\x02\u2940\u2941" + - "\x05\u0480\u0241\x02\u2941\u2942\x05\u05CE\u02E8\x02\u2942\u294A\x03\x02" + - "\x02\x02\u2943\u2944\x05\u05D2\u02EA\x02\u2944\u2945\x05\u0480\u0241\x02" + - "\u2945\u2946\x07\x1A\x02\x02\u2946\u2947\x05\u0480\u0241\x02\u2947\u2948" + - "\x05\u05D4\u02EB\x02\u2948\u294A\x03\x02\x02\x02\u2949\u293A\x03\x02\x02" + - "\x02\u2949\u293D\x03\x02\x02\x02\u2949\u293E\x03\x02\x02\x02\u2949\u293F" + - "\x03\x02\x02\x02\u2949\u2943\x03\x02\x02\x02\u294A\u05CD\x03\x02\x02\x02" + - "\u294B\u294F\x03\x02\x02\x02\u294C\u294D\x07f\x02\x02\u294D\u294F\x05" + - "\u04F4\u027B\x02\u294E\u294B\x03\x02\x02\x02\u294E\u294C\x03\x02\x02\x02" + - "\u294F\u05CF\x03\x02\x02\x02\u2950\u295D\x03\x02\x02\x02\u2951\u2952\x07" + - "\x04\x02\x02\u2952\u2957\x05\u0480\u0241\x02\u2953\u2954\x07\b\x02\x02" + - "\u2954\u2956\x05\u0480\u0241\x02\u2955\u2953\x03\x02\x02\x02\u2956\u2959" + - "\x03\x02\x02\x02\u2957\u2955\x03\x02\x02\x02\u2957\u2958\x03\x02\x02\x02" + - "\u2958\u295A\x03\x02\x02\x02\u2959\u2957\x03\x02\x02\x02\u295A\u295B\x07" + - "\x05\x02\x02\u295B\u295D\x03\x02\x02\x02\u295C\u2950\x03\x02\x02\x02\u295C" + - "\u2951\x03\x02\x02\x02\u295D\u05D1\x03\x02\x02\x02\u295E\u2961\x03\x02" + - "\x02\x02\u295F\u2961\x07\u01F1\x02\x02\u2960\u295E\x03\x02\x02\x02\u2960" + - "\u295F\x03\x02\x02\x02\u2961\u05D3\x03\x02\x02\x02\u2962\u2966\x03\x02" + - "\x02\x02\u2963\u2964\x07\x95\x02\x02\u2964\u2966\x05\u0480\u0241\x02\u2965" + - "\u2962\x03\x02\x02\x02\u2965\u2963\x03\x02\x02\x02\u2966\u05D5\x03\x02" + - "\x02\x02\u2967\u2968\x05\u020A\u0106\x02\u2968\u05D7\x03\x02\x02\x02\u2969" + - "\u296A\x05\u0630\u0319\x02\u296A\u296B\x07\u01F2\x02\x02\u296B\u296C\x05" + - "\u05D6\u02EC\x02\u296C\u296D\x05\u05DA\u02EE\x02\u296D\u296E\x07F\x02" + - "\x02\u296E\u296F\x07%\x02\x02\u296F\u2970\x05\u0480\u0241\x02\u2970\u2971" + - "\x05\u05F4\u02FB\x02\u2971\u05D9\x03\x02\x02\x02\u2972\u2976\x03\x02\x02" + - "\x02\u2973\u2974\x07\u01F3\x02\x02\u2974\u2976\x05\u0540\u02A1\x02\u2975" + - "\u2972\x03\x02\x02\x02\u2975\u2973\x03\x02\x02\x02\u2976\u05DB\x03\x02" + - "\x02\x02\u2977\u2978\x05\u05DE\u02F0\x02\u2978\u297A\x05\u0632\u031A\x02" + - "\u2979\u297B\x05\u0634\u031B\x02\u297A\u2979\x03\x02\x02\x02\u297A\u297B" + - "\x03\x02\x02\x02\u297B\u297C\x03\x02\x02\x02\u297C\u297D\x07\t\x02\x02" + - "\u297D\u05DD\x03\x02\x02\x02\u297E\u297F\tD\x02\x02\u297F\u05DF\x03\x02" + - "\x02\x02\u2980\u298C\x07\u01F5\x02\x02\u2981\u2982\x07\u0105\x02\x02\u2982" + - "\u298D\x05\u063A\u031E\x02\u2983\u2989\x07\u01F6\x02\x02\u2984\u2985\x07" + - "\xCC\x02\x02\u2985\u2986\x05\u0480\u0241\x02\u2986\u2987\x05\u05CE\u02E8" + - "\x02\u2987\u298A\x03\x02\x02\x02\u2988\u298A\x05\u03B8\u01DD\x02\u2989" + - "\u2984\x03\x02\x02\x02\u2989\u2988\x03\x02\x02\x02\u298A\u298D\x03\x02" + - "\x02\x02\u298B\u298D\x05\u05E2\u02F2\x02\u298C\u2981\x03\x02\x02\x02\u298C" + - "\u2983\x03\x02\x02\x02\u298C\u298B\x03\x02\x02\x02\u298D\u298E\x03\x02" + - "\x02\x02\u298E\u298F\x07\t\x02\x02\u298F\u05E1\x03\x02\x02\x02\u2990\u2993" + - "\x03\x02\x02\x02\u2991\u2993\x05\u063A\u031E\x02\u2992\u2990\x03\x02\x02" + - "\x02\u2992\u2991\x03\x02\x02\x02\u2993\u05E3\x03\x02\x02\x02\u2994\u2996" + - "\x07\u01F7\x02\x02\u2995\u2997\x05\u05E6\u02F4\x02\u2996\u2995\x03\x02" + - "\x02\x02\u2996\u2997\x03\x02\x02\x02\u2997\u2998\x03\x02\x02\x02\u2998" + - "\u2999\x05\u0542\u02A2\x02\u2999\u299A\x05\u05E8\u02F5\x02\u299A\u299B" + - "\x05\u05EA\u02F6\x02\u299B\u299C\x07\t\x02\x02\u299C\u29B7\x03\x02\x02" + - "\x02\u299D\u299F\x07\u01F7\x02\x02\u299E\u29A0\x05\u05E6\u02F4\x02\u299F" + - "\u299E\x03\x02\x02\x02\u299F\u29A0\x03\x02\x02\x02\u29A0\u29A1\x03\x02" + - "\x02\x02\u29A1\u29A2\x05\u0558\u02AD\x02\u29A2\u29A3\x05\u05EA\u02F6\x02" + - "\u29A3\u29A4\x07\t\x02\x02\u29A4\u29B7\x03\x02\x02\x02\u29A5\u29A7\x07" + - "\u01F7\x02\x02\u29A6\u29A8\x05\u05E6\u02F4\x02\u29A7\u29A6\x03\x02\x02" + - "\x02\u29A7\u29A8\x03\x02\x02\x02\u29A8\u29A9\x03\x02\x02\x02\u29A9\u29AA" + - "\x07\u01F8\x02\x02\u29AA\u29AB\x05\u0542\u02A2\x02\u29AB\u29AC\x05\u05EA" + - "\u02F6\x02\u29AC\u29AD\x07\t\x02\x02\u29AD\u29B7\x03\x02\x02\x02\u29AE" + - "\u29B0\x07\u01F7\x02\x02\u29AF\u29B1\x05\u05E6\u02F4\x02\u29B0\u29AF\x03" + - "\x02\x02\x02\u29B0\u29B1\x03\x02\x02\x02\u29B1\u29B2\x03\x02\x02\x02\u29B2" + - "\u29B3\x05\u05EA\u02F6\x02\u29B3\u29B4\x07\t\x02\x02\u29B4\u29B7\x03\x02" + - "\x02\x02\u29B5\u29B7\x07\u01F7\x02\x02\u29B6\u2994\x03\x02\x02\x02\u29B6" + - "\u299D\x03\x02\x02\x02\u29B6\u29A5\x03\x02\x02\x02\u29B6\u29AE\x03\x02" + - "\x02\x02\u29B6\u29B5\x03\x02\x02\x02\u29B7\u05E5\x03\x02\x02\x02\u29B8" + - "\u29B9\tE\x02\x02\u29B9\u05E7\x03\x02\x02\x02\u29BA\u29C2\x03\x02\x02" + - "\x02\u29BB\u29BC\x07\b\x02\x02\u29BC\u29BE\x05\u0480\u0241\x02\u29BD\u29BB" + - "\x03\x02\x02\x02\u29BE\u29BF\x03\x02\x02\x02\u29BF\u29BD\x03\x02\x02\x02" + - "\u29BF\u29C0\x03\x02\x02\x02\u29C0\u29C2\x03\x02\x02\x02\u29C1\u29BA\x03" + - "\x02\x02\x02\u29C1\u29BD\x03\x02\x02\x02\u29C2\u05E9\x03\x02\x02\x02\u29C3" + - "\u29C7\x03\x02\x02\x02\u29C4\u29C5\x07f\x02\x02\u29C5\u29C7\x05\u05EE" + - "\u02F8\x02\u29C6\u29C3\x03\x02\x02\x02\u29C6\u29C4\x03\x02\x02\x02\u29C7" + - "\u05EB\x03\x02\x02\x02\u29C8\u29C9\x05\u0558\u02AD\x02\u29C9\u29CA\x07" + - "\f\x02\x02\u29CA\u29CB\x05\u0480\u0241\x02\u29CB\u05ED\x03\x02\x02\x02" + - "\u29CC\u29D1\x05\u05EC\u02F7\x02\u29CD\u29CE\x07\b\x02\x02\u29CE\u29D0" + - "\x05\u05EC\u02F7\x02\u29CF\u29CD\x03\x02\x02\x02\u29D0\u29D3\x03\x02\x02" + - "\x02\u29D1\u29CF\x03\x02\x02\x02\u29D1\u29D2\x03\x02\x02\x02\u29D2\u05EF" + - "\x03\x02\x02\x02\u29D3\u29D1\x03\x02\x02\x02\u29D4\u29D5\x07\u01FF\x02" + - "\x02\u29D5\u29D6\x05\u063A\u031E\x02\u29D6\u29D7\x05\u05F2\u02FA\x02\u29D7" + - "\u29D8\x07\t\x02\x02\u29D8\u05F1\x03\x02\x02\x02\u29D9\u29DD\x03\x02\x02" + - "\x02\u29DA\u29DB\x07\b\x02\x02\u29DB\u29DD\x05\u063A\u031E\x02\u29DC\u29D9" + - "\x03\x02\x02\x02\u29DC\u29DA\x03\x02\x02\x02\u29DD\u05F3\x03\x02\x02\x02" + - "\u29DE\u29DF\x07\u0200\x02\x02\u29DF\u29E0\x05\u059C\u02CF\x02\u29E0\u29E1" + - "\x07\u01BF\x02\x02\u29E1\u29E2\x07\u0200\x02\x02\u29E2\u29E3\x05\u0632" + - "\u031A\x02\u29E3\u29E4\x07\t\x02\x02\u29E4\u05F5\x03\x02\x02\x02\u29E5" + - "\u29E6\x05\u0644\u0323\x02\u29E6\u29E7\x07\t\x02\x02\u29E7\u05F7\x03\x02" + - "\x02\x02\u29E8\u29E9\x07\xCC\x02\x02\u29E9\u29F1\x05\u0480\u0241\x02\u29EA" + - "\u29EB\x05\u05FE\u0300\x02\u29EB\u29EC\x05\u05FA\u02FE\x02\u29EC\u29F2" + - "\x03\x02\x02\x02\u29ED\u29EE\x05\u05FA\u02FE\x02\u29EE\u29EF\x05\u05FE" + - "\u0300\x02\u29EF\u29F2\x03\x02\x02\x02\u29F0\u29F2\x03\x02\x02\x02\u29F1" + - "\u29EA\x03\x02\x02\x02\u29F1\u29ED\x03\x02\x02\x02\u29F1\u29F0\x03\x02" + - "\x02\x02\u29F2\u29F3\x03\x02\x02\x02\u29F3\u29F4\x07\t\x02\x02\u29F4\u05F9" + - "\x03\x02\x02\x02\u29F5\u29F9\x03\x02\x02\x02\u29F6\u29F7\x07f\x02\x02" + - "\u29F7\u29F9\x05\u05FC\u02FF\x02\u29F8\u29F5\x03\x02\x02\x02\u29F8\u29F6" + - "\x03\x02\x02\x02\u29F9\u05FB\x03\x02\x02\x02\u29FA\u29FF\x05\u0480\u0241" + - "\x02\u29FB\u29FC\x07\b\x02\x02\u29FC\u29FE\x05\u0480\u0241\x02\u29FD\u29FB" + - "\x03\x02\x02\x02\u29FE\u2A01\x03\x02\x02\x02\u29FF\u29FD\x03\x02\x02\x02" + - "\u29FF\u2A00\x03\x02\x02\x02\u2A00\u05FD\x03\x02\x02\x02\u2A01\u29FF\x03" + - "\x02\x02\x02\u2A02\u2A09\x03\x02\x02\x02\u2A03\u2A05\x07I\x02\x02\u2A04" + - "\u2A06\x07\u0153\x02\x02\u2A05\u2A04\x03\x02\x02\x02\u2A05\u2A06\x03\x02" + - "\x02\x02\u2A06\u2A07\x03\x02\x02\x02\u2A07\u2A09\x05\u060E\u0308\x02\u2A08" + - "\u2A02\x03\x02\x02\x02\u2A08\u2A03\x03\x02\x02\x02\u2A09\u05FF\x03\x02" + - "\x02\x02\u2A0A\u2A1C\x07\u0201\x02\x02\u2A0B\u2A0C\x05\u0622\u0312\x02" + - "\u2A0C\u2A0D\x05\u0608\u0305\x02\u2A0D\u2A13\x07@\x02\x02\u2A0E\u2A14" + - "\x05\u03B8\u01DD\x02\u2A0F\u2A10\x07\xCC\x02\x02\u2A10\u2A11\x05\u063A" + - "\u031E\x02\u2A11\u2A12\x05\u0606\u0304\x02\u2A12\u2A14\x03\x02\x02\x02" + - "\u2A13\u2A0E\x03\x02\x02\x02\u2A13\u2A0F\x03\x02\x02\x02\u2A14\u2A1D\x03" + - "\x02\x02\x02\u2A15\u2A1A\x05\u0550\u02A9\x02\u2A16\u2A17\x07\x04\x02\x02" + - "\u2A17\u2A18\x05\u0604\u0303\x02\u2A18\u2A19\x07\x05\x02\x02\u2A19\u2A1B" + - "\x03\x02\x02\x02\u2A1A\u2A16\x03\x02\x02\x02\u2A1A\u2A1B\x03\x02\x02\x02" + - "\u2A1B\u2A1D\x03\x02\x02\x02\u2A1C\u2A0B\x03\x02\x02\x02\u2A1C\u2A15\x03" + - "\x02\x02\x02\u2A1D\u2A1E\x03\x02\x02\x02\u2A1E\u2A1F\x07\t\x02\x02\u2A1F" + - "\u0601\x03\x02\x02\x02\u2A20\u2A21\x05\u0550\u02A9\x02\u2A21\u2A22\x07" + - "\x16\x02\x02\u2A22\u2A23\x05\u0480\u0241\x02\u2A23\u2A26\x03\x02\x02\x02" + - "\u2A24\u2A26\x05\u0480\u0241\x02\u2A25\u2A20\x03\x02\x02\x02\u2A25\u2A24" + - "\x03\x02\x02\x02\u2A26\u0603\x03\x02\x02\x02\u2A27\u2A2C\x05\u0602\u0302" + - "\x02\u2A28\u2A29\x07\b\x02\x02\u2A29\u2A2B\x05\u0602\u0302\x02\u2A2A\u2A28" + - "\x03\x02\x02\x02\u2A2B\u2A2E\x03\x02\x02\x02\u2A2C\u2A2A\x03\x02\x02\x02" + - "\u2A2C\u2A2D\x03\x02\x02\x02\u2A2D\u0605\x03\x02\x02\x02\u2A2E\u2A2C\x03" + - "\x02\x02\x02\u2A2F\u2A33\x03\x02\x02\x02\u2A30\u2A31\x07f\x02\x02\u2A31" + - "\u2A33\x05\u04F4\u027B\x02\u2A32\u2A2F\x03\x02\x02\x02\u2A32\u2A30\x03" + - "\x02\x02\x02\u2A33\u0607\x03\x02\x02\x02\u2A34\u2A39\x03\x02\x02\x02\u2A35" + - "\u2A36\x05\u060A\u0306\x02\u2A36\u2A37\x07\u013D\x02\x02\u2A37\u2A39\x03" + - "\x02\x02\x02\u2A38\u2A34\x03\x02\x02\x02\u2A38\u2A35\x03\x02\x02\x02\u2A39" + - "\u0609\x03\x02\x02\x02\u2A3A\u2A3D\x03\x02\x02\x02\u2A3B\u2A3D\x07\u0106" + - "\x02\x02\u2A3C\u2A3A\x03\x02\x02\x02\u2A3C\u2A3B\x03\x02\x02\x02\u2A3D" + - "\u060B\x03\x02\x02\x02\u2A3E\u2A40\x07?\x02\x02\u2A3F\u2A41\x05\u0612" + - "\u030A\x02\u2A40\u2A3F\x03\x02\x02\x02\u2A40\u2A41\x03\x02\x02\x02\u2A41" + - "\u2A42\x03\x02\x02\x02\u2A42\u2A43\x05\u0610\u0309\x02\u2A43\u2A44\x05" + - "\u0622\u0312\x02\u2A44\u2A45\x07I\x02\x02\u2A45\u2A46\x05\u060E\u0308" + - "\x02\u2A46\u2A47\x07\t\x02\x02\u2A47\u060D\x03\x02\x02\x02\u2A48\u2A49" + - "\x05\u04F4\u027B\x02\u2A49\u060F\x03\x02\x02\x02\u2A4A\u2A4E\x03\x02\x02" + - "\x02\u2A4B\u2A4E\x07B\x02\x02\u2A4C\u2A4E\x07F\x02\x02\u2A4D\u2A4A\x03" + - "\x02\x02\x02\u2A4D\u2A4B\x03\x02\x02\x02\u2A4D\u2A4C\x03\x02\x02\x02\u2A4E" + - "\u0611\x03\x02\x02\x02\u2A4F\u2A5F\x07\u0105\x02\x02\u2A50\u2A5F\x07\u011E" + - "\x02\x02\u2A51\u2A5F\x07\xD1\x02\x02\u2A52\u2A5F\x07\xF2\x02\x02\u2A53" + - "\u2A54\x07\x84\x02\x02\u2A54\u2A5F\x05\u0480\u0241\x02\u2A55\u2A56\x07" + - "\u012C\x02\x02\u2A56\u2A5F\x05\u0480\u0241\x02\u2A57\u2A5F\x05\u0480\u0241" + - "\x02\u2A58\u2A5F\x07 \x02\x02\u2A59\u2A5C\tF\x02\x02\u2A5A\u2A5D\x05\u0480" + - "\u0241\x02\u2A5B\u2A5D\x07 \x02\x02\u2A5C\u2A5A\x03\x02\x02\x02\u2A5C" + - "\u2A5B\x03\x02\x02\x02\u2A5C\u2A5D\x03\x02\x02\x02\u2A5D\u2A5F\x03\x02" + - "\x02\x02\u2A5E\u2A4F\x03\x02\x02\x02\u2A5E\u2A50\x03\x02\x02\x02\u2A5E" + - "\u2A51\x03\x02\x02\x02\u2A5E\u2A52\x03\x02\x02\x02\u2A5E\u2A53\x03\x02" + - "\x02\x02\u2A5E\u2A55\x03\x02\x02\x02\u2A5E\u2A57\x03\x02\x02\x02\u2A5E" + - "\u2A58\x03\x02\x02\x02\u2A5E\u2A59\x03\x02\x02\x02\u2A5F\u0613\x03\x02" + - "\x02\x02\u2A60\u2A62\x07\u0102\x02\x02\u2A61\u2A63\x05\u0612\u030A\x02" + - "\u2A62\u2A61\x03\x02\x02\x02\u2A62\u2A63\x03\x02\x02\x02\u2A63\u2A64\x03" + - "\x02\x02\x02\u2A64\u2A65\x05\u0622\u0312\x02\u2A65\u2A66\x07\t\x02\x02" + - "\u2A66\u0615\x03\x02\x02\x02\u2A67\u2A68\x07\x9F\x02\x02\u2A68\u2A69\x05" + - "\u0622\u0312\x02\u2A69\u2A6A\x07\t\x02\x02\u2A6A\u0617\x03\x02\x02\x02" + - "\u2A6B\u2A6C\x07P\x02\x02\u2A6C\u2A6D\x07\t\x02\x02\u2A6D\u0619\x03\x02" + - "\x02\x02\u2A6E\u2A70\x07\xA3\x02\x02\u2A6F\u2A71\x05\u061E\u0310\x02\u2A70" + - "\u2A6F\x03\x02\x02\x02\u2A70\u2A71\x03\x02\x02\x02\u2A71\u2A72\x03\x02" + - "\x02\x02\u2A72\u2A73\x07\t\x02\x02\u2A73\u061B\x03\x02\x02\x02\u2A74\u2A76" + - "\x07\u0138\x02\x02\u2A75\u2A77\x05\u061E\u0310\x02\u2A76\u2A75\x03\x02" + - "\x02\x02\u2A76\u2A77\x03\x02\x02\x02\u2A77\u2A78\x03\x02\x02\x02\u2A78" + - "\u2A79\x07\t\x02\x02\u2A79\u061D\x03\x02\x02\x02\u2A7A\u2A7C\x07#\x02" + - "\x02\u2A7B\u2A7D\x07\u0106\x02\x02\u2A7C\u2A7B\x03\x02\x02\x02\u2A7C\u2A7D" + - "\x03\x02\x02\x02\u2A7D\u2A7E\x03\x02\x02\x02\u2A7E\u2A7F\x07\x9B\x02\x02" + - "\u2A7F\u061F\x03\x02\x02\x02\u2A80\u2A81\x07\u0146\x02\x02\u2A81\u2A82" + - "\x05\u020C\u0107\x02\u2A82\u2A83\x07`\x02\x02\u2A83\u2A84\x077\x02\x02" + - "\u2A84\u2A85\x07\t\x02\x02\u2A85\u2A8D\x03\x02\x02\x02\u2A86\u2A89\x07" + - "\u0132\x02\x02\u2A87\u2A8A\x05\u020C\u0107\x02\u2A88\u2A8A\x07 \x02\x02" + - "\u2A89\u2A87\x03\x02\x02\x02\u2A89\u2A88\x03\x02\x02\x02\u2A8A\u2A8B\x03" + - "\x02\x02\x02\u2A8B\u2A8D\x07\t\x02\x02\u2A8C\u2A80\x03\x02\x02\x02\u2A8C" + - "\u2A86\x03\x02\x02\x02\u2A8D\u0621\x03\x02\x02\x02\u2A8E\u2A91\x05\u0550" + - "\u02A9\x02\u2A8F\u2A91\x07\x1E\x02\x02\u2A90\u2A8E\x03\x02\x02\x02\u2A90" + - "\u2A8F\x03\x02\x02\x02\u2A91\u0623\x03\x02\x02\x02\u2A92\u2A96\x03\x02" + - "\x02\x02\u2A93\u2A94\x07\u01FE\x02\x02\u2A94\u2A96\x05\u0626\u0314\x02" + - "\u2A95\u2A92\x03\x02\x02\x02\u2A95\u2A93\x03\x02\x02\x02\u2A96\u0625\x03" + - "\x02\x02\x02\u2A97\u2A99\x05\u0628\u0315\x02\u2A98\u2A97\x03\x02\x02\x02" + - "\u2A99\u2A9A\x03\x02\x02\x02\u2A9A\u2A98\x03\x02\x02\x02\u2A9A\u2A9B\x03" + - "\x02\x02\x02\u2A9B\u0627\x03\x02\x02\x02\u2A9C\u2A9D\x07h\x02\x02\u2A9D" + - "\u2A9E\x05\u062A\u0316\x02\u2A9E\u2A9F\x07_\x02\x02\u2A9F\u2AA0\x05\u059C" + - "\u02CF\x02\u2AA0\u0629\x03\x02\x02\x02\u2AA1\u2AA6\x05\u062C\u0317\x02" + - "\u2AA2\u2AA3\x07T\x02\x02\u2AA3\u2AA5\x05\u062C\u0317\x02\u2AA4\u2AA2" + - "\x03\x02\x02\x02\u2AA5\u2AA8\x03\x02\x02\x02\u2AA6\u2AA4\x03\x02\x02\x02" + - "\u2AA6\u2AA7\x03\x02\x02\x02\u2AA7\u062B\x03\x02\x02\x02\u2AA8\u2AA6\x03" + - "\x02\x02\x02\u2AA9\u2AAD\x05\u0636\u031C\x02\u2AAA\u2AAB\x07\u01F8\x02" + - "\x02\u2AAB\u2AAD\x05\u0542\u02A2\x02\u2AAC\u2AA9\x03\x02\x02\x02\u2AAC" + - "\u2AAA\x03\x02\x02\x02\u2AAD\u062D\x03\x02\x02\x02\u2AAE\u2AB1\x03\x02" + - "\x02\x02\u2AAF\u2AB1\x05\u0578\u02BD\x02\u2AB0\u2AAE\x03\x02\x02\x02\u2AB0" + - "\u2AAF\x03\x02\x02\x02\u2AB1\u062F\x03\x02\x02\x02\u2AB2\u2AB5\x03\x02" + - "\x02\x02\u2AB3\u2AB5\x05\u0578\u02BD\x02\u2AB4\u2AB2\x03\x02\x02\x02\u2AB4" + - "\u2AB3\x03\x02\x02\x02\u2AB5\u0631\x03\x02\x02\x02\u2AB6\u2AB9\x03\x02" + - "\x02\x02\u2AB7\u2AB9\x05\u0636\u031C\x02\u2AB8\u2AB6\x03\x02\x02\x02\u2AB8" + - "\u2AB7\x03\x02\x02\x02\u2AB9\u0633\x03\x02\x02\x02\u2ABA\u2ABB\x07h\x02" + - "\x02\u2ABB\u2ABC\x05\u063E\u0320\x02\u2ABC\u0635\x03\x02\x02\x02\u2ABD" + - "\u2AC0\x05\u0550\u02A9\x02\u2ABE\u2AC0\x05\u0638\u031D\x02\u2ABF\u2ABD" + - "\x03\x02\x02\x02\u2ABF\u2ABE\x03\x02\x02\x02\u2AC0\u0637\x03\x02\x02\x02" + - "\u2AC1\u2AC2\tG\x02\x02\u2AC2\u0639\x03\x02\x02\x02\u2AC3\u2AC5\x05\u0524" + - "\u0293\x02\u2AC4\u2AC3\x03\x02\x02\x02\u2AC4\u2AC5\x03\x02\x02\x02\u2AC5" + - "\u2AC7\x03\x02\x02\x02\u2AC6\u2AC8\x05\u03D0\u01E9\x02\u2AC7\u2AC6\x03" + - "\x02\x02\x02\u2AC7\u2AC8\x03\x02\x02\x02\u2AC8\u2ACA\x03\x02\x02\x02\u2AC9" + - "\u2ACB\x05\u0418\u020D\x02\u2ACA\u2AC9\x03\x02\x02\x02\u2ACA\u2ACB\x03" + - "\x02\x02\x02\u2ACB\u2ACD\x03\x02\x02\x02\u2ACC\u2ACE\x05\u043C\u021F\x02" + - "\u2ACD\u2ACC\x03\x02\x02\x02\u2ACD\u2ACE\x03\x02\x02\x02\u2ACE\u2AD0\x03" + - "\x02\x02\x02\u2ACF\u2AD1\x05\u03FA\u01FE\x02\u2AD0\u2ACF\x03\x02\x02\x02" + - "\u2AD0\u2AD1\x03\x02\x02\x02\u2AD1\u2AD3\x03\x02\x02\x02\u2AD2\u2AD4\x05" + - "\u0408\u0205\x02\u2AD3\u2AD2\x03\x02\x02\x02\u2AD3\u2AD4\x03\x02\x02\x02" + - "\u2AD4\u2AD6\x03\x02\x02\x02\u2AD5\u2AD7\x05\u04CC\u0267\x02\u2AD6\u2AD5" + - "\x03\x02\x02\x02\u2AD6\u2AD7\x03\x02\x02\x02\u2AD7\u063B\x03\x02\x02\x02" + - "\u2AD8\u2AD9\x05\u063A\u031E\x02\u2AD9\u063D\x03\x02\x02\x02\u2ADA\u2ADB" + - "\x05\u063A\u031E\x02\u2ADB\u063F\x03\x02\x02\x02\u2ADC\u2ADD\x05\u0480" + - "\u0241\x02\u2ADD\u0641\x03\x02\x02\x02\u2ADE\u2ADF\x05\u0480\u0241\x02" + - "\u2ADF\u0643\x03\x02\x02\x02\u2AE0\u2AE2\x05\b\x05\x02\u2AE1\u2AE3\x05" + - "\u0646\u0324\x02\u2AE2\u2AE1\x03\x02\x02\x02\u2AE2\u2AE3\x03\x02\x02\x02" + - "\u2AE3\u0645\x03\x02\x02\x02\u2AE4\u2AE5\x07I\x02\x02\u2AE5\u2AE6\x05" + - "\u03D2\u01EA\x02\u2AE6\u2AE7\x05\u060E\u0308\x02\u2AE7\u0647\x03\x02\x02" + - "\x02\u042C\u064E\u0652\u06D1\u06D5\u06DE\u06E7\u06ED\u06F3\u0702\u070E" + - "\u0714\u071C\u0724\u0729\u0733\u073B\u074D\u0750\u0755\u075E\u0767\u076B" + - "\u0777\u078B\u0798\u079F\u07A7\u07AC\u07B3\u07B9\u07C0\u07CB\u07CF\u07D3" + - "\u07E0\u07E4\u07E9\u07EE\u07FA\u0803\u0810\u0815\u0820\u0826\u082C\u0831" + - "\u083C\u0842\u0848\u0851\u085B\u086A\u0870\u0877\u087C\u0883\u088E\u08A6" + - "\u08AD\u08B6\u08BF\u08C7\u08D1\u08DA\u08E3\u08EB\u08F3\u08FC\u0905\u0909" + - "\u0910\u0918\u0922\u0928\u092C\u0930\u0934\u0938\u093D\u0940\u0944\u0959" + - "\u095F\u09BE\u09C5\u09D5\u09E3\u09ED\u09EF\u09F4\u09F8\u09FB\u0A01\u0A03" + - "\u0A1F\u0A29\u0A36\u0A3D\u0A43\u0A47\u0A4D\u0A52\u0A55\u0A57\u0A5C\u0A60" + - "\u0A64\u0A68\u0A6C\u0A6F\u0A73\u0A7B\u0A7F\u0A83\u0A8C\u0A93\u0A98\u0A9F" + - "\u0AA4\u0AAB\u0AB0\u0AC2\u0AC7\u0AD3\u0AD8\u0AE1\u0AE8\u0AEF\u0AF5\u0AFA" + - "\u0AFE\u0B01\u0B04\u0B07\u0B0A\u0B0D\u0B12\u0B15\u0B18\u0B1B\u0B1E\u0B21" + - "\u0B27\u0B2B\u0B2E\u0B31\u0B34\u0B37\u0B39\u0B42\u0B4F\u0B57\u0B5D\u0B61" + - "\u0B66\u0B6D\u0B74\u0B7F\u0B86\u0B89\u0B8E\u0B91\u0B98\u0BA1\u0BA8\u0BAD" + - "\u0BB0\u0BB3\u0BB5\u0BBA\u0BC1\u0BCB\u0BD5\u0BE2\u0BE5\u0BE8\u0BEF\u0BF7" + - "\u0BFA\u0BFD\u0C04\u0C08\u0C0E\u0C11\u0C14\u0C17\u0C23\u0C26\u0C29\u0C2D" + - "\u0C3B\u0C4D\u0C58\u0C67\u0C77\u0C8C\u0C91\u0C94\u0C98\u0C9B\u0CA1\u0CA4" + - "\u0CA6\u0CAF\u0CB8\u0CCB\u0CCF\u0CDA\u0CE3\u0CE9\u0CEF\u0CF3\u0CF6\u0CF9" + - "\u0CFC\u0CFF\u0D05\u0D09\u0D10\u0D16\u0D1A\u0D1D\u0D20\u0D23\u0D2B\u0D2F" + - "\u0D33\u0D39\u0D3D\u0D43\u0D51\u0D5A\u0D6B\u0D70\u0D73\u0D75\u0D7F\u0D86" + - "\u0D8B\u0D8E\u0D91\u0D98\u0D9B\u0D9D\u0DA3\u0DAC\u0DB6\u0DBB\u0DC4\u0DCD" + - "\u0DD1\u0DD8\u0DE2\u0DED\u0E5B\u0E63\u0E66\u0E70\u0E75\u0E7F\u0E8A\u0E96" + - "\u0EA3\u0EAD\u0EBA\u0EBD\u0EC4\u0ECD\u0ED0\u0ED7\u0ED9\u0EE1\u0EEB\u0EED" + - "\u0EF5\u0EF9\u0EFE\u0F09\u0F0D\u0F12\u0F1C\u0F22\u0F2F\u0F35\u0F37\u0F3E" + - "\u0F46\u0F4B\u0F5A\u0F67\u0F69\u0F6D\u0F81\u0F92\u0F95\u0F98\u0F9B\u0F9E" + - "\u0FA6\u0FA9\u0FAC\u0FDA\u0FDD\u0FE0\u0FF2\u0FF9\u1002\u1008\u100F\u1019" + - "\u1021\u1026\u1032\u1043\u1049\u1050\u1058\u1066\u1082\u1089\u1097\u10A6" + - "\u10B3\u10BC\u10D5\u10E0\u1123\u112E\u1134\u113C\u1147\u1155\u115E\u1168" + - "\u1174\u1183\u118E\u1196\u11A0\u11A7\u11AA\u11B0\u11B3\u11C2\u11CF\u11EC" + - "\u11F3\u1202\u120B\u1216\u1218\u1221\u122C\u122E\u1235\u1244\u124A\u1252" + - "\u1258\u1260\u126A\u1270\u1278\u127E\u1286\u128D\u1296\u1298\u12B1\u12B8" + - "\u12C3\u12C9\u12D2\u12D7\u12DD\u12E4\u12E9\u12ED\u12F0\u12F6\u138B\u138F" + - "\u1394\u139F\u13AA\u13B5\u13C0\u13CB\u13D6\u13E1\u13ED\u13F8\u1400\u1407" + - "\u140D\u1415\u141A\u141F\u1424\u142A\u1431\u1437\u143D\u1442\u1448\u144F" + - "\u1454\u145A\u1461\u1464\u1471\u147A\u1486\u1488\u1499\u14A0\u14A5\u14A9" + - "\u14AD\u14B1\u14B3\u14EF\u14F6\u14FC\u1507\u150A\u1511\u1514\u151E\u1521" + - "\u1523\u1536\u1542\u154B\u1554\u1560\u1562\u1568\u156C\u156F\u1574\u157A" + - "\u157D\u1580\u1583\u1587\u158B\u1594\u159A\u159D\u15A0\u15A3\u15A5\u15B5" + - "\u15B9\u15BC\u15BF\u15C2\u15C5\u15CA\u15CD\u15CF\u15DC\u15E8\u15F6\u15FA" + - "\u1606\u1608\u1611\u161A\u1622\u162B\u162D\u1631\u163A\u163F\u1645\u164A" + - "\u164E\u1653\u1665\u166A\u1679\u1682\u168D\u1693\u16BA\u16C4\u16CB\u16D6" + - "\u16E4\u16EC\u16F1\u16F9\u1701\u1707\u170F\u1715\u171D\u171F\u1725\u172D" + - "\u172F\u1735\u173D\u173F\u1757\u175E\u1768\u1774\u1779\u1786\u1792\u179E" + - "\u17A0\u17A6\u17AB\u17B3\u17BA\u17E7\u17EC\u17F3\u17F8\u17FF\u1809\u1813" + - "\u1817\u1822\u1833\u187A\u193D\u194A\u1955\u1962\u196E\u197C\u199C\u19AA" + - "\u1A1A\u1A1C\u1A27\u1A32\u1A3D\u1A4A\u1A56\u1A61\u1A68\u1B45\u1B54\u1B5F" + - "\u1B66\u1B9C\u1C29\u1C2F\u1C32\u1C3C\u1C59\u1C63\u1C6A\u1C81\u1C8A\u1C96" + - "\u1C9C\u1CA4\u1CA6\u1CAA\u1CB4\u1CB8\u1CC2\u1CC5\u1CC9\u1CCD\u1CD5\u1CE0" + - "\u1CEC\u1CF0\u1CF3\u1CF7\u1CFA\u1CFF\u1D03\u1D06\u1D0A\u1D0D\u1D11\u1D14" + - "\u1D1F\u1D26\u1D33\u1D41\u1D45\u1D4A\u1D51\u1D58\u1D5B\u1D60\u1D63\u1D6C" + - "\u1D6E\u1D73\u1D77\u1D83\u1D86\u1D8D\u1D91\u1D96\u1DA0\u1DA9\u1DAC\u1DB1" + - "\u1DBC\u1DC0\u1DC6\u1DCD\u1DE1\u1DF6\u1DFA\u1DFF\u1E52\u1E58\u1E65\u1E69" + - "\u1E6D\u1E71\u1E77\u1E7E\u1E81\u1E84\u1E87\u1E8A\u1E91\u1E93\u1E97\u1E9A" + - "\u1EA1\u1EA3\u1EAA\u1EB1\u1EB5\u1EB9\u1EC9\u1ED0\u1EDA\u1EE7\u1EF2\u1EF9" + - "\u1EFE\u1F02\u1F06\u1F0B\u1F18\u1F1D\u1F21\u1F29\u1F2C\u1F30\u1F3B\u1F3E" + - "\u1F40\u1F50\u1F53\u1F5A\u1F5D\u1F62\u1F71\u1F77\u1F80\u1F89\u1F90\u1F93" + - "\u1F99\u1F9E\u1FA4\u1FAA\u1FAD\u1FB0\u1FB7\u1FBB\u1FBE\u1FCD\u1FD0\u1FD7" + - "\u1FDA\u1FE1\u1FE4\u1FE7\u1FEE\u1FFB\u2005\u2017\u2019\u2021\u2025\u202F" + - "\u2033\u2037\u203B\u203D\u2042\u2046\u204A\u204C\u204E\u2052\u2056\u2059" + - "\u205C\u2061\u2064\u2067\u206A\u206D\u2070\u2073\u207C\u207E\u2083\u2087" + - "\u208D\u2091\u2095\u209E\u20A3\u20A7\u20B0\u20B9\u20BD\u20C0\u20C4\u20C9" + - "\u20CF\u20DB\u20EA\u20F1\u20F3\u20F6\u20FA\u20FE\u2100\u2108\u2111\u2117" + - "\u2119\u211B\u2122\u2126\u212F\u2133\u2142\u214A\u2166\u216D\u2171\u2174" + - "\u2179\u217D\u2180\u2190\u219B\u21A0\u21A3\u21A7\u21AB\u21AF\u21B4\u21B8" + - "\u21BC\u21BE\u21C7\u21CC\u21D2\u21D6\u21D8\u21DF\u21E4\u21EA\u21EC\u21F0" + - "\u21F7\u21FE\u2201\u2207\u220B\u2214\u2218\u2220\u2222\u2229\u222E\u2231" + - "\u2239\u2242\u224A\u224C\u2250\u2257\u226A\u2273\u2279\u228C\u2295\u229B" + - "\u229F\u22A4\u22AE\u22B5\u22BE\u22C1\u22CA\u22CC\u22D2\u22D6\u22DB\u22E5" + - "\u22EB\u22ED\u22F3\u22F7\u22FA\u2307\u230D\u2311\u2315\u2318\u2320\u2324" + - "\u2328\u2330\u2337\u233E\u2342\u2348\u234A\u2353\u2356\u2360\u2370\u2376" + - "\u237B\u2382\u238B\u2392\u239A\u23A2\u23A7\u23AB\u23AE\u23B4\u23B9\u23C9" + - "\u23CC\u23CE\u23DA\u23DC\u23E0\u23E8\u23EA\u23EE\u23F0\u23F8\u23FC\u2405" + - "\u240D\u2413\u2416\u241F\u2424\u242B\u2435\u244F\u245A\u245C\u245E\u2466" + - "\u247D\u2485\u248F\u2492\u2497\u249C\u24A0\u24A6\u24A9\u24AC\u24AF\u24B3" + - "\u24C1\u24C8\u24CF\u24D6\u24E8\u24F0\u24FC\u2502\u250F\u2536\u2538\u254C" + - "\u2556\u2561\u256D\u2574\u2580\u258C\u2592\u259A\u25AB\u25C4\u25CE\u25D2" + - "\u25D5\u25D8\u25DB\u25E8\u25ED\u25F2\u25F4\u25FC\u2605\u260E\u2613\u261C" + - "\u2621\u262F\u2639\u2641\u264F\u2656\u265E\u2666\u266D\u2673\u267C\u268B" + - "\u2696\u26B7\u26C0\u26C7\u26CB\u26CF\u26D6\u26E4\u26E9\u26EE\u26F2\u26F4" + - "\u26F7\u26FE\u2703\u270D\u2715\u2718\u271F\u2724\u272B\u2738\u2744\u2749" + - "\u2751\u2758\u275D\u2769\u2771\u2776\u2780\u2787\u278E\u2795\u279B\u27A1" + - "\u27A9\u27AD\u27B4\u27ED\u27FA\u2811\u2819\u281D\u2829\u282B\u2832\u283B" + - "\u284D\u2855\u285E\u2865\u286F\u2875\u287C\u2881\u2887\u288B\u2892\u28B0" + - "\u28C4\u28C8\u28D8\u28DF\u28EC\u28F4\u2908\u290E\u291A\u291F\u2929\u2949" + - "\u294E\u2957\u295C\u2960\u2965\u2975\u297A\u2989\u298C\u2992\u2996\u299F" + - "\u29A7\u29B0\u29B6\u29BF\u29C1\u29C6\u29D1\u29DC\u29F1\u29F8\u29FF\u2A05" + - "\u2A08\u2A13\u2A1A\u2A1C\u2A25\u2A2C\u2A32\u2A38\u2A3C\u2A40\u2A4D\u2A5C" + - "\u2A5E\u2A62\u2A70\u2A76\u2A7C\u2A89\u2A8C\u2A90\u2A95\u2A9A\u2AA6\u2AAC" + - "\u2AB0\u2AB4\u2AB8\u2ABF\u2AC4\u2AC7\u2ACA\u2ACD\u2AD0\u2AD3\u2AD6\u2AE2"; + "\x02\x02\x02\u290F\u2928\x05\u05FA\u02FE\x02\u2910\u2928\x05\u05FE\u0300" + + "\x02\u2911\u2928\x05\u05C0\u02E1\x02\u2912\u2928\x05\u05D0\u02E9\x02\u2913" + + "\u2928\x05\u05D6\u02EC\x02\u2914\u2928\x05\u05E0\u02F1\x02\u2915\u2928" + + "\x05\u05E2\u02F2\x02\u2916\u2928\x05\u05E4\u02F3\x02\u2917\u2928\x05\u05F2" + + "\u02FA\x02\u2918\u2928\x05\u05F6\u02FC\x02\u2919\u2928\x05\u060A\u0306" + + "\x02\u291A\u2928\x05\u0610\u0309\x02\u291B\u2928\x05\u0612\u030A\x02\u291C" + + "\u2928\x05\u05BA\u02DE\x02\u291D\u2928\x05\u05BC\u02DF\x02\u291E\u2928" + + "\x05\u05C2\u02E2\x02\u291F\u2928\x05\u061A\u030E\x02\u2920\u2928\x05\u0626" + + "\u0314\x02\u2921\u2928\x05\u062E\u0318\x02\u2922\u2928\x05\u0630\u0319" + + "\x02\u2923\u2928\x05\u0632\u031A\x02\u2924\u2928\x05\u0634\u031B\x02\u2925" + + "\u2928\x05\u0636\u031C\x02\u2926\u2928\x05\u063A\u031E\x02\u2927\u290C" + + "\x03\x02\x02\x02\u2927\u290F\x03\x02\x02\x02\u2927\u2910\x03\x02\x02\x02" + + "\u2927\u2911\x03\x02\x02\x02\u2927\u2912\x03\x02\x02\x02\u2927\u2913\x03" + + "\x02\x02\x02\u2927\u2914\x03\x02\x02\x02\u2927\u2915\x03\x02\x02\x02\u2927" + + "\u2916\x03\x02\x02\x02\u2927\u2917\x03\x02\x02\x02\u2927\u2918\x03\x02" + + "\x02\x02\u2927\u2919\x03\x02\x02\x02\u2927\u291A\x03\x02\x02\x02\u2927" + + "\u291B\x03\x02\x02\x02\u2927\u291C\x03\x02\x02\x02\u2927\u291D\x03\x02" + + "\x02\x02\u2927\u291E\x03\x02\x02\x02\u2927\u291F\x03\x02\x02\x02\u2927" + + "\u2920\x03\x02\x02\x02\u2927\u2921\x03\x02\x02\x02\u2927\u2922\x03\x02" + + "\x02\x02\u2927\u2923\x03\x02\x02\x02\u2927\u2924\x03\x02\x02\x02\u2927" + + "\u2925\x03\x02\x02\x02\u2927\u2926\x03\x02\x02\x02\u2928\u05B9\x03\x02" + + "\x02\x02\u2929\u292A\x07\u01F4\x02\x02\u292A\u292B\x05\u0658\u032D\x02" + + "\u292B\u292C\x07\t\x02\x02\u292C\u05BB\x03\x02\x02\x02\u292D\u292E\x07" + + "\u01B3\x02\x02\u292E\u292F\x05\u0650\u0329\x02\u292F\u2930\x07\x04\x02" + + "\x02\u2930\u2931\x05\u05BE\u02E0\x02\u2931\u2932\x07\x05\x02\x02\u2932" + + "\u2933\x07\t\x02\x02\u2933\u293C\x03\x02\x02\x02\u2934\u2935\x07;\x02" + + "\x02\u2935\u2936\x05\u0650\u0329\x02\u2936\u2937\x07\x04\x02\x02\u2937" + + "\u2938\x05\u05BE\u02E0\x02\u2938\u2939\x07\x05\x02\x02\u2939\u293A\x07" + + "\t\x02\x02\u293A\u293C\x03\x02\x02\x02\u293B\u292D\x03\x02\x02\x02\u293B" + + "\u2934\x03\x02\x02\x02\u293C\u05BD\x03\x02\x02\x02\u293D\u2940\x03\x02" + + "\x02\x02\u293E\u2940\x05\u0502\u0282\x02\u293F\u293D\x03\x02\x02\x02\u293F" + + "\u293E\x03\x02\x02\x02\u2940\u05BF\x03\x02\x02\x02\u2941\u2942\x05\u05CE" + + "\u02E8\x02\u2942\u2943\x05\u05B4\u02DB\x02\u2943\u2944\x05\u0654\u032B" + + "\x02\u2944\u2945\x07\t\x02\x02\u2945\u05C1\x03\x02\x02\x02\u2946\u2947" + + "\x07\u01F5\x02\x02\u2947\u2948\x05\u05C4\u02E3\x02\u2948\u2949\x07\u01F6" + + "\x02\x02\u2949\u294A\x05\u05C6\u02E4\x02\u294A\u294B\x07\t\x02\x02\u294B" + + "\u05C3\x03\x02\x02\x02\u294C\u2950\x03\x02\x02\x02\u294D\u2950\x07\u01B4" + + "\x02\x02\u294E\u2950\x07\u01F7\x02\x02\u294F\u294C\x03\x02\x02\x02\u294F" + + "\u294D\x03\x02\x02\x02\u294F\u294E\x03\x02\x02\x02\u2950\u05C5\x03\x02" + + "\x02\x02\u2951\u2956\x05\u05C8\u02E5\x02\u2952\u2953\x07\b\x02\x02\u2953" + + "\u2955\x05\u05C8\u02E5\x02\u2954\u2952\x03\x02\x02\x02\u2955\u2958\x03" + + "\x02\x02\x02\u2956\u2954\x03\x02\x02\x02\u2956\u2957\x03\x02\x02\x02\u2957" + + "\u05C7\x03\x02\x02\x02\u2958\u2956\x03\x02\x02\x02\u2959\u295A\x05\u05CC" + + "\u02E7\x02\u295A\u295B\x05\u05B4\u02DB\x02\u295B\u295C\x05\u05CA\u02E6" + + "\x02\u295C\u05C9\x03\x02\x02\x02\u295D\u295E\x05\u0562\u02B2\x02\u295E" + + "\u05CB\x03\x02\x02\x02\u295F\u2960\x05\u05CE\u02E8\x02\u2960\u05CD\x03" + + "\x02\x02\x02\u2961\u2964\x05\u0214\u010B\x02\u2962\u2964\x07\x1E\x02\x02" + + "\u2963\u2961\x03\x02\x02\x02\u2963\u2962\x03\x02\x02\x02\u2964\u296B\x03" + + "\x02\x02\x02\u2965\u2966\x07\x06\x02\x02\u2966\u2967\x05\u065A\u032E\x02" + + "\u2967\u2968\x07\x07\x02\x02\u2968\u296A\x03\x02\x02\x02\u2969\u2965\x03" + + "\x02\x02\x02\u296A\u296D\x03\x02\x02\x02\u296B\u2969\x03\x02\x02\x02\u296B" + + "\u296C\x03\x02\x02\x02\u296C\u05CF\x03\x02\x02\x02\u296D\u296B\x03\x02" + + "\x02\x02\u296E\u296F\x07\xDE\x02\x02\u296F\u2970\x05\u0656\u032C\x02\u2970" + + "\u2971\x07_\x02\x02\u2971\u2972\x05\u05B6\u02DC\x02\u2972\u2973\x05\u05D2" + + "\u02EA\x02\u2973\u2974\x05\u05D4\u02EB\x02\u2974\u2975\x07\u01C8\x02\x02" + + "\u2975\u2976\x07\xDE\x02\x02\u2976\u2977\x07\t\x02\x02\u2977\u05D1\x03" + + "\x02\x02\x02\u2978\u2979\x07\u01F8\x02\x02\u2979\u297A\x05\u048E\u0248" + + "\x02\u297A\u297B\x07_\x02\x02\u297B\u297C\x05\u05B6\u02DC\x02\u297C\u297E" + + "\x03\x02\x02\x02\u297D\u2978\x03\x02\x02\x02\u297E\u2981\x03\x02\x02\x02" + + "\u297F\u297D\x03\x02\x02\x02\u297F\u2980\x03\x02\x02\x02\u2980\u05D3\x03" + + "\x02\x02\x02\u2981\u297F\x03\x02\x02\x02\u2982\u2986\x03\x02\x02\x02\u2983" + + "\u2984\x07<\x02\x02\u2984\u2986\x05\u05B6\u02DC\x02\u2985\u2982\x03\x02" + + "\x02\x02\u2985\u2983\x03\x02\x02\x02\u2986\u05D5\x03\x02\x02\x02\u2987" + + "\u2988\x07*\x02\x02\u2988\u2989\x05\u05D8\u02ED\x02\u2989\u298A\x05\u05DA" + + "\u02EE\x02\u298A\u298B\x05\u05DE\u02F0\x02\u298B\u298C\x07\u01C8\x02\x02" + + "\u298C\u298D\x07*\x02\x02\u298D\u298E\x07\t\x02\x02\u298E\u05D7\x03\x02" + + "\x02\x02\u298F\u2992\x03\x02\x02\x02\u2990\u2992\x05\u0654\u032B\x02\u2991" + + "\u298F\x03\x02\x02\x02\u2991\u2990\x03\x02\x02\x02\u2992\u05D9\x03\x02" + + "\x02\x02\u2993\u2995\x05\u05DC\u02EF\x02\u2994\u2993\x03\x02\x02\x02\u2995" + + "\u2996\x03\x02\x02\x02\u2996\u2994\x03\x02\x02\x02\u2996\u2997\x03\x02" + + "\x02\x02\u2997\u05DB\x03\x02\x02\x02\u2998\u2999\x07h\x02\x02\u2999\u299A" + + "\x05\u0502\u0282\x02\u299A\u299B\x07_\x02\x02\u299B\u299C\x05\u05B6\u02DC" + + "\x02\u299C\u05DD\x03\x02\x02\x02\u299D\u29A1\x03\x02\x02\x02\u299E\u299F" + + "\x07<\x02\x02\u299F\u29A1\x05\u05B6\u02DC\x02\u29A0\u299D\x03\x02\x02" + + "\x02\u29A0\u299E\x03\x02\x02\x02\u29A1\u05DF\x03\x02\x02\x02\u29A2\u29A3" + + "\x05\u064A\u0326\x02\u29A3\u29A4\x05\u060E\u0308\x02\u29A4\u05E1\x03\x02" + + "\x02\x02\u29A5\u29A6\x05\u064A\u0326\x02\u29A6\u29A7\x07\u01F9\x02\x02" + + "\u29A7\u29A8\x05\u065C\u032F\x02\u29A8\u29A9\x05\u060E\u0308\x02\u29A9" + + "\u05E3\x03\x02\x02\x02\u29AA\u29AB\x05\u064A\u0326\x02\u29AB\u29AC\x07" + + "@\x02\x02\u29AC\u29AD\x05\u05E6\u02F4\x02\u29AD\u29AE\x05\u060E\u0308" + + "\x02\u29AE\u05E5\x03\x02\x02\x02\u29AF\u29B0\x05\u05F0\u02F9\x02\u29B0" + + "\u29C0\x07F\x02\x02\u29B1\u29B2\x05\u03C0\u01E1\x02\u29B2\u29B3\x05\u05EA" + + "\u02F6\x02\u29B3\u29C1\x03\x02\x02\x02\u29B4\u29C1\x05\u03C6\u01E4\x02" + + "\u29B5\u29C1\x05\u037C\u01BF\x02\u29B6\u29B7\x07\xCC\x02\x02\u29B7\u29B8" + + "\x05\u048E\u0248\x02\u29B8\u29B9\x05\u05E8\u02F5\x02\u29B9\u29C1\x03\x02" + + "\x02\x02\u29BA\u29BB\x05\u05EC\u02F7\x02\u29BB\u29BC\x05\u048E\u0248\x02" + + "\u29BC\u29BD\x07\x1A\x02\x02\u29BD\u29BE\x05\u048E\u0248\x02\u29BE\u29BF" + + "\x05\u05EE\u02F8\x02\u29BF\u29C1\x03\x02\x02\x02\u29C0\u29B1\x03\x02\x02" + + "\x02\u29C0\u29B4\x03\x02\x02\x02\u29C0\u29B5\x03\x02\x02\x02\u29C0\u29B6" + + "\x03\x02\x02\x02\u29C0\u29BA\x03\x02\x02\x02\u29C1\u05E7\x03\x02\x02\x02" + + "\u29C2\u29C6\x03\x02\x02\x02\u29C3\u29C4\x07f\x02\x02\u29C4\u29C6\x05" + + "\u0502\u0282\x02\u29C5\u29C2\x03\x02\x02\x02\u29C5\u29C3\x03\x02\x02\x02" + + "\u29C6\u05E9\x03\x02\x02\x02\u29C7\u29D4\x03\x02\x02\x02\u29C8\u29C9\x07" + + "\x04\x02\x02\u29C9\u29CE\x05\u048E\u0248\x02\u29CA\u29CB\x07\b\x02\x02" + + "\u29CB\u29CD\x05\u048E\u0248\x02\u29CC\u29CA\x03\x02\x02\x02\u29CD\u29D0" + + "\x03\x02\x02\x02\u29CE\u29CC\x03\x02\x02\x02\u29CE\u29CF\x03\x02\x02\x02" + + "\u29CF\u29D1\x03\x02\x02\x02\u29D0\u29CE\x03\x02\x02\x02\u29D1\u29D2\x07" + + "\x05\x02\x02\u29D2\u29D4\x03\x02\x02\x02\u29D3\u29C7\x03\x02\x02\x02\u29D3" + + "\u29C8\x03\x02\x02\x02\u29D4\u05EB\x03\x02\x02\x02\u29D5\u29D8\x03\x02" + + "\x02\x02\u29D6\u29D8\x07\u01FA\x02\x02\u29D7\u29D5\x03\x02\x02\x02\u29D7" + + "\u29D6\x03\x02\x02\x02\u29D8\u05ED\x03\x02\x02\x02\u29D9\u29DD\x03\x02" + + "\x02\x02\u29DA\u29DB\x07\x95\x02\x02\u29DB\u29DD\x05\u048E\u0248\x02\u29DC" + + "\u29D9\x03\x02\x02\x02\u29DC\u29DA\x03\x02\x02\x02\u29DD\u05EF\x03\x02" + + "\x02\x02\u29DE\u29DF\x05\u0212\u010A\x02\u29DF\u05F1\x03\x02\x02\x02\u29E0" + + "\u29E1\x05\u064A\u0326\x02\u29E1\u29E2\x07\u01FB\x02\x02\u29E2\u29E3\x05" + + "\u05F0\u02F9\x02\u29E3\u29E4\x05\u05F4\u02FB\x02\u29E4\u29E5\x07F\x02" + + "\x02\u29E5\u29E6\x07%\x02\x02\u29E6\u29E7\x05\u048E\u0248\x02\u29E7\u29E8" + + "\x05\u060E\u0308\x02\u29E8\u05F3\x03\x02\x02\x02\u29E9\u29ED\x03\x02\x02" + + "\x02\u29EA\u29EB\x07\u01FC\x02\x02\u29EB\u29ED\x05\u0550\u02A9\x02\u29EC" + + "\u29E9\x03\x02\x02\x02\u29EC\u29EA\x03\x02\x02\x02\u29ED\u05F5\x03\x02" + + "\x02\x02\u29EE\u29EF\x05\u05F8\u02FD\x02\u29EF\u29F1\x05\u064C\u0327\x02" + + "\u29F0\u29F2\x05\u064E\u0328\x02\u29F1\u29F0\x03\x02\x02\x02\u29F1\u29F2" + + "\x03\x02\x02\x02\u29F2\u29F3\x03\x02\x02\x02\u29F3\u29F4\x07\t\x02\x02" + + "\u29F4\u05F7\x03\x02\x02\x02\u29F5\u29F6\tJ\x02\x02\u29F6\u05F9\x03\x02" + + "\x02\x02\u29F7\u2A03\x07\u01FE\x02\x02\u29F8\u29F9\x07\u010E\x02\x02\u29F9" + + "\u2A04\x05\u0654\u032B\x02\u29FA\u2A00\x07\u01FF\x02\x02\u29FB\u29FC\x07" + + "\xCC\x02\x02\u29FC\u29FD\x05\u048E\u0248\x02\u29FD\u29FE\x05\u05E8\u02F5" + + "\x02\u29FE\u2A01\x03\x02\x02\x02\u29FF\u2A01\x05\u03C6\u01E4\x02\u2A00" + + "\u29FB\x03\x02\x02\x02\u2A00\u29FF\x03\x02\x02\x02\u2A01\u2A04\x03\x02" + + "\x02\x02\u2A02\u2A04\x05\u05FC\u02FF\x02\u2A03\u29F8\x03\x02\x02\x02\u2A03" + + "\u29FA\x03\x02\x02\x02\u2A03\u2A02\x03\x02\x02\x02\u2A04\u2A05\x03\x02" + + "\x02\x02\u2A05\u2A06\x07\t\x02\x02\u2A06\u05FB\x03\x02\x02\x02\u2A07\u2A0A" + + "\x03\x02\x02\x02\u2A08\u2A0A\x05\u0654\u032B\x02\u2A09\u2A07\x03\x02\x02" + + "\x02\u2A09\u2A08\x03\x02\x02\x02\u2A0A\u05FD\x03\x02\x02\x02\u2A0B\u2A0D" + + "\x07\u0200\x02\x02\u2A0C\u2A0E\x05\u0600\u0301\x02\u2A0D\u2A0C\x03\x02" + + "\x02\x02\u2A0D\u2A0E\x03\x02\x02\x02\u2A0E\u2A0F\x03\x02\x02\x02\u2A0F" + + "\u2A10\x05\u0552\u02AA\x02\u2A10\u2A11\x05\u0602\u0302\x02\u2A11\u2A12" + + "\x05\u0604\u0303\x02\u2A12\u2A13\x07\t\x02\x02\u2A13\u2A2E\x03\x02\x02" + + "\x02\u2A14\u2A16\x07\u0200\x02\x02\u2A15\u2A17\x05\u0600\u0301\x02\u2A16" + + "\u2A15\x03\x02\x02\x02\u2A16\u2A17\x03\x02\x02\x02\u2A17\u2A18\x03\x02" + + "\x02\x02\u2A18\u2A19\x05\u0572\u02BA\x02\u2A19\u2A1A\x05\u0604\u0303\x02" + + "\u2A1A\u2A1B\x07\t\x02\x02\u2A1B\u2A2E\x03\x02\x02\x02\u2A1C\u2A1E\x07" + + "\u0200\x02\x02\u2A1D\u2A1F\x05\u0600\u0301\x02\u2A1E\u2A1D\x03\x02\x02" + + "\x02\u2A1E\u2A1F\x03\x02\x02\x02\u2A1F\u2A20\x03\x02\x02\x02\u2A20\u2A21" + + "\x07\u0201\x02\x02\u2A21\u2A22\x05\u0552\u02AA\x02\u2A22\u2A23\x05\u0604" + + "\u0303\x02\u2A23\u2A24\x07\t\x02\x02\u2A24\u2A2E\x03\x02\x02\x02\u2A25" + + "\u2A27\x07\u0200\x02\x02\u2A26\u2A28\x05\u0600\u0301\x02\u2A27\u2A26\x03" + + "\x02\x02\x02\u2A27\u2A28\x03\x02\x02\x02\u2A28\u2A29\x03\x02\x02\x02\u2A29" + + "\u2A2A\x05\u0604\u0303\x02\u2A2A\u2A2B\x07\t\x02\x02\u2A2B\u2A2E\x03\x02" + + "\x02\x02\u2A2C\u2A2E\x07\u0200\x02\x02\u2A2D\u2A0B\x03\x02\x02\x02\u2A2D" + + "\u2A14\x03\x02\x02\x02\u2A2D\u2A1C\x03\x02\x02\x02\u2A2D\u2A25\x03\x02" + + "\x02\x02\u2A2D\u2A2C\x03\x02\x02\x02\u2A2E\u05FF\x03\x02\x02\x02\u2A2F" + + "\u2A30\tK\x02\x02\u2A30\u0601\x03\x02\x02\x02\u2A31\u2A39\x03\x02\x02" + + "\x02\u2A32\u2A33\x07\b\x02\x02\u2A33\u2A35\x05\u048E\u0248\x02\u2A34\u2A32" + + "\x03\x02\x02\x02\u2A35\u2A36\x03\x02\x02\x02\u2A36\u2A34\x03\x02\x02\x02" + + "\u2A36\u2A37\x03\x02\x02\x02\u2A37\u2A39\x03\x02\x02\x02\u2A38\u2A31\x03" + + "\x02\x02\x02\u2A38\u2A34\x03\x02\x02\x02\u2A39\u0603\x03\x02\x02\x02\u2A3A" + + "\u2A3E\x03\x02\x02\x02\u2A3B\u2A3C\x07f\x02\x02\u2A3C\u2A3E\x05\u0608" + + "\u0305\x02\u2A3D\u2A3A\x03\x02\x02\x02\u2A3D\u2A3B\x03\x02\x02\x02\u2A3E" + + "\u0605\x03\x02\x02\x02\u2A3F\u2A40\x05\u0572\u02BA\x02\u2A40\u2A41\x07" + + "\f\x02\x02\u2A41\u2A42\x05\u048E\u0248\x02\u2A42\u0607\x03\x02\x02\x02" + + "\u2A43\u2A48\x05\u0606\u0304\x02\u2A44\u2A45\x07\b\x02\x02\u2A45\u2A47" + + "\x05\u0606\u0304\x02\u2A46\u2A44\x03\x02\x02\x02\u2A47\u2A4A\x03\x02\x02" + + "\x02\u2A48\u2A46\x03\x02\x02\x02\u2A48\u2A49\x03\x02\x02\x02\u2A49\u0609" + + "\x03\x02\x02\x02\u2A4A\u2A48\x03\x02\x02\x02\u2A4B\u2A4C\x07\u0208\x02" + + "\x02\u2A4C\u2A4D\x05\u0654\u032B\x02\u2A4D\u2A4E\x05\u060C\u0307\x02\u2A4E" + + "\u2A4F\x07\t\x02\x02\u2A4F\u060B\x03\x02\x02\x02\u2A50\u2A54\x03\x02\x02" + + "\x02\u2A51\u2A52\x07\b\x02\x02\u2A52\u2A54\x05\u0654\u032B\x02\u2A53\u2A50" + + "\x03\x02\x02\x02\u2A53\u2A51\x03\x02\x02\x02\u2A54\u060D\x03\x02\x02\x02" + + "\u2A55\u2A56\x07\u0209\x02\x02\u2A56\u2A57\x05\u05B6\u02DC\x02\u2A57\u2A58" + + "\x07\u01C8\x02\x02\u2A58\u2A59\x07\u0209\x02\x02\u2A59\u2A5A\x05\u064C" + + "\u0327\x02\u2A5A\u2A5B\x07\t\x02\x02\u2A5B\u060F\x03\x02\x02\x02\u2A5C" + + "\u2A5D\x05\u065E\u0330\x02\u2A5D\u2A5E\x07\t\x02\x02\u2A5E\u0611\x03\x02" + + "\x02\x02\u2A5F\u2A60\x07\xCC\x02\x02\u2A60\u2A68\x05\u048E\u0248\x02\u2A61" + + "\u2A62\x05\u0618\u030D\x02\u2A62\u2A63\x05\u0614\u030B\x02\u2A63\u2A69" + + "\x03\x02\x02\x02\u2A64\u2A65\x05\u0614\u030B\x02\u2A65\u2A66\x05\u0618" + + "\u030D\x02\u2A66\u2A69\x03\x02\x02\x02\u2A67\u2A69\x03\x02\x02\x02\u2A68" + + "\u2A61\x03\x02\x02\x02\u2A68\u2A64\x03\x02\x02\x02\u2A68\u2A67\x03\x02" + + "\x02\x02\u2A69\u2A6A\x03\x02\x02\x02\u2A6A\u2A6B\x07\t\x02\x02\u2A6B\u0613" + + "\x03\x02\x02\x02\u2A6C\u2A70\x03\x02\x02\x02\u2A6D\u2A6E\x07f\x02\x02" + + "\u2A6E\u2A70\x05\u0616\u030C\x02\u2A6F\u2A6C\x03\x02\x02\x02\u2A6F\u2A6D" + + "\x03\x02\x02\x02\u2A70\u0615\x03\x02\x02\x02\u2A71\u2A76\x05\u048E\u0248" + + "\x02\u2A72\u2A73\x07\b\x02\x02\u2A73\u2A75\x05\u048E\u0248\x02\u2A74\u2A72" + + "\x03\x02\x02\x02\u2A75\u2A78\x03\x02\x02\x02\u2A76\u2A74\x03\x02\x02\x02" + + "\u2A76\u2A77\x03\x02\x02\x02\u2A77\u0617\x03\x02\x02\x02\u2A78\u2A76\x03" + + "\x02\x02\x02\u2A79\u2A80\x03\x02\x02\x02\u2A7A\u2A7C\x07I\x02\x02\u2A7B" + + "\u2A7D\x07\u015C\x02\x02\u2A7C\u2A7B\x03\x02\x02\x02\u2A7C\u2A7D\x03\x02" + + "\x02\x02\u2A7D\u2A7E\x03\x02\x02\x02\u2A7E\u2A80\x05\u0628\u0315\x02\u2A7F" + + "\u2A79\x03\x02\x02\x02\u2A7F\u2A7A\x03\x02\x02\x02\u2A80\u0619\x03\x02" + + "\x02\x02\u2A81\u2A93\x07\u020A\x02\x02\u2A82\u2A83\x05\u063C\u031F\x02" + + "\u2A83\u2A84\x05\u0622\u0312\x02\u2A84\u2A8A\x07@\x02\x02\u2A85\u2A8B" + + "\x05\u03C6\u01E4\x02\u2A86\u2A87\x07\xCC\x02\x02\u2A87\u2A88\x05\u0654" + + "\u032B\x02\u2A88\u2A89\x05\u0620\u0311\x02\u2A89\u2A8B\x03\x02\x02\x02" + + "\u2A8A\u2A85\x03\x02\x02\x02\u2A8A\u2A86\x03\x02\x02\x02\u2A8B\u2A94\x03" + + "\x02\x02\x02\u2A8C\u2A91\x05\u0562\u02B2\x02\u2A8D\u2A8E\x07\x04\x02\x02" + + "\u2A8E\u2A8F\x05\u061E\u0310\x02\u2A8F\u2A90\x07\x05\x02\x02\u2A90\u2A92" + + "\x03\x02\x02\x02\u2A91\u2A8D\x03\x02\x02\x02\u2A91\u2A92\x03\x02\x02\x02" + + "\u2A92\u2A94\x03\x02\x02\x02\u2A93\u2A82\x03\x02\x02\x02\u2A93\u2A8C\x03" + + "\x02\x02\x02\u2A94\u2A95\x03\x02\x02\x02\u2A95\u2A96\x07\t\x02\x02\u2A96" + + "\u061B\x03\x02\x02\x02\u2A97\u2A98\x05\u0562\u02B2\x02\u2A98\u2A99\x07" + + "\x16\x02\x02\u2A99\u2A9A\x05\u048E\u0248\x02\u2A9A\u2A9D\x03\x02\x02\x02" + + "\u2A9B\u2A9D\x05\u048E\u0248\x02\u2A9C\u2A97\x03\x02\x02\x02\u2A9C\u2A9B" + + "\x03\x02\x02\x02\u2A9D\u061D\x03\x02\x02\x02\u2A9E\u2AA3\x05\u061C\u030F" + + "\x02\u2A9F\u2AA0\x07\b\x02\x02\u2AA0\u2AA2\x05\u061C\u030F\x02\u2AA1\u2A9F" + + "\x03\x02\x02\x02\u2AA2\u2AA5\x03\x02\x02\x02\u2AA3\u2AA1\x03\x02\x02\x02" + + "\u2AA3\u2AA4\x03\x02\x02\x02\u2AA4\u061F\x03\x02\x02\x02\u2AA5\u2AA3\x03" + + "\x02\x02\x02\u2AA6\u2AAA\x03\x02\x02\x02\u2AA7\u2AA8\x07f\x02\x02\u2AA8" + + "\u2AAA\x05\u0502\u0282\x02\u2AA9\u2AA6\x03\x02\x02\x02\u2AA9\u2AA7\x03" + + "\x02\x02\x02\u2AAA\u0621\x03\x02\x02\x02\u2AAB\u2AB0\x03\x02\x02\x02\u2AAC" + + "\u2AAD\x05\u0624\u0313\x02\u2AAD\u2AAE\x07\u0146\x02\x02\u2AAE\u2AB0\x03" + + "\x02\x02\x02\u2AAF\u2AAB\x03\x02\x02\x02\u2AAF\u2AAC\x03\x02\x02\x02\u2AB0" + + "\u0623\x03\x02\x02\x02\u2AB1\u2AB4\x03\x02\x02\x02\u2AB2\u2AB4\x07\u010F" + + "\x02\x02\u2AB3\u2AB1\x03\x02\x02\x02\u2AB3\u2AB2\x03\x02\x02\x02\u2AB4" + + "\u0625\x03\x02\x02\x02\u2AB5\u2AB7\x07?\x02\x02\u2AB6\u2AB8\x05\u062C" + + "\u0317\x02\u2AB7\u2AB6\x03\x02\x02\x02\u2AB7\u2AB8\x03\x02\x02\x02\u2AB8" + + "\u2AB9\x03\x02\x02\x02\u2AB9\u2ABA\x05\u062A\u0316\x02\u2ABA\u2ABB\x05" + + "\u063C\u031F\x02\u2ABB\u2ABC\x07I\x02\x02\u2ABC\u2ABD\x05\u0628\u0315" + + "\x02\u2ABD\u2ABE\x07\t\x02\x02\u2ABE\u0627\x03\x02\x02\x02\u2ABF\u2AC0" + + "\x05\u0502\u0282\x02\u2AC0\u0629\x03\x02\x02\x02\u2AC1\u2AC5\x03\x02\x02" + + "\x02\u2AC2\u2AC5\x07B\x02\x02\u2AC3\u2AC5\x07F\x02\x02\u2AC4\u2AC1\x03" + + "\x02\x02\x02\u2AC4\u2AC2\x03\x02\x02\x02\u2AC4\u2AC3\x03\x02\x02\x02\u2AC5" + + "\u062B\x03\x02\x02\x02\u2AC6\u2AD6\x07\u010E\x02\x02\u2AC7\u2AD6\x07\u0127" + + "\x02\x02\u2AC8\u2AD6\x07\xD1\x02\x02\u2AC9\u2AD6\x07\xFB\x02\x02\u2ACA" + + "\u2ACB\x07\x84\x02\x02\u2ACB\u2AD6\x05\u048E\u0248\x02\u2ACC\u2ACD\x07" + + "\u0135\x02\x02\u2ACD\u2AD6\x05\u048E\u0248\x02\u2ACE\u2AD6\x05\u048E\u0248" + + "\x02\u2ACF\u2AD6\x07 \x02\x02\u2AD0\u2AD3\tL\x02\x02\u2AD1\u2AD4\x05\u048E" + + "\u0248\x02\u2AD2\u2AD4\x07 \x02\x02\u2AD3\u2AD1\x03\x02\x02\x02\u2AD3" + + "\u2AD2\x03\x02\x02\x02\u2AD3\u2AD4\x03\x02\x02\x02\u2AD4\u2AD6\x03\x02" + + "\x02\x02\u2AD5\u2AC6\x03\x02\x02\x02\u2AD5\u2AC7\x03\x02\x02\x02\u2AD5" + + "\u2AC8\x03\x02\x02\x02\u2AD5\u2AC9\x03\x02\x02\x02\u2AD5\u2ACA\x03\x02" + + "\x02\x02\u2AD5\u2ACC\x03\x02\x02\x02\u2AD5\u2ACE\x03\x02\x02\x02\u2AD5" + + "\u2ACF\x03\x02\x02\x02\u2AD5\u2AD0\x03\x02\x02\x02\u2AD6\u062D\x03\x02" + + "\x02\x02\u2AD7\u2AD9\x07\u010B\x02\x02\u2AD8\u2ADA\x05\u062C\u0317\x02" + + "\u2AD9\u2AD8\x03\x02\x02\x02\u2AD9\u2ADA\x03\x02\x02\x02\u2ADA\u2ADB\x03" + + "\x02\x02\x02\u2ADB\u2ADC\x05\u063C\u031F\x02\u2ADC\u2ADD\x07\t\x02\x02" + + "\u2ADD\u062F\x03\x02\x02\x02\u2ADE\u2ADF\x07\x9F\x02\x02\u2ADF\u2AE0\x05" + + "\u063C\u031F\x02\u2AE0\u2AE1\x07\t\x02\x02\u2AE1\u0631\x03\x02\x02\x02" + + "\u2AE2\u2AE3\x07P\x02\x02\u2AE3\u2AE4\x07\t\x02\x02\u2AE4\u0633\x03\x02" + + "\x02\x02\u2AE5\u2AE7\x07\xA3\x02\x02\u2AE6\u2AE8\x05\u0638\u031D\x02\u2AE7" + + "\u2AE6\x03\x02\x02\x02\u2AE7\u2AE8\x03\x02\x02\x02\u2AE8\u2AE9\x03\x02" + + "\x02\x02\u2AE9\u2AEA\x07\t\x02\x02\u2AEA\u0635\x03\x02\x02\x02\u2AEB\u2AED" + + "\x07\u0141\x02\x02\u2AEC\u2AEE\x05\u0638\u031D\x02\u2AED\u2AEC\x03\x02" + + "\x02\x02\u2AED\u2AEE\x03\x02\x02\x02\u2AEE\u2AEF\x03\x02\x02\x02\u2AEF" + + "\u2AF0\x07\t\x02\x02\u2AF0\u0637\x03\x02\x02\x02\u2AF1\u2AF3\x07#\x02" + + "\x02\u2AF2\u2AF4\x07\u010F\x02\x02\u2AF3\u2AF2\x03\x02\x02\x02\u2AF3\u2AF4" + + "\x03\x02\x02\x02\u2AF4\u2AF5\x03\x02\x02\x02\u2AF5\u2AF6\x07\x9B\x02\x02" + + "\u2AF6\u0639\x03\x02\x02\x02\u2AF7\u2AF8\x07\u014F\x02\x02\u2AF8\u2AF9" + + "\x05\u0214\u010B\x02\u2AF9\u2AFA\x07`\x02\x02\u2AFA\u2AFB\x077\x02\x02" + + "\u2AFB\u2AFC\x07\t\x02\x02\u2AFC\u2B04\x03\x02\x02\x02\u2AFD\u2B00\x07" + + "\u013B\x02\x02\u2AFE\u2B01\x05\u0214\u010B\x02\u2AFF\u2B01\x07 \x02\x02" + + "\u2B00\u2AFE\x03\x02\x02\x02\u2B00\u2AFF\x03\x02\x02\x02\u2B01\u2B02\x03" + + "\x02\x02\x02\u2B02\u2B04\x07\t\x02\x02\u2B03\u2AF7\x03\x02\x02\x02\u2B03" + + "\u2AFD\x03\x02\x02\x02\u2B04\u063B\x03\x02\x02\x02\u2B05\u2B08\x05\u0562" + + "\u02B2\x02\u2B06\u2B08\x07\x1E\x02\x02\u2B07\u2B05\x03\x02\x02\x02\u2B07" + + "\u2B06\x03\x02\x02\x02\u2B08\u063D\x03\x02\x02\x02\u2B09\u2B0D\x03\x02" + + "\x02\x02\u2B0A\u2B0B\x07\u0207\x02\x02\u2B0B\u2B0D\x05\u0640\u0321\x02" + + "\u2B0C\u2B09\x03\x02\x02\x02\u2B0C\u2B0A\x03\x02\x02\x02\u2B0D\u063F\x03" + + "\x02\x02\x02\u2B0E\u2B10\x05\u0642\u0322\x02\u2B0F\u2B0E\x03\x02\x02\x02" + + "\u2B10\u2B11\x03\x02\x02\x02\u2B11\u2B0F\x03\x02\x02\x02\u2B11\u2B12\x03" + + "\x02\x02\x02\u2B12\u0641\x03\x02\x02\x02\u2B13\u2B14\x07h\x02\x02\u2B14" + + "\u2B15\x05\u0644\u0323\x02\u2B15\u2B16\x07_\x02\x02\u2B16\u2B17\x05\u05B6" + + "\u02DC\x02\u2B17\u0643\x03\x02\x02\x02\u2B18\u2B1D\x05\u0646\u0324\x02" + + "\u2B19\u2B1A\x07T\x02\x02\u2B1A\u2B1C\x05\u0646\u0324\x02\u2B1B\u2B19" + + "\x03\x02\x02\x02\u2B1C\u2B1F\x03\x02\x02\x02\u2B1D\u2B1B\x03\x02\x02\x02" + + "\u2B1D\u2B1E\x03\x02\x02\x02\u2B1E\u0645\x03\x02\x02\x02\u2B1F\u2B1D\x03" + + "\x02\x02\x02\u2B20\u2B24\x05\u0650\u0329\x02\u2B21\u2B22\x07\u0201\x02" + + "\x02\u2B22\u2B24\x05\u0552\u02AA\x02\u2B23\u2B20\x03\x02\x02\x02\u2B23" + + "\u2B21\x03\x02\x02\x02\u2B24\u0647\x03\x02\x02\x02\u2B25\u2B28\x03\x02" + + "\x02\x02\u2B26\u2B28\x05\u0592\u02CA\x02\u2B27\u2B25\x03\x02\x02\x02\u2B27" + + "\u2B26\x03\x02\x02\x02\u2B28\u0649\x03\x02\x02\x02\u2B29\u2B2C\x03\x02" + + "\x02\x02\u2B2A\u2B2C\x05\u0592\u02CA\x02\u2B2B\u2B29\x03\x02\x02\x02\u2B2B" + + "\u2B2A\x03\x02\x02\x02\u2B2C\u064B\x03\x02\x02\x02\u2B2D\u2B30\x03\x02" + + "\x02\x02\u2B2E\u2B30\x05\u0650\u0329\x02\u2B2F\u2B2D\x03\x02\x02\x02\u2B2F" + + "\u2B2E\x03\x02\x02\x02\u2B30\u064D\x03\x02\x02\x02\u2B31\u2B32\x07h\x02" + + "\x02\u2B32\u2B33\x05\u0658\u032D\x02\u2B33\u064F\x03\x02\x02\x02\u2B34" + + "\u2B37\x05\u0562\u02B2\x02\u2B35\u2B37\x05\u0652\u032A\x02\u2B36\u2B34" + + "\x03\x02\x02\x02\u2B36\u2B35\x03\x02\x02\x02\u2B37\u0651\x03\x02\x02\x02" + + "\u2B38\u2B39\tM\x02\x02\u2B39\u0653\x03\x02\x02\x02\u2B3A\u2B3C\x05\u0532" + + "\u029A\x02\u2B3B\u2B3A\x03\x02\x02\x02\u2B3B\u2B3C\x03\x02\x02\x02\u2B3C" + + "\u2B3E\x03\x02\x02\x02\u2B3D\u2B3F\x05\u03DE\u01F0\x02\u2B3E\u2B3D\x03" + + "\x02\x02\x02\u2B3E\u2B3F\x03\x02\x02\x02\u2B3F\u2B41\x03\x02\x02\x02\u2B40" + + "\u2B42\x05\u0426\u0214\x02\u2B41\u2B40\x03\x02\x02\x02\u2B41\u2B42\x03" + + "\x02\x02\x02\u2B42\u2B44\x03\x02\x02\x02\u2B43\u2B45\x05\u044A\u0226\x02" + + "\u2B44\u2B43\x03\x02\x02\x02\u2B44\u2B45\x03\x02\x02\x02\u2B45\u2B47\x03" + + "\x02\x02\x02\u2B46\u2B48\x05\u0408\u0205\x02\u2B47\u2B46\x03\x02\x02\x02" + + "\u2B47\u2B48\x03\x02\x02\x02\u2B48\u2B4A\x03\x02\x02\x02\u2B49\u2B4B\x05" + + "\u0416\u020C\x02\u2B4A\u2B49\x03\x02\x02\x02\u2B4A\u2B4B\x03\x02\x02\x02" + + "\u2B4B\u2B4D\x03\x02\x02\x02\u2B4C\u2B4E\x05\u04DA\u026E\x02\u2B4D\u2B4C" + + "\x03\x02\x02\x02\u2B4D\u2B4E\x03\x02\x02\x02\u2B4E\u0655\x03\x02\x02\x02" + + "\u2B4F\u2B50\x05\u0654\u032B\x02\u2B50\u0657\x03\x02\x02\x02\u2B51\u2B52" + + "\x05\u0654\u032B\x02\u2B52\u0659\x03\x02\x02\x02\u2B53\u2B54\x05\u048E" + + "\u0248\x02\u2B54\u065B\x03\x02\x02\x02\u2B55\u2B56\x05\u048E\u0248\x02" + + "\u2B56\u065D\x03\x02\x02\x02\u2B57\u2B59\x05\b\x05\x02\u2B58\u2B5A\x05" + + "\u0660\u0331\x02\u2B59\u2B58\x03\x02\x02\x02\u2B59\u2B5A\x03\x02\x02\x02" + + "\u2B5A\u065F\x03\x02\x02\x02\u2B5B\u2B5C\x07I\x02\x02\u2B5C\u2B5D\x05" + + "\u03E0\u01F1\x02\u2B5D\u2B5E\x05\u0628\u0315\x02\u2B5E\u0661\x03\x02\x02" + + "\x02\u0440\u0668\u066C\u06EB\u06EF\u06F8\u0701\u0707\u070D\u0720\u072C" + + "\u0732\u073A\u0742\u0748\u0751\u0759\u076B\u076E\u0773\u077C\u0785\u0789" + + "\u0795\u07A9\u07B6\u07BD\u07C5\u07CA\u07D1\u07D7\u07DE\u07E9\u07ED\u07F1" + + "\u07FE\u0802\u0807\u080C\u0818\u0821\u082E\u0833\u083E\u0844\u084A\u084F" + + "\u085A\u0860\u0866\u086F\u0879\u0888\u088E\u0895\u089A\u08A1\u08AC\u08C4" + + "\u08CB\u08D4\u08DD\u08E5\u08EF\u08F8\u0901\u0909\u0911\u091A\u0923\u0927" + + "\u092E\u0936\u0940\u0946\u094A\u094E\u0952\u0956\u095B\u095E\u0962\u0977" + + "\u097D\u09DC\u09E3\u09F3\u0A01\u0A0B\u0A0D\u0A12\u0A16\u0A19\u0A1F\u0A21" + + "\u0A3D\u0A47\u0A54\u0A5B\u0A61\u0A65\u0A6B\u0A70\u0A73\u0A75\u0A7A\u0A7E" + + "\u0A82\u0A86\u0A8A\u0A8D\u0A91\u0A99\u0A9D\u0AA1\u0AAA\u0AB1\u0AB6\u0ABD" + + "\u0AC2\u0AC9\u0ACE\u0AE0\u0AE5\u0AF1\u0AF6\u0AFF\u0B06\u0B0D\u0B13\u0B18" + + "\u0B1C\u0B1F\u0B22\u0B25\u0B28\u0B2B\u0B30\u0B33\u0B36\u0B39\u0B3C\u0B3F" + + "\u0B45\u0B49\u0B4C\u0B4F\u0B52\u0B55\u0B57\u0B60\u0B6F\u0B77\u0B7D\u0B81" + + "\u0B86\u0B8A\u0B91\u0B98\u0B9D\u0BA1\u0BA4\u0BA8\u0BAB\u0BAD\u0BB4\u0BB7" + + "\u0BBC\u0BBF\u0BC6\u0BCF\u0BD6\u0BDB\u0BDE\u0BE1\u0BE3\u0BE8\u0BED\u0BFA" + + "\u0C04\u0C11\u0C14\u0C17\u0C1E\u0C26\u0C29\u0C2C\u0C33\u0C37\u0C3D\u0C40" + + "\u0C43\u0C46\u0C52\u0C55\u0C58\u0C5C\u0C6A\u0C7C\u0C87\u0C96\u0CA6\u0CBB" + + "\u0CC0\u0CC3\u0CC7\u0CCA\u0CD0\u0CD3\u0CD5\u0CE0\u0CE9\u0CFC\u0D00\u0D0B" + + "\u0D14\u0D1A\u0D20\u0D24\u0D27\u0D2A\u0D2D\u0D30\u0D36\u0D3A\u0D41\u0D47" + + "\u0D4B\u0D4E\u0D51\u0D54\u0D5C\u0D60\u0D64\u0D6A\u0D6E\u0D74\u0D82\u0D8B" + + "\u0D9C\u0DA1\u0DA4\u0DA6\u0DB0\u0DB7\u0DBC\u0DBF\u0DC2\u0DC9\u0DCC\u0DCE" + + "\u0DD4\u0DDD\u0DE7\u0DEC\u0DF5\u0DFE\u0E02\u0E09\u0E13\u0E1E\u0E8C\u0E94" + + "\u0E97\u0EA1\u0EA6\u0EB0\u0EBB\u0EC7\u0ED4\u0EDE\u0EEB\u0EEE\u0EF5\u0EFE" + + "\u0F01\u0F08\u0F0A\u0F12\u0F1C\u0F1E\u0F26\u0F2A\u0F2F\u0F3A\u0F3E\u0F43" + + "\u0F4D\u0F53\u0F60\u0F66\u0F68\u0F6F\u0F77\u0F7C\u0F8B\u0F98\u0F9A\u0F9E" + + "\u0FB2\u0FC3\u0FC6\u0FC9\u0FCC\u0FCF\u0FD7\u0FDA\u0FDD\u100B\u100E\u1011" + + "\u101C\u1025\u1029\u102C\u1035\u103B\u103F\u104A\u1054\u105C\u1061\u106D" + + "\u107E\u1084\u108B\u1093\u10A1\u10BD\u10C4\u10D2\u10E1\u10EE\u10F7\u1110" + + "\u111B\u115E\u1169\u116F\u1177\u1182\u1190\u1199\u11A3\u11AF\u11BE\u11C9" + + "\u11D1\u11DB\u11E2\u11E5\u11EB\u11EE\u11FD\u120A\u1227\u122E\u123D\u1246" + + "\u1251\u1253\u125C\u1267\u1269\u1270\u127F\u1285\u128D\u1293\u129B\u12A5" + + "\u12AB\u12B3\u12B9\u12C1\u12C8\u12D1\u12D3\u12EC\u12F3\u12FE\u1304\u130D" + + "\u1312\u1318\u131F\u1324\u1328\u132B\u1331\u13C6\u13CA\u13CF\u13DA\u13E5" + + "\u13F0\u13FB\u1406\u1411\u141C\u1428\u1433\u143B\u1442\u1448\u1450\u1455" + + "\u145A\u145F\u1465\u146C\u1472\u1478\u147D\u1483\u148A\u148F\u1495\u149C" + + "\u149F\u14AC\u14B5\u14C1\u14C3\u14D5\u14DC\u14E6\u14EB\u14EF\u14F3\u14F7" + + "\u14F9\u1535\u153C\u1542\u154D\u1550\u1557\u155A\u1564\u1567\u1569\u157C" + + "\u1588\u1591\u159A\u15A6\u15A8\u15AE\u15B2\u15B5\u15BA\u15C0\u15C3\u15C6" + + "\u15C9\u15CD\u15D1\u15DA\u15E0\u15E3\u15E6\u15E9\u15EB\u15FB\u15FF\u1602" + + "\u1605\u1608\u160B\u1610\u1613\u1615\u1622\u162E\u163C\u1640\u164C\u164E" + + "\u1653\u165B\u1665\u166E\u1676\u167F\u1681\u1685\u168E\u1693\u1699\u169E" + + "\u16A2\u16A7\u16B9\u16BE\u16CD\u16D6\u16E1\u16E7\u170C\u1716\u171D\u1728" + + "\u1736\u173E\u1743\u174B\u1753\u1759\u1761\u1767\u176F\u1771\u1777\u177F" + + "\u1781\u1787\u178F\u1791\u17A9\u17B0\u17BA\u17C6\u17CB\u17D8\u17E4\u17F0" + + "\u17F2\u17F8\u17FD\u1805\u180C\u1839\u183E\u1845\u184A\u1851\u185B\u1865" + + "\u1869\u1874\u1885\u18CC\u198F\u199C\u19A7\u19B4\u19C0\u19CE\u19EE\u19FC" + + "\u1A6C\u1A6E\u1A79\u1A84\u1A8F\u1A9C\u1AA8\u1AB3\u1ABA\u1B97\u1BA6\u1BB1" + + "\u1BB8\u1BEE\u1C7B\u1C81\u1C84\u1C8E\u1CAB\u1CB5\u1CBC\u1CD3\u1CDC\u1CE8" + + "\u1CEE\u1CF6\u1CF8\u1CFC\u1D06\u1D0A\u1D14\u1D17\u1D1B\u1D1F\u1D27\u1D32" + + "\u1D3E\u1D42\u1D45\u1D49\u1D4C\u1D51\u1D55\u1D58\u1D5C\u1D5F\u1D63\u1D66" + + "\u1D71\u1D78\u1D85\u1D93\u1D97\u1D9C\u1DA3\u1DAA\u1DAD\u1DB2\u1DB5\u1DBE" + + "\u1DC0\u1DC5\u1DC9\u1DD5\u1DD8\u1DDF\u1DE3\u1DE8\u1DF2\u1DFB\u1DFE\u1E03" + + "\u1E0E\u1E12\u1E18\u1E1F\u1E33\u1E48\u1E4C\u1E51\u1EA4\u1EAA\u1EB7\u1EBB" + + "\u1EBF\u1EC3\u1EC9\u1ED0\u1ED3\u1ED6\u1ED9\u1EDC\u1EE3\u1EE5\u1EE9\u1EEC" + + "\u1EF3\u1EF5\u1EFC\u1F03\u1F07\u1F0B\u1F1B\u1F22\u1F2C\u1F39\u1F44\u1F4B" + + "\u1F50\u1F54\u1F58\u1F5D\u1F6A\u1F6F\u1F73\u1F7B\u1F7E\u1F82\u1F8D\u1F90" + + "\u1F92\u1FA2\u1FA5\u1FAC\u1FAF\u1FB4\u1FC3\u1FC9\u1FD2\u1FDB\u1FE2\u1FE5" + + "\u1FEB\u1FF0\u1FF6\u1FFC\u1FFF\u2002\u2009\u200D\u2010\u201F\u2022\u2029" + + "\u202C\u2033\u2036\u2039\u2040\u204D\u2057\u2069\u206B\u2073\u2077\u2081" + + "\u2085\u2089\u208D\u208F\u2094\u2098\u209C\u209E\u20A0\u20A4\u20A8\u20AB" + + "\u20AE\u20B1\u20B4\u20B6\u20B9\u20BC\u20BF\u20C2\u20C5\u20C8\u20D1\u20D3" + + "\u20D8\u20DC\u20E2\u20E6\u20EA\u20F3\u20F8\u20FC\u2105\u210E\u2112\u2115" + + "\u2119\u211E\u2124\u2130\u213F\u2146\u2149\u214D\u2151\u2153\u215B\u2164" + + "\u216A\u216C\u216E\u2175\u2179\u2182"; + private static readonly _serializedATNSegment20: string = + "\u2186\u2195\u219D\u21B9\u21C0\u21C4\u21C7\u21CC\u21D0\u21D3\u21E3\u21EE" + + "\u21F3\u21F6\u21FA\u21FE\u2202\u2207\u220B\u220F\u2211\u221A\u221F\u2225" + + "\u2229\u222B\u2232\u2237\u223D\u223F\u2243\u224A\u2251\u2254\u225A\u225E" + + "\u2267\u226A\u226E\u2276\u2278\u227F\u2284\u2287\u228F\u2298\u22A0\u22A2" + + "\u22A6\u22AD\u22C0\u22C9\u22CF\u22E2\u22EB\u22F1\u22F5\u22FA\u2304\u230B" + + "\u2314\u2317\u2320\u2322\u2328\u232C\u2331\u233B\u2341\u2343\u2349\u234D" + + "\u2350\u235D\u2363\u2367\u236B\u236E\u2376\u237A\u237E\u2386\u238D\u2394" + + "\u2398\u239E\u23A0\u23A9\u23AC\u23B6\u23C6\u23CC\u23D1\u23D8\u23E1\u23E8" + + "\u23F0\u23F8\u23FD\u2401\u2404\u240A\u240F\u241F\u2422\u2424\u2430\u2432" + + "\u2436\u243E\u2440\u2444\u2446\u244E\u2452\u245B\u2463\u2469\u246C\u2475" + + "\u247A\u2481\u248B\u24A5\u24B0\u24B2\u24B4\u24BC\u24D3\u24DB\u24E5\u24E8" + + "\u24ED\u24F2\u24F6\u24FC\u24FF\u2502\u2505\u2509\u2517\u251E\u2525\u252C" + + "\u253E\u2546\u2552\u2558\u2565\u258C\u258E\u25A2\u25AC\u25B7\u25C3\u25CA" + + "\u25D6\u25E2\u25E8\u25F0\u2601\u261A\u2624\u2628\u262B\u262E\u2631\u263E" + + "\u2643\u2648\u264A\u2652\u265B\u2664\u2669\u2672\u2677\u2685\u268F\u2697" + + "\u26A5\u26AC\u26B4\u26BC\u26C3\u26C9\u26D2\u26E1\u26EC\u270D\u2716\u271D" + + "\u2721\u2725\u272C\u273A\u273F\u2744\u2748\u274A\u274D\u2754\u2759\u2763" + + "\u276B\u276E\u2775\u277A\u277E\u2785\u2792\u279E\u27A3\u27AB\u27B2\u27B7" + + "\u27C3\u27CB\u27D0\u27DA\u27E4\u27EB\u27F2\u27FD\u2800\u2802\u2806\u2809" + + "\u2812\u2818\u2820\u2824\u282B\u2864\u2871\u2888\u2890\u2894\u28A0\u28A2" + + "\u28A9\u28B2\u28C4\u28CC\u28D5\u28DC\u28E6\u28EC\u28F3\u28F8\u28FE\u2902" + + "\u2909\u2927\u293B\u293F\u294F\u2956\u2963\u296B\u297F\u2985\u2991\u2996" + + "\u29A0\u29C0\u29C5\u29CE\u29D3\u29D7\u29DC\u29EC\u29F1\u2A00\u2A03\u2A09" + + "\u2A0D\u2A16\u2A1E\u2A27\u2A2D\u2A36\u2A38\u2A3D\u2A48\u2A53\u2A68\u2A6F" + + "\u2A76\u2A7C\u2A7F\u2A8A\u2A91\u2A93\u2A9C\u2AA3\u2AA9\u2AAF\u2AB3\u2AB7" + + "\u2AC4\u2AD3\u2AD5\u2AD9\u2AE7\u2AED\u2AF3\u2B00\u2B03\u2B07\u2B0C\u2B11" + + "\u2B1D\u2B23\u2B27\u2B2B\u2B2F\u2B36\u2B3B\u2B3E\u2B41\u2B44\u2B47\u2B4A" + + "\u2B4D\u2B59"; public static readonly _serializedATN: string = Utils.join( [ PostgreSQLParser._serializedATNSegment0, @@ -72319,6 +72676,7 @@ export class PostgreSQLParser extends PostgreSQLParserBase { PostgreSQLParser._serializedATNSegment17, PostgreSQLParser._serializedATNSegment18, PostgreSQLParser._serializedATNSegment19, + PostgreSQLParser._serializedATNSegment20, ], "", ); @@ -72877,7 +73235,7 @@ export class PlsqlconsolecommandContext extends ParserRuleContext { export class CallstmtContext extends ParserRuleContext { - public CALL(): TerminalNode { return this.getToken(PostgreSQLParser.CALL, 0); } + public KW_CALL(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CALL, 0); } public func_application(): Func_applicationContext { return this.getRuleContext(0, Func_applicationContext); } @@ -72910,8 +73268,8 @@ export class CallstmtContext extends ParserRuleContext { export class CreaterolestmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public ROLE(): TerminalNode { return this.getToken(PostgreSQLParser.ROLE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_ROLE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ROLE, 0); } public roleid(): RoleidContext { return this.getRuleContext(0, RoleidContext); } @@ -72950,7 +73308,7 @@ export class CreaterolestmtContext extends ParserRuleContext { export class Opt_withContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -73056,22 +73414,31 @@ export class AlteroptrolelistContext extends ParserRuleContext { export class AlteroptroleelemContext extends ParserRuleContext { - public PASSWORD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PASSWORD, 0); } + public KW_PASSWORD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PASSWORD, 0); } public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } - public ENCRYPTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENCRYPTED, 0); } - public UNENCRYPTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNENCRYPTED, 0); } - public INHERIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INHERIT, 0); } - public CONNECTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONNECTION, 0); } - public LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LIMIT, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } + public KW_ENCRYPTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENCRYPTED, 0); } + public KW_UNENCRYPTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNENCRYPTED, 0); } + public KW_INHERIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INHERIT, 0); } + public KW_NOINHERIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOINHERIT, 0); } + public KW_CREATEUSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CREATEUSER, 0); } + public KW_NOCREATEUSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOCREATEUSER, 0); } + public KW_CREATEROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CREATEROLE, 0); } + public KW_NOCREATEROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOCREATEROLE, 0); } + public KW_CREATEDB(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CREATEDB, 0); } + public KW_NOCREATEDB(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOCREATEDB, 0); } + public KW_SUPERUSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SUPERUSER, 0); } + public KW_NOSUPERUSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOSUPERUSER, 0); } + public KW_CONNECTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONNECTION, 0); } + public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LIMIT, 0); } public signediconst(): SignediconstContext | undefined { return this.tryGetRuleContext(0, SignediconstContext); } - public VALID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALID, 0); } - public UNTIL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNTIL, 0); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } + public KW_VALID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALID, 0); } + public KW_UNTIL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNTIL, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } public role_list(): Role_listContext | undefined { return this.tryGetRuleContext(0, Role_listContext); } @@ -73110,17 +73477,17 @@ export class CreateoptroleelemContext extends ParserRuleContext { public alteroptroleelem(): AlteroptroleelemContext | undefined { return this.tryGetRuleContext(0, AlteroptroleelemContext); } - public SYSID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SYSID, 0); } + public KW_SYSID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SYSID, 0); } public iconst(): IconstContext | undefined { return this.tryGetRuleContext(0, IconstContext); } - public ADMIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADMIN, 0); } + public KW_ADMIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADMIN, 0); } public role_list(): Role_listContext | undefined { return this.tryGetRuleContext(0, Role_listContext); } - public ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLE, 0); } - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } - public GROUP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUP_P, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLE, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUP, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -73150,8 +73517,8 @@ export class CreateoptroleelemContext extends ParserRuleContext { export class CreateuserstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public USER(): TerminalNode { return this.getToken(PostgreSQLParser.USER, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_USER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USER, 0); } public roleid(): RoleidContext { return this.getRuleContext(0, RoleidContext); } @@ -73190,15 +73557,15 @@ export class CreateuserstmtContext extends ParserRuleContext { export class AlterrolestmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } public rolespec(): RolespecContext { return this.getRuleContext(0, RolespecContext); } public alteroptrolelist(): AlteroptrolelistContext { return this.getRuleContext(0, AlteroptrolelistContext); } - public ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLE, 0); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLE, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } public opt_with(): Opt_withContext | undefined { return this.tryGetRuleContext(0, Opt_withContext); } @@ -73231,8 +73598,8 @@ export class AlterrolestmtContext extends ParserRuleContext { export class Opt_in_databaseContext extends ParserRuleContext { - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } - public DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATABASE, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATABASE, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } @@ -73265,19 +73632,19 @@ export class Opt_in_databaseContext extends ParserRuleContext { export class AlterrolesetstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public rolespec(): RolespecContext { - return this.getRuleContext(0, RolespecContext); - } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } public opt_in_database(): Opt_in_databaseContext { return this.getRuleContext(0, Opt_in_databaseContext); } public setresetclause(): SetresetclauseContext { return this.getRuleContext(0, SetresetclauseContext); } - public ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLE, 0); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLE, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public rolespec(): RolespecContext | undefined { + return this.tryGetRuleContext(0, RolespecContext); + } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -73307,15 +73674,15 @@ export class AlterrolesetstmtContext extends ParserRuleContext { export class DroprolestmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } public role_list(): Role_listContext { return this.getRuleContext(0, Role_listContext); } - public ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLE, 0); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } - public GROUP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUP_P, 0); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLE, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUP, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -73345,10 +73712,10 @@ export class DroprolestmtContext extends ParserRuleContext { export class CreategroupstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public GROUP_P(): TerminalNode { return this.getToken(PostgreSQLParser.GROUP_P, 0); } - public roleid(): RoleidContext { - return this.getRuleContext(0, RoleidContext); + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_GROUP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GROUP, 0); } + public groupname(): GroupnameContext { + return this.getRuleContext(0, GroupnameContext); } public optrolelist(): OptrolelistContext { return this.getRuleContext(0, OptrolelistContext); @@ -73385,15 +73752,15 @@ export class CreategroupstmtContext extends ParserRuleContext { export class AltergroupstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public GROUP_P(): TerminalNode { return this.getToken(PostgreSQLParser.GROUP_P, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_GROUP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GROUP, 0); } public rolespec(): RolespecContext { return this.getRuleContext(0, RolespecContext); } public add_drop(): Add_dropContext { return this.getRuleContext(0, Add_dropContext); } - public USER(): TerminalNode { return this.getToken(PostgreSQLParser.USER, 0); } + public KW_USER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USER, 0); } public role_list(): Role_listContext { return this.getRuleContext(0, Role_listContext); } @@ -73426,8 +73793,8 @@ export class AltergroupstmtContext extends ParserRuleContext { export class Add_dropContext extends ParserRuleContext { - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -73457,21 +73824,21 @@ export class Add_dropContext extends ParserRuleContext { export class CreateschemastmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public SCHEMA(): TerminalNode { return this.getToken(PostgreSQLParser.SCHEMA, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_SCHEMA(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SCHEMA, 0); } public optschemaeltlist(): OptschemaeltlistContext { return this.getRuleContext(0, OptschemaeltlistContext); } - public AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AUTHORIZATION, 0); } + public KW_AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AUTHORIZATION, 0); } public rolespec(): RolespecContext | undefined { return this.tryGetRuleContext(0, RolespecContext); } public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public optschemaname(): OptschemanameContext | undefined { return this.tryGetRuleContext(0, OptschemanameContext); } @@ -73621,12 +73988,12 @@ export class Schema_stmtContext extends ParserRuleContext { export class VariablesetstmtContext extends ParserRuleContext { - public SET(): TerminalNode { return this.getToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SET, 0); } public set_rest(): Set_restContext { return this.getRuleContext(0, Set_restContext); } - public LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCAL, 0); } - public SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SESSION, 0); } + public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCAL, 0); } + public KW_SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SESSION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -73656,13 +74023,13 @@ export class VariablesetstmtContext extends ParserRuleContext { export class Set_restContext extends ParserRuleContext { - public TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSACTION, 0); } + public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSACTION, 0); } public transaction_mode_list(): Transaction_mode_listContext | undefined { return this.tryGetRuleContext(0, Transaction_mode_listContext); } - public SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SESSION, 0); } - public CHARACTERISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHARACTERISTICS, 0); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SESSION, 0); } + public KW_CHARACTERISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHARACTERISTICS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public set_rest_more(): Set_rest_moreContext | undefined { return this.tryGetRuleContext(0, Set_rest_moreContext); } @@ -73701,7 +74068,7 @@ export class Generic_setContext extends ParserRuleContext { public var_list(): Var_listContext { return this.getRuleContext(0, Var_listContext); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } public EQUAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EQUAL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); @@ -73738,35 +74105,35 @@ export class Set_rest_moreContext extends ParserRuleContext { public var_name(): Var_nameContext | undefined { return this.tryGetRuleContext(0, Var_nameContext); } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public CURRENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_P, 0); } - public TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIME, 0); } - public ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ZONE, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT, 0); } + public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIME, 0); } + public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ZONE, 0); } public zone_value(): Zone_valueContext | undefined { return this.tryGetRuleContext(0, Zone_valueContext); } - public CATALOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CATALOG, 0); } + public KW_CATALOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CATALOG, 0); } public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } - public NAMES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NAMES, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } + public KW_NAMES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NAMES, 0); } public opt_encoding(): Opt_encodingContext | undefined { return this.tryGetRuleContext(0, Opt_encodingContext); } - public ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLE, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLE, 0); } public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | undefined { return this.tryGetRuleContext(0, Nonreservedword_or_sconstContext); } - public SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SESSION, 0); } - public AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AUTHORIZATION, 0); } - public XML_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XML_P, 0); } - public OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPTION, 0); } + public KW_SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SESSION, 0); } + public KW_AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AUTHORIZATION, 0); } + public KW_XML(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XML, 0); } + public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPTION, 0); } public document_or_content(): Document_or_contentContext | undefined { return this.tryGetRuleContext(0, Document_or_contentContext); } - public TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSACTION, 0); } - public SNAPSHOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SNAPSHOT, 0); } + public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSACTION, 0); } + public KW_SNAPSHOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SNAPSHOT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -73925,11 +74292,11 @@ export class Var_valueContext extends ParserRuleContext { export class Iso_levelContext extends ParserRuleContext { - public READ(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.READ, 0); } - public UNCOMMITTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNCOMMITTED, 0); } - public COMMITTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMITTED, 0); } - public REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REPEATABLE, 0); } - public SERIALIZABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SERIALIZABLE, 0); } + public KW_READ(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_READ, 0); } + public KW_UNCOMMITTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNCOMMITTED, 0); } + public KW_COMMITTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COMMITTED, 0); } + public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REPEATABLE, 0); } + public KW_SERIALIZABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SERIALIZABLE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -73959,9 +74326,9 @@ export class Iso_levelContext extends ParserRuleContext { export class Opt_boolean_or_stringContext extends ParserRuleContext { - public TRUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRUE_P, 0); } - public FALSE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FALSE_P, 0); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } + public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRUE, 0); } + public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FALSE, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | undefined { return this.tryGetRuleContext(0, Nonreservedword_or_sconstContext); } @@ -74014,8 +74381,8 @@ export class Zone_valueContext extends ParserRuleContext { public numericonly(): NumericonlyContext | undefined { return this.tryGetRuleContext(0, NumericonlyContext); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } - public LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCAL, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } + public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCAL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74048,7 +74415,7 @@ export class Opt_encodingContext extends ParserRuleContext { public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74113,7 +74480,7 @@ export class Nonreservedword_or_sconstContext extends ParserRuleContext { export class VariableresetstmtContext extends ParserRuleContext { - public RESET(): TerminalNode { return this.getToken(PostgreSQLParser.RESET, 0); } + public KW_RESET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_RESET, 0); } public reset_rest(): Reset_restContext { return this.getRuleContext(0, Reset_restContext); } @@ -74149,13 +74516,13 @@ export class Reset_restContext extends ParserRuleContext { public generic_reset(): Generic_resetContext | undefined { return this.tryGetRuleContext(0, Generic_resetContext); } - public TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIME, 0); } - public ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ZONE, 0); } - public TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSACTION, 0); } - public ISOLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ISOLATION, 0); } - public LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEVEL, 0); } - public SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SESSION, 0); } - public AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AUTHORIZATION, 0); } + public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIME, 0); } + public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ZONE, 0); } + public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSACTION, 0); } + public KW_ISOLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ISOLATION, 0); } + public KW_LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEVEL, 0); } + public KW_SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SESSION, 0); } + public KW_AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AUTHORIZATION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74188,7 +74555,7 @@ export class Generic_resetContext extends ParserRuleContext { public var_name(): Var_nameContext | undefined { return this.tryGetRuleContext(0, Var_nameContext); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74218,7 +74585,7 @@ export class Generic_resetContext extends ParserRuleContext { export class SetresetclauseContext extends ParserRuleContext { - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } public set_rest(): Set_restContext | undefined { return this.tryGetRuleContext(0, Set_restContext); } @@ -74254,7 +74621,7 @@ export class SetresetclauseContext extends ParserRuleContext { export class FunctionsetresetclauseContext extends ParserRuleContext { - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } public set_rest_more(): Set_rest_moreContext | undefined { return this.tryGetRuleContext(0, Set_rest_moreContext); } @@ -74290,18 +74657,18 @@ export class FunctionsetresetclauseContext extends ParserRuleContext { export class VariableshowstmtContext extends ParserRuleContext { - public SHOW(): TerminalNode { return this.getToken(PostgreSQLParser.SHOW, 0); } + public KW_SHOW(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SHOW, 0); } public var_name(): Var_nameContext | undefined { return this.tryGetRuleContext(0, Var_nameContext); } - public TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIME, 0); } - public ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ZONE, 0); } - public TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSACTION, 0); } - public ISOLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ISOLATION, 0); } - public LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEVEL, 0); } - public SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SESSION, 0); } - public AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AUTHORIZATION, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIME, 0); } + public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ZONE, 0); } + public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSACTION, 0); } + public KW_ISOLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ISOLATION, 0); } + public KW_LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEVEL, 0); } + public KW_SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SESSION, 0); } + public KW_AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AUTHORIZATION, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74331,8 +74698,8 @@ export class VariableshowstmtContext extends ParserRuleContext { export class ConstraintssetstmtContext extends ParserRuleContext { - public SET(): TerminalNode { return this.getToken(PostgreSQLParser.SET, 0); } - public CONSTRAINTS(): TerminalNode { return this.getToken(PostgreSQLParser.CONSTRAINTS, 0); } + public KW_SET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SET, 0); } + public KW_CONSTRAINTS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CONSTRAINTS, 0); } public constraints_set_list(): Constraints_set_listContext { return this.getRuleContext(0, Constraints_set_listContext); } @@ -74368,7 +74735,7 @@ export class ConstraintssetstmtContext extends ParserRuleContext { export class Constraints_set_listContext extends ParserRuleContext { - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } public qualified_name_list(): Qualified_name_listContext | undefined { return this.tryGetRuleContext(0, Qualified_name_listContext); } @@ -74401,8 +74768,8 @@ export class Constraints_set_listContext extends ParserRuleContext { export class Constraints_set_modeContext extends ParserRuleContext { - public DEFERRED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFERRED, 0); } - public IMMEDIATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IMMEDIATE, 0); } + public KW_DEFERRED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFERRED, 0); } + public KW_IMMEDIATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IMMEDIATE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74432,7 +74799,7 @@ export class Constraints_set_modeContext extends ParserRuleContext { export class CheckpointstmtContext extends ParserRuleContext { - public CHECKPOINT(): TerminalNode { return this.getToken(PostgreSQLParser.CHECKPOINT, 0); } + public KW_CHECKPOINT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CHECKPOINT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74462,12 +74829,12 @@ export class CheckpointstmtContext extends ParserRuleContext { export class DiscardstmtContext extends ParserRuleContext { - public DISCARD(): TerminalNode { return this.getToken(PostgreSQLParser.DISCARD, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public TEMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMP, 0); } - public TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPORARY, 0); } - public PLANS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PLANS, 0); } - public SEQUENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCES, 0); } + public KW_DISCARD(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DISCARD, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_TEMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMP, 0); } + public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPORARY, 0); } + public KW_PLANS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PLANS, 0); } + public KW_SEQUENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCES, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74497,8 +74864,8 @@ export class DiscardstmtContext extends ParserRuleContext { export class AltertablestmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } public relation_expr(): Relation_exprContext | undefined { return this.tryGetRuleContext(0, Relation_exprContext); } @@ -74508,17 +74875,17 @@ export class AltertablestmtContext extends ParserRuleContext { public partition_cmd(): Partition_cmdContext | undefined { return this.tryGetRuleContext(0, Partition_cmdContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } - public TABLESPACE(): TerminalNode[]; - public TABLESPACE(i: number): TerminalNode; - public TABLESPACE(i?: number): TerminalNode | TerminalNode[] { + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } + public KW_TABLESPACE(): TerminalNode[]; + public KW_TABLESPACE(i: number): TerminalNode; + public KW_TABLESPACE(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.TABLESPACE); + return this.getTokens(PostgreSQLParser.KW_TABLESPACE); } else { - return this.getToken(PostgreSQLParser.TABLESPACE, i); + return this.getToken(PostgreSQLParser.KW_TABLESPACE, i); } } public name(): NameContext[]; @@ -74530,26 +74897,26 @@ export class AltertablestmtContext extends ParserRuleContext { return this.getRuleContext(i, NameContext); } } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public OWNED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OWNED, 0); } - public BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BY, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_OWNED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OWNED, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BY, 0); } public role_list(): Role_listContext | undefined { return this.tryGetRuleContext(0, Role_listContext); } public opt_nowait(): Opt_nowaitContext | undefined { return this.tryGetRuleContext(0, Opt_nowaitContext); } - public INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEX, 0); } + public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEX, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } public index_partition_cmd(): Index_partition_cmdContext | undefined { return this.tryGetRuleContext(0, Index_partition_cmdContext); } - public SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCE, 0); } - public VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VIEW, 0); } - public MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MATERIALIZED, 0); } - public FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOREIGN, 0); } + public KW_SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCE, 0); } + public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VIEW, 0); } + public KW_MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MATERIALIZED, 0); } + public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOREIGN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74626,15 +74993,15 @@ export class Alter_table_cmdsContext extends ParserRuleContext { export class Partition_cmdContext extends ParserRuleContext { - public ATTACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ATTACH, 0); } - public PARTITION(): TerminalNode { return this.getToken(PostgreSQLParser.PARTITION, 0); } + public KW_ATTACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ATTACH, 0); } + public KW_PARTITION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PARTITION, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } public partitionboundspec(): PartitionboundspecContext | undefined { return this.tryGetRuleContext(0, PartitionboundspecContext); } - public DETACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DETACH, 0); } + public KW_DETACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DETACH, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74664,8 +75031,8 @@ export class Partition_cmdContext extends ParserRuleContext { export class Index_partition_cmdContext extends ParserRuleContext { - public ATTACH(): TerminalNode { return this.getToken(PostgreSQLParser.ATTACH, 0); } - public PARTITION(): TerminalNode { return this.getToken(PostgreSQLParser.PARTITION, 0); } + public KW_ATTACH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ATTACH, 0); } + public KW_PARTITION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PARTITION, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } @@ -74698,15 +75065,15 @@ export class Index_partition_cmdContext extends ParserRuleContext { export class Alter_table_cmdContext extends ParserRuleContext { - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } public columnDef(): ColumnDefContext | undefined { return this.tryGetRuleContext(0, ColumnDefContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLUMN, 0); } - public ALTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALTER, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLUMN, 0); } + public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALTER, 0); } public colid(): ColidContext[]; public colid(i: number): ColidContext; public colid(i?: number): ColidContext | ColidContext[] { @@ -74722,11 +75089,11 @@ export class Alter_table_cmdContext extends ParserRuleContext { public opt_column(): Opt_columnContext | undefined { return this.tryGetRuleContext(0, Opt_columnContext); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public EXPRESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXPRESSION, 0); } - public STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STATISTICS, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_EXPRESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXPRESSION, 0); } + public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATISTICS, 0); } public signediconst(): SignediconstContext | undefined { return this.tryGetRuleContext(0, SignediconstContext); } @@ -74736,14 +75103,14 @@ export class Alter_table_cmdContext extends ParserRuleContext { public reloptions(): ReloptionsContext | undefined { return this.tryGetRuleContext(0, ReloptionsContext); } - public RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESET, 0); } - public STORAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STORAGE, 0); } - public GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GENERATED, 0); } + public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESET, 0); } + public KW_STORAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STORAGE, 0); } + public KW_GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GENERATED, 0); } public generated_when(): Generated_whenContext | undefined { return this.tryGetRuleContext(0, Generated_whenContext); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } - public IDENTITY_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IDENTITY_P, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } + public KW_IDENTITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IDENTITY, 0); } public optparenthesizedseqoptlist(): OptparenthesizedseqoptlistContext | undefined { return this.tryGetRuleContext(0, OptparenthesizedseqoptlistContext); } @@ -74753,7 +75120,7 @@ export class Alter_table_cmdContext extends ParserRuleContext { public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } public typename(): TypenameContext | undefined { return this.tryGetRuleContext(0, TypenameContext); } @@ -74772,50 +75139,50 @@ export class Alter_table_cmdContext extends ParserRuleContext { public tableconstraint(): TableconstraintContext | undefined { return this.tryGetRuleContext(0, TableconstraintContext); } - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } public constraintattributespec(): ConstraintattributespecContext | undefined { return this.tryGetRuleContext(0, ConstraintattributespecContext); } - public VALIDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALIDATE, 0); } - public WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITHOUT, 0); } - public OIDS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OIDS, 0); } - public CLUSTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLUSTER, 0); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } - public LOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOGGED, 0); } - public UNLOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNLOGGED, 0); } - public ENABLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENABLE_P, 0); } - public TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRIGGER, 0); } - public ALWAYS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALWAYS, 0); } - public REPLICA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REPLICA, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } - public DISABLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISABLE_P, 0); } - public RULE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RULE, 0); } - public INHERIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INHERIT, 0); } + public KW_VALIDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALIDATE, 0); } + public KW_WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITHOUT, 0); } + public KW_OIDS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OIDS, 0); } + public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLUSTER, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } + public KW_LOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOGGED, 0); } + public KW_UNLOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNLOGGED, 0); } + public KW_ENABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENABLE, 0); } + public KW_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIGGER, 0); } + public KW_ALWAYS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALWAYS, 0); } + public KW_REPLICA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REPLICA, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } + public KW_DISABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISABLE, 0); } + public KW_RULE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RULE, 0); } + public KW_INHERIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INHERIT, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OF, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OF, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public OWNER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OWNER, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } + public KW_OWNER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OWNER, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } public rolespec(): RolespecContext | undefined { return this.tryGetRuleContext(0, RolespecContext); } - public TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLESPACE, 0); } + public KW_TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLESPACE, 0); } public replica_identity(): Replica_identityContext | undefined { return this.tryGetRuleContext(0, Replica_identityContext); } - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } - public LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEVEL, 0); } - public SECURITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SECURITY, 0); } - public FORCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FORCE, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } + public KW_LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEVEL, 0); } + public KW_SECURITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SECURITY, 0); } + public KW_FORCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FORCE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74845,12 +75212,12 @@ export class Alter_table_cmdContext extends ParserRuleContext { export class Alter_column_defaultContext extends ParserRuleContext { - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public DEFAULT(): TerminalNode { return this.getToken(PostgreSQLParser.DEFAULT, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_DEFAULT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DEFAULT, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74880,8 +75247,8 @@ export class Alter_column_defaultContext extends ParserRuleContext { export class Opt_drop_behaviorContext extends ParserRuleContext { - public CASCADE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CASCADE, 0); } - public RESTRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESTRICT, 0); } + public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CASCADE, 0); } + public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESTRICT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -74911,7 +75278,7 @@ export class Opt_drop_behaviorContext extends ParserRuleContext { export class Opt_collate_clauseContext extends ParserRuleContext { - public COLLATE(): TerminalNode { return this.getToken(PostgreSQLParser.COLLATE, 0); } + public KW_COLLATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_COLLATE, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } @@ -74944,7 +75311,7 @@ export class Opt_collate_clauseContext extends ParserRuleContext { export class Alter_usingContext extends ParserRuleContext { - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } @@ -74977,11 +75344,11 @@ export class Alter_usingContext extends ParserRuleContext { export class Replica_identityContext extends ParserRuleContext { - public NOTHING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOTHING, 0); } - public FULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FULL, 0); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } - public INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEX, 0); } + public KW_NOTHING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOTHING, 0); } + public KW_FULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FULL, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } + public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEX, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } @@ -75048,7 +75415,7 @@ export class ReloptionsContext extends ParserRuleContext { export class Opt_reloptionsContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } public reloptions(): ReloptionsContext { return this.getRuleContext(0, ReloptionsContext); } @@ -75209,18 +75576,18 @@ export class Alter_identity_column_option_listContext extends ParserRuleContext export class Alter_identity_column_optionContext extends ParserRuleContext { - public RESTART(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESTART, 0); } + public KW_RESTART(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESTART, 0); } public numericonly(): NumericonlyContext | undefined { return this.tryGetRuleContext(0, NumericonlyContext); } public opt_with(): Opt_withContext | undefined { return this.tryGetRuleContext(0, Opt_withContext); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } public seqoptelem(): SeqoptelemContext | undefined { return this.tryGetRuleContext(0, SeqoptelemContext); } - public GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GENERATED, 0); } + public KW_GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GENERATED, 0); } public generated_when(): Generated_whenContext | undefined { return this.tryGetRuleContext(0, Generated_whenContext); } @@ -75253,9 +75620,9 @@ export class Alter_identity_column_optionContext extends ParserRuleContext { export class PartitionboundspecContext extends ParserRuleContext { - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } - public VALUES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALUES, 0); } - public WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITH, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } + public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALUES, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } public OPEN_PAREN(): TerminalNode[]; public OPEN_PAREN(i: number): TerminalNode; public OPEN_PAREN(i?: number): TerminalNode | TerminalNode[] { @@ -75277,7 +75644,7 @@ export class PartitionboundspecContext extends ParserRuleContext { return this.getToken(PostgreSQLParser.CLOSE_PAREN, i); } } - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } public expr_list(): Expr_listContext[]; public expr_list(i: number): Expr_listContext; public expr_list(i?: number): Expr_listContext | Expr_listContext[] { @@ -75287,9 +75654,9 @@ export class PartitionboundspecContext extends ParserRuleContext { return this.getRuleContext(i, Expr_listContext); } } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -75401,8 +75768,8 @@ export class Hash_partboundContext extends ParserRuleContext { export class AltercompositetypestmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public TYPE_P(): TerminalNode { return this.getToken(PostgreSQLParser.TYPE_P, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_TYPE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TYPE, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } @@ -75485,22 +75852,22 @@ export class Alter_type_cmdsContext extends ParserRuleContext { export class Alter_type_cmdContext extends ParserRuleContext { - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } - public ATTRIBUTE(): TerminalNode { return this.getToken(PostgreSQLParser.ATTRIBUTE, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } + public KW_ATTRIBUTE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ATTRIBUTE, 0); } public tablefuncelement(): TablefuncelementContext | undefined { return this.tryGetRuleContext(0, TablefuncelementContext); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public ALTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALTER, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } public typename(): TypenameContext | undefined { return this.tryGetRuleContext(0, TypenameContext); } @@ -75539,11 +75906,11 @@ export class Alter_type_cmdContext extends ParserRuleContext { export class CloseportalstmtContext extends ParserRuleContext { - public CLOSE(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE, 0); } + public KW_CLOSE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CLOSE, 0); } public cursor_name(): Cursor_nameContext | undefined { return this.tryGetRuleContext(0, Cursor_nameContext); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -75573,7 +75940,7 @@ export class CloseportalstmtContext extends ParserRuleContext { export class CopystmtContext extends ParserRuleContext { - public COPY(): TerminalNode { return this.getToken(PostgreSQLParser.COPY, 0); } + public KW_COPY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_COPY, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } @@ -75609,7 +75976,7 @@ export class CopystmtContext extends ParserRuleContext { return this.tryGetRuleContext(0, PreparablestmtContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -75639,8 +76006,8 @@ export class CopystmtContext extends ParserRuleContext { export class Copy_fromContext extends ParserRuleContext { - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -75670,7 +76037,7 @@ export class Copy_fromContext extends ParserRuleContext { export class Opt_programContext extends ParserRuleContext { - public PROGRAM(): TerminalNode { return this.getToken(PostgreSQLParser.PROGRAM, 0); } + public KW_PROGRAM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PROGRAM, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -75703,8 +76070,8 @@ export class Copy_file_nameContext extends ParserRuleContext { public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public STDIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STDIN, 0); } - public STDOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STDOUT, 0); } + public KW_STDIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STDIN, 0); } + public KW_STDOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STDOUT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -75809,27 +76176,27 @@ export class Copy_opt_listContext extends ParserRuleContext { export class Copy_opt_itemContext extends ParserRuleContext { - public BINARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BINARY, 0); } - public FREEZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FREEZE, 0); } - public DELIMITER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DELIMITER, 0); } + public KW_BINARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BINARY, 0); } + public KW_FREEZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FREEZE, 0); } + public KW_DELIMITER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DELIMITER, 0); } public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } public opt_as(): Opt_asContext | undefined { return this.tryGetRuleContext(0, Opt_asContext); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } - public CSV(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CSV, 0); } - public HEADER_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HEADER_P, 0); } - public QUOTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.QUOTE, 0); } - public ESCAPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ESCAPE, 0); } - public FORCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FORCE, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } + public KW_CSV(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CSV, 0); } + public KW_HEADER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HEADER, 0); } + public KW_QUOTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_QUOTE, 0); } + public KW_ESCAPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ESCAPE, 0); } + public KW_FORCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FORCE, 0); } public columnlist(): ColumnlistContext | undefined { return this.tryGetRuleContext(0, ColumnlistContext); } public STAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STAR, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public ENCODING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENCODING, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_ENCODING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENCODING, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -75859,7 +76226,7 @@ export class Copy_opt_itemContext extends ParserRuleContext { export class Opt_binaryContext extends ParserRuleContext { - public BINARY(): TerminalNode { return this.getToken(PostgreSQLParser.BINARY, 0); } + public KW_BINARY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BINARY, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -75889,7 +76256,7 @@ export class Opt_binaryContext extends ParserRuleContext { export class Copy_delimiterContext extends ParserRuleContext { - public DELIMITERS(): TerminalNode { return this.getToken(PostgreSQLParser.DELIMITERS, 0); } + public KW_DELIMITERS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DELIMITERS, 0); } public sconst(): SconstContext { return this.getRuleContext(0, SconstContext); } @@ -75925,7 +76292,7 @@ export class Copy_delimiterContext extends ParserRuleContext { export class Opt_usingContext extends ParserRuleContext { - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -76157,35 +76524,32 @@ export class Copy_generic_opt_arg_list_itemContext extends ParserRuleContext { export class CreatestmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public TABLE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLE, 0); } - public qualified_name(): Qualified_nameContext[]; - public qualified_name(i: number): Qualified_nameContext; - public qualified_name(i?: number): Qualified_nameContext | Qualified_nameContext[] { - if (i === undefined) { - return this.getRuleContexts(Qualified_nameContext); - } else { - return this.getRuleContext(i, Qualified_nameContext); - } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLE, 0); } + public table_qualified_name(): Table_qualified_nameContext { + return this.getRuleContext(0, Table_qualified_nameContext); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OF, 0); } + public KW_OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OF, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public PARTITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARTITION, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARTITION, 0); } + public qualified_name(): Qualified_nameContext | undefined { + return this.tryGetRuleContext(0, Qualified_nameContext); + } public partitionboundspec(): PartitionboundspecContext | undefined { return this.tryGetRuleContext(0, PartitionboundspecContext); } public opttemp(): OpttempContext | undefined { return this.tryGetRuleContext(0, OpttempContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public opttableelementlist(): OpttableelementlistContext | undefined { - return this.tryGetRuleContext(0, OpttableelementlistContext); + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public table_column_list(): Table_column_listContext | undefined { + return this.tryGetRuleContext(0, Table_column_listContext); } public optinherit(): OptinheritContext | undefined { return this.tryGetRuleContext(0, OptinheritContext); @@ -76237,11 +76601,11 @@ export class CreatestmtContext extends ParserRuleContext { export class OpttempContext extends ParserRuleContext { - public TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPORARY, 0); } - public TEMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMP, 0); } - public LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCAL, 0); } - public GLOBAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GLOBAL, 0); } - public UNLOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNLOGGED, 0); } + public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPORARY, 0); } + public KW_TEMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMP, 0); } + public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCAL, 0); } + public KW_GLOBAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GLOBAL, 0); } + public KW_UNLOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNLOGGED, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -76270,6 +76634,38 @@ export class OpttempContext extends ParserRuleContext { } +export class Table_column_listContext extends ParserRuleContext { + public tableelementlist(): TableelementlistContext { + return this.getRuleContext(0, TableelementlistContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_table_column_list; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterTable_column_list) { + listener.enterTable_column_list(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitTable_column_list) { + listener.exitTable_column_list(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitTable_column_list) { + return visitor.visitTable_column_list(this); + } else { + return visitor.visitChildren(this); + } + } +} + + export class OpttableelementlistContext extends ParserRuleContext { public tableelementlist(): TableelementlistContext { return this.getRuleContext(0, TableelementlistContext); @@ -76516,6 +76912,10 @@ export class ColumnDefContext extends ParserRuleContext { public create_generic_options(): Create_generic_optionsContext | undefined { return this.tryGetRuleContext(0, Create_generic_optionsContext); } + public KW_COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATE, 0); } + public any_name(): Any_nameContext | undefined { + return this.tryGetRuleContext(0, Any_nameContext); + } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -76551,8 +76951,8 @@ export class ColumnOptionsContext extends ParserRuleContext { public colquallist(): ColquallistContext { return this.getRuleContext(0, ColquallistContext); } - public WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITH, 0); } - public OPTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPTIONS, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } + public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPTIONS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -76620,19 +77020,18 @@ export class ColquallistContext extends ParserRuleContext { export class ColconstraintContext extends ParserRuleContext { - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } + public colconstraintelem(): ColconstraintelemContext { + return this.getRuleContext(0, ColconstraintelemContext); + } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } - public colconstraintelem(): ColconstraintelemContext | undefined { - return this.tryGetRuleContext(0, ColconstraintelemContext); + public deferrable_trigger(): Deferrable_triggerContext | undefined { + return this.tryGetRuleContext(0, Deferrable_triggerContext); } - public constraintattr(): ConstraintattrContext | undefined { - return this.tryGetRuleContext(0, ConstraintattrContext); - } - public COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATE, 0); } - public any_name(): Any_nameContext | undefined { - return this.tryGetRuleContext(0, Any_nameContext); + public initially_trigger(): Initially_triggerContext | undefined { + return this.tryGetRuleContext(0, Initially_triggerContext); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); @@ -76663,18 +77062,18 @@ export class ColconstraintContext extends ParserRuleContext { export class ColconstraintelemContext extends ParserRuleContext { - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } - public UNIQUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNIQUE, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } + public KW_UNIQUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNIQUE, 0); } public opt_definition(): Opt_definitionContext | undefined { return this.tryGetRuleContext(0, Opt_definitionContext); } public optconstablespace(): OptconstablespaceContext | undefined { return this.tryGetRuleContext(0, OptconstablespaceContext); } - public PRIMARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRIMARY, 0); } - public KEY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KEY, 0); } - public CHECK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHECK, 0); } + public KW_PRIMARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRIMARY, 0); } + public KW_KEY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_KEY, 0); } + public KW_CHECK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHECK, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); @@ -76683,21 +77082,21 @@ export class ColconstraintelemContext extends ParserRuleContext { public opt_no_inherit(): Opt_no_inheritContext | undefined { return this.tryGetRuleContext(0, Opt_no_inheritContext); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } public b_expr(): B_exprContext | undefined { return this.tryGetRuleContext(0, B_exprContext); } - public GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GENERATED, 0); } + public KW_GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GENERATED, 0); } public generated_when(): Generated_whenContext | undefined { return this.tryGetRuleContext(0, Generated_whenContext); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } - public IDENTITY_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IDENTITY_P, 0); } - public STORED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STORED, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } + public KW_IDENTITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IDENTITY, 0); } + public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STORED, 0); } public optparenthesizedseqoptlist(): OptparenthesizedseqoptlistContext | undefined { return this.tryGetRuleContext(0, OptparenthesizedseqoptlistContext); } - public REFERENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REFERENCES, 0); } + public KW_REFERENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REFERENCES, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } @@ -76739,9 +77138,9 @@ export class ColconstraintelemContext extends ParserRuleContext { export class Generated_whenContext extends ParserRuleContext { - public ALWAYS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALWAYS, 0); } - public BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BY, 0); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_ALWAYS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALWAYS, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BY, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -76770,33 +77169,62 @@ export class Generated_whenContext extends ParserRuleContext { } -export class ConstraintattrContext extends ParserRuleContext { - public DEFERRABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFERRABLE, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public INITIALLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INITIALLY, 0); } - public DEFERRED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFERRED, 0); } - public IMMEDIATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IMMEDIATE, 0); } +export class Deferrable_triggerContext extends ParserRuleContext { + public KW_DEFERRABLE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DEFERRABLE, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } // @Override - public get ruleIndex(): number { return PostgreSQLParser.RULE_constraintattr; } + public get ruleIndex(): number { return PostgreSQLParser.RULE_deferrable_trigger; } // @Override public enterRule(listener: PostgreSQLParserListener): void { - if (listener.enterConstraintattr) { - listener.enterConstraintattr(this); + if (listener.enterDeferrable_trigger) { + listener.enterDeferrable_trigger(this); } } // @Override public exitRule(listener: PostgreSQLParserListener): void { - if (listener.exitConstraintattr) { - listener.exitConstraintattr(this); + if (listener.exitDeferrable_trigger) { + listener.exitDeferrable_trigger(this); } } // @Override public accept(visitor: PostgreSQLParserVisitor): Result { - if (visitor.visitConstraintattr) { - return visitor.visitConstraintattr(this); + if (visitor.visitDeferrable_trigger) { + return visitor.visitDeferrable_trigger(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class Initially_triggerContext extends ParserRuleContext { + public KW_INITIALLY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INITIALLY, 0); } + public KW_DEFERRED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFERRED, 0); } + public KW_IMMEDIATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IMMEDIATE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_initially_trigger; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterInitially_trigger) { + listener.enterInitially_trigger(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitInitially_trigger) { + listener.exitInitially_trigger(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitInitially_trigger) { + return visitor.visitInitially_trigger(this); } else { return visitor.visitChildren(this); } @@ -76805,7 +77233,7 @@ export class ConstraintattrContext extends ParserRuleContext { export class TablelikeclauseContext extends ParserRuleContext { - public LIKE(): TerminalNode { return this.getToken(PostgreSQLParser.LIKE, 0); } + public KW_LIKE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_LIKE, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } @@ -76850,22 +77278,22 @@ export class TablelikeoptionlistContext extends ParserRuleContext { return this.getRuleContext(i, TablelikeoptionContext); } } - public INCLUDING(): TerminalNode[]; - public INCLUDING(i: number): TerminalNode; - public INCLUDING(i?: number): TerminalNode | TerminalNode[] { + public KW_INCLUDING(): TerminalNode[]; + public KW_INCLUDING(i: number): TerminalNode; + public KW_INCLUDING(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.INCLUDING); + return this.getTokens(PostgreSQLParser.KW_INCLUDING); } else { - return this.getToken(PostgreSQLParser.INCLUDING, i); + return this.getToken(PostgreSQLParser.KW_INCLUDING, i); } } - public EXCLUDING(): TerminalNode[]; - public EXCLUDING(i: number): TerminalNode; - public EXCLUDING(i?: number): TerminalNode | TerminalNode[] { + public KW_EXCLUDING(): TerminalNode[]; + public KW_EXCLUDING(i: number): TerminalNode; + public KW_EXCLUDING(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.EXCLUDING); + return this.getTokens(PostgreSQLParser.KW_EXCLUDING); } else { - return this.getToken(PostgreSQLParser.EXCLUDING, i); + return this.getToken(PostgreSQLParser.KW_EXCLUDING, i); } } constructor(parent: ParserRuleContext | undefined, invokingState: number) { @@ -76897,15 +77325,15 @@ export class TablelikeoptionlistContext extends ParserRuleContext { export class TablelikeoptionContext extends ParserRuleContext { - public COMMENTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMENTS, 0); } - public CONSTRAINTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINTS, 0); } - public DEFAULTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULTS, 0); } - public IDENTITY_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IDENTITY_P, 0); } - public GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GENERATED, 0); } - public INDEXES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEXES, 0); } - public STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STATISTICS, 0); } - public STORAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STORAGE, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_COMMENTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COMMENTS, 0); } + public KW_CONSTRAINTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINTS, 0); } + public KW_DEFAULTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULTS, 0); } + public KW_IDENTITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IDENTITY, 0); } + public KW_GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GENERATED, 0); } + public KW_INDEXES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEXES, 0); } + public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATISTICS, 0); } + public KW_STORAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STORAGE, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -76935,7 +77363,7 @@ export class TablelikeoptionContext extends ParserRuleContext { export class TableconstraintContext extends ParserRuleContext { - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } @@ -76971,7 +77399,7 @@ export class TableconstraintContext extends ParserRuleContext { export class ConstraintelemContext extends ParserRuleContext { - public CHECK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHECK, 0); } + public KW_CHECK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHECK, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); @@ -76980,7 +77408,7 @@ export class ConstraintelemContext extends ParserRuleContext { public constraintattributespec(): ConstraintattributespecContext | undefined { return this.tryGetRuleContext(0, ConstraintattributespecContext); } - public UNIQUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNIQUE, 0); } + public KW_UNIQUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNIQUE, 0); } public columnlist(): ColumnlistContext | undefined { return this.tryGetRuleContext(0, ColumnlistContext); } @@ -76996,9 +77424,9 @@ export class ConstraintelemContext extends ParserRuleContext { public optconstablespace(): OptconstablespaceContext | undefined { return this.tryGetRuleContext(0, OptconstablespaceContext); } - public PRIMARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRIMARY, 0); } - public KEY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KEY, 0); } - public EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCLUDE, 0); } + public KW_PRIMARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRIMARY, 0); } + public KW_KEY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_KEY, 0); } + public KW_EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCLUDE, 0); } public exclusionconstraintlist(): ExclusionconstraintlistContext | undefined { return this.tryGetRuleContext(0, ExclusionconstraintlistContext); } @@ -77008,8 +77436,8 @@ export class ConstraintelemContext extends ParserRuleContext { public exclusionwhereclause(): ExclusionwhereclauseContext | undefined { return this.tryGetRuleContext(0, ExclusionwhereclauseContext); } - public FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOREIGN, 0); } - public REFERENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REFERENCES, 0); } + public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_REFERENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REFERENCES, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } @@ -77051,8 +77479,8 @@ export class ConstraintelemContext extends ParserRuleContext { export class Opt_no_inheritContext extends ParserRuleContext { - public NO(): TerminalNode { return this.getToken(PostgreSQLParser.NO, 0); } - public INHERIT(): TerminalNode { return this.getToken(PostgreSQLParser.INHERIT, 0); } + public KW_NO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_NO, 0); } + public KW_INHERIT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INHERIT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -77195,7 +77623,7 @@ export class ColumnElemContext extends ParserRuleContext { export class Opt_c_includeContext extends ParserRuleContext { - public INCLUDE(): TerminalNode { return this.getToken(PostgreSQLParser.INCLUDE, 0); } + public KW_INCLUDE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INCLUDE, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public columnlist(): ColumnlistContext { return this.getRuleContext(0, ColumnlistContext); @@ -77230,10 +77658,10 @@ export class Opt_c_includeContext extends ParserRuleContext { export class Key_matchContext extends ParserRuleContext { - public MATCH(): TerminalNode { return this.getToken(PostgreSQLParser.MATCH, 0); } - public FULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FULL, 0); } - public PARTIAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARTIAL, 0); } - public SIMPLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SIMPLE, 0); } + public KW_MATCH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MATCH, 0); } + public KW_FULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FULL, 0); } + public KW_PARTIAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARTIAL, 0); } + public KW_SIMPLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SIMPLE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -77313,11 +77741,11 @@ export class ExclusionconstraintelemContext extends ParserRuleContext { public index_elem(): Index_elemContext { return this.getRuleContext(0, Index_elemContext); } - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } public any_operator(): Any_operatorContext | undefined { return this.tryGetRuleContext(0, Any_operatorContext); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { @@ -77349,7 +77777,7 @@ export class ExclusionconstraintelemContext extends ParserRuleContext { export class ExclusionwhereclauseContext extends ParserRuleContext { - public WHERE(): TerminalNode { return this.getToken(PostgreSQLParser.WHERE, 0); } + public KW_WHERE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHERE, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); @@ -77419,8 +77847,8 @@ export class Key_actionsContext extends ParserRuleContext { export class Key_updateContext extends ParserRuleContext { - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } - public UPDATE(): TerminalNode { return this.getToken(PostgreSQLParser.UPDATE, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } + public KW_UPDATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_UPDATE, 0); } public key_action(): Key_actionContext { return this.getRuleContext(0, Key_actionContext); } @@ -77453,8 +77881,8 @@ export class Key_updateContext extends ParserRuleContext { export class Key_deleteContext extends ParserRuleContext { - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } - public DELETE_P(): TerminalNode { return this.getToken(PostgreSQLParser.DELETE_P, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } + public KW_DELETE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DELETE, 0); } public key_action(): Key_actionContext { return this.getRuleContext(0, Key_actionContext); } @@ -77487,13 +77915,13 @@ export class Key_deleteContext extends ParserRuleContext { export class Key_actionContext extends ParserRuleContext { - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public ACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ACTION, 0); } - public RESTRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESTRICT, 0); } - public CASCADE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CASCADE, 0); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_ACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ACTION, 0); } + public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESTRICT, 0); } + public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CASCADE, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -77523,7 +77951,7 @@ export class Key_actionContext extends ParserRuleContext { export class OptinheritContext extends ParserRuleContext { - public INHERITS(): TerminalNode { return this.getToken(PostgreSQLParser.INHERITS, 0); } + public KW_INHERITS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INHERITS, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public qualified_name_list(): Qualified_name_listContext { return this.getRuleContext(0, Qualified_name_listContext); @@ -77590,8 +78018,8 @@ export class OptpartitionspecContext extends ParserRuleContext { export class PartitionspecContext extends ParserRuleContext { - public PARTITION(): TerminalNode { return this.getToken(PostgreSQLParser.PARTITION, 0); } - public BY(): TerminalNode { return this.getToken(PostgreSQLParser.BY, 0); } + public KW_PARTITION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PARTITION, 0); } + public KW_BY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BY, 0); } public colid(): ColidContext { return this.getRuleContext(0, ColidContext); } @@ -77722,7 +78150,7 @@ export class Part_elemContext extends ParserRuleContext { export class Table_access_method_clauseContext extends ParserRuleContext { - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -77755,12 +78183,12 @@ export class Table_access_method_clauseContext extends ParserRuleContext { export class OptwithContext extends ParserRuleContext { - public WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITH, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } public reloptions(): ReloptionsContext | undefined { return this.tryGetRuleContext(0, ReloptionsContext); } - public WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITHOUT, 0); } - public OIDS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OIDS, 0); } + public KW_WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITHOUT, 0); } + public KW_OIDS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OIDS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -77790,12 +78218,12 @@ export class OptwithContext extends ParserRuleContext { export class OncommitoptionContext extends ParserRuleContext { - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } - public COMMIT(): TerminalNode { return this.getToken(PostgreSQLParser.COMMIT, 0); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } - public DELETE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DELETE_P, 0); } - public ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROWS, 0); } - public PRESERVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRESERVE, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } + public KW_COMMIT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_COMMIT, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } + public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DELETE, 0); } + public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROWS, 0); } + public KW_PRESERVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRESERVE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -77825,7 +78253,7 @@ export class OncommitoptionContext extends ParserRuleContext { export class OpttablespaceContext extends ParserRuleContext { - public TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLESPACE, 0); } + public KW_TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLESPACE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -77858,9 +78286,9 @@ export class OpttablespaceContext extends ParserRuleContext { export class OptconstablespaceContext extends ParserRuleContext { - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } - public INDEX(): TerminalNode { return this.getToken(PostgreSQLParser.INDEX, 0); } - public TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLESPACE, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } + public KW_INDEX(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INDEX, 0); } + public KW_TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLESPACE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -77893,8 +78321,8 @@ export class OptconstablespaceContext extends ParserRuleContext { export class ExistingindexContext extends ParserRuleContext { - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } - public INDEX(): TerminalNode { return this.getToken(PostgreSQLParser.INDEX, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } + public KW_INDEX(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INDEX, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -77927,22 +78355,22 @@ export class ExistingindexContext extends ParserRuleContext { export class CreatestatsstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public STATISTICS(): TerminalNode { return this.getToken(PostgreSQLParser.STATISTICS, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_STATISTICS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_STATISTICS, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public expr_list(): Expr_listContext { return this.getRuleContext(0, Expr_listContext); } - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } public from_list(): From_listContext { return this.getRuleContext(0, From_listContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public opt_name_list(): Opt_name_listContext | undefined { return this.tryGetRuleContext(0, Opt_name_listContext); } @@ -77975,25 +78403,25 @@ export class CreatestatsstmtContext extends ParserRuleContext { export class AlterstatsstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public STATISTICS(): TerminalNode[]; - public STATISTICS(i: number): TerminalNode; - public STATISTICS(i?: number): TerminalNode | TerminalNode[] { + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_STATISTICS(): TerminalNode[]; + public KW_STATISTICS(i: number): TerminalNode; + public KW_STATISTICS(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.STATISTICS); + return this.getTokens(PostgreSQLParser.KW_STATISTICS); } else { - return this.getToken(PostgreSQLParser.STATISTICS, i); + return this.getToken(PostgreSQLParser.KW_STATISTICS, i); } } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public SET(): TerminalNode { return this.getToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SET, 0); } public signediconst(): SignediconstContext { return this.getRuleContext(0, SignediconstContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -78023,21 +78451,21 @@ export class AlterstatsstmtContext extends ParserRuleContext { export class CreateasstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public TABLE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLE, 0); } public create_as_target(): Create_as_targetContext { return this.getRuleContext(0, Create_as_targetContext); } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public selectstmt(): SelectstmtContext { return this.getRuleContext(0, SelectstmtContext); } public opttemp(): OpttempContext | undefined { return this.tryGetRuleContext(0, OpttempContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public opt_with_data(): Opt_with_dataContext | undefined { return this.tryGetRuleContext(0, Opt_with_dataContext); } @@ -78117,9 +78545,9 @@ export class Create_as_targetContext extends ParserRuleContext { export class Opt_with_dataContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } - public DATA_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATA_P, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } + public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATA, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -78149,22 +78577,22 @@ export class Opt_with_dataContext extends ParserRuleContext { export class CreatematviewstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public MATERIALIZED(): TerminalNode { return this.getToken(PostgreSQLParser.MATERIALIZED, 0); } - public VIEW(): TerminalNode { return this.getToken(PostgreSQLParser.VIEW, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_MATERIALIZED(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MATERIALIZED, 0); } + public KW_VIEW(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VIEW, 0); } public create_mv_target(): Create_mv_targetContext { return this.getRuleContext(0, Create_mv_targetContext); } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public selectstmt(): SelectstmtContext { return this.getRuleContext(0, SelectstmtContext); } public optnolog(): OptnologContext | undefined { return this.tryGetRuleContext(0, OptnologContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public opt_with_data(): Opt_with_dataContext | undefined { return this.tryGetRuleContext(0, Opt_with_dataContext); } @@ -78241,7 +78669,7 @@ export class Create_mv_targetContext extends ParserRuleContext { export class OptnologContext extends ParserRuleContext { - public UNLOGGED(): TerminalNode { return this.getToken(PostgreSQLParser.UNLOGGED, 0); } + public KW_UNLOGGED(): TerminalNode { return this.getToken(PostgreSQLParser.KW_UNLOGGED, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -78271,9 +78699,9 @@ export class OptnologContext extends ParserRuleContext { export class RefreshmatviewstmtContext extends ParserRuleContext { - public REFRESH(): TerminalNode { return this.getToken(PostgreSQLParser.REFRESH, 0); } - public MATERIALIZED(): TerminalNode { return this.getToken(PostgreSQLParser.MATERIALIZED, 0); } - public VIEW(): TerminalNode { return this.getToken(PostgreSQLParser.VIEW, 0); } + public KW_REFRESH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_REFRESH, 0); } + public KW_MATERIALIZED(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MATERIALIZED, 0); } + public KW_VIEW(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VIEW, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } @@ -78312,17 +78740,17 @@ export class RefreshmatviewstmtContext extends ParserRuleContext { export class CreateseqstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public SEQUENCE(): TerminalNode { return this.getToken(PostgreSQLParser.SEQUENCE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_SEQUENCE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SEQUENCE, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } public opttemp(): OpttempContext | undefined { return this.tryGetRuleContext(0, OpttempContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public optseqoptlist(): OptseqoptlistContext | undefined { return this.tryGetRuleContext(0, OptseqoptlistContext); } @@ -78355,16 +78783,16 @@ export class CreateseqstmtContext extends ParserRuleContext { export class AlterseqstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public SEQUENCE(): TerminalNode { return this.getToken(PostgreSQLParser.SEQUENCE, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_SEQUENCE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SEQUENCE, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } public seqoptlist(): SeqoptlistContext { return this.getRuleContext(0, SeqoptlistContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -78498,34 +78926,34 @@ export class SeqoptlistContext extends ParserRuleContext { export class SeqoptelemContext extends ParserRuleContext { - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public simpletypename(): SimpletypenameContext | undefined { return this.tryGetRuleContext(0, SimpletypenameContext); } - public CACHE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CACHE, 0); } + public KW_CACHE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CACHE, 0); } public numericonly(): NumericonlyContext | undefined { return this.tryGetRuleContext(0, NumericonlyContext); } - public CYCLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CYCLE, 0); } - public INCREMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INCREMENT, 0); } + public KW_CYCLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CYCLE, 0); } + public KW_INCREMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INCREMENT, 0); } public opt_by(): Opt_byContext | undefined { return this.tryGetRuleContext(0, Opt_byContext); } - public MAXVALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MAXVALUE, 0); } - public MINVALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MINVALUE, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public OWNED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OWNED, 0); } - public BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BY, 0); } + public KW_MAXVALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MAXVALUE, 0); } + public KW_MINVALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MINVALUE, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_OWNED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OWNED, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BY, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCE, 0); } - public NAME_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NAME_P, 0); } - public START(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.START, 0); } + public KW_SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCE, 0); } + public KW_NAME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NAME, 0); } + public KW_START(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_START, 0); } public opt_with(): Opt_withContext | undefined { return this.tryGetRuleContext(0, Opt_withContext); } - public RESTART(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESTART, 0); } + public KW_RESTART(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESTART, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -78555,7 +78983,7 @@ export class SeqoptelemContext extends ParserRuleContext { export class Opt_byContext extends ParserRuleContext { - public BY(): TerminalNode { return this.getToken(PostgreSQLParser.BY, 0); } + public KW_BY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BY, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -78669,8 +79097,8 @@ export class Numericonly_listContext extends ParserRuleContext { export class CreateplangstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public LANGUAGE(): TerminalNode { return this.getToken(PostgreSQLParser.LANGUAGE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_LANGUAGE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_LANGUAGE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -78683,7 +79111,7 @@ export class CreateplangstmtContext extends ParserRuleContext { public opt_procedural(): Opt_proceduralContext | undefined { return this.tryGetRuleContext(0, Opt_proceduralContext); } - public HANDLER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HANDLER, 0); } + public KW_HANDLER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HANDLER, 0); } public handler_name(): Handler_nameContext | undefined { return this.tryGetRuleContext(0, Handler_nameContext); } @@ -78722,7 +79150,7 @@ export class CreateplangstmtContext extends ParserRuleContext { export class Opt_trustedContext extends ParserRuleContext { - public TRUSTED(): TerminalNode { return this.getToken(PostgreSQLParser.TRUSTED, 0); } + public KW_TRUSTED(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TRUSTED, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -78787,7 +79215,7 @@ export class Handler_nameContext extends ParserRuleContext { export class Opt_inline_handlerContext extends ParserRuleContext { - public INLINE_P(): TerminalNode { return this.getToken(PostgreSQLParser.INLINE_P, 0); } + public KW_INLINE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INLINE, 0); } public handler_name(): Handler_nameContext { return this.getRuleContext(0, Handler_nameContext); } @@ -78820,11 +79248,11 @@ export class Opt_inline_handlerContext extends ParserRuleContext { export class Validator_clauseContext extends ParserRuleContext { - public VALIDATOR(): TerminalNode { return this.getToken(PostgreSQLParser.VALIDATOR, 0); } + public KW_VALIDATOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VALIDATOR, 0); } public handler_name(): Handler_nameContext | undefined { return this.tryGetRuleContext(0, Handler_nameContext); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -78886,7 +79314,7 @@ export class Opt_validatorContext extends ParserRuleContext { export class Opt_proceduralContext extends ParserRuleContext { - public PROCEDURAL(): TerminalNode { return this.getToken(PostgreSQLParser.PROCEDURAL, 0); } + public KW_PROCEDURAL(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PROCEDURAL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -78916,12 +79344,12 @@ export class Opt_proceduralContext extends ParserRuleContext { export class CreatetablespacestmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLESPACE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLESPACE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public LOCATION(): TerminalNode { return this.getToken(PostgreSQLParser.LOCATION, 0); } + public KW_LOCATION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_LOCATION, 0); } public sconst(): SconstContext { return this.getRuleContext(0, SconstContext); } @@ -78960,7 +79388,7 @@ export class CreatetablespacestmtContext extends ParserRuleContext { export class OpttablespaceownerContext extends ParserRuleContext { - public OWNER(): TerminalNode { return this.getToken(PostgreSQLParser.OWNER, 0); } + public KW_OWNER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OWNER, 0); } public rolespec(): RolespecContext { return this.getRuleContext(0, RolespecContext); } @@ -78993,13 +79421,13 @@ export class OpttablespaceownerContext extends ParserRuleContext { export class DroptablespacestmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLESPACE, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLESPACE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -79029,17 +79457,17 @@ export class DroptablespacestmtContext extends ParserRuleContext { export class CreateextensionstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public EXTENSION(): TerminalNode { return this.getToken(PostgreSQLParser.EXTENSION, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_EXTENSION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXTENSION, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } public create_extension_opt_list(): Create_extension_opt_listContext { return this.getRuleContext(0, Create_extension_opt_listContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public opt_with(): Opt_withContext | undefined { return this.tryGetRuleContext(0, Opt_withContext); } @@ -79110,16 +79538,16 @@ export class Create_extension_opt_listContext extends ParserRuleContext { export class Create_extension_opt_itemContext extends ParserRuleContext { - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } - public VERSION_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VERSION_P, 0); } + public KW_VERSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VERSION, 0); } public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | undefined { return this.tryGetRuleContext(0, Nonreservedword_or_sconstContext); } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public CASCADE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CASCADE, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CASCADE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -79149,12 +79577,12 @@ export class Create_extension_opt_itemContext extends ParserRuleContext { export class AlterextensionstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public EXTENSION(): TerminalNode { return this.getToken(PostgreSQLParser.EXTENSION, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_EXTENSION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXTENSION, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public UPDATE(): TerminalNode { return this.getToken(PostgreSQLParser.UPDATE, 0); } + public KW_UPDATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_UPDATE, 0); } public alter_extension_opt_list(): Alter_extension_opt_listContext { return this.getRuleContext(0, Alter_extension_opt_listContext); } @@ -79225,7 +79653,7 @@ export class Alter_extension_opt_listContext extends ParserRuleContext { export class Alter_extension_opt_itemContext extends ParserRuleContext { - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext { return this.getRuleContext(0, Nonreservedword_or_sconstContext); } @@ -79258,8 +79686,8 @@ export class Alter_extension_opt_itemContext extends ParserRuleContext { export class AlterextensioncontentsstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public EXTENSION(): TerminalNode { return this.getToken(PostgreSQLParser.EXTENSION, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_EXTENSION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXTENSION, 0); } public name(): NameContext[]; public name(i: number): NameContext; public name(i?: number): NameContext | NameContext[] { @@ -79281,11 +79709,11 @@ export class AlterextensioncontentsstmtContext extends ParserRuleContext { public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AGGREGATE, 0); } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AGGREGATE, 0); } public aggregate_with_argtypes(): Aggregate_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Aggregate_with_argtypesContext); } - public CAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CAST, 0); } + public KW_CAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CAST, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public typename(): TypenameContext[]; public typename(i: number): TypenameContext; @@ -79296,26 +79724,26 @@ export class AlterextensioncontentsstmtContext extends ParserRuleContext { return this.getRuleContext(i, TypenameContext); } } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public DOMAIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOMAIN_P, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_DOMAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOMAIN, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes(): Function_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypesContext); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public operator_with_argtypes(): Operator_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Operator_with_argtypesContext); } - public CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLASS, 0); } - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } - public FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FAMILY, 0); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } - public TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSFORM, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } - public LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LANGUAGE, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } + public KW_CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLASS, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } + public KW_FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FAMILY, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } + public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSFORM, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } + public KW_LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LANGUAGE, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -79345,10 +79773,10 @@ export class AlterextensioncontentsstmtContext extends ParserRuleContext { export class CreatefdwstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.FOREIGN, 0); } - public DATA_P(): TerminalNode { return this.getToken(PostgreSQLParser.DATA_P, 0); } - public WRAPPER(): TerminalNode { return this.getToken(PostgreSQLParser.WRAPPER, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_DATA(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DATA, 0); } + public KW_WRAPPER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WRAPPER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -79387,12 +79815,12 @@ export class CreatefdwstmtContext extends ParserRuleContext { export class Fdw_optionContext extends ParserRuleContext { - public HANDLER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HANDLER, 0); } + public KW_HANDLER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HANDLER, 0); } public handler_name(): Handler_nameContext | undefined { return this.tryGetRuleContext(0, Handler_nameContext); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public VALIDATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALIDATOR, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_VALIDATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALIDATOR, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -79492,10 +79920,10 @@ export class Opt_fdw_optionsContext extends ParserRuleContext { export class AlterfdwstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.FOREIGN, 0); } - public DATA_P(): TerminalNode { return this.getToken(PostgreSQLParser.DATA_P, 0); } - public WRAPPER(): TerminalNode { return this.getToken(PostgreSQLParser.WRAPPER, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_DATA(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DATA, 0); } + public KW_WRAPPER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WRAPPER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -79537,7 +79965,7 @@ export class AlterfdwstmtContext extends ParserRuleContext { export class Create_generic_optionsContext extends ParserRuleContext { - public OPTIONS(): TerminalNode { return this.getToken(PostgreSQLParser.OPTIONS, 0); } + public KW_OPTIONS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPTIONS, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public generic_option_list(): Generic_option_listContext { return this.getRuleContext(0, Generic_option_listContext); @@ -79619,7 +80047,7 @@ export class Generic_option_listContext extends ParserRuleContext { export class Alter_generic_optionsContext extends ParserRuleContext { - public OPTIONS(): TerminalNode { return this.getToken(PostgreSQLParser.OPTIONS, 0); } + public KW_OPTIONS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPTIONS, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public alter_generic_option_list(): Alter_generic_option_listContext { return this.getRuleContext(0, Alter_generic_option_listContext); @@ -79701,15 +80129,12 @@ export class Alter_generic_option_listContext extends ParserRuleContext { export class Alter_generic_option_elemContext extends ParserRuleContext { - public generic_option_elem(): Generic_option_elemContext | undefined { - return this.tryGetRuleContext(0, Generic_option_elemContext); - } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } - public generic_option_name(): Generic_option_nameContext | undefined { - return this.tryGetRuleContext(0, Generic_option_nameContext); + public generic_option_elem(): Generic_option_elemContext { + return this.getRuleContext(0, Generic_option_elemContext); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -79838,8 +80263,8 @@ export class Generic_option_argContext extends ParserRuleContext { export class CreateforeignserverstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.SERVER, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SERVER, 0); } public name(): NameContext[]; public name(i: number): NameContext; public name(i?: number): NameContext | NameContext[] { @@ -79849,9 +80274,9 @@ export class CreateforeignserverstmtContext extends ParserRuleContext { return this.getRuleContext(i, NameContext); } } - public FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.FOREIGN, 0); } - public DATA_P(): TerminalNode { return this.getToken(PostgreSQLParser.DATA_P, 0); } - public WRAPPER(): TerminalNode { return this.getToken(PostgreSQLParser.WRAPPER, 0); } + public KW_FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_DATA(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DATA, 0); } + public KW_WRAPPER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WRAPPER, 0); } public opt_type(): Opt_typeContext | undefined { return this.tryGetRuleContext(0, Opt_typeContext); } @@ -79861,9 +80286,9 @@ export class CreateforeignserverstmtContext extends ParserRuleContext { public create_generic_options(): Create_generic_optionsContext | undefined { return this.tryGetRuleContext(0, Create_generic_optionsContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -79893,7 +80318,7 @@ export class CreateforeignserverstmtContext extends ParserRuleContext { export class Opt_typeContext extends ParserRuleContext { - public TYPE_P(): TerminalNode { return this.getToken(PostgreSQLParser.TYPE_P, 0); } + public KW_TYPE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TYPE, 0); } public sconst(): SconstContext { return this.getRuleContext(0, SconstContext); } @@ -79926,11 +80351,11 @@ export class Opt_typeContext extends ParserRuleContext { export class Foreign_server_versionContext extends ParserRuleContext { - public VERSION_P(): TerminalNode { return this.getToken(PostgreSQLParser.VERSION_P, 0); } + public KW_VERSION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VERSION, 0); } public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -79992,8 +80417,8 @@ export class Opt_foreign_server_versionContext extends ParserRuleContext { export class AlterforeignserverstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.SERVER, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SERVER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -80032,9 +80457,9 @@ export class AlterforeignserverstmtContext extends ParserRuleContext { export class CreateforeigntablestmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.FOREIGN, 0); } - public TABLE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLE, 0); } public qualified_name(): Qualified_nameContext[]; public qualified_name(i: number): Qualified_nameContext; public qualified_name(i?: number): Qualified_nameContext | Qualified_nameContext[] { @@ -80046,7 +80471,7 @@ export class CreateforeigntablestmtContext extends ParserRuleContext { } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.SERVER, 0); } + public KW_SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SERVER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -80059,11 +80484,11 @@ export class CreateforeigntablestmtContext extends ParserRuleContext { public create_generic_options(): Create_generic_optionsContext | undefined { return this.tryGetRuleContext(0, Create_generic_optionsContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public PARTITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARTITION, 0); } - public OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OF, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARTITION, 0); } + public KW_OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OF, 0); } public partitionboundspec(): PartitionboundspecContext | undefined { return this.tryGetRuleContext(0, PartitionboundspecContext); } @@ -80099,9 +80524,9 @@ export class CreateforeigntablestmtContext extends ParserRuleContext { export class ImportforeignschemastmtContext extends ParserRuleContext { - public IMPORT_P(): TerminalNode { return this.getToken(PostgreSQLParser.IMPORT_P, 0); } - public FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.FOREIGN, 0); } - public SCHEMA(): TerminalNode { return this.getToken(PostgreSQLParser.SCHEMA, 0); } + public KW_IMPORT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IMPORT, 0); } + public KW_FOREIGN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_SCHEMA(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SCHEMA, 0); } public name(): NameContext[]; public name(i: number): NameContext; public name(i?: number): NameContext | NameContext[] { @@ -80111,9 +80536,9 @@ export class ImportforeignschemastmtContext extends ParserRuleContext { return this.getRuleContext(i, NameContext); } } - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } - public SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.SERVER, 0); } - public INTO(): TerminalNode { return this.getToken(PostgreSQLParser.INTO, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } + public KW_SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SERVER, 0); } + public KW_INTO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INTO, 0); } public import_qualification(): Import_qualificationContext | undefined { return this.tryGetRuleContext(0, Import_qualificationContext); } @@ -80149,9 +80574,9 @@ export class ImportforeignschemastmtContext extends ParserRuleContext { export class Import_qualification_typeContext extends ParserRuleContext { - public LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LIMIT, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } - public EXCEPT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCEPT, 0); } + public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LIMIT, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } + public KW_EXCEPT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCEPT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -80218,23 +80643,23 @@ export class Import_qualificationContext extends ParserRuleContext { export class CreateusermappingstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public USER(): TerminalNode { return this.getToken(PostgreSQLParser.USER, 0); } - public MAPPING(): TerminalNode { return this.getToken(PostgreSQLParser.MAPPING, 0); } - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_USER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USER, 0); } + public KW_MAPPING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MAPPING, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public auth_ident(): Auth_identContext { return this.getRuleContext(0, Auth_identContext); } - public SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.SERVER, 0); } + public KW_SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SERVER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } public create_generic_options(): Create_generic_optionsContext | undefined { return this.tryGetRuleContext(0, Create_generic_optionsContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -80267,7 +80692,7 @@ export class Auth_identContext extends ParserRuleContext { public rolespec(): RolespecContext | undefined { return this.tryGetRuleContext(0, RolespecContext); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -80297,19 +80722,19 @@ export class Auth_identContext extends ParserRuleContext { export class DropusermappingstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public USER(): TerminalNode { return this.getToken(PostgreSQLParser.USER, 0); } - public MAPPING(): TerminalNode { return this.getToken(PostgreSQLParser.MAPPING, 0); } - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_USER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USER, 0); } + public KW_MAPPING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MAPPING, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public auth_ident(): Auth_identContext { return this.getRuleContext(0, Auth_identContext); } - public SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.SERVER, 0); } + public KW_SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SERVER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -80339,14 +80764,14 @@ export class DropusermappingstmtContext extends ParserRuleContext { export class AlterusermappingstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public USER(): TerminalNode { return this.getToken(PostgreSQLParser.USER, 0); } - public MAPPING(): TerminalNode { return this.getToken(PostgreSQLParser.MAPPING, 0); } - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_USER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USER, 0); } + public KW_MAPPING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MAPPING, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public auth_ident(): Auth_identContext { return this.getRuleContext(0, Auth_identContext); } - public SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.SERVER, 0); } + public KW_SERVER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SERVER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -80382,12 +80807,12 @@ export class AlterusermappingstmtContext extends ParserRuleContext { export class CreatepolicystmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public POLICY(): TerminalNode { return this.getToken(PostgreSQLParser.POLICY, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_POLICY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_POLICY, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } @@ -80435,12 +80860,12 @@ export class CreatepolicystmtContext extends ParserRuleContext { export class AlterpolicystmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public POLICY(): TerminalNode { return this.getToken(PostgreSQLParser.POLICY, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_POLICY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_POLICY, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } @@ -80482,7 +80907,7 @@ export class AlterpolicystmtContext extends ParserRuleContext { export class RowsecurityoptionalexprContext extends ParserRuleContext { - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); @@ -80517,8 +80942,8 @@ export class RowsecurityoptionalexprContext extends ParserRuleContext { export class RowsecurityoptionalwithcheckContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } - public CHECK(): TerminalNode { return this.getToken(PostgreSQLParser.CHECK, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } + public KW_CHECK(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CHECK, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); @@ -80553,7 +80978,7 @@ export class RowsecurityoptionalwithcheckContext extends ParserRuleContext { export class RowsecuritydefaulttoroleContext extends ParserRuleContext { - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } public role_list(): Role_listContext { return this.getRuleContext(0, Role_listContext); } @@ -80586,7 +81011,7 @@ export class RowsecuritydefaulttoroleContext extends ParserRuleContext { export class RowsecurityoptionaltoroleContext extends ParserRuleContext { - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } public role_list(): Role_listContext { return this.getRuleContext(0, Role_listContext); } @@ -80619,7 +81044,7 @@ export class RowsecurityoptionaltoroleContext extends ParserRuleContext { export class RowsecuritydefaultpermissiveContext extends ParserRuleContext { - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public identifier(): IdentifierContext { return this.getRuleContext(0, IdentifierContext); } @@ -80652,7 +81077,7 @@ export class RowsecuritydefaultpermissiveContext extends ParserRuleContext { export class RowsecuritydefaultforcmdContext extends ParserRuleContext { - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public row_security_cmd(): Row_security_cmdContext { return this.getRuleContext(0, Row_security_cmdContext); } @@ -80685,11 +81110,11 @@ export class RowsecuritydefaultforcmdContext extends ParserRuleContext { export class Row_security_cmdContext extends ParserRuleContext { - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SELECT, 0); } - public INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INSERT, 0); } - public UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UPDATE, 0); } - public DELETE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DELETE_P, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SELECT, 0); } + public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSERT, 0); } + public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UPDATE, 0); } + public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DELETE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -80719,17 +81144,17 @@ export class Row_security_cmdContext extends ParserRuleContext { export class CreateamstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public ACCESS(): TerminalNode { return this.getToken(PostgreSQLParser.ACCESS, 0); } - public METHOD(): TerminalNode { return this.getToken(PostgreSQLParser.METHOD, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_ACCESS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ACCESS, 0); } + public KW_METHOD(): TerminalNode { return this.getToken(PostgreSQLParser.KW_METHOD, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public TYPE_P(): TerminalNode { return this.getToken(PostgreSQLParser.TYPE_P, 0); } + public KW_TYPE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TYPE, 0); } public am_type(): Am_typeContext { return this.getRuleContext(0, Am_typeContext); } - public HANDLER(): TerminalNode { return this.getToken(PostgreSQLParser.HANDLER, 0); } + public KW_HANDLER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_HANDLER, 0); } public handler_name(): Handler_nameContext { return this.getRuleContext(0, Handler_nameContext); } @@ -80762,8 +81187,8 @@ export class CreateamstmtContext extends ParserRuleContext { export class Am_typeContext extends ParserRuleContext { - public INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEX, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEX, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -80793,22 +81218,22 @@ export class Am_typeContext extends ParserRuleContext { export class CreatetrigstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public TRIGGER(): TerminalNode { return this.getToken(PostgreSQLParser.TRIGGER, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_TRIGGER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TRIGGER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public triggeractiontime(): TriggeractiontimeContext | undefined { - return this.tryGetRuleContext(0, TriggeractiontimeContext); + public triggeractiontime(): TriggeractiontimeContext { + return this.getRuleContext(0, TriggeractiontimeContext); } public triggerevents(): TriggereventsContext { return this.getRuleContext(0, TriggereventsContext); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } - public EXECUTE(): TerminalNode { return this.getToken(PostgreSQLParser.EXECUTE, 0); } + public KW_EXECUTE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXECUTE, 0); } public function_or_procedure(): Function_or_procedureContext { return this.getRuleContext(0, Function_or_procedureContext); } @@ -80829,17 +81254,16 @@ export class CreatetrigstmtContext extends ParserRuleContext { public triggerwhen(): TriggerwhenContext | undefined { return this.tryGetRuleContext(0, TriggerwhenContext); } - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } - public AFTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AFTER, 0); } public constraintattributespec(): ConstraintattributespecContext | undefined { return this.tryGetRuleContext(0, ConstraintattributespecContext); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } - public EACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EACH, 0); } - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } public optconstrfromtable(): OptconstrfromtableContext | undefined { return this.tryGetRuleContext(0, OptconstrfromtableContext); } + public foreachrow(): ForeachrowContext | undefined { + return this.tryGetRuleContext(0, ForeachrowContext); + } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -80869,10 +81293,10 @@ export class CreatetrigstmtContext extends ParserRuleContext { export class TriggeractiontimeContext extends ParserRuleContext { - public BEFORE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BEFORE, 0); } - public AFTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AFTER, 0); } - public INSTEAD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INSTEAD, 0); } - public OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OF, 0); } + public KW_BEFORE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BEFORE, 0); } + public KW_AFTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AFTER, 0); } + public KW_INSTEAD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSTEAD, 0); } + public KW_OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OF, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -80901,6 +81325,71 @@ export class TriggeractiontimeContext extends ParserRuleContext { } +export class ForeachrowContext extends ParserRuleContext { + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } + public roworstatment(): RoworstatmentContext { + return this.getRuleContext(0, RoworstatmentContext); + } + public KW_EACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EACH, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_foreachrow; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterForeachrow) { + listener.enterForeachrow(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitForeachrow) { + listener.exitForeachrow(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitForeachrow) { + return visitor.visitForeachrow(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class RoworstatmentContext extends ParserRuleContext { + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } + public KW_STATEMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATEMENT, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_roworstatment; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterRoworstatment) { + listener.enterRoworstatment(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitRoworstatment) { + listener.exitRoworstatment(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitRoworstatment) { + return visitor.visitRoworstatment(this); + } else { + return visitor.visitChildren(this); + } + } +} + + export class TriggereventsContext extends ParserRuleContext { public triggeroneevent(): TriggeroneeventContext[]; public triggeroneevent(i: number): TriggeroneeventContext; @@ -80911,13 +81400,13 @@ export class TriggereventsContext extends ParserRuleContext { return this.getRuleContext(i, TriggeroneeventContext); } } - public OR(): TerminalNode[]; - public OR(i: number): TerminalNode; - public OR(i?: number): TerminalNode | TerminalNode[] { + public KW_OR(): TerminalNode[]; + public KW_OR(i: number): TerminalNode; + public KW_OR(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.OR); + return this.getTokens(PostgreSQLParser.KW_OR); } else { - return this.getToken(PostgreSQLParser.OR, i); + return this.getToken(PostgreSQLParser.KW_OR, i); } } constructor(parent: ParserRuleContext | undefined, invokingState: number) { @@ -80949,14 +81438,14 @@ export class TriggereventsContext extends ParserRuleContext { export class TriggeroneeventContext extends ParserRuleContext { - public INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INSERT, 0); } - public DELETE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DELETE_P, 0); } - public UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UPDATE, 0); } - public OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OF, 0); } + public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSERT, 0); } + public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DELETE, 0); } + public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UPDATE, 0); } + public KW_OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OF, 0); } public columnlist(): ColumnlistContext | undefined { return this.tryGetRuleContext(0, ColumnlistContext); } - public TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRUNCATE, 0); } + public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRUNCATE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -80986,7 +81475,7 @@ export class TriggeroneeventContext extends ParserRuleContext { export class TriggerreferencingContext extends ParserRuleContext { - public REFERENCING(): TerminalNode { return this.getToken(PostgreSQLParser.REFERENCING, 0); } + public KW_REFERENCING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_REFERENCING, 0); } public triggertransitions(): TriggertransitionsContext { return this.getRuleContext(0, TriggertransitionsContext); } @@ -81098,8 +81587,8 @@ export class TriggertransitionContext extends ParserRuleContext { export class TransitionoldornewContext extends ParserRuleContext { - public NEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NEW, 0); } - public OLD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OLD, 0); } + public KW_NEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NEW, 0); } + public KW_OLD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OLD, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -81129,8 +81618,8 @@ export class TransitionoldornewContext extends ParserRuleContext { export class TransitionrowortableContext extends ParserRuleContext { - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -81192,7 +81681,7 @@ export class TransitionrelnameContext extends ParserRuleContext { export class TriggerforspecContext extends ParserRuleContext { - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public triggerfortype(): TriggerfortypeContext { return this.getRuleContext(0, TriggerfortypeContext); } @@ -81228,7 +81717,7 @@ export class TriggerforspecContext extends ParserRuleContext { export class TriggerforopteachContext extends ParserRuleContext { - public EACH(): TerminalNode { return this.getToken(PostgreSQLParser.EACH, 0); } + public KW_EACH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EACH, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -81258,8 +81747,8 @@ export class TriggerforopteachContext extends ParserRuleContext { export class TriggerfortypeContext extends ParserRuleContext { - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } - public STATEMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STATEMENT, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } + public KW_STATEMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATEMENT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -81289,7 +81778,7 @@ export class TriggerfortypeContext extends ParserRuleContext { export class TriggerwhenContext extends ParserRuleContext { - public WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.WHEN, 0); } + public KW_WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHEN, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); @@ -81324,8 +81813,8 @@ export class TriggerwhenContext extends ParserRuleContext { export class Function_or_procedureContext extends ParserRuleContext { - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -81443,7 +81932,7 @@ export class TriggerfuncargContext extends ParserRuleContext { export class OptconstrfromtableContext extends ParserRuleContext { - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } @@ -81514,14 +82003,14 @@ export class ConstraintattributespecContext extends ParserRuleContext { export class ConstraintattributeElemContext extends ParserRuleContext { - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public DEFERRABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFERRABLE, 0); } - public INITIALLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INITIALLY, 0); } - public IMMEDIATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IMMEDIATE, 0); } - public DEFERRED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFERRED, 0); } - public VALID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALID, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public INHERIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INHERIT, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_DEFERRABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFERRABLE, 0); } + public KW_INITIALLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INITIALLY, 0); } + public KW_IMMEDIATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IMMEDIATE, 0); } + public KW_DEFERRED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFERRED, 0); } + public KW_VALID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALID, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_INHERIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INHERIT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -81551,17 +82040,17 @@ export class ConstraintattributeElemContext extends ParserRuleContext { export class CreateeventtrigstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public EVENT(): TerminalNode { return this.getToken(PostgreSQLParser.EVENT, 0); } - public TRIGGER(): TerminalNode { return this.getToken(PostgreSQLParser.TRIGGER, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_EVENT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EVENT, 0); } + public KW_TRIGGER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TRIGGER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public collabel(): CollabelContext { return this.getRuleContext(0, CollabelContext); } - public EXECUTE(): TerminalNode { return this.getToken(PostgreSQLParser.EXECUTE, 0); } + public KW_EXECUTE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXECUTE, 0); } public function_or_procedure(): Function_or_procedureContext { return this.getRuleContext(0, Function_or_procedureContext); } @@ -81570,7 +82059,7 @@ export class CreateeventtrigstmtContext extends ParserRuleContext { } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public CLOSE_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public WHEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WHEN, 0); } + public KW_WHEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WHEN, 0); } public event_trigger_when_list(): Event_trigger_when_listContext | undefined { return this.tryGetRuleContext(0, Event_trigger_when_listContext); } @@ -81612,13 +82101,13 @@ export class Event_trigger_when_listContext extends ParserRuleContext { return this.getRuleContext(i, Event_trigger_when_itemContext); } } - public AND(): TerminalNode[]; - public AND(i: number): TerminalNode; - public AND(i?: number): TerminalNode | TerminalNode[] { + public KW_AND(): TerminalNode[]; + public KW_AND(i: number): TerminalNode; + public KW_AND(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.AND); + return this.getTokens(PostgreSQLParser.KW_AND); } else { - return this.getToken(PostgreSQLParser.AND, i); + return this.getToken(PostgreSQLParser.KW_AND, i); } } constructor(parent: ParserRuleContext | undefined, invokingState: number) { @@ -81653,7 +82142,7 @@ export class Event_trigger_when_itemContext extends ParserRuleContext { public colid(): ColidContext { return this.getRuleContext(0, ColidContext); } - public IN_P(): TerminalNode { return this.getToken(PostgreSQLParser.IN_P, 0); } + public KW_IN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IN, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public event_trigger_value_list(): Event_trigger_value_listContext { return this.getRuleContext(0, Event_trigger_value_listContext); @@ -81735,9 +82224,9 @@ export class Event_trigger_value_listContext extends ParserRuleContext { export class AltereventtrigstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public EVENT(): TerminalNode { return this.getToken(PostgreSQLParser.EVENT, 0); } - public TRIGGER(): TerminalNode { return this.getToken(PostgreSQLParser.TRIGGER, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_EVENT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EVENT, 0); } + public KW_TRIGGER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TRIGGER, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -81773,10 +82262,10 @@ export class AltereventtrigstmtContext extends ParserRuleContext { export class Enable_triggerContext extends ParserRuleContext { - public ENABLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENABLE_P, 0); } - public REPLICA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REPLICA, 0); } - public ALWAYS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALWAYS, 0); } - public DISABLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISABLE_P, 0); } + public KW_ENABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENABLE, 0); } + public KW_REPLICA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REPLICA, 0); } + public KW_ALWAYS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALWAYS, 0); } + public KW_DISABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISABLE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -81806,12 +82295,12 @@ export class Enable_triggerContext extends ParserRuleContext { export class CreateassertionstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public ASSERTION(): TerminalNode { return this.getToken(PostgreSQLParser.ASSERTION, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_ASSERTION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ASSERTION, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public CHECK(): TerminalNode { return this.getToken(PostgreSQLParser.CHECK, 0); } + public KW_CHECK(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CHECK, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); @@ -81849,8 +82338,8 @@ export class CreateassertionstmtContext extends ParserRuleContext { export class DefinestmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AGGREGATE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AGGREGATE, 0); } public func_name(): Func_nameContext | undefined { return this.tryGetRuleContext(0, Func_nameContext); } @@ -81866,11 +82355,11 @@ export class DefinestmtContext extends ParserRuleContext { public old_aggr_definition(): Old_aggr_definitionContext | undefined { return this.tryGetRuleContext(0, Old_aggr_definitionContext); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public any_operator(): Any_operatorContext | undefined { return this.tryGetRuleContext(0, Any_operatorContext); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } public any_name(): Any_nameContext[]; public any_name(i: number): Any_nameContext; public any_name(i?: number): Any_nameContext | Any_nameContext[] { @@ -81880,28 +82369,28 @@ export class DefinestmtContext extends ParserRuleContext { return this.getRuleContext(i, Any_nameContext); } } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } public opttablefuncelementlist(): OpttablefuncelementlistContext | undefined { return this.tryGetRuleContext(0, OpttablefuncelementlistContext); } - public ENUM_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENUM_P, 0); } + public KW_ENUM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENUM, 0); } public opt_enum_val_list(): Opt_enum_val_listContext | undefined { return this.tryGetRuleContext(0, Opt_enum_val_listContext); } - public RANGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RANGE, 0); } - public TEXT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEXT_P, 0); } - public SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEARCH, 0); } - public PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARSER, 0); } - public DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DICTIONARY, 0); } - public TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPLATE, 0); } - public CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONFIGURATION, 0); } - public COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATION, 0); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } + public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RANGE, 0); } + public KW_TEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEXT, 0); } + public KW_SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEARCH, 0); } + public KW_PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARSER, 0); } + public KW_DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DICTIONARY, 0); } + public KW_TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPLATE, 0); } + public KW_CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONFIGURATION, 0); } + public KW_COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATION, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -82063,7 +82552,7 @@ export class Def_argContext extends ParserRuleContext { public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public NONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NONE, 0); } + public KW_NONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NONE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -82289,13 +82778,13 @@ export class Enum_val_listContext extends ParserRuleContext { export class AlterenumstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public TYPE_P(): TerminalNode { return this.getToken(PostgreSQLParser.TYPE_P, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_TYPE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TYPE, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } - public VALUE_P(): TerminalNode { return this.getToken(PostgreSQLParser.VALUE_P, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } + public KW_VALUE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VALUE, 0); } public sconst(): SconstContext[]; public sconst(i: number): SconstContext; public sconst(i?: number): SconstContext | SconstContext[] { @@ -82308,10 +82797,10 @@ export class AlterenumstmtContext extends ParserRuleContext { public opt_if_not_exists(): Opt_if_not_existsContext | undefined { return this.tryGetRuleContext(0, Opt_if_not_existsContext); } - public BEFORE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BEFORE, 0); } - public AFTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AFTER, 0); } - public RENAME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RENAME, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } + public KW_BEFORE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BEFORE, 0); } + public KW_AFTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AFTER, 0); } + public KW_RENAME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RENAME, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -82341,9 +82830,9 @@ export class AlterenumstmtContext extends ParserRuleContext { export class Opt_if_not_existsContext extends ParserRuleContext { - public IF_P(): TerminalNode { return this.getToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode { return this.getToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode { return this.getToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -82373,22 +82862,22 @@ export class Opt_if_not_existsContext extends ParserRuleContext { export class CreateopclassstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.OPERATOR, 0); } - public CLASS(): TerminalNode { return this.getToken(PostgreSQLParser.CLASS, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPERATOR, 0); } + public KW_CLASS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CLASS, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } - public TYPE_P(): TerminalNode { return this.getToken(PostgreSQLParser.TYPE_P, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } + public KW_TYPE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TYPE, 0); } public typename(): TypenameContext { return this.getRuleContext(0, TypenameContext); } - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public opclass_item_list(): Opclass_item_listContext { return this.getRuleContext(0, Opclass_item_listContext); } @@ -82474,7 +82963,7 @@ export class Opclass_item_listContext extends ParserRuleContext { export class Opclass_itemContext extends ParserRuleContext { - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public iconst(): IconstContext | undefined { return this.tryGetRuleContext(0, IconstContext); } @@ -82490,7 +82979,7 @@ export class Opclass_itemContext extends ParserRuleContext { public operator_with_argtypes(): Operator_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Operator_with_argtypesContext); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes(): Function_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypesContext); } @@ -82499,7 +82988,7 @@ export class Opclass_itemContext extends ParserRuleContext { return this.tryGetRuleContext(0, Type_listContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public STORAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STORAGE, 0); } + public KW_STORAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STORAGE, 0); } public typename(): TypenameContext | undefined { return this.tryGetRuleContext(0, TypenameContext); } @@ -82532,7 +83021,7 @@ export class Opclass_itemContext extends ParserRuleContext { export class Opt_defaultContext extends ParserRuleContext { - public DEFAULT(): TerminalNode { return this.getToken(PostgreSQLParser.DEFAULT, 0); } + public KW_DEFAULT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DEFAULT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -82562,7 +83051,7 @@ export class Opt_defaultContext extends ParserRuleContext { export class Opt_opfamilyContext extends ParserRuleContext { - public FAMILY(): TerminalNode { return this.getToken(PostgreSQLParser.FAMILY, 0); } + public KW_FAMILY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FAMILY, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } @@ -82595,10 +83084,10 @@ export class Opt_opfamilyContext extends ParserRuleContext { export class Opclass_purposeContext extends ParserRuleContext { - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } - public SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEARCH, 0); } - public ORDER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ORDER, 0); } - public BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BY, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } + public KW_SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEARCH, 0); } + public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ORDER, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BY, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } @@ -82631,7 +83120,7 @@ export class Opclass_purposeContext extends ParserRuleContext { export class Opt_recheckContext extends ParserRuleContext { - public RECHECK(): TerminalNode { return this.getToken(PostgreSQLParser.RECHECK, 0); } + public KW_RECHECK(): TerminalNode { return this.getToken(PostgreSQLParser.KW_RECHECK, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -82661,13 +83150,13 @@ export class Opt_recheckContext extends ParserRuleContext { export class CreateopfamilystmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.OPERATOR, 0); } - public FAMILY(): TerminalNode { return this.getToken(PostgreSQLParser.FAMILY, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPERATOR, 0); } + public KW_FAMILY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FAMILY, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -82700,21 +83189,21 @@ export class CreateopfamilystmtContext extends ParserRuleContext { export class AlteropfamilystmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.OPERATOR, 0); } - public FAMILY(): TerminalNode { return this.getToken(PostgreSQLParser.FAMILY, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPERATOR, 0); } + public KW_FAMILY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FAMILY, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } public opclass_item_list(): Opclass_item_listContext | undefined { return this.tryGetRuleContext(0, Opclass_item_listContext); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } public opclass_drop_list(): Opclass_drop_listContext | undefined { return this.tryGetRuleContext(0, Opclass_drop_listContext); } @@ -82794,7 +83283,7 @@ export class Opclass_drop_listContext extends ParserRuleContext { export class Opclass_dropContext extends ParserRuleContext { - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public iconst(): IconstContext { return this.getRuleContext(0, IconstContext); } @@ -82803,7 +83292,7 @@ export class Opclass_dropContext extends ParserRuleContext { return this.getRuleContext(0, Type_listContext); } public CLOSE_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -82833,21 +83322,21 @@ export class Opclass_dropContext extends ParserRuleContext { export class DropopclassstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.OPERATOR, 0); } - public CLASS(): TerminalNode { return this.getToken(PostgreSQLParser.CLASS, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPERATOR, 0); } + public KW_CLASS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CLASS, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -82877,21 +83366,21 @@ export class DropopclassstmtContext extends ParserRuleContext { export class DropopfamilystmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.OPERATOR, 0); } - public FAMILY(): TerminalNode { return this.getToken(PostgreSQLParser.FAMILY, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPERATOR, 0); } + public KW_FAMILY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FAMILY, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -82921,9 +83410,9 @@ export class DropopfamilystmtContext extends ParserRuleContext { export class DropownedstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public OWNED(): TerminalNode { return this.getToken(PostgreSQLParser.OWNED, 0); } - public BY(): TerminalNode { return this.getToken(PostgreSQLParser.BY, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_OWNED(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OWNED, 0); } + public KW_BY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BY, 0); } public role_list(): Role_listContext { return this.getRuleContext(0, Role_listContext); } @@ -82959,13 +83448,13 @@ export class DropownedstmtContext extends ParserRuleContext { export class ReassignownedstmtContext extends ParserRuleContext { - public REASSIGN(): TerminalNode { return this.getToken(PostgreSQLParser.REASSIGN, 0); } - public OWNED(): TerminalNode { return this.getToken(PostgreSQLParser.OWNED, 0); } - public BY(): TerminalNode { return this.getToken(PostgreSQLParser.BY, 0); } + public KW_REASSIGN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_REASSIGN, 0); } + public KW_OWNED(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OWNED, 0); } + public KW_BY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BY, 0); } public role_list(): Role_listContext { return this.getRuleContext(0, Role_listContext); } - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } public rolespec(): RolespecContext { return this.getRuleContext(0, RolespecContext); } @@ -82998,12 +83487,12 @@ export class ReassignownedstmtContext extends ParserRuleContext { export class DropstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } public object_type_any_name(): Object_type_any_nameContext | undefined { return this.tryGetRuleContext(0, Object_type_any_nameContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public any_name_list(): Any_name_listContext | undefined { return this.tryGetRuleContext(0, Any_name_listContext); } @@ -83022,17 +83511,17 @@ export class DropstmtContext extends ParserRuleContext { public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } public type_name_list(): Type_name_listContext | undefined { return this.tryGetRuleContext(0, Type_name_listContext); } - public DOMAIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOMAIN_P, 0); } - public INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEX, 0); } - public CONCURRENTLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONCURRENTLY, 0); } + public KW_DOMAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOMAIN, 0); } + public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEX, 0); } + public KW_CONCURRENTLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONCURRENTLY, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83062,21 +83551,21 @@ export class DropstmtContext extends ParserRuleContext { export class Object_type_any_nameContext extends ParserRuleContext { - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } - public SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCE, 0); } - public VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VIEW, 0); } - public MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MATERIALIZED, 0); } - public INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEX, 0); } - public FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOREIGN, 0); } - public COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATION, 0); } - public CONVERSION_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONVERSION_P, 0); } - public STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STATISTICS, 0); } - public TEXT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEXT_P, 0); } - public SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEARCH, 0); } - public PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARSER, 0); } - public DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DICTIONARY, 0); } - public TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPLATE, 0); } - public CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONFIGURATION, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } + public KW_SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCE, 0); } + public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VIEW, 0); } + public KW_MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MATERIALIZED, 0); } + public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEX, 0); } + public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATION, 0); } + public KW_CONVERSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONVERSION, 0); } + public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATISTICS, 0); } + public KW_TEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEXT, 0); } + public KW_SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEARCH, 0); } + public KW_PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARSER, 0); } + public KW_DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DICTIONARY, 0); } + public KW_TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPLATE, 0); } + public KW_CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONFIGURATION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83109,10 +83598,10 @@ export class Object_type_nameContext extends ParserRuleContext { public drop_type_name(): Drop_type_nameContext | undefined { return this.tryGetRuleContext(0, Drop_type_nameContext); } - public DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATABASE, 0); } - public ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLE, 0); } - public SUBSCRIPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SUBSCRIPTION, 0); } - public TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLESPACE, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATABASE, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLE, 0); } + public KW_SUBSCRIPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SUBSCRIPTION, 0); } + public KW_TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLESPACE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83142,21 +83631,21 @@ export class Object_type_nameContext extends ParserRuleContext { export class Drop_type_nameContext extends ParserRuleContext { - public ACCESS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ACCESS, 0); } - public METHOD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.METHOD, 0); } - public EVENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EVENT, 0); } - public TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRIGGER, 0); } - public EXTENSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXTENSION, 0); } - public FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOREIGN, 0); } - public DATA_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATA_P, 0); } - public WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WRAPPER, 0); } - public LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LANGUAGE, 0); } + public KW_ACCESS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ACCESS, 0); } + public KW_METHOD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_METHOD, 0); } + public KW_EVENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EVENT, 0); } + public KW_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIGGER, 0); } + public KW_EXTENSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXTENSION, 0); } + public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATA, 0); } + public KW_WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WRAPPER, 0); } + public KW_LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LANGUAGE, 0); } public opt_procedural(): Opt_proceduralContext | undefined { return this.tryGetRuleContext(0, Opt_proceduralContext); } - public PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PUBLICATION, 0); } - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } - public SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SERVER, 0); } + public KW_PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PUBLICATION, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } + public KW_SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SERVER, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83186,9 +83675,9 @@ export class Drop_type_nameContext extends ParserRuleContext { export class Object_type_name_on_any_nameContext extends ParserRuleContext { - public POLICY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.POLICY, 0); } - public RULE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RULE, 0); } - public TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRIGGER, 0); } + public KW_POLICY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_POLICY, 0); } + public KW_RULE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RULE, 0); } + public KW_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIGGER, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83394,7 +83883,7 @@ export class Type_name_listContext extends ParserRuleContext { export class TruncatestmtContext extends ParserRuleContext { - public TRUNCATE(): TerminalNode { return this.getToken(PostgreSQLParser.TRUNCATE, 0); } + public KW_TRUNCATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TRUNCATE, 0); } public relation_expr_list(): Relation_expr_listContext { return this.getRuleContext(0, Relation_expr_listContext); } @@ -83436,9 +83925,9 @@ export class TruncatestmtContext extends ParserRuleContext { export class Opt_restart_seqsContext extends ParserRuleContext { - public CONTINUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONTINUE_P, 0); } - public IDENTITY_P(): TerminalNode { return this.getToken(PostgreSQLParser.IDENTITY_P, 0); } - public RESTART(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESTART, 0); } + public KW_CONTINUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONTINUE, 0); } + public KW_IDENTITY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IDENTITY, 0); } + public KW_RESTART(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESTART, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83468,14 +83957,14 @@ export class Opt_restart_seqsContext extends ParserRuleContext { export class CommentstmtContext extends ParserRuleContext { - public COMMENT(): TerminalNode { return this.getToken(PostgreSQLParser.COMMENT, 0); } - public ON(): TerminalNode[]; - public ON(i: number): TerminalNode; - public ON(i?: number): TerminalNode | TerminalNode[] { + public KW_COMMENT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_COMMENT, 0); } + public KW_ON(): TerminalNode[]; + public KW_ON(i: number): TerminalNode; + public KW_ON(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.ON); + return this.getTokens(PostgreSQLParser.KW_ON); } else { - return this.getToken(PostgreSQLParser.ON, i); + return this.getToken(PostgreSQLParser.KW_ON, i); } } public object_type_any_name(): Object_type_any_nameContext | undefined { @@ -83484,18 +83973,18 @@ export class CommentstmtContext extends ParserRuleContext { public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public IS(): TerminalNode { return this.getToken(PostgreSQLParser.IS, 0); } + public KW_IS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IS, 0); } public comment_text(): Comment_textContext { return this.getRuleContext(0, Comment_textContext); } - public COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLUMN, 0); } + public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLUMN, 0); } public object_type_name(): Object_type_nameContext | undefined { return this.tryGetRuleContext(0, Object_type_nameContext); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } public typename(): TypenameContext[]; public typename(i: number): TypenameContext; public typename(i?: number): TypenameContext | TypenameContext[] { @@ -83505,39 +83994,39 @@ export class CommentstmtContext extends ParserRuleContext { return this.getRuleContext(i, TypenameContext); } } - public DOMAIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOMAIN_P, 0); } - public AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AGGREGATE, 0); } + public KW_DOMAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOMAIN, 0); } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AGGREGATE, 0); } public aggregate_with_argtypes(): Aggregate_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Aggregate_with_argtypesContext); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes(): Function_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypesContext); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public operator_with_argtypes(): Operator_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Operator_with_argtypesContext); } - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } public object_type_name_on_any_name(): Object_type_name_on_any_nameContext | undefined { return this.tryGetRuleContext(0, Object_type_name_on_any_nameContext); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } - public TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSFORM, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } - public LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LANGUAGE, 0); } - public CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLASS, 0); } - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } - public FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FAMILY, 0); } - public LARGE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LARGE_P, 0); } - public OBJECT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OBJECT_P, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } + public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSFORM, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } + public KW_LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LANGUAGE, 0); } + public KW_CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLASS, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } + public KW_FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FAMILY, 0); } + public KW_LARGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LARGE, 0); } + public KW_OBJECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OBJECT, 0); } public numericonly(): NumericonlyContext | undefined { return this.tryGetRuleContext(0, NumericonlyContext); } - public CAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CAST, 0); } + public KW_CAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CAST, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); @@ -83571,7 +84060,7 @@ export class Comment_textContext extends ParserRuleContext { public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83601,49 +84090,49 @@ export class Comment_textContext extends ParserRuleContext { export class SeclabelstmtContext extends ParserRuleContext { - public SECURITY(): TerminalNode { return this.getToken(PostgreSQLParser.SECURITY, 0); } - public LABEL(): TerminalNode { return this.getToken(PostgreSQLParser.LABEL, 0); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_SECURITY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SECURITY, 0); } + public KW_LABEL(): TerminalNode { return this.getToken(PostgreSQLParser.KW_LABEL, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public object_type_any_name(): Object_type_any_nameContext | undefined { return this.tryGetRuleContext(0, Object_type_any_nameContext); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public IS(): TerminalNode { return this.getToken(PostgreSQLParser.IS, 0); } + public KW_IS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IS, 0); } public security_label(): Security_labelContext { return this.getRuleContext(0, Security_labelContext); } public opt_provider(): Opt_providerContext | undefined { return this.tryGetRuleContext(0, Opt_providerContext); } - public COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLUMN, 0); } + public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLUMN, 0); } public object_type_name(): Object_type_nameContext | undefined { return this.tryGetRuleContext(0, Object_type_nameContext); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } public typename(): TypenameContext | undefined { return this.tryGetRuleContext(0, TypenameContext); } - public DOMAIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOMAIN_P, 0); } - public AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AGGREGATE, 0); } + public KW_DOMAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOMAIN, 0); } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AGGREGATE, 0); } public aggregate_with_argtypes(): Aggregate_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Aggregate_with_argtypesContext); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes(): Function_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypesContext); } - public LARGE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LARGE_P, 0); } - public OBJECT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OBJECT_P, 0); } + public KW_LARGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LARGE, 0); } + public KW_OBJECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OBJECT, 0); } public numericonly(): NumericonlyContext | undefined { return this.tryGetRuleContext(0, NumericonlyContext); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83673,7 +84162,7 @@ export class SeclabelstmtContext extends ParserRuleContext { export class Opt_providerContext extends ParserRuleContext { - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext { return this.getRuleContext(0, Nonreservedword_or_sconstContext); } @@ -83709,7 +84198,7 @@ export class Security_labelContext extends ParserRuleContext { public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83739,11 +84228,11 @@ export class Security_labelContext extends ParserRuleContext { export class FetchstmtContext extends ParserRuleContext { - public FETCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FETCH, 0); } + public KW_FETCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FETCH, 0); } public fetch_args(): Fetch_argsContext { return this.getRuleContext(0, Fetch_argsContext); } - public MOVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MOVE, 0); } + public KW_MOVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MOVE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83779,21 +84268,21 @@ export class Fetch_argsContext extends ParserRuleContext { public from_in(): From_inContext | undefined { return this.tryGetRuleContext(0, From_inContext); } - public NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NEXT, 0); } + public KW_NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NEXT, 0); } public opt_from_in(): Opt_from_inContext | undefined { return this.tryGetRuleContext(0, Opt_from_inContext); } - public PRIOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRIOR, 0); } - public FIRST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FIRST_P, 0); } - public LAST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LAST_P, 0); } - public ABSOLUTE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ABSOLUTE_P, 0); } + public KW_PRIOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRIOR, 0); } + public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FIRST, 0); } + public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LAST, 0); } + public KW_ABSOLUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ABSOLUTE, 0); } public signediconst(): SignediconstContext | undefined { return this.tryGetRuleContext(0, SignediconstContext); } - public RELATIVE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RELATIVE_P, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public FORWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FORWARD, 0); } - public BACKWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BACKWARD, 0); } + public KW_RELATIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RELATIVE, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_FORWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FORWARD, 0); } + public KW_BACKWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BACKWARD, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83823,8 +84312,8 @@ export class Fetch_argsContext extends ParserRuleContext { export class From_inContext extends ParserRuleContext { - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83886,15 +84375,15 @@ export class Opt_from_inContext extends ParserRuleContext { export class GrantstmtContext extends ParserRuleContext { - public GRANT(): TerminalNode { return this.getToken(PostgreSQLParser.GRANT, 0); } + public KW_GRANT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GRANT, 0); } public privileges(): PrivilegesContext { return this.getRuleContext(0, PrivilegesContext); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public privilege_target(): Privilege_targetContext { return this.getRuleContext(0, Privilege_targetContext); } - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } public grantee_list(): Grantee_listContext { return this.getRuleContext(0, Grantee_listContext); } @@ -83930,24 +84419,24 @@ export class GrantstmtContext extends ParserRuleContext { export class RevokestmtContext extends ParserRuleContext { - public REVOKE(): TerminalNode { return this.getToken(PostgreSQLParser.REVOKE, 0); } + public KW_REVOKE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_REVOKE, 0); } public privileges(): PrivilegesContext { return this.getRuleContext(0, PrivilegesContext); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public privilege_target(): Privilege_targetContext { return this.getRuleContext(0, Privilege_targetContext); } - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } public grantee_list(): Grantee_listContext { return this.getRuleContext(0, Grantee_listContext); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public GRANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GRANT, 0); } - public OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPTION, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } + public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GRANT, 0); } + public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPTION, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -83980,13 +84469,16 @@ export class PrivilegesContext extends ParserRuleContext { public privilege_list(): Privilege_listContext | undefined { return this.tryGetRuleContext(0, Privilege_listContext); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public PRIVILEGES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRIVILEGES, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_PRIVILEGES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRIVILEGES, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public columnlist(): ColumnlistContext | undefined { return this.tryGetRuleContext(0, ColumnlistContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } + public beforeprivilegeselectlist(): BeforeprivilegeselectlistContext | undefined { + return this.tryGetRuleContext(0, BeforeprivilegeselectlistContext); + } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84015,6 +84507,95 @@ export class PrivilegesContext extends ParserRuleContext { } +export class BeforeprivilegeselectlistContext extends ParserRuleContext { + public beforeprivilegeselect(): BeforeprivilegeselectContext[]; + public beforeprivilegeselect(i: number): BeforeprivilegeselectContext; + public beforeprivilegeselect(i?: number): BeforeprivilegeselectContext | BeforeprivilegeselectContext[] { + if (i === undefined) { + return this.getRuleContexts(BeforeprivilegeselectContext); + } else { + return this.getRuleContext(i, BeforeprivilegeselectContext); + } + } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_beforeprivilegeselectlist; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterBeforeprivilegeselectlist) { + listener.enterBeforeprivilegeselectlist(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitBeforeprivilegeselectlist) { + listener.exitBeforeprivilegeselectlist(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitBeforeprivilegeselectlist) { + return visitor.visitBeforeprivilegeselectlist(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class BeforeprivilegeselectContext extends ParserRuleContext { + public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SELECT, 0); } + public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSERT, 0); } + public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UPDATE, 0); } + public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DELETE, 0); } + public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRUNCATE, 0); } + public KW_PEFERENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PEFERENCES, 0); } + public KW_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIGGER, 0); } + public KW_USAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USAGE, 0); } + public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_CONNECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONNECT, 0); } + public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPORARY, 0); } + public KW_TEMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMP, 0); } + public KW_EXECUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXECUTE, 0); } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_beforeprivilegeselect; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterBeforeprivilegeselect) { + listener.enterBeforeprivilegeselect(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitBeforeprivilegeselect) { + listener.exitBeforeprivilegeselect(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitBeforeprivilegeselect) { + return visitor.visitBeforeprivilegeselect(this); + } else { + return visitor.visitChildren(this); + } + } +} + + export class Privilege_listContext extends ParserRuleContext { public privilege(): PrivilegeContext[]; public privilege(i: number): PrivilegeContext; @@ -84063,12 +84644,12 @@ export class Privilege_listContext extends ParserRuleContext { export class PrivilegeContext extends ParserRuleContext { - public SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SELECT, 0); } + public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SELECT, 0); } public opt_column_list(): Opt_column_listContext | undefined { return this.tryGetRuleContext(0, Opt_column_listContext); } - public REFERENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REFERENCES, 0); } - public CREATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CREATE, 0); } + public KW_REFERENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REFERENCES, 0); } + public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CREATE, 0); } public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } @@ -84104,42 +84685,42 @@ export class Privilege_targetContext extends ParserRuleContext { public qualified_name_list(): Qualified_name_listContext | undefined { return this.tryGetRuleContext(0, Qualified_name_listContext); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } - public SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCE, 0); } - public FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOREIGN, 0); } - public DATA_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATA_P, 0); } - public WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WRAPPER, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } + public KW_SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCE, 0); } + public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATA, 0); } + public KW_WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WRAPPER, 0); } public name_list(): Name_listContext | undefined { return this.tryGetRuleContext(0, Name_listContext); } - public SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SERVER, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SERVER, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes_list(): Function_with_argtypes_listContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypes_listContext); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } - public DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATABASE, 0); } - public DOMAIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOMAIN_P, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATABASE, 0); } + public KW_DOMAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOMAIN, 0); } public any_name_list(): Any_name_listContext | undefined { return this.tryGetRuleContext(0, Any_name_listContext); } - public LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LANGUAGE, 0); } - public LARGE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LARGE_P, 0); } - public OBJECT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OBJECT_P, 0); } + public KW_LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LANGUAGE, 0); } + public KW_LARGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LARGE, 0); } + public KW_OBJECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OBJECT, 0); } public numericonly_list(): Numericonly_listContext | undefined { return this.tryGetRuleContext(0, Numericonly_listContext); } - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } - public TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLESPACE, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public TABLES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLES, 0); } - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } - public SEQUENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCES, 0); } - public FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTIONS, 0); } - public PROCEDURES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURES, 0); } - public ROUTINES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINES, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } + public KW_TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLESPACE, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLES, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } + public KW_SEQUENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCES, 0); } + public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTIONS, 0); } + public KW_PROCEDURES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURES, 0); } + public KW_ROUTINES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINES, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84219,7 +84800,7 @@ export class GranteeContext extends ParserRuleContext { public rolespec(): RolespecContext { return this.getRuleContext(0, RolespecContext); } - public GROUP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUP_P, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUP, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84249,9 +84830,9 @@ export class GranteeContext extends ParserRuleContext { export class Opt_grant_grant_optionContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } - public GRANT(): TerminalNode { return this.getToken(PostgreSQLParser.GRANT, 0); } - public OPTION(): TerminalNode { return this.getToken(PostgreSQLParser.OPTION, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } + public KW_GRANT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GRANT, 0); } + public KW_OPTION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPTION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84281,11 +84862,11 @@ export class Opt_grant_grant_optionContext extends ParserRuleContext { export class GrantrolestmtContext extends ParserRuleContext { - public GRANT(): TerminalNode { return this.getToken(PostgreSQLParser.GRANT, 0); } + public KW_GRANT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GRANT, 0); } public privilege_list(): Privilege_listContext { return this.getRuleContext(0, Privilege_listContext); } - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } public role_list(): Role_listContext { return this.getRuleContext(0, Role_listContext); } @@ -84324,11 +84905,11 @@ export class GrantrolestmtContext extends ParserRuleContext { export class RevokerolestmtContext extends ParserRuleContext { - public REVOKE(): TerminalNode { return this.getToken(PostgreSQLParser.REVOKE, 0); } + public KW_REVOKE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_REVOKE, 0); } public privilege_list(): Privilege_listContext { return this.getRuleContext(0, Privilege_listContext); } - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } public role_list(): Role_listContext { return this.getRuleContext(0, Role_listContext); } @@ -84338,9 +84919,9 @@ export class RevokerolestmtContext extends ParserRuleContext { public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public ADMIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADMIN, 0); } - public OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPTION, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } + public KW_ADMIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADMIN, 0); } + public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPTION, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84370,9 +84951,9 @@ export class RevokerolestmtContext extends ParserRuleContext { export class Opt_grant_admin_optionContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } - public ADMIN(): TerminalNode { return this.getToken(PostgreSQLParser.ADMIN, 0); } - public OPTION(): TerminalNode { return this.getToken(PostgreSQLParser.OPTION, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } + public KW_ADMIN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ADMIN, 0); } + public KW_OPTION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPTION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84402,8 +84983,8 @@ export class Opt_grant_admin_optionContext extends ParserRuleContext { export class Opt_granted_byContext extends ParserRuleContext { - public GRANTED(): TerminalNode { return this.getToken(PostgreSQLParser.GRANTED, 0); } - public BY(): TerminalNode { return this.getToken(PostgreSQLParser.BY, 0); } + public KW_GRANTED(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GRANTED, 0); } + public KW_BY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BY, 0); } public rolespec(): RolespecContext { return this.getRuleContext(0, RolespecContext); } @@ -84436,9 +85017,9 @@ export class Opt_granted_byContext extends ParserRuleContext { export class AlterdefaultprivilegesstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public DEFAULT(): TerminalNode { return this.getToken(PostgreSQLParser.DEFAULT, 0); } - public PRIVILEGES(): TerminalNode { return this.getToken(PostgreSQLParser.PRIVILEGES, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_DEFAULT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DEFAULT, 0); } + public KW_PRIVILEGES(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PRIVILEGES, 0); } public defacloptionlist(): DefacloptionlistContext { return this.getRuleContext(0, DefacloptionlistContext); } @@ -84512,17 +85093,17 @@ export class DefacloptionlistContext extends ParserRuleContext { export class DefacloptionContext extends ParserRuleContext { - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } public name_list(): Name_listContext | undefined { return this.tryGetRuleContext(0, Name_listContext); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } - public ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLE, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLE, 0); } public role_list(): Role_listContext | undefined { return this.tryGetRuleContext(0, Role_listContext); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84552,28 +85133,28 @@ export class DefacloptionContext extends ParserRuleContext { export class DefaclactionContext extends ParserRuleContext { - public GRANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GRANT, 0); } + public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GRANT, 0); } public privileges(): PrivilegesContext { return this.getRuleContext(0, PrivilegesContext); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public defacl_privilege_target(): Defacl_privilege_targetContext { return this.getRuleContext(0, Defacl_privilege_targetContext); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } public grantee_list(): Grantee_listContext { return this.getRuleContext(0, Grantee_listContext); } public opt_grant_grant_option(): Opt_grant_grant_optionContext | undefined { return this.tryGetRuleContext(0, Opt_grant_grant_optionContext); } - public REVOKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REVOKE, 0); } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } + public KW_REVOKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REVOKE, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPTION, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } + public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPTION, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84603,12 +85184,12 @@ export class DefaclactionContext extends ParserRuleContext { export class Defacl_privilege_targetContext extends ParserRuleContext { - public TABLES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLES, 0); } - public FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTIONS, 0); } - public ROUTINES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINES, 0); } - public SEQUENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCES, 0); } - public TYPES_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPES_P, 0); } - public SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMAS, 0); } + public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLES, 0); } + public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTIONS, 0); } + public KW_ROUTINES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINES, 0); } + public KW_SEQUENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCES, 0); } + public KW_TYPES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPES, 0); } + public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMAS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84638,9 +85219,9 @@ export class Defacl_privilege_targetContext extends ParserRuleContext { export class IndexstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public INDEX(): TerminalNode { return this.getToken(PostgreSQLParser.INDEX, 0); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_INDEX(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INDEX, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public relation_expr(): Relation_exprContext { return this.getRuleContext(0, Relation_exprContext); } @@ -84673,9 +85254,9 @@ export class IndexstmtContext extends ParserRuleContext { public where_clause(): Where_clauseContext | undefined { return this.tryGetRuleContext(0, Where_clauseContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } @@ -84708,7 +85289,7 @@ export class IndexstmtContext extends ParserRuleContext { export class Opt_uniqueContext extends ParserRuleContext { - public UNIQUE(): TerminalNode { return this.getToken(PostgreSQLParser.UNIQUE, 0); } + public KW_UNIQUE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_UNIQUE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84738,7 +85319,7 @@ export class Opt_uniqueContext extends ParserRuleContext { export class Opt_concurrentlyContext extends ParserRuleContext { - public CONCURRENTLY(): TerminalNode { return this.getToken(PostgreSQLParser.CONCURRENTLY, 0); } + public KW_CONCURRENTLY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CONCURRENTLY, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -84800,7 +85381,7 @@ export class Opt_index_nameContext extends ParserRuleContext { export class Access_method_clauseContext extends ParserRuleContext { - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -84970,7 +85551,7 @@ export class Index_elemContext extends ParserRuleContext { export class Opt_includeContext extends ParserRuleContext { - public INCLUDE(): TerminalNode { return this.getToken(PostgreSQLParser.INCLUDE, 0); } + public KW_INCLUDE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INCLUDE, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public index_including_params(): Index_including_paramsContext { return this.getRuleContext(0, Index_including_paramsContext); @@ -85052,7 +85633,7 @@ export class Index_including_paramsContext extends ParserRuleContext { export class Opt_collateContext extends ParserRuleContext { - public COLLATE(): TerminalNode { return this.getToken(PostgreSQLParser.COLLATE, 0); } + public KW_COLLATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_COLLATE, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } @@ -85117,8 +85698,8 @@ export class Opt_classContext extends ParserRuleContext { export class Opt_asc_descContext extends ParserRuleContext { - public ASC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ASC, 0); } - public DESC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DESC, 0); } + public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ASC, 0); } + public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DESC, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -85148,9 +85729,9 @@ export class Opt_asc_descContext extends ParserRuleContext { export class Opt_nulls_orderContext extends ParserRuleContext { - public NULLS_P(): TerminalNode { return this.getToken(PostgreSQLParser.NULLS_P, 0); } - public FIRST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FIRST_P, 0); } - public LAST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LAST_P, 0); } + public KW_NULLS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_NULLS, 0); } + public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FIRST, 0); } + public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LAST, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -85180,7 +85761,7 @@ export class Opt_nulls_orderContext extends ParserRuleContext { export class CreatefunctionstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } public func_name(): Func_nameContext { return this.getRuleContext(0, Func_nameContext); } @@ -85190,16 +85771,20 @@ export class CreatefunctionstmtContext extends ParserRuleContext { public createfunc_opt_list(): Createfunc_opt_listContext { return this.getRuleContext(0, Createfunc_opt_listContext); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } public opt_or_replace(): Opt_or_replaceContext | undefined { return this.tryGetRuleContext(0, Opt_or_replaceContext); } - public RETURNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RETURNS, 0); } + public KW_RETURNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RETURNS, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } + public attrilist(): AttrilistContext | undefined { + return this.tryGetRuleContext(0, AttrilistContext); + } public func_return(): Func_returnContext | undefined { return this.tryGetRuleContext(0, Func_returnContext); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public table_func_column_list(): Table_func_column_listContext | undefined { return this.tryGetRuleContext(0, Table_func_column_listContext); @@ -85233,9 +85818,58 @@ export class CreatefunctionstmtContext extends ParserRuleContext { } +export class AttrilistContext extends ParserRuleContext { + public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } + public colid(): ColidContext[]; + public colid(i: number): ColidContext; + public colid(i?: number): ColidContext | ColidContext[] { + if (i === undefined) { + return this.getRuleContexts(ColidContext); + } else { + return this.getRuleContext(i, ColidContext); + } + } + public CLOSE_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); } + public COMMA(): TerminalNode[]; + public COMMA(i: number): TerminalNode; + public COMMA(i?: number): TerminalNode | TerminalNode[] { + if (i === undefined) { + return this.getTokens(PostgreSQLParser.COMMA); + } else { + return this.getToken(PostgreSQLParser.COMMA, i); + } + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_attrilist; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterAttrilist) { + listener.enterAttrilist(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitAttrilist) { + listener.exitAttrilist(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitAttrilist) { + return visitor.visitAttrilist(this); + } else { + return visitor.visitChildren(this); + } + } +} + + export class Opt_or_replaceContext extends ParserRuleContext { - public OR(): TerminalNode { return this.getToken(PostgreSQLParser.OR, 0); } - public REPLACE(): TerminalNode { return this.getToken(PostgreSQLParser.REPLACE, 0); } + public KW_OR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OR, 0); } + public KW_REPLACE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_REPLACE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -85556,10 +86190,10 @@ export class Func_argContext extends ParserRuleContext { export class Arg_classContext extends ParserRuleContext { - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } - public OUT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OUT_P, 0); } - public INOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INOUT, 0); } - public VARIADIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VARIADIC, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } + public KW_OUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OUT, 0); } + public KW_INOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INOUT, 0); } + public KW_VARIADIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VARIADIC, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -85663,8 +86297,8 @@ export class Func_typeContext extends ParserRuleContext { return this.tryGetRuleContext(0, AttrsContext); } public PERCENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PERCENT, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } - public SETOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SETOF, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } + public KW_SETOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SETOF, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -85700,7 +86334,7 @@ export class Func_arg_with_defaultContext extends ParserRuleContext { public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } public EQUAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EQUAL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); @@ -85775,8 +86409,8 @@ export class Aggr_argsContext extends ParserRuleContext { return this.getRuleContext(i, Aggr_args_listContext); } } - public ORDER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ORDER, 0); } - public BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BY, 0); } + public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ORDER, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BY, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -85973,42 +86607,42 @@ export class Createfunc_opt_listContext extends ParserRuleContext { export class Common_func_opt_itemContext extends ParserRuleContext { - public CALLED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CALLED, 0); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } - public NULL_P(): TerminalNode[]; - public NULL_P(i: number): TerminalNode; - public NULL_P(i?: number): TerminalNode | TerminalNode[] { + public KW_CALLED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CALLED, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } + public KW_NULL(): TerminalNode[]; + public KW_NULL(i: number): TerminalNode; + public KW_NULL(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.NULL_P); + return this.getTokens(PostgreSQLParser.KW_NULL); } else { - return this.getToken(PostgreSQLParser.NULL_P, i); + return this.getToken(PostgreSQLParser.KW_NULL, i); } } - public INPUT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INPUT_P, 0); } - public RETURNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RETURNS, 0); } - public STRICT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STRICT_P, 0); } - public IMMUTABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IMMUTABLE, 0); } - public STABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STABLE, 0); } - public VOLATILE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VOLATILE, 0); } - public EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXTERNAL, 0); } - public SECURITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SECURITY, 0); } - public DEFINER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFINER, 0); } - public INVOKER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INVOKER, 0); } - public LEAKPROOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEAKPROOF, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public COST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COST, 0); } + public KW_INPUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INPUT, 0); } + public KW_RETURNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RETURNS, 0); } + public KW_STRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STRICT, 0); } + public KW_IMMUTABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IMMUTABLE, 0); } + public KW_STABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STABLE, 0); } + public KW_VOLATILE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VOLATILE, 0); } + public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXTERNAL, 0); } + public KW_SECURITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SECURITY, 0); } + public KW_DEFINER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFINER, 0); } + public KW_INVOKER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INVOKER, 0); } + public KW_LEAKPROOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEAKPROOF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_COST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COST, 0); } public numericonly(): NumericonlyContext | undefined { return this.tryGetRuleContext(0, NumericonlyContext); } - public ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROWS, 0); } - public SUPPORT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SUPPORT, 0); } + public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROWS, 0); } + public KW_SUPPORT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SUPPORT, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } public functionsetresetclause(): FunctionsetresetclauseContext | undefined { return this.tryGetRuleContext(0, FunctionsetresetclauseContext); } - public PARALLEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARALLEL, 0); } + public KW_PARALLEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARALLEL, 0); } public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } @@ -86041,19 +86675,19 @@ export class Common_func_opt_itemContext extends ParserRuleContext { export class Createfunc_opt_itemContext extends ParserRuleContext { - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public func_as(): Func_asContext | undefined { return this.tryGetRuleContext(0, Func_asContext); } - public LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LANGUAGE, 0); } + public KW_LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LANGUAGE, 0); } public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | undefined { return this.tryGetRuleContext(0, Nonreservedword_or_sconstContext); } - public TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSFORM, 0); } + public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSFORM, 0); } public transform_type_list(): Transform_type_listContext | undefined { return this.tryGetRuleContext(0, Transform_type_listContext); } - public WINDOW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WINDOW, 0); } + public KW_WINDOW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WINDOW, 0); } public common_func_opt_item(): Common_func_opt_itemContext | undefined { return this.tryGetRuleContext(0, Common_func_opt_itemContext); } @@ -86127,22 +86761,22 @@ export class Func_asContext extends ParserRuleContext { export class Transform_type_listContext extends ParserRuleContext { - public FOR(): TerminalNode[]; - public FOR(i: number): TerminalNode; - public FOR(i?: number): TerminalNode | TerminalNode[] { + public KW_FOR(): TerminalNode[]; + public KW_FOR(i: number): TerminalNode; + public KW_FOR(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.FOR); + return this.getTokens(PostgreSQLParser.KW_FOR); } else { - return this.getToken(PostgreSQLParser.FOR, i); + return this.getToken(PostgreSQLParser.KW_FOR, i); } } - public TYPE_P(): TerminalNode[]; - public TYPE_P(i: number): TerminalNode; - public TYPE_P(i?: number): TerminalNode | TerminalNode[] { + public KW_TYPE(): TerminalNode[]; + public KW_TYPE(i: number): TerminalNode; + public KW_TYPE(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.TYPE_P); + return this.getTokens(PostgreSQLParser.KW_TYPE); } else { - return this.getToken(PostgreSQLParser.TYPE_P, i); + return this.getToken(PostgreSQLParser.KW_TYPE, i); } } public typename(): TypenameContext[]; @@ -86192,7 +86826,7 @@ export class Transform_type_listContext extends ParserRuleContext { export class Opt_definitionContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } public definition(): DefinitionContext { return this.getRuleContext(0, DefinitionContext); } @@ -86307,16 +86941,16 @@ export class Table_func_column_listContext extends ParserRuleContext { export class AlterfunctionstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } public function_with_argtypes(): Function_with_argtypesContext { return this.getRuleContext(0, Function_with_argtypesContext); } public alterfunc_opt_list(): Alterfunc_opt_listContext { return this.getRuleContext(0, Alterfunc_opt_listContext); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } public opt_restrict(): Opt_restrictContext | undefined { return this.tryGetRuleContext(0, Opt_restrictContext); } @@ -86387,7 +87021,7 @@ export class Alterfunc_opt_listContext extends ParserRuleContext { export class Opt_restrictContext extends ParserRuleContext { - public RESTRICT(): TerminalNode { return this.getToken(PostgreSQLParser.RESTRICT, 0); } + public KW_RESTRICT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_RESTRICT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -86417,18 +87051,18 @@ export class Opt_restrictContext extends ParserRuleContext { export class RemovefuncstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes_list(): Function_with_argtypes_listContext { return this.getRuleContext(0, Function_with_argtypes_listContext); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -86458,16 +87092,16 @@ export class RemovefuncstmtContext extends ParserRuleContext { export class RemoveaggrstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public AGGREGATE(): TerminalNode { return this.getToken(PostgreSQLParser.AGGREGATE, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_AGGREGATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AGGREGATE, 0); } public aggregate_with_argtypes_list(): Aggregate_with_argtypes_listContext { return this.getRuleContext(0, Aggregate_with_argtypes_listContext); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -86497,16 +87131,16 @@ export class RemoveaggrstmtContext extends ParserRuleContext { export class RemoveoperstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.OPERATOR, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPERATOR, 0); } public operator_with_argtypes_list(): Operator_with_argtypes_listContext { return this.getRuleContext(0, Operator_with_argtypes_listContext); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -86548,7 +87182,7 @@ export class Oper_argtypesContext extends ParserRuleContext { } public CLOSE_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); } public COMMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMA, 0); } - public NONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NONE, 0); } + public KW_NONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NONE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -86710,7 +87344,7 @@ export class Operator_with_argtypesContext extends ParserRuleContext { export class DostmtContext extends ParserRuleContext { - public DO(): TerminalNode { return this.getToken(PostgreSQLParser.DO, 0); } + public KW_DO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DO, 0); } public dostmt_opt_list(): Dostmt_opt_listContext { return this.getRuleContext(0, Dostmt_opt_listContext); } @@ -86784,7 +87418,7 @@ export class Dostmt_opt_itemContext extends ParserRuleContext { public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LANGUAGE, 0); } + public KW_LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LANGUAGE, 0); } public nonreservedword_or_sconst(): Nonreservedword_or_sconstContext | undefined { return this.tryGetRuleContext(0, Nonreservedword_or_sconstContext); } @@ -86817,8 +87451,8 @@ export class Dostmt_opt_itemContext extends ParserRuleContext { export class CreatecaststmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public CAST(): TerminalNode { return this.getToken(PostgreSQLParser.CAST, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_CAST(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CAST, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public typename(): TypenameContext[]; public typename(i: number): TypenameContext; @@ -86829,18 +87463,18 @@ export class CreatecaststmtContext extends ParserRuleContext { return this.getRuleContext(i, TypenameContext); } } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public CLOSE_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITH, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes(): Function_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypesContext); } public cast_context(): Cast_contextContext | undefined { return this.tryGetRuleContext(0, Cast_contextContext); } - public WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITHOUT, 0); } - public INOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INOUT, 0); } + public KW_WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITHOUT, 0); } + public KW_INOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INOUT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -86870,9 +87504,9 @@ export class CreatecaststmtContext extends ParserRuleContext { export class Cast_contextContext extends ParserRuleContext { - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } - public IMPLICIT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IMPLICIT_P, 0); } - public ASSIGNMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ASSIGNMENT, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } + public KW_IMPLICIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IMPLICIT, 0); } + public KW_ASSIGNMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ASSIGNMENT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -86902,8 +87536,8 @@ export class Cast_contextContext extends ParserRuleContext { export class DropcaststmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public CAST(): TerminalNode { return this.getToken(PostgreSQLParser.CAST, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_CAST(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CAST, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public typename(): TypenameContext[]; public typename(i: number): TypenameContext; @@ -86914,7 +87548,7 @@ export class DropcaststmtContext extends ParserRuleContext { return this.getRuleContext(i, TypenameContext); } } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public CLOSE_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); } public opt_if_exists(): Opt_if_existsContext | undefined { return this.tryGetRuleContext(0, Opt_if_existsContext); @@ -86951,8 +87585,8 @@ export class DropcaststmtContext extends ParserRuleContext { export class Opt_if_existsContext extends ParserRuleContext { - public IF_P(): TerminalNode { return this.getToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode { return this.getToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -86982,13 +87616,13 @@ export class Opt_if_existsContext extends ParserRuleContext { export class CreatetransformstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public TRANSFORM(): TerminalNode { return this.getToken(PostgreSQLParser.TRANSFORM, 0); } - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_TRANSFORM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TRANSFORM, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public typename(): TypenameContext { return this.getRuleContext(0, TypenameContext); } - public LANGUAGE(): TerminalNode { return this.getToken(PostgreSQLParser.LANGUAGE, 0); } + public KW_LANGUAGE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_LANGUAGE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -87029,32 +87663,32 @@ export class CreatetransformstmtContext extends ParserRuleContext { export class Transform_element_listContext extends ParserRuleContext { - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public SQL_P(): TerminalNode[]; - public SQL_P(i: number): TerminalNode; - public SQL_P(i?: number): TerminalNode | TerminalNode[] { + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_SQL(): TerminalNode[]; + public KW_SQL(i: number): TerminalNode; + public KW_SQL(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.SQL_P); + return this.getTokens(PostgreSQLParser.KW_SQL); } else { - return this.getToken(PostgreSQLParser.SQL_P, i); + return this.getToken(PostgreSQLParser.KW_SQL, i); } } - public WITH(): TerminalNode[]; - public WITH(i: number): TerminalNode; - public WITH(i?: number): TerminalNode | TerminalNode[] { + public KW_WITH(): TerminalNode[]; + public KW_WITH(i: number): TerminalNode; + public KW_WITH(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.WITH); + return this.getTokens(PostgreSQLParser.KW_WITH); } else { - return this.getToken(PostgreSQLParser.WITH, i); + return this.getToken(PostgreSQLParser.KW_WITH, i); } } - public FUNCTION(): TerminalNode[]; - public FUNCTION(i: number): TerminalNode; - public FUNCTION(i?: number): TerminalNode | TerminalNode[] { + public KW_FUNCTION(): TerminalNode[]; + public KW_FUNCTION(i: number): TerminalNode; + public KW_FUNCTION(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.FUNCTION); + return this.getTokens(PostgreSQLParser.KW_FUNCTION); } else { - return this.getToken(PostgreSQLParser.FUNCTION, i); + return this.getToken(PostgreSQLParser.KW_FUNCTION, i); } } public function_with_argtypes(): Function_with_argtypesContext[]; @@ -87067,7 +87701,7 @@ export class Transform_element_listContext extends ParserRuleContext { } } public COMMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMA, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87097,13 +87731,13 @@ export class Transform_element_listContext extends ParserRuleContext { export class DroptransformstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public TRANSFORM(): TerminalNode { return this.getToken(PostgreSQLParser.TRANSFORM, 0); } - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_TRANSFORM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TRANSFORM, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public typename(): TypenameContext { return this.getRuleContext(0, TypenameContext); } - public LANGUAGE(): TerminalNode { return this.getToken(PostgreSQLParser.LANGUAGE, 0); } + public KW_LANGUAGE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_LANGUAGE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -87142,7 +87776,7 @@ export class DroptransformstmtContext extends ParserRuleContext { export class ReindexstmtContext extends ParserRuleContext { - public REINDEX(): TerminalNode { return this.getToken(PostgreSQLParser.REINDEX, 0); } + public KW_REINDEX(): TerminalNode { return this.getToken(PostgreSQLParser.KW_REINDEX, 0); } public reindex_target_type(): Reindex_target_typeContext | undefined { return this.tryGetRuleContext(0, Reindex_target_typeContext); } @@ -87192,8 +87826,8 @@ export class ReindexstmtContext extends ParserRuleContext { export class Reindex_target_typeContext extends ParserRuleContext { - public INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEX, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEX, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87223,9 +87857,9 @@ export class Reindex_target_typeContext extends ParserRuleContext { export class Reindex_target_multitableContext extends ParserRuleContext { - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } - public SYSTEM_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SYSTEM_P, 0); } - public DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATABASE, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } + public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SYSTEM, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATABASE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87302,7 +87936,7 @@ export class Reindex_option_listContext extends ParserRuleContext { export class Reindex_option_elemContext extends ParserRuleContext { - public VERBOSE(): TerminalNode { return this.getToken(PostgreSQLParser.VERBOSE, 0); } + public KW_VERBOSE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VERBOSE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87332,16 +87966,16 @@ export class Reindex_option_elemContext extends ParserRuleContext { export class AltertblspcstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLESPACE, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_TABLESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLESPACE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } public reloptions(): ReloptionsContext { return this.getRuleContext(0, ReloptionsContext); } - public RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESET, 0); } + public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESET, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87371,13 +88005,13 @@ export class AltertblspcstmtContext extends ParserRuleContext { export class RenamestmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AGGREGATE, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AGGREGATE, 0); } public aggregate_with_argtypes(): Aggregate_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Aggregate_with_argtypesContext); } - public RENAME(): TerminalNode { return this.getToken(PostgreSQLParser.RENAME, 0); } - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } + public KW_RENAME(): TerminalNode { return this.getToken(PostgreSQLParser.KW_RENAME, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } public name(): NameContext[]; public name(i: number): NameContext; public name(i?: number): NameContext | NameContext[] { @@ -87387,22 +88021,22 @@ export class RenamestmtContext extends ParserRuleContext { return this.getRuleContext(i, NameContext); } } - public COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATION, 0); } + public KW_COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATION, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public CONVERSION_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONVERSION_P, 0); } - public DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATABASE, 0); } - public DOMAIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOMAIN_P, 0); } - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } - public FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOREIGN, 0); } - public DATA_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATA_P, 0); } - public WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WRAPPER, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_CONVERSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONVERSION, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATABASE, 0); } + public KW_DOMAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOMAIN, 0); } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } + public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATA, 0); } + public KW_WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WRAPPER, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes(): Function_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypesContext); } - public GROUP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUP_P, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUP, 0); } public roleid(): RoleidContext[]; public roleid(i: number): RoleidContext; public roleid(i?: number): RoleidContext | RoleidContext[] { @@ -87412,53 +88046,53 @@ export class RenamestmtContext extends ParserRuleContext { return this.getRuleContext(i, RoleidContext); } } - public LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LANGUAGE, 0); } + public KW_LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LANGUAGE, 0); } public opt_procedural(): Opt_proceduralContext | undefined { return this.tryGetRuleContext(0, Opt_proceduralContext); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } - public CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLASS, 0); } - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } - public FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FAMILY, 0); } - public POLICY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.POLICY, 0); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } + public KW_CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLASS, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } + public KW_FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FAMILY, 0); } + public KW_POLICY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_POLICY, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PUBLICATION, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } - public SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SERVER, 0); } - public SUBSCRIPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SUBSCRIPTION, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PUBLICATION, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } + public KW_SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SERVER, 0); } + public KW_SUBSCRIPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SUBSCRIPTION, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } public relation_expr(): Relation_exprContext | undefined { return this.tryGetRuleContext(0, Relation_exprContext); } - public SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCE, 0); } - public VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VIEW, 0); } - public MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MATERIALIZED, 0); } - public INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEX, 0); } + public KW_SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCE, 0); } + public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VIEW, 0); } + public KW_MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MATERIALIZED, 0); } + public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEX, 0); } public opt_column(): Opt_columnContext | undefined { return this.tryGetRuleContext(0, Opt_columnContext); } - public RULE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RULE, 0); } - public TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRIGGER, 0); } - public EVENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EVENT, 0); } - public ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLE, 0); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } - public TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLESPACE, 0); } - public STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STATISTICS, 0); } - public TEXT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEXT_P, 0); } - public SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEARCH, 0); } - public PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARSER, 0); } - public DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DICTIONARY, 0); } - public TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPLATE, 0); } - public CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONFIGURATION, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } - public ATTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ATTRIBUTE, 0); } + public KW_RULE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RULE, 0); } + public KW_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIGGER, 0); } + public KW_EVENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EVENT, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLE, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } + public KW_TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLESPACE, 0); } + public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATISTICS, 0); } + public KW_TEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEXT, 0); } + public KW_SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEARCH, 0); } + public KW_PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARSER, 0); } + public KW_DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DICTIONARY, 0); } + public KW_TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPLATE, 0); } + public KW_CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONFIGURATION, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } + public KW_ATTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ATTRIBUTE, 0); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } @@ -87491,7 +88125,7 @@ export class RenamestmtContext extends ParserRuleContext { export class Opt_columnContext extends ParserRuleContext { - public COLUMN(): TerminalNode { return this.getToken(PostgreSQLParser.COLUMN, 0); } + public KW_COLUMN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_COLUMN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87521,8 +88155,8 @@ export class Opt_columnContext extends ParserRuleContext { export class Opt_set_dataContext extends ParserRuleContext { - public SET(): TerminalNode { return this.getToken(PostgreSQLParser.SET, 0); } - public DATA_P(): TerminalNode { return this.getToken(PostgreSQLParser.DATA_P, 0); } + public KW_SET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SET, 0); } + public KW_DATA(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DATA, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87552,22 +88186,22 @@ export class Opt_set_dataContext extends ParserRuleContext { export class AlterobjectdependsstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes(): Function_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypesContext); } - public DEPENDS(): TerminalNode { return this.getToken(PostgreSQLParser.DEPENDS, 0); } - public ON(): TerminalNode[]; - public ON(i: number): TerminalNode; - public ON(i?: number): TerminalNode | TerminalNode[] { + public KW_DEPENDS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DEPENDS, 0); } + public KW_ON(): TerminalNode[]; + public KW_ON(i: number): TerminalNode; + public KW_ON(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.ON); + return this.getTokens(PostgreSQLParser.KW_ON); } else { - return this.getToken(PostgreSQLParser.ON, i); + return this.getToken(PostgreSQLParser.KW_ON, i); } } - public EXTENSION(): TerminalNode { return this.getToken(PostgreSQLParser.EXTENSION, 0); } + public KW_EXTENSION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXTENSION, 0); } public name(): NameContext[]; public name(i: number): NameContext; public name(i?: number): NameContext | NameContext[] { @@ -87580,15 +88214,15 @@ export class AlterobjectdependsstmtContext extends ParserRuleContext { public opt_no(): Opt_noContext | undefined { return this.tryGetRuleContext(0, Opt_noContext); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } - public TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRIGGER, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } + public KW_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIGGER, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } - public MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MATERIALIZED, 0); } - public VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VIEW, 0); } - public INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEX, 0); } + public KW_MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MATERIALIZED, 0); } + public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VIEW, 0); } + public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEX, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87618,7 +88252,7 @@ export class AlterobjectdependsstmtContext extends ParserRuleContext { export class Opt_noContext extends ParserRuleContext { - public NO(): TerminalNode { return this.getToken(PostgreSQLParser.NO, 0); } + public KW_NO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_NO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87648,13 +88282,13 @@ export class Opt_noContext extends ParserRuleContext { export class AlterobjectschemastmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AGGREGATE, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AGGREGATE, 0); } public aggregate_with_argtypes(): Aggregate_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Aggregate_with_argtypesContext); } - public SET(): TerminalNode { return this.getToken(PostgreSQLParser.SET, 0); } - public SCHEMA(): TerminalNode { return this.getToken(PostgreSQLParser.SCHEMA, 0); } + public KW_SET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SET, 0); } + public KW_SCHEMA(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SCHEMA, 0); } public name(): NameContext[]; public name(i: number): NameContext; public name(i?: number): NameContext | NameContext[] { @@ -87664,47 +88298,47 @@ export class AlterobjectschemastmtContext extends ParserRuleContext { return this.getRuleContext(i, NameContext); } } - public COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATION, 0); } + public KW_COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATION, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public CONVERSION_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONVERSION_P, 0); } - public DOMAIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOMAIN_P, 0); } - public EXTENSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXTENSION, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_CONVERSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONVERSION, 0); } + public KW_DOMAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOMAIN, 0); } + public KW_EXTENSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXTENSION, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes(): Function_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypesContext); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public operator_with_argtypes(): Operator_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Operator_with_argtypesContext); } - public CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLASS, 0); } - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } - public FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FAMILY, 0); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLASS, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } + public KW_FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FAMILY, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } public relation_expr(): Relation_exprContext | undefined { return this.tryGetRuleContext(0, Relation_exprContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STATISTICS, 0); } - public TEXT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEXT_P, 0); } - public SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEARCH, 0); } - public PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARSER, 0); } - public DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DICTIONARY, 0); } - public TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPLATE, 0); } - public CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONFIGURATION, 0); } - public SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCE, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATISTICS, 0); } + public KW_TEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEXT, 0); } + public KW_SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEARCH, 0); } + public KW_PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARSER, 0); } + public KW_DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DICTIONARY, 0); } + public KW_TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPLATE, 0); } + public KW_CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONFIGURATION, 0); } + public KW_SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCE, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } - public VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VIEW, 0); } - public MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MATERIALIZED, 0); } - public FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOREIGN, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } + public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VIEW, 0); } + public KW_MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MATERIALIZED, 0); } + public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -87734,12 +88368,12 @@ export class AlterobjectschemastmtContext extends ParserRuleContext { export class AlteroperatorstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.OPERATOR, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_OPERATOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPERATOR, 0); } public operator_with_argtypes(): Operator_with_argtypesContext { return this.getRuleContext(0, Operator_with_argtypesContext); } - public SET(): TerminalNode { return this.getToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SET, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public operator_def_list(): Operator_def_listContext { return this.getRuleContext(0, Operator_def_listContext); @@ -87825,7 +88459,7 @@ export class Operator_def_elemContext extends ParserRuleContext { return this.getRuleContext(0, CollabelContext); } public EQUAL(): TerminalNode { return this.getToken(PostgreSQLParser.EQUAL, 0); } - public NONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NONE, 0); } + public KW_NONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NONE, 0); } public operator_def_arg(): Operator_def_argContext | undefined { return this.tryGetRuleContext(0, Operator_def_argContext); } @@ -87902,12 +88536,12 @@ export class Operator_def_argContext extends ParserRuleContext { export class AltertypestmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public TYPE_P(): TerminalNode { return this.getToken(PostgreSQLParser.TYPE_P, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_TYPE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TYPE, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public SET(): TerminalNode { return this.getToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SET, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public operator_def_list(): Operator_def_listContext { return this.getRuleContext(0, Operator_def_listContext); @@ -87942,64 +88576,64 @@ export class AltertypestmtContext extends ParserRuleContext { export class AlterownerstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AGGREGATE, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AGGREGATE, 0); } public aggregate_with_argtypes(): Aggregate_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Aggregate_with_argtypesContext); } - public OWNER(): TerminalNode { return this.getToken(PostgreSQLParser.OWNER, 0); } - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } + public KW_OWNER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OWNER, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } public rolespec(): RolespecContext { return this.getRuleContext(0, RolespecContext); } - public COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATION, 0); } + public KW_COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATION, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public CONVERSION_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONVERSION_P, 0); } - public DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATABASE, 0); } + public KW_CONVERSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONVERSION, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATABASE, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } - public DOMAIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOMAIN_P, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } + public KW_DOMAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOMAIN, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } public function_with_argtypes(): Function_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Function_with_argtypesContext); } - public LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LANGUAGE, 0); } + public KW_LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LANGUAGE, 0); } public opt_procedural(): Opt_proceduralContext | undefined { return this.tryGetRuleContext(0, Opt_proceduralContext); } - public LARGE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LARGE_P, 0); } - public OBJECT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OBJECT_P, 0); } + public KW_LARGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LARGE, 0); } + public KW_OBJECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OBJECT, 0); } public numericonly(): NumericonlyContext | undefined { return this.tryGetRuleContext(0, NumericonlyContext); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public operator_with_argtypes(): Operator_with_argtypesContext | undefined { return this.tryGetRuleContext(0, Operator_with_argtypesContext); } - public CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLASS, 0); } - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } - public FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FAMILY, 0); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } - public TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLESPACE, 0); } - public STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STATISTICS, 0); } - public TEXT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEXT_P, 0); } - public SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEARCH, 0); } - public DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DICTIONARY, 0); } - public CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONFIGURATION, 0); } - public FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOREIGN, 0); } - public DATA_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATA_P, 0); } - public WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WRAPPER, 0); } - public SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SERVER, 0); } - public EVENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EVENT, 0); } - public TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRIGGER, 0); } - public PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PUBLICATION, 0); } - public SUBSCRIPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SUBSCRIPTION, 0); } + public KW_CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLASS, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } + public KW_FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FAMILY, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } + public KW_TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLESPACE, 0); } + public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATISTICS, 0); } + public KW_TEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEXT, 0); } + public KW_SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEARCH, 0); } + public KW_DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DICTIONARY, 0); } + public KW_CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONFIGURATION, 0); } + public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATA, 0); } + public KW_WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WRAPPER, 0); } + public KW_SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SERVER, 0); } + public KW_EVENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EVENT, 0); } + public KW_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIGGER, 0); } + public KW_PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PUBLICATION, 0); } + public KW_SUBSCRIPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SUBSCRIPTION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -88029,8 +88663,8 @@ export class AlterownerstmtContext extends ParserRuleContext { export class CreatepublicationstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public PUBLICATION(): TerminalNode { return this.getToken(PostgreSQLParser.PUBLICATION, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_PUBLICATION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PUBLICATION, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -88101,13 +88735,13 @@ export class Opt_publication_for_tablesContext extends ParserRuleContext { export class Publication_for_tablesContext extends ParserRuleContext { - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } public relation_expr_list(): Relation_expr_listContext | undefined { return this.tryGetRuleContext(0, Relation_expr_listContext); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public TABLES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLES, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLES, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -88137,21 +88771,21 @@ export class Publication_for_tablesContext extends ParserRuleContext { export class AlterpublicationstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public PUBLICATION(): TerminalNode { return this.getToken(PostgreSQLParser.PUBLICATION, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_PUBLICATION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PUBLICATION, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } public definition(): DefinitionContext | undefined { return this.tryGetRuleContext(0, DefinitionContext); } - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } public relation_expr_list(): Relation_expr_listContext | undefined { return this.tryGetRuleContext(0, Relation_expr_listContext); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -88181,16 +88815,16 @@ export class AlterpublicationstmtContext extends ParserRuleContext { export class CreatesubscriptionstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public SUBSCRIPTION(): TerminalNode { return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_SUBSCRIPTION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SUBSCRIPTION, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public CONNECTION(): TerminalNode { return this.getToken(PostgreSQLParser.CONNECTION, 0); } + public KW_CONNECTION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CONNECTION, 0); } public sconst(): SconstContext { return this.getRuleContext(0, SconstContext); } - public PUBLICATION(): TerminalNode { return this.getToken(PostgreSQLParser.PUBLICATION, 0); } + public KW_PUBLICATION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PUBLICATION, 0); } public publication_name_list(): Publication_name_listContext { return this.getRuleContext(0, Publication_name_listContext); } @@ -88305,29 +88939,29 @@ export class Publication_name_itemContext extends ParserRuleContext { export class AltersubscriptionstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public SUBSCRIPTION(): TerminalNode { return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_SUBSCRIPTION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SUBSCRIPTION, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } public definition(): DefinitionContext | undefined { return this.tryGetRuleContext(0, DefinitionContext); } - public CONNECTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONNECTION, 0); } + public KW_CONNECTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONNECTION, 0); } public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public REFRESH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REFRESH, 0); } - public PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PUBLICATION, 0); } + public KW_REFRESH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REFRESH, 0); } + public KW_PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PUBLICATION, 0); } public opt_definition(): Opt_definitionContext | undefined { return this.tryGetRuleContext(0, Opt_definitionContext); } public publication_name_list(): Publication_name_listContext | undefined { return this.tryGetRuleContext(0, Publication_name_listContext); } - public ENABLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENABLE_P, 0); } - public DISABLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISABLE_P, 0); } + public KW_ENABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENABLE, 0); } + public KW_DISABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISABLE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -88357,16 +88991,16 @@ export class AltersubscriptionstmtContext extends ParserRuleContext { export class DropsubscriptionstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public SUBSCRIPTION(): TerminalNode { return this.getToken(PostgreSQLParser.SUBSCRIPTION, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_SUBSCRIPTION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SUBSCRIPTION, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -88396,21 +89030,21 @@ export class DropsubscriptionstmtContext extends ParserRuleContext { export class RulestmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public RULE(): TerminalNode { return this.getToken(PostgreSQLParser.RULE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_RULE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_RULE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } public event(): EventContext { return this.getRuleContext(0, EventContext); } - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } - public DO(): TerminalNode { return this.getToken(PostgreSQLParser.DO, 0); } + public KW_DO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DO, 0); } public ruleactionlist(): RuleactionlistContext { return this.getRuleContext(0, RuleactionlistContext); } @@ -88452,7 +89086,7 @@ export class RulestmtContext extends ParserRuleContext { export class RuleactionlistContext extends ParserRuleContext { - public NOTHING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOTHING, 0); } + public KW_NOTHING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOTHING, 0); } public ruleactionstmt(): RuleactionstmtContext | undefined { return this.tryGetRuleContext(0, RuleactionstmtContext); } @@ -88613,10 +89247,10 @@ export class RuleactionstmtOrEmptyContext extends ParserRuleContext { export class EventContext extends ParserRuleContext { - public SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SELECT, 0); } - public UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UPDATE, 0); } - public DELETE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DELETE_P, 0); } - public INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INSERT, 0); } + public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SELECT, 0); } + public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UPDATE, 0); } + public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DELETE, 0); } + public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSERT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -88646,8 +89280,8 @@ export class EventContext extends ParserRuleContext { export class Opt_insteadContext extends ParserRuleContext { - public INSTEAD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INSTEAD, 0); } - public ALSO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALSO, 0); } + public KW_INSTEAD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSTEAD, 0); } + public KW_ALSO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALSO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -88677,7 +89311,7 @@ export class Opt_insteadContext extends ParserRuleContext { export class NotifystmtContext extends ParserRuleContext { - public NOTIFY(): TerminalNode { return this.getToken(PostgreSQLParser.NOTIFY, 0); } + public KW_NOTIFY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_NOTIFY, 0); } public colid(): ColidContext { return this.getRuleContext(0, ColidContext); } @@ -88746,7 +89380,7 @@ export class Notify_payloadContext extends ParserRuleContext { export class ListenstmtContext extends ParserRuleContext { - public LISTEN(): TerminalNode { return this.getToken(PostgreSQLParser.LISTEN, 0); } + public KW_LISTEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_LISTEN, 0); } public colid(): ColidContext { return this.getRuleContext(0, ColidContext); } @@ -88779,7 +89413,7 @@ export class ListenstmtContext extends ParserRuleContext { export class UnlistenstmtContext extends ParserRuleContext { - public UNLISTEN(): TerminalNode { return this.getToken(PostgreSQLParser.UNLISTEN, 0); } + public KW_UNLISTEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_UNLISTEN, 0); } public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } @@ -88813,33 +89447,33 @@ export class UnlistenstmtContext extends ParserRuleContext { export class TransactionstmtContext extends ParserRuleContext { - public ABORT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ABORT_P, 0); } + public KW_ABORT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ABORT, 0); } public opt_transaction(): Opt_transactionContext | undefined { return this.tryGetRuleContext(0, Opt_transactionContext); } public opt_transaction_chain(): Opt_transaction_chainContext | undefined { return this.tryGetRuleContext(0, Opt_transaction_chainContext); } - public BEGIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BEGIN_P, 0); } + public KW_BEGIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BEGIN, 0); } public transaction_mode_list_or_empty(): Transaction_mode_list_or_emptyContext | undefined { return this.tryGetRuleContext(0, Transaction_mode_list_or_emptyContext); } - public START(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.START, 0); } - public TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSACTION, 0); } - public COMMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMIT, 0); } - public END_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.END_P, 0); } - public ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLLBACK, 0); } - public SAVEPOINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SAVEPOINT, 0); } + public KW_START(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_START, 0); } + public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSACTION, 0); } + public KW_COMMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COMMIT, 0); } + public KW_END(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_END, 0); } + public KW_ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLLBACK, 0); } + public KW_SAVEPOINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SAVEPOINT, 0); } public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } - public RELEASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RELEASE, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } - public PREPARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PREPARE, 0); } + public KW_RELEASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RELEASE, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } + public KW_PREPARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PREPARE, 0); } public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } - public PREPARED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PREPARED, 0); } + public KW_PREPARED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PREPARED, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -88869,8 +89503,8 @@ export class TransactionstmtContext extends ParserRuleContext { export class Opt_transactionContext extends ParserRuleContext { - public WORK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WORK, 0); } - public TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSACTION, 0); } + public KW_WORK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WORK, 0); } + public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSACTION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -88900,16 +89534,16 @@ export class Opt_transactionContext extends ParserRuleContext { export class Transaction_mode_itemContext extends ParserRuleContext { - public ISOLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ISOLATION, 0); } - public LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEVEL, 0); } + public KW_ISOLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ISOLATION, 0); } + public KW_LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEVEL, 0); } public iso_level(): Iso_levelContext | undefined { return this.tryGetRuleContext(0, Iso_levelContext); } - public READ(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.READ, 0); } - public ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ONLY, 0); } - public WRITE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WRITE, 0); } - public DEFERRABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFERRABLE, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } + public KW_READ(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_READ, 0); } + public KW_ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ONLY, 0); } + public KW_WRITE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WRITE, 0); } + public KW_DEFERRABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFERRABLE, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89018,9 +89652,9 @@ export class Transaction_mode_list_or_emptyContext extends ParserRuleContext { export class Opt_transaction_chainContext extends ParserRuleContext { - public AND(): TerminalNode { return this.getToken(PostgreSQLParser.AND, 0); } - public CHAIN(): TerminalNode { return this.getToken(PostgreSQLParser.CHAIN, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } + public KW_AND(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AND, 0); } + public KW_CHAIN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CHAIN, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89050,23 +89684,23 @@ export class Opt_transaction_chainContext extends ParserRuleContext { export class ViewstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public selectstmt(): SelectstmtContext { return this.getRuleContext(0, SelectstmtContext); } - public VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VIEW, 0); } + public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VIEW, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } - public RECURSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RECURSIVE, 0); } + public KW_RECURSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RECURSIVE, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public columnlist(): ColumnlistContext | undefined { return this.tryGetRuleContext(0, ColumnlistContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public OR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OR, 0); } - public REPLACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REPLACE, 0); } + public KW_OR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OR, 0); } + public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REPLACE, 0); } public opttemp(): OpttempContext | undefined { return this.tryGetRuleContext(0, OpttempContext); } @@ -89108,11 +89742,11 @@ export class ViewstmtContext extends ParserRuleContext { export class Opt_check_optionContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } - public CHECK(): TerminalNode { return this.getToken(PostgreSQLParser.CHECK, 0); } - public OPTION(): TerminalNode { return this.getToken(PostgreSQLParser.OPTION, 0); } - public CASCADED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CASCADED, 0); } - public LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCAL, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } + public KW_CHECK(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CHECK, 0); } + public KW_OPTION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPTION, 0); } + public KW_CASCADED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CASCADED, 0); } + public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCAL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89142,7 +89776,7 @@ export class Opt_check_optionContext extends ParserRuleContext { export class LoadstmtContext extends ParserRuleContext { - public LOAD(): TerminalNode { return this.getToken(PostgreSQLParser.LOAD, 0); } + public KW_LOAD(): TerminalNode { return this.getToken(PostgreSQLParser.KW_LOAD, 0); } public file_name(): File_nameContext { return this.getRuleContext(0, File_nameContext); } @@ -89175,8 +89809,8 @@ export class LoadstmtContext extends ParserRuleContext { export class CreatedbstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public DATABASE(): TerminalNode { return this.getToken(PostgreSQLParser.DATABASE, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_DATABASE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DATABASE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -89294,7 +89928,7 @@ export class Createdb_opt_itemContext extends ParserRuleContext { public opt_boolean_or_string(): Opt_boolean_or_stringContext | undefined { return this.tryGetRuleContext(0, Opt_boolean_or_stringContext); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } public opt_equal(): Opt_equalContext | undefined { return this.tryGetRuleContext(0, Opt_equalContext); } @@ -89330,13 +89964,13 @@ export class Createdb_opt_nameContext extends ParserRuleContext { public identifier(): IdentifierContext | undefined { return this.tryGetRuleContext(0, IdentifierContext); } - public CONNECTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONNECTION, 0); } - public LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LIMIT, 0); } - public ENCODING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENCODING, 0); } - public LOCATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCATION, 0); } - public OWNER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OWNER, 0); } - public TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLESPACE, 0); } - public TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPLATE, 0); } + public KW_CONNECTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONNECTION, 0); } + public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LIMIT, 0); } + public KW_ENCODING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENCODING, 0); } + public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCATION, 0); } + public KW_OWNER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OWNER, 0); } + public KW_TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLESPACE, 0); } + public KW_TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPLATE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89396,8 +90030,8 @@ export class Opt_equalContext extends ParserRuleContext { export class AlterdatabasestmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public DATABASE(): TerminalNode { return this.getToken(PostgreSQLParser.DATABASE, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_DATABASE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DATABASE, 0); } public name(): NameContext[]; public name(i: number): NameContext; public name(i?: number): NameContext | NameContext[] { @@ -89407,9 +90041,9 @@ export class AlterdatabasestmtContext extends ParserRuleContext { return this.getRuleContext(i, NameContext); } } - public WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITH, 0); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLESPACE, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLESPACE, 0); } public createdb_opt_list(): Createdb_opt_listContext | undefined { return this.tryGetRuleContext(0, Createdb_opt_listContext); } @@ -89442,8 +90076,8 @@ export class AlterdatabasestmtContext extends ParserRuleContext { export class AlterdatabasesetstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public DATABASE(): TerminalNode { return this.getToken(PostgreSQLParser.DATABASE, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_DATABASE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DATABASE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -89479,13 +90113,13 @@ export class AlterdatabasesetstmtContext extends ParserRuleContext { export class DropdbstmtContext extends ParserRuleContext { - public DROP(): TerminalNode { return this.getToken(PostgreSQLParser.DROP, 0); } - public DATABASE(): TerminalNode { return this.getToken(PostgreSQLParser.DATABASE, 0); } + public KW_DROP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DROP, 0); } + public KW_DATABASE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DATABASE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public drop_option_list(): Drop_option_listContext | undefined { return this.tryGetRuleContext(0, Drop_option_listContext); @@ -89570,7 +90204,7 @@ export class Drop_option_listContext extends ParserRuleContext { export class Drop_optionContext extends ParserRuleContext { - public FORCE(): TerminalNode { return this.getToken(PostgreSQLParser.FORCE, 0); } + public KW_FORCE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FORCE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89600,13 +90234,13 @@ export class Drop_optionContext extends ParserRuleContext { export class AltercollationstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public COLLATION(): TerminalNode { return this.getToken(PostgreSQLParser.COLLATION, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_COLLATION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_COLLATION, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } - public REFRESH(): TerminalNode { return this.getToken(PostgreSQLParser.REFRESH, 0); } - public VERSION_P(): TerminalNode { return this.getToken(PostgreSQLParser.VERSION_P, 0); } + public KW_REFRESH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_REFRESH, 0); } + public KW_VERSION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VERSION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89636,13 +90270,13 @@ export class AltercollationstmtContext extends ParserRuleContext { export class AltersystemstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public SYSTEM_P(): TerminalNode { return this.getToken(PostgreSQLParser.SYSTEM_P, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_SYSTEM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SYSTEM, 0); } public generic_set(): Generic_setContext { return this.getRuleContext(0, Generic_setContext); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESET, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESET, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89672,8 +90306,8 @@ export class AltersystemstmtContext extends ParserRuleContext { export class CreatedomainstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public DOMAIN_P(): TerminalNode { return this.getToken(PostgreSQLParser.DOMAIN_P, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_DOMAIN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DOMAIN, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } @@ -89715,29 +90349,29 @@ export class CreatedomainstmtContext extends ParserRuleContext { export class AlterdomainstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public DOMAIN_P(): TerminalNode { return this.getToken(PostgreSQLParser.DOMAIN_P, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_DOMAIN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DOMAIN, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } public alter_column_default(): Alter_column_defaultContext | undefined { return this.tryGetRuleContext(0, Alter_column_defaultContext); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } public tableconstraint(): TableconstraintContext | undefined { return this.tryGetRuleContext(0, TableconstraintContext); } - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } - public VALIDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALIDATE, 0); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_VALIDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALIDATE, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } public opt_drop_behavior(): Opt_drop_behaviorContext | undefined { return this.tryGetRuleContext(0, Opt_drop_behaviorContext); } @@ -89770,7 +90404,7 @@ export class AlterdomainstmtContext extends ParserRuleContext { export class Opt_asContext extends ParserRuleContext { - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89800,10 +90434,10 @@ export class Opt_asContext extends ParserRuleContext { export class AltertsdictionarystmtContext extends ParserRuleContext { - public ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.ALTER, 0); } - public TEXT_P(): TerminalNode { return this.getToken(PostgreSQLParser.TEXT_P, 0); } - public SEARCH(): TerminalNode { return this.getToken(PostgreSQLParser.SEARCH, 0); } - public DICTIONARY(): TerminalNode { return this.getToken(PostgreSQLParser.DICTIONARY, 0); } + public KW_ALTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_TEXT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TEXT, 0); } + public KW_SEARCH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SEARCH, 0); } + public KW_DICTIONARY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DICTIONARY, 0); } public any_name(): Any_nameContext { return this.getRuleContext(0, Any_nameContext); } @@ -89839,18 +90473,18 @@ export class AltertsdictionarystmtContext extends ParserRuleContext { export class AltertsconfigurationstmtContext extends ParserRuleContext { - public ALTER(): TerminalNode[]; - public ALTER(i: number): TerminalNode; - public ALTER(i?: number): TerminalNode | TerminalNode[] { + public KW_ALTER(): TerminalNode[]; + public KW_ALTER(i: number): TerminalNode; + public KW_ALTER(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.ALTER); + return this.getTokens(PostgreSQLParser.KW_ALTER); } else { - return this.getToken(PostgreSQLParser.ALTER, i); + return this.getToken(PostgreSQLParser.KW_ALTER, i); } } - public TEXT_P(): TerminalNode { return this.getToken(PostgreSQLParser.TEXT_P, 0); } - public SEARCH(): TerminalNode { return this.getToken(PostgreSQLParser.SEARCH, 0); } - public CONFIGURATION(): TerminalNode { return this.getToken(PostgreSQLParser.CONFIGURATION, 0); } + public KW_TEXT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TEXT, 0); } + public KW_SEARCH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SEARCH, 0); } + public KW_CONFIGURATION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CONFIGURATION, 0); } public any_name(): Any_nameContext[]; public any_name(i: number): Any_nameContext; public any_name(i?: number): Any_nameContext | Any_nameContext[] { @@ -89860,9 +90494,9 @@ export class AltertsconfigurationstmtContext extends ParserRuleContext { return this.getRuleContext(i, Any_nameContext); } } - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } - public MAPPING(): TerminalNode { return this.getToken(PostgreSQLParser.MAPPING, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } + public KW_MAPPING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MAPPING, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } public name_list(): Name_listContext | undefined { return this.tryGetRuleContext(0, Name_listContext); } @@ -89872,10 +90506,10 @@ export class AltertsconfigurationstmtContext extends ParserRuleContext { public any_name_list(): Any_name_listContext | undefined { return this.tryGetRuleContext(0, Any_name_listContext); } - public REPLACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REPLACE, 0); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REPLACE, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89905,7 +90539,7 @@ export class AltertsconfigurationstmtContext extends ParserRuleContext { export class Any_withContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -89935,8 +90569,8 @@ export class Any_withContext extends ParserRuleContext { export class CreateconversionstmtContext extends ParserRuleContext { - public CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.CREATE, 0); } - public CONVERSION_P(): TerminalNode { return this.getToken(PostgreSQLParser.CONVERSION_P, 0); } + public KW_CREATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_CONVERSION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CONVERSION, 0); } public any_name(): Any_nameContext[]; public any_name(i: number): Any_nameContext; public any_name(i?: number): Any_nameContext | Any_nameContext[] { @@ -89946,7 +90580,7 @@ export class CreateconversionstmtContext extends ParserRuleContext { return this.getRuleContext(i, Any_nameContext); } } - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public sconst(): SconstContext[]; public sconst(i: number): SconstContext; public sconst(i?: number): SconstContext | SconstContext[] { @@ -89956,8 +90590,8 @@ export class CreateconversionstmtContext extends ParserRuleContext { return this.getRuleContext(i, SconstContext); } } - public TO(): TerminalNode { return this.getToken(PostgreSQLParser.TO, 0); } - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } + public KW_TO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TO, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } public opt_default(): Opt_defaultContext | undefined { return this.tryGetRuleContext(0, Opt_defaultContext); } @@ -89990,7 +90624,7 @@ export class CreateconversionstmtContext extends ParserRuleContext { export class ClusterstmtContext extends ParserRuleContext { - public CLUSTER(): TerminalNode { return this.getToken(PostgreSQLParser.CLUSTER, 0); } + public KW_CLUSTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CLUSTER, 0); } public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } @@ -90003,7 +90637,7 @@ export class ClusterstmtContext extends ParserRuleContext { public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -90033,7 +90667,7 @@ export class ClusterstmtContext extends ParserRuleContext { export class Cluster_index_specificationContext extends ParserRuleContext { - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } @@ -90066,7 +90700,7 @@ export class Cluster_index_specificationContext extends ParserRuleContext { export class VacuumstmtContext extends ParserRuleContext { - public VACUUM(): TerminalNode { return this.getToken(PostgreSQLParser.VACUUM, 0); } + public KW_VACUUM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VACUUM, 0); } public opt_full(): Opt_fullContext | undefined { return this.tryGetRuleContext(0, Opt_fullContext); } @@ -90206,8 +90840,8 @@ export class Vac_analyze_option_listContext extends ParserRuleContext { export class Analyze_keywordContext extends ParserRuleContext { - public ANALYZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ANALYZE, 0); } - public ANALYSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ANALYSE, 0); } + public KW_ANALYZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ANALYZE, 0); } + public KW_ANALYSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ANALYSE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -90374,7 +91008,7 @@ export class Opt_analyzeContext extends ParserRuleContext { export class Opt_verboseContext extends ParserRuleContext { - public VERBOSE(): TerminalNode { return this.getToken(PostgreSQLParser.VERBOSE, 0); } + public KW_VERBOSE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VERBOSE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -90404,7 +91038,7 @@ export class Opt_verboseContext extends ParserRuleContext { export class Opt_fullContext extends ParserRuleContext { - public FULL(): TerminalNode { return this.getToken(PostgreSQLParser.FULL, 0); } + public KW_FULL(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FULL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -90434,7 +91068,7 @@ export class Opt_fullContext extends ParserRuleContext { export class Opt_freezeContext extends ParserRuleContext { - public FREEZE(): TerminalNode { return this.getToken(PostgreSQLParser.FREEZE, 0); } + public KW_FREEZE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FREEZE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -90612,7 +91246,7 @@ export class Opt_vacuum_relation_listContext extends ParserRuleContext { export class ExplainstmtContext extends ParserRuleContext { - public EXPLAIN(): TerminalNode { return this.getToken(PostgreSQLParser.EXPLAIN, 0); } + public KW_EXPLAIN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXPLAIN, 0); } public explainablestmt(): ExplainablestmtContext { return this.getRuleContext(0, ExplainablestmtContext); } @@ -90622,7 +91256,7 @@ export class ExplainstmtContext extends ParserRuleContext { public opt_verbose(): Opt_verboseContext | undefined { return this.tryGetRuleContext(0, Opt_verboseContext); } - public VERBOSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VERBOSE, 0); } + public KW_VERBOSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VERBOSE, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public explain_option_list(): Explain_option_listContext | undefined { return this.tryGetRuleContext(0, Explain_option_listContext); @@ -90865,11 +91499,11 @@ export class Explain_option_argContext extends ParserRuleContext { export class PreparestmtContext extends ParserRuleContext { - public PREPARE(): TerminalNode { return this.getToken(PostgreSQLParser.PREPARE, 0); } + public KW_PREPARE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PREPARE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public preparablestmt(): PreparablestmtContext { return this.getRuleContext(0, PreparablestmtContext); } @@ -90980,28 +91614,28 @@ export class PreparablestmtContext extends ParserRuleContext { export class ExecutestmtContext extends ParserRuleContext { - public EXECUTE(): TerminalNode { return this.getToken(PostgreSQLParser.EXECUTE, 0); } + public KW_EXECUTE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXECUTE, 0); } public name(): NameContext { return this.getRuleContext(0, NameContext); } public execute_param_clause(): Execute_param_clauseContext | undefined { return this.tryGetRuleContext(0, Execute_param_clauseContext); } - public CREATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CREATE, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } public create_as_target(): Create_as_targetContext | undefined { return this.tryGetRuleContext(0, Create_as_targetContext); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public opttemp(): OpttempContext | undefined { return this.tryGetRuleContext(0, OpttempContext); } public opt_with_data(): Opt_with_dataContext | undefined { return this.tryGetRuleContext(0, Opt_with_dataContext); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -91065,12 +91699,12 @@ export class Execute_param_clauseContext extends ParserRuleContext { export class DeallocatestmtContext extends ParserRuleContext { - public DEALLOCATE(): TerminalNode { return this.getToken(PostgreSQLParser.DEALLOCATE, 0); } + public KW_DEALLOCATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DEALLOCATE, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } - public PREPARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PREPARE, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_PREPARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PREPARE, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -91100,8 +91734,8 @@ export class DeallocatestmtContext extends ParserRuleContext { export class InsertstmtContext extends ParserRuleContext { - public INSERT(): TerminalNode { return this.getToken(PostgreSQLParser.INSERT, 0); } - public INTO(): TerminalNode { return this.getToken(PostgreSQLParser.INTO, 0); } + public KW_INSERT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INSERT, 0); } + public KW_INTO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INTO, 0); } public insert_target(): Insert_targetContext { return this.getRuleContext(0, Insert_targetContext); } @@ -91149,7 +91783,7 @@ export class Insert_targetContext extends ParserRuleContext { public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } @@ -91185,18 +91819,18 @@ export class Insert_restContext extends ParserRuleContext { public selectstmt(): SelectstmtContext | undefined { return this.tryGetRuleContext(0, SelectstmtContext); } - public OVERRIDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OVERRIDING, 0); } + public KW_OVERRIDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OVERRIDING, 0); } public override_kind(): Override_kindContext | undefined { return this.tryGetRuleContext(0, Override_kindContext); } - public VALUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALUE_P, 0); } + public KW_VALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALUE, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public insert_column_list(): Insert_column_listContext | undefined { return this.tryGetRuleContext(0, Insert_column_listContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } - public VALUES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALUES, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } + public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALUES, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -91226,8 +91860,8 @@ export class Insert_restContext extends ParserRuleContext { export class Override_kindContext extends ParserRuleContext { - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } - public SYSTEM_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SYSTEM_P, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } + public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SYSTEM, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -91339,15 +91973,15 @@ export class Insert_column_itemContext extends ParserRuleContext { export class Opt_on_conflictContext extends ParserRuleContext { - public ON(): TerminalNode { return this.getToken(PostgreSQLParser.ON, 0); } - public CONFLICT(): TerminalNode { return this.getToken(PostgreSQLParser.CONFLICT, 0); } - public DO(): TerminalNode { return this.getToken(PostgreSQLParser.DO, 0); } - public UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UPDATE, 0); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } + public KW_ON(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ON, 0); } + public KW_CONFLICT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CONFLICT, 0); } + public KW_DO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DO, 0); } + public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UPDATE, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } public set_clause_list(): Set_clause_listContext | undefined { return this.tryGetRuleContext(0, Set_clause_listContext); } - public NOTHING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOTHING, 0); } + public KW_NOTHING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOTHING, 0); } public opt_conf_expr(): Opt_conf_exprContext | undefined { return this.tryGetRuleContext(0, Opt_conf_exprContext); } @@ -91391,8 +92025,8 @@ export class Opt_conf_exprContext extends ParserRuleContext { public where_clause(): Where_clauseContext | undefined { return this.tryGetRuleContext(0, Where_clauseContext); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } public name(): NameContext | undefined { return this.tryGetRuleContext(0, NameContext); } @@ -91425,7 +92059,7 @@ export class Opt_conf_exprContext extends ParserRuleContext { export class Returning_clauseContext extends ParserRuleContext { - public RETURNING(): TerminalNode { return this.getToken(PostgreSQLParser.RETURNING, 0); } + public KW_RETURNING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_RETURNING, 0); } public target_list(): Target_listContext { return this.getRuleContext(0, Target_listContext); } @@ -91458,8 +92092,8 @@ export class Returning_clauseContext extends ParserRuleContext { export class DeletestmtContext extends ParserRuleContext { - public DELETE_P(): TerminalNode { return this.getToken(PostgreSQLParser.DELETE_P, 0); } - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } + public KW_DELETE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DELETE, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } public relation_expr_opt_alias(): Relation_expr_opt_aliasContext { return this.getRuleContext(0, Relation_expr_opt_aliasContext); } @@ -91504,7 +92138,7 @@ export class DeletestmtContext extends ParserRuleContext { export class Using_clauseContext extends ParserRuleContext { - public USING(): TerminalNode { return this.getToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_USING, 0); } public from_list(): From_listContext { return this.getRuleContext(0, From_listContext); } @@ -91537,7 +92171,7 @@ export class Using_clauseContext extends ParserRuleContext { export class LockstmtContext extends ParserRuleContext { - public LOCK_P(): TerminalNode { return this.getToken(PostgreSQLParser.LOCK_P, 0); } + public KW_LOCK(): TerminalNode { return this.getToken(PostgreSQLParser.KW_LOCK, 0); } public relation_expr_list(): Relation_expr_listContext { return this.getRuleContext(0, Relation_expr_listContext); } @@ -91579,11 +92213,11 @@ export class LockstmtContext extends ParserRuleContext { export class Opt_lockContext extends ParserRuleContext { - public IN_P(): TerminalNode { return this.getToken(PostgreSQLParser.IN_P, 0); } + public KW_IN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IN, 0); } public lock_type(): Lock_typeContext { return this.getRuleContext(0, Lock_typeContext); } - public MODE(): TerminalNode { return this.getToken(PostgreSQLParser.MODE, 0); } + public KW_MODE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MODE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -91613,11 +92247,11 @@ export class Opt_lockContext extends ParserRuleContext { export class Lock_typeContext extends ParserRuleContext { - public ACCESS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ACCESS, 0); } - public SHARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SHARE, 0); } - public EXCLUSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCLUSIVE, 0); } - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } - public UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UPDATE, 0); } + public KW_ACCESS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ACCESS, 0); } + public KW_SHARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SHARE, 0); } + public KW_EXCLUSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCLUSIVE, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } + public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UPDATE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -91647,7 +92281,7 @@ export class Lock_typeContext extends ParserRuleContext { export class Opt_nowaitContext extends ParserRuleContext { - public NOWAIT(): TerminalNode { return this.getToken(PostgreSQLParser.NOWAIT, 0); } + public KW_NOWAIT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_NOWAIT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -91677,9 +92311,9 @@ export class Opt_nowaitContext extends ParserRuleContext { export class Opt_nowait_or_skipContext extends ParserRuleContext { - public NOWAIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOWAIT, 0); } - public SKIP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SKIP_P, 0); } - public LOCKED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCKED, 0); } + public KW_NOWAIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOWAIT, 0); } + public KW_SKIP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SKIP, 0); } + public KW_LOCKED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCKED, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -91709,11 +92343,11 @@ export class Opt_nowait_or_skipContext extends ParserRuleContext { export class UpdatestmtContext extends ParserRuleContext { - public UPDATE(): TerminalNode { return this.getToken(PostgreSQLParser.UPDATE, 0); } + public KW_UPDATE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_UPDATE, 0); } public relation_expr_opt_alias(): Relation_expr_opt_aliasContext { return this.getRuleContext(0, Relation_expr_opt_aliasContext); } - public SET(): TerminalNode { return this.getToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SET, 0); } public set_clause_list(): Set_clause_listContext { return this.getRuleContext(0, Set_clause_listContext); } @@ -91928,18 +92562,18 @@ export class Set_target_listContext extends ParserRuleContext { export class DeclarecursorstmtContext extends ParserRuleContext { - public DECLARE(): TerminalNode { return this.getToken(PostgreSQLParser.DECLARE, 0); } + public KW_DECLARE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DECLARE, 0); } public cursor_name(): Cursor_nameContext { return this.getRuleContext(0, Cursor_nameContext); } public cursor_options(): Cursor_optionsContext { return this.getRuleContext(0, Cursor_optionsContext); } - public CURSOR(): TerminalNode { return this.getToken(PostgreSQLParser.CURSOR, 0); } + public KW_CURSOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CURSOR, 0); } public opt_hold(): Opt_holdContext { return this.getRuleContext(0, Opt_holdContext); } - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public selectstmt(): SelectstmtContext { return this.getRuleContext(0, SelectstmtContext); } @@ -92004,40 +92638,40 @@ export class Cursor_nameContext extends ParserRuleContext { export class Cursor_optionsContext extends ParserRuleContext { - public NO(): TerminalNode[]; - public NO(i: number): TerminalNode; - public NO(i?: number): TerminalNode | TerminalNode[] { + public KW_NO(): TerminalNode[]; + public KW_NO(i: number): TerminalNode; + public KW_NO(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.NO); + return this.getTokens(PostgreSQLParser.KW_NO); } else { - return this.getToken(PostgreSQLParser.NO, i); + return this.getToken(PostgreSQLParser.KW_NO, i); } } - public SCROLL(): TerminalNode[]; - public SCROLL(i: number): TerminalNode; - public SCROLL(i?: number): TerminalNode | TerminalNode[] { + public KW_SCROLL(): TerminalNode[]; + public KW_SCROLL(i: number): TerminalNode; + public KW_SCROLL(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.SCROLL); + return this.getTokens(PostgreSQLParser.KW_SCROLL); } else { - return this.getToken(PostgreSQLParser.SCROLL, i); + return this.getToken(PostgreSQLParser.KW_SCROLL, i); } } - public BINARY(): TerminalNode[]; - public BINARY(i: number): TerminalNode; - public BINARY(i?: number): TerminalNode | TerminalNode[] { + public KW_BINARY(): TerminalNode[]; + public KW_BINARY(i: number): TerminalNode; + public KW_BINARY(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.BINARY); + return this.getTokens(PostgreSQLParser.KW_BINARY); } else { - return this.getToken(PostgreSQLParser.BINARY, i); + return this.getToken(PostgreSQLParser.KW_BINARY, i); } } - public INSENSITIVE(): TerminalNode[]; - public INSENSITIVE(i: number): TerminalNode; - public INSENSITIVE(i?: number): TerminalNode | TerminalNode[] { + public KW_INSENSITIVE(): TerminalNode[]; + public KW_INSENSITIVE(i: number): TerminalNode; + public KW_INSENSITIVE(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.INSENSITIVE); + return this.getTokens(PostgreSQLParser.KW_INSENSITIVE); } else { - return this.getToken(PostgreSQLParser.INSENSITIVE, i); + return this.getToken(PostgreSQLParser.KW_INSENSITIVE, i); } } constructor(parent: ParserRuleContext | undefined, invokingState: number) { @@ -92069,9 +92703,9 @@ export class Cursor_optionsContext extends ParserRuleContext { export class Opt_holdContext extends ParserRuleContext { - public WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITH, 0); } - public HOLD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HOLD, 0); } - public WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITHOUT, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } + public KW_HOLD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HOLD, 0); } + public KW_WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITHOUT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -92258,11 +92892,11 @@ export class Select_clauseContext extends ParserRuleContext { export class Simple_selectContext extends ParserRuleContext { - public SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SELECT, 0); } + public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SELECT, 0); } public values_clause(): Values_clauseContext | undefined { return this.tryGetRuleContext(0, Values_clauseContext); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } public relation_expr(): Relation_exprContext | undefined { return this.tryGetRuleContext(0, Relation_exprContext); } @@ -92284,12 +92918,6 @@ export class Simple_selectContext extends ParserRuleContext { return this.getRuleContext(i, Set_operator_with_all_or_distinctContext); } } - public distinct_clause(): Distinct_clauseContext | undefined { - return this.tryGetRuleContext(0, Distinct_clauseContext); - } - public target_list(): Target_listContext | undefined { - return this.tryGetRuleContext(0, Target_listContext); - } public simple_select(): Simple_selectContext[]; public simple_select(i: number): Simple_selectContext; public simple_select(i?: number): Simple_selectContext | Simple_selectContext[] { @@ -92329,6 +92957,12 @@ export class Simple_selectContext extends ParserRuleContext { public opt_target_list(): Opt_target_listContext | undefined { return this.tryGetRuleContext(0, Opt_target_listContext); } + public distinct_clause(): Distinct_clauseContext | undefined { + return this.tryGetRuleContext(0, Distinct_clauseContext); + } + public target_list(): Target_listContext | undefined { + return this.tryGetRuleContext(0, Target_listContext); + } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -92368,7 +93002,7 @@ export class Set_operatorContext extends ParserRuleContext { } } export class UnionContext extends Set_operatorContext { - public UNION(): TerminalNode { return this.getToken(PostgreSQLParser.UNION, 0); } + public KW_UNION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_UNION, 0); } constructor(ctx: Set_operatorContext) { super(ctx.parent, ctx.invokingState); this.copyFrom(ctx); @@ -92395,7 +93029,7 @@ export class UnionContext extends Set_operatorContext { } } export class IntersectContext extends Set_operatorContext { - public INTERSECT(): TerminalNode { return this.getToken(PostgreSQLParser.INTERSECT, 0); } + public KW_INTERSECT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INTERSECT, 0); } constructor(ctx: Set_operatorContext) { super(ctx.parent, ctx.invokingState); this.copyFrom(ctx); @@ -92422,7 +93056,7 @@ export class IntersectContext extends Set_operatorContext { } } export class ExceptContext extends Set_operatorContext { - public EXCEPT(): TerminalNode { return this.getToken(PostgreSQLParser.EXCEPT, 0); } + public KW_EXCEPT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXCEPT, 0); } constructor(ctx: Set_operatorContext) { super(ctx.parent, ctx.invokingState); this.copyFrom(ctx); @@ -92486,11 +93120,11 @@ export class Set_operator_with_all_or_distinctContext extends ParserRuleContext export class With_clauseContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } public cte_list(): Cte_listContext { return this.getRuleContext(0, Cte_listContext); } - public RECURSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RECURSIVE, 0); } + public KW_RECURSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RECURSIVE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -92570,7 +93204,7 @@ export class Common_table_exprContext extends ParserRuleContext { public name(): NameContext { return this.getRuleContext(0, NameContext); } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public preparablestmt(): PreparablestmtContext { return this.getRuleContext(0, PreparablestmtContext); @@ -92611,8 +93245,8 @@ export class Common_table_exprContext extends ParserRuleContext { export class Opt_materializedContext extends ParserRuleContext { - public MATERIALIZED(): TerminalNode { return this.getToken(PostgreSQLParser.MATERIALIZED, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } + public KW_MATERIALIZED(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MATERIALIZED, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -92674,7 +93308,7 @@ export class Opt_with_clauseContext extends ParserRuleContext { export class Into_clauseContext extends ParserRuleContext { - public INTO(): TerminalNode { return this.getToken(PostgreSQLParser.INTO, 0); } + public KW_INTO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INTO, 0); } public opt_strict(): Opt_strictContext | undefined { return this.tryGetRuleContext(0, Opt_strictContext); } @@ -92713,7 +93347,7 @@ export class Into_clauseContext extends ParserRuleContext { export class Opt_strictContext extends ParserRuleContext { - public STRICT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STRICT_P, 0); } + public KW_STRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STRICT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -92746,15 +93380,15 @@ export class OpttempTableNameContext extends ParserRuleContext { public qualified_name(): Qualified_nameContext { return this.getRuleContext(0, Qualified_nameContext); } - public TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPORARY, 0); } - public TEMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMP, 0); } + public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPORARY, 0); } + public KW_TEMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMP, 0); } public opt_table(): Opt_tableContext | undefined { return this.tryGetRuleContext(0, Opt_tableContext); } - public LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCAL, 0); } - public GLOBAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GLOBAL, 0); } - public UNLOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNLOGGED, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } + public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCAL, 0); } + public KW_GLOBAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GLOBAL, 0); } + public KW_UNLOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNLOGGED, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -92784,7 +93418,7 @@ export class OpttempTableNameContext extends ParserRuleContext { export class Opt_tableContext extends ParserRuleContext { - public TABLE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLE, 0); } + public KW_TABLE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -92814,8 +93448,8 @@ export class Opt_tableContext extends ParserRuleContext { export class All_or_distinctContext extends ParserRuleContext { - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISTINCT, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISTINCT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -92845,8 +93479,8 @@ export class All_or_distinctContext extends ParserRuleContext { export class Distinct_clauseContext extends ParserRuleContext { - public DISTINCT(): TerminalNode { return this.getToken(PostgreSQLParser.DISTINCT, 0); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } + public KW_DISTINCT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DISTINCT, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public expr_list(): Expr_listContext | undefined { return this.tryGetRuleContext(0, Expr_listContext); @@ -92881,7 +93515,7 @@ export class Distinct_clauseContext extends ParserRuleContext { export class Opt_all_clauseContext extends ParserRuleContext { - public ALL(): TerminalNode { return this.getToken(PostgreSQLParser.ALL, 0); } + public KW_ALL(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ALL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -92943,8 +93577,8 @@ export class Opt_sort_clauseContext extends ParserRuleContext { export class Sort_clauseContext extends ParserRuleContext { - public ORDER(): TerminalNode { return this.getToken(PostgreSQLParser.ORDER, 0); } - public BY(): TerminalNode { return this.getToken(PostgreSQLParser.BY, 0); } + public KW_ORDER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ORDER, 0); } + public KW_BY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BY, 0); } public sortby_list(): Sortby_listContext { return this.getRuleContext(0, Sortby_listContext); } @@ -93027,16 +93661,16 @@ export class SortbyContext extends ParserRuleContext { public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } public qual_all_op(): Qual_all_opContext | undefined { return this.tryGetRuleContext(0, Qual_all_opContext); } - public opt_nulls_order(): Opt_nulls_orderContext | undefined { - return this.tryGetRuleContext(0, Opt_nulls_orderContext); - } public opt_asc_desc(): Opt_asc_descContext | undefined { return this.tryGetRuleContext(0, Opt_asc_descContext); } + public opt_nulls_order(): Opt_nulls_orderContext | undefined { + return this.tryGetRuleContext(0, Opt_nulls_orderContext); + } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -93133,7 +93767,7 @@ export class Opt_select_limitContext extends ParserRuleContext { export class Limit_clauseContext extends ParserRuleContext { - public LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LIMIT, 0); } + public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LIMIT, 0); } public select_limit_value(): Select_limit_valueContext | undefined { return this.tryGetRuleContext(0, Select_limit_valueContext); } @@ -93141,7 +93775,7 @@ export class Limit_clauseContext extends ParserRuleContext { public select_offset_value(): Select_offset_valueContext | undefined { return this.tryGetRuleContext(0, Select_offset_valueContext); } - public FETCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FETCH, 0); } + public KW_FETCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FETCH, 0); } public first_or_next(): First_or_nextContext | undefined { return this.tryGetRuleContext(0, First_or_nextContext); } @@ -93151,9 +93785,9 @@ export class Limit_clauseContext extends ParserRuleContext { public row_or_rows(): Row_or_rowsContext | undefined { return this.tryGetRuleContext(0, Row_or_rowsContext); } - public ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ONLY, 0); } - public WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITH, 0); } - public TIES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIES, 0); } + public KW_ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ONLY, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } + public KW_TIES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIES, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -93183,7 +93817,7 @@ export class Limit_clauseContext extends ParserRuleContext { export class Offset_clauseContext extends ParserRuleContext { - public OFFSET(): TerminalNode { return this.getToken(PostgreSQLParser.OFFSET, 0); } + public KW_OFFSET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OFFSET, 0); } public select_offset_value(): Select_offset_valueContext | undefined { return this.tryGetRuleContext(0, Select_offset_valueContext); } @@ -93225,7 +93859,7 @@ export class Select_limit_valueContext extends ParserRuleContext { public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -93359,8 +93993,8 @@ export class I_or_f_constContext extends ParserRuleContext { export class Row_or_rowsContext extends ParserRuleContext { - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } - public ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROWS, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } + public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROWS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -93390,8 +94024,8 @@ export class Row_or_rowsContext extends ParserRuleContext { export class First_or_nextContext extends ParserRuleContext { - public FIRST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FIRST_P, 0); } - public NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NEXT, 0); } + public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FIRST, 0); } + public KW_NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NEXT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -93421,8 +94055,8 @@ export class First_or_nextContext extends ParserRuleContext { export class Group_clauseContext extends ParserRuleContext { - public GROUP_P(): TerminalNode { return this.getToken(PostgreSQLParser.GROUP_P, 0); } - public BY(): TerminalNode { return this.getToken(PostgreSQLParser.BY, 0); } + public KW_GROUP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GROUP, 0); } + public KW_BY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BY, 0); } public group_by_list(): Group_by_listContext { return this.getRuleContext(0, Group_by_listContext); } @@ -93577,7 +94211,7 @@ export class Empty_grouping_setContext extends ParserRuleContext { export class Rollup_clauseContext extends ParserRuleContext { - public ROLLUP(): TerminalNode { return this.getToken(PostgreSQLParser.ROLLUP, 0); } + public KW_ROLLUP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ROLLUP, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public expr_list(): Expr_listContext { return this.getRuleContext(0, Expr_listContext); @@ -93612,7 +94246,7 @@ export class Rollup_clauseContext extends ParserRuleContext { export class Cube_clauseContext extends ParserRuleContext { - public CUBE(): TerminalNode { return this.getToken(PostgreSQLParser.CUBE, 0); } + public KW_CUBE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CUBE, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public expr_list(): Expr_listContext { return this.getRuleContext(0, Expr_listContext); @@ -93647,8 +94281,8 @@ export class Cube_clauseContext extends ParserRuleContext { export class Grouping_sets_clauseContext extends ParserRuleContext { - public GROUPING(): TerminalNode { return this.getToken(PostgreSQLParser.GROUPING, 0); } - public SETS(): TerminalNode { return this.getToken(PostgreSQLParser.SETS, 0); } + public KW_GROUPING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GROUPING, 0); } + public KW_SETS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SETS, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public group_by_list(): Group_by_listContext { return this.getRuleContext(0, Group_by_listContext); @@ -93683,7 +94317,7 @@ export class Grouping_sets_clauseContext extends ParserRuleContext { export class Having_clauseContext extends ParserRuleContext { - public HAVING(): TerminalNode { return this.getToken(PostgreSQLParser.HAVING, 0); } + public KW_HAVING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_HAVING, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } @@ -93719,9 +94353,9 @@ export class For_locking_clauseContext extends ParserRuleContext { public for_locking_items(): For_locking_itemsContext | undefined { return this.tryGetRuleContext(0, For_locking_itemsContext); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } - public READ(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.READ, 0); } - public ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ONLY, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } + public KW_READ(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_READ, 0); } + public KW_ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ONLY, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -93859,11 +94493,11 @@ export class For_locking_itemContext extends ParserRuleContext { export class For_locking_strengthContext extends ParserRuleContext { - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } - public UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UPDATE, 0); } - public SHARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SHARE, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public KEY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KEY, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } + public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UPDATE, 0); } + public KW_SHARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SHARE, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_KEY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_KEY, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -93893,7 +94527,7 @@ export class For_locking_strengthContext extends ParserRuleContext { export class Locked_rels_listContext extends ParserRuleContext { - public OF(): TerminalNode { return this.getToken(PostgreSQLParser.OF, 0); } + public KW_OF(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OF, 0); } public qualified_name_list(): Qualified_name_listContext { return this.getRuleContext(0, Qualified_name_listContext); } @@ -93926,7 +94560,7 @@ export class Locked_rels_listContext extends ParserRuleContext { export class Values_clauseContext extends ParserRuleContext { - public VALUES(): TerminalNode { return this.getToken(PostgreSQLParser.VALUES, 0); } + public KW_VALUES(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VALUES, 0); } public OPEN_PAREN(): TerminalNode[]; public OPEN_PAREN(i: number): TerminalNode; public OPEN_PAREN(i?: number): TerminalNode | TerminalNode[] { @@ -93992,7 +94626,7 @@ export class Values_clauseContext extends ParserRuleContext { export class From_clauseContext extends ParserRuleContext { - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } public from_list(): From_listContext { return this.getRuleContext(0, From_listContext); } @@ -94084,7 +94718,7 @@ export class Table_refContext extends ParserRuleContext { public select_with_parens(): Select_with_parensContext | undefined { return this.tryGetRuleContext(0, Select_with_parensContext); } - public LATERAL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LATERAL_P, 0); } + public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LATERAL, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public table_ref(): Table_refContext[]; public table_ref(i: number): Table_refContext; @@ -94096,31 +94730,31 @@ export class Table_refContext extends ParserRuleContext { } } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public CROSS(): TerminalNode[]; - public CROSS(i: number): TerminalNode; - public CROSS(i?: number): TerminalNode | TerminalNode[] { + public KW_CROSS(): TerminalNode[]; + public KW_CROSS(i: number): TerminalNode; + public KW_CROSS(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.CROSS); + return this.getTokens(PostgreSQLParser.KW_CROSS); } else { - return this.getToken(PostgreSQLParser.CROSS, i); + return this.getToken(PostgreSQLParser.KW_CROSS, i); } } - public JOIN(): TerminalNode[]; - public JOIN(i: number): TerminalNode; - public JOIN(i?: number): TerminalNode | TerminalNode[] { + public KW_JOIN(): TerminalNode[]; + public KW_JOIN(i: number): TerminalNode; + public KW_JOIN(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.JOIN); + return this.getTokens(PostgreSQLParser.KW_JOIN); } else { - return this.getToken(PostgreSQLParser.JOIN, i); + return this.getToken(PostgreSQLParser.KW_JOIN, i); } } - public NATURAL(): TerminalNode[]; - public NATURAL(i: number): TerminalNode; - public NATURAL(i?: number): TerminalNode | TerminalNode[] { + public KW_NATURAL(): TerminalNode[]; + public KW_NATURAL(i: number): TerminalNode; + public KW_NATURAL(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.NATURAL); + return this.getTokens(PostgreSQLParser.KW_NATURAL); } else { - return this.getToken(PostgreSQLParser.NATURAL, i); + return this.getToken(PostgreSQLParser.KW_NATURAL, i); } } public join_qual(): Join_qualContext[]; @@ -94182,7 +94816,7 @@ export class Alias_clauseContext extends ParserRuleContext { public colid(): ColidContext { return this.getRuleContext(0, ColidContext); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public name_list(): Name_listContext | undefined { return this.tryGetRuleContext(0, Name_listContext); @@ -94257,7 +94891,7 @@ export class Func_alias_clauseContext extends ParserRuleContext { return this.tryGetRuleContext(0, TablefuncelementlistContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } @@ -94290,11 +94924,11 @@ export class Func_alias_clauseContext extends ParserRuleContext { export class Join_typeContext extends ParserRuleContext { - public FULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FULL, 0); } - public LEFT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEFT, 0); } - public RIGHT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RIGHT, 0); } - public INNER_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INNER_P, 0); } - public OUTER_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OUTER_P, 0); } + public KW_FULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FULL, 0); } + public KW_LEFT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEFT, 0); } + public KW_RIGHT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RIGHT, 0); } + public KW_INNER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INNER, 0); } + public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OUTER, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -94324,13 +94958,13 @@ export class Join_typeContext extends ParserRuleContext { export class Join_qualContext extends ParserRuleContext { - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public name_list(): Name_listContext | undefined { return this.tryGetRuleContext(0, Name_listContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } @@ -94366,8 +95000,8 @@ export class Relation_exprContext extends ParserRuleContext { public qualified_name(): Qualified_nameContext | undefined { return this.tryGetRuleContext(0, Qualified_nameContext); } + public KW_ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ONLY, 0); } public STAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STAR, 0); } - public ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ONLY, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { @@ -94452,7 +95086,7 @@ export class Relation_expr_opt_aliasContext extends ParserRuleContext { public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -94482,7 +95116,7 @@ export class Relation_expr_opt_aliasContext extends ParserRuleContext { export class Tablesample_clauseContext extends ParserRuleContext { - public TABLESAMPLE(): TerminalNode { return this.getToken(PostgreSQLParser.TABLESAMPLE, 0); } + public KW_TABLESAMPLE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TABLESAMPLE, 0); } public func_name(): Func_nameContext { return this.getRuleContext(0, Func_nameContext); } @@ -94523,7 +95157,7 @@ export class Tablesample_clauseContext extends ParserRuleContext { export class Opt_repeatable_clauseContext extends ParserRuleContext { - public REPEATABLE(): TerminalNode { return this.getToken(PostgreSQLParser.REPEATABLE, 0); } + public KW_REPEATABLE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_REPEATABLE, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); @@ -94564,8 +95198,8 @@ export class Func_tableContext extends ParserRuleContext { public opt_ordinality(): Opt_ordinalityContext | undefined { return this.tryGetRuleContext(0, Opt_ordinalityContext); } - public ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROWS, 0); } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } + public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROWS, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public rowsfrom_list(): Rowsfrom_listContext | undefined { return this.tryGetRuleContext(0, Rowsfrom_listContext); @@ -94682,7 +95316,7 @@ export class Rowsfrom_listContext extends ParserRuleContext { export class Opt_col_def_listContext extends ParserRuleContext { - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public tablefuncelementlist(): TablefuncelementlistContext { return this.getRuleContext(0, TablefuncelementlistContext); @@ -94717,8 +95351,8 @@ export class Opt_col_def_listContext extends ParserRuleContext { export class Opt_ordinalityContext extends ParserRuleContext { - public WITH(): TerminalNode { return this.getToken(PostgreSQLParser.WITH, 0); } - public ORDINALITY(): TerminalNode { return this.getToken(PostgreSQLParser.ORDINALITY, 0); } + public KW_WITH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITH, 0); } + public KW_ORDINALITY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ORDINALITY, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -94748,7 +95382,7 @@ export class Opt_ordinalityContext extends ParserRuleContext { export class Where_clauseContext extends ParserRuleContext { - public WHERE(): TerminalNode { return this.getToken(PostgreSQLParser.WHERE, 0); } + public KW_WHERE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHERE, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } @@ -94781,9 +95415,9 @@ export class Where_clauseContext extends ParserRuleContext { export class Where_or_current_clauseContext extends ParserRuleContext { - public WHERE(): TerminalNode { return this.getToken(PostgreSQLParser.WHERE, 0); } - public CURRENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_P, 0); } - public OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OF, 0); } + public KW_WHERE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHERE, 0); } + public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT, 0); } + public KW_OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OF, 0); } public cursor_name(): Cursor_nameContext | undefined { return this.tryGetRuleContext(0, Cursor_nameContext); } @@ -94936,7 +95570,7 @@ export class TablefuncelementContext extends ParserRuleContext { export class XmltableContext extends ParserRuleContext { - public XMLTABLE(): TerminalNode { return this.getToken(PostgreSQLParser.XMLTABLE, 0); } + public KW_XMLTABLE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_XMLTABLE, 0); } public OPEN_PAREN(): TerminalNode[]; public OPEN_PAREN(i: number): TerminalNode; public OPEN_PAREN(i?: number): TerminalNode | TerminalNode[] { @@ -94961,11 +95595,11 @@ export class XmltableContext extends ParserRuleContext { public xmlexists_argument(): Xmlexists_argumentContext | undefined { return this.tryGetRuleContext(0, Xmlexists_argumentContext); } - public COLUMNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLUMNS, 0); } + public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLUMNS, 0); } public xmltable_column_list(): Xmltable_column_listContext | undefined { return this.tryGetRuleContext(0, Xmltable_column_listContext); } - public XMLNAMESPACES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLNAMESPACES, 0); } + public KW_XMLNAMESPACES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLNAMESPACES, 0); } public xml_namespace_list(): Xml_namespace_listContext | undefined { return this.tryGetRuleContext(0, Xml_namespace_listContext); } @@ -95052,8 +95686,8 @@ export class Xmltable_column_elContext extends ParserRuleContext { public typename(): TypenameContext | undefined { return this.tryGetRuleContext(0, TypenameContext); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } - public ORDINALITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ORDINALITY, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } + public KW_ORDINALITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ORDINALITY, 0); } public xmltable_column_option_list(): Xmltable_column_option_listContext | undefined { return this.tryGetRuleContext(0, Xmltable_column_option_listContext); } @@ -95124,15 +95758,15 @@ export class Xmltable_column_option_listContext extends ParserRuleContext { export class Xmltable_column_option_elContext extends ParserRuleContext { - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } public identifier(): IdentifierContext | undefined { return this.tryGetRuleContext(0, IdentifierContext); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -95212,11 +95846,11 @@ export class Xml_namespace_elContext extends ParserRuleContext { public b_expr(): B_exprContext { return this.getRuleContext(0, B_exprContext); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public collabel(): CollabelContext | undefined { return this.tryGetRuleContext(0, CollabelContext); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -95252,8 +95886,8 @@ export class TypenameContext extends ParserRuleContext { public opt_array_bounds(): Opt_array_boundsContext | undefined { return this.tryGetRuleContext(0, Opt_array_boundsContext); } - public ARRAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ARRAY, 0); } - public SETOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SETOF, 0); } + public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ARRAY, 0); } + public KW_SETOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SETOF, 0); } public OPEN_BRACKET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_BRACKET, 0); } public iconst(): IconstContext | undefined { return this.tryGetRuleContext(0, IconstContext); @@ -95263,8 +95897,8 @@ export class TypenameContext extends ParserRuleContext { return this.tryGetRuleContext(0, Qualified_nameContext); } public PERCENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PERCENT, 0); } - public ROWTYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROWTYPE, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } + public KW_ROWTYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROWTYPE, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -95518,24 +96152,24 @@ export class Opt_type_modifiersContext extends ParserRuleContext { export class NumericContext extends ParserRuleContext { - public INT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INT_P, 0); } - public INTEGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INTEGER, 0); } - public SMALLINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SMALLINT, 0); } - public BIGINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BIGINT, 0); } - public REAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REAL, 0); } - public FLOAT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FLOAT_P, 0); } + public KW_INT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INT, 0); } + public KW_INTEGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INTEGER, 0); } + public KW_SMALLINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SMALLINT, 0); } + public KW_BIGINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BIGINT, 0); } + public KW_REAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REAL, 0); } + public KW_FLOAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FLOAT, 0); } public opt_float(): Opt_floatContext | undefined { return this.tryGetRuleContext(0, Opt_floatContext); } - public DOUBLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOUBLE_P, 0); } - public PRECISION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRECISION, 0); } - public DECIMAL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DECIMAL_P, 0); } + public KW_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOUBLE, 0); } + public KW_PRECISION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRECISION, 0); } + public KW_DECIMAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DECIMAL, 0); } public opt_type_modifiers(): Opt_type_modifiersContext | undefined { return this.tryGetRuleContext(0, Opt_type_modifiersContext); } - public DEC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEC, 0); } - public NUMERIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NUMERIC, 0); } - public BOOLEAN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BOOLEAN_P, 0); } + public KW_DEC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEC, 0); } + public KW_NUMERIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NUMERIC, 0); } + public KW_BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BOOLEAN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -95669,7 +96303,7 @@ export class ConstbitContext extends ParserRuleContext { export class BitwithlengthContext extends ParserRuleContext { - public BIT(): TerminalNode { return this.getToken(PostgreSQLParser.BIT, 0); } + public KW_BIT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BIT, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public expr_list(): Expr_listContext { return this.getRuleContext(0, Expr_listContext); @@ -95707,7 +96341,7 @@ export class BitwithlengthContext extends ParserRuleContext { export class BitwithoutlengthContext extends ParserRuleContext { - public BIT(): TerminalNode { return this.getToken(PostgreSQLParser.BIT, 0); } + public KW_BIT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BIT, 0); } public opt_varying(): Opt_varyingContext | undefined { return this.tryGetRuleContext(0, Opt_varyingContext); } @@ -95814,14 +96448,14 @@ export class ConstcharacterContext extends ParserRuleContext { export class Character_cContext extends ParserRuleContext { - public CHARACTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHARACTER, 0); } - public CHAR_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHAR_P, 0); } - public NCHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NCHAR, 0); } + public KW_CHARACTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHARACTER, 0); } + public KW_CHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHAR, 0); } + public KW_NCHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NCHAR, 0); } public opt_varying(): Opt_varyingContext | undefined { return this.tryGetRuleContext(0, Opt_varyingContext); } - public VARCHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VARCHAR, 0); } - public NATIONAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NATIONAL, 0); } + public KW_VARCHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VARCHAR, 0); } + public KW_NATIONAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NATIONAL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -95851,7 +96485,7 @@ export class Character_cContext extends ParserRuleContext { export class Opt_varyingContext extends ParserRuleContext { - public VARYING(): TerminalNode { return this.getToken(PostgreSQLParser.VARYING, 0); } + public KW_VARYING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VARYING, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -95881,8 +96515,8 @@ export class Opt_varyingContext extends ParserRuleContext { export class ConstdatetimeContext extends ParserRuleContext { - public TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIMESTAMP, 0); } - public TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIME, 0); } + public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIMESTAMP, 0); } + public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIME, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public iconst(): IconstContext | undefined { return this.tryGetRuleContext(0, IconstContext); @@ -95920,7 +96554,7 @@ export class ConstdatetimeContext extends ParserRuleContext { export class ConstintervalContext extends ParserRuleContext { - public INTERVAL(): TerminalNode { return this.getToken(PostgreSQLParser.INTERVAL, 0); } + public KW_INTERVAL(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INTERVAL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -95950,10 +96584,10 @@ export class ConstintervalContext extends ParserRuleContext { export class Opt_timezoneContext extends ParserRuleContext { - public WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITH, 0); } - public TIME(): TerminalNode { return this.getToken(PostgreSQLParser.TIME, 0); } - public ZONE(): TerminalNode { return this.getToken(PostgreSQLParser.ZONE, 0); } - public WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITHOUT, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } + public KW_TIME(): TerminalNode { return this.getToken(PostgreSQLParser.KW_TIME, 0); } + public KW_ZONE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ZONE, 0); } + public KW_WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITHOUT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -95983,15 +96617,15 @@ export class Opt_timezoneContext extends ParserRuleContext { export class Opt_intervalContext extends ParserRuleContext { - public YEAR_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.YEAR_P, 0); } - public MONTH_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MONTH_P, 0); } - public DAY_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DAY_P, 0); } - public HOUR_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HOUR_P, 0); } - public MINUTE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MINUTE_P, 0); } + public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_YEAR, 0); } + public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MONTH, 0); } + public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DAY, 0); } + public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HOUR, 0); } + public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MINUTE, 0); } public interval_second(): Interval_secondContext | undefined { return this.tryGetRuleContext(0, Interval_secondContext); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -96021,7 +96655,7 @@ export class Opt_intervalContext extends ParserRuleContext { export class Interval_secondContext extends ParserRuleContext { - public SECOND_P(): TerminalNode { return this.getToken(PostgreSQLParser.SECOND_P, 0); } + public KW_SECOND(): TerminalNode { return this.getToken(PostgreSQLParser.KW_SECOND, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public iconst(): IconstContext | undefined { return this.tryGetRuleContext(0, IconstContext); @@ -96056,7 +96690,7 @@ export class Interval_secondContext extends ParserRuleContext { export class Opt_escapeContext extends ParserRuleContext { - public ESCAPE(): TerminalNode { return this.getToken(PostgreSQLParser.ESCAPE, 0); } + public KW_ESCAPE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ESCAPE, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } @@ -96221,13 +96855,13 @@ export class A_expr_orContext extends ParserRuleContext { return this.getRuleContext(i, A_expr_andContext); } } - public OR(): TerminalNode[]; - public OR(i: number): TerminalNode; - public OR(i?: number): TerminalNode | TerminalNode[] { + public KW_OR(): TerminalNode[]; + public KW_OR(i: number): TerminalNode; + public KW_OR(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.OR); + return this.getTokens(PostgreSQLParser.KW_OR); } else { - return this.getToken(PostgreSQLParser.OR, i); + return this.getToken(PostgreSQLParser.KW_OR, i); } } constructor(parent: ParserRuleContext | undefined, invokingState: number) { @@ -96268,13 +96902,13 @@ export class A_expr_andContext extends ParserRuleContext { return this.getRuleContext(i, A_expr_inContext); } } - public AND(): TerminalNode[]; - public AND(i: number): TerminalNode; - public AND(i?: number): TerminalNode | TerminalNode[] { + public KW_AND(): TerminalNode[]; + public KW_AND(i: number): TerminalNode; + public KW_AND(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.AND); + return this.getTokens(PostgreSQLParser.KW_AND); } else { - return this.getToken(PostgreSQLParser.AND, i); + return this.getToken(PostgreSQLParser.KW_AND, i); } } constructor(parent: ParserRuleContext | undefined, invokingState: number) { @@ -96309,11 +96943,11 @@ export class A_expr_inContext extends ParserRuleContext { public a_expr_unary_not(): A_expr_unary_notContext { return this.getRuleContext(0, A_expr_unary_notContext); } - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } public in_expr(): In_exprContext | undefined { return this.tryGetRuleContext(0, In_exprContext); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -96346,7 +96980,7 @@ export class A_expr_unary_notContext extends ParserRuleContext { public a_expr_isnull(): A_expr_isnullContext { return this.getRuleContext(0, A_expr_isnullContext); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -96379,8 +97013,8 @@ export class A_expr_isnullContext extends ParserRuleContext { public a_expr_is_not(): A_expr_is_notContext { return this.getRuleContext(0, A_expr_is_notContext); } - public ISNULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ISNULL, 0); } - public NOTNULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOTNULL, 0); } + public KW_ISNULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ISNULL, 0); } + public KW_NOTNULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOTNULL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -96413,25 +97047,25 @@ export class A_expr_is_notContext extends ParserRuleContext { public a_expr_compare(): A_expr_compareContext { return this.getRuleContext(0, A_expr_compareContext); } - public IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IS, 0); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } - public TRUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRUE_P, 0); } - public FALSE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FALSE_P, 0); } - public UNKNOWN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNKNOWN, 0); } - public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISTINCT, 0); } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } + public KW_IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IS, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } + public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRUE, 0); } + public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FALSE, 0); } + public KW_UNKNOWN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNKNOWN, 0); } + public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISTINCT, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } - public OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OF, 0); } + public KW_OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OF, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public type_list(): Type_listContext | undefined { return this.tryGetRuleContext(0, Type_listContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public DOCUMENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOCUMENT_P, 0); } - public NORMALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NORMALIZED, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } + public KW_DOCUMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOCUMENT, 0); } + public KW_NORMALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NORMALIZED, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } public unicode_normal_form(): Unicode_normal_formContext | undefined { return this.tryGetRuleContext(0, Unicode_normal_formContext); } @@ -96531,16 +97165,16 @@ export class A_expr_likeContext extends ParserRuleContext { return this.getRuleContext(i, A_expr_qual_opContext); } } - public LIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LIKE, 0); } - public ILIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ILIKE, 0); } - public SIMILAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SIMILAR, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } - public BETWEEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BETWEEN, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } + public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LIKE, 0); } + public KW_ILIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ILIKE, 0); } + public KW_SIMILAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SIMILAR, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } + public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BETWEEN, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } public opt_escape(): Opt_escapeContext | undefined { return this.tryGetRuleContext(0, Opt_escapeContext); } - public SYMMETRIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SYMMETRIC, 0); } + public KW_SYMMETRIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SYMMETRIC, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -96846,9 +97480,9 @@ export class A_expr_at_time_zoneContext extends ParserRuleContext { public a_expr_collate(): A_expr_collateContext { return this.getRuleContext(0, A_expr_collateContext); } - public AT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AT, 0); } - public TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIME, 0); } - public ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ZONE, 0); } + public KW_AT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AT, 0); } + public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIME, 0); } + public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ZONE, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } @@ -96884,7 +97518,7 @@ export class A_expr_collateContext extends ParserRuleContext { public a_expr_typecast(): A_expr_typecastContext { return this.getRuleContext(0, A_expr_typecastContext); } - public COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATE, 0); } + public KW_COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATE, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } @@ -96998,17 +97632,17 @@ export class B_exprContext extends ParserRuleContext { public LESS_EQUALS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LESS_EQUALS, 0); } public GREATER_EQUALS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GREATER_EQUALS, 0); } public NOT_EQUALS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT_EQUALS, 0); } - public IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IS, 0); } - public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISTINCT, 0); } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OF, 0); } + public KW_IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IS, 0); } + public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISTINCT, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OF, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public type_list(): Type_listContext | undefined { return this.tryGetRuleContext(0, Type_listContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public DOCUMENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOCUMENT_P, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } + public KW_DOCUMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOCUMENT, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -97048,7 +97682,7 @@ export class C_exprContext extends ParserRuleContext { } } export class C_expr_existsContext extends C_exprContext { - public EXISTS(): TerminalNode { return this.getToken(PostgreSQLParser.EXISTS, 0); } + public KW_EXISTS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXISTS, 0); } public select_with_parens(): Select_with_parensContext { return this.getRuleContext(0, Select_with_parensContext); } @@ -97079,7 +97713,7 @@ export class C_expr_existsContext extends C_exprContext { } export class C_expr_exprContext extends C_exprContext { public _a_expr_in_parens!: A_exprContext; - public ARRAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ARRAY, 0); } + public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ARRAY, 0); } public select_with_parens(): Select_with_parensContext | undefined { return this.tryGetRuleContext(0, Select_with_parensContext); } @@ -97090,13 +97724,13 @@ export class C_expr_exprContext extends C_exprContext { public opt_indirection(): Opt_indirectionContext | undefined { return this.tryGetRuleContext(0, Opt_indirectionContext); } - public GROUPING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUPING, 0); } + public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUPING, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public expr_list(): Expr_listContext | undefined { return this.tryGetRuleContext(0, Expr_listContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public UNIQUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNIQUE, 0); } + public KW_UNIQUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNIQUE, 0); } public columnref(): ColumnrefContext | undefined { return this.tryGetRuleContext(0, ColumnrefContext); } @@ -97130,7 +97764,7 @@ export class C_expr_exprContext extends C_exprContext { return this.getRuleContext(i, RowContext); } } - public OVERLAPS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OVERLAPS, 0); } + public KW_OVERLAPS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OVERLAPS, 0); } constructor(ctx: C_exprContext) { super(ctx.parent, ctx.invokingState); this.copyFrom(ctx); @@ -97226,13 +97860,13 @@ export class Func_applicationContext extends ParserRuleContext { public func_arg_list(): Func_arg_listContext | undefined { return this.tryGetRuleContext(0, Func_arg_listContext); } - public VARIADIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VARIADIC, 0); } + public KW_VARIADIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VARIADIC, 0); } public func_arg_expr(): Func_arg_exprContext | undefined { return this.tryGetRuleContext(0, Func_arg_exprContext); } public STAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STAR, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISTINCT, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISTINCT, 0); } public COMMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMA, 0); } public opt_sort_clause(): Opt_sort_clauseContext | undefined { return this.tryGetRuleContext(0, Opt_sort_clauseContext); @@ -97345,8 +97979,8 @@ export class Func_expr_windowlessContext extends ParserRuleContext { export class Func_expr_common_subexprContext extends ParserRuleContext { - public COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATION, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } + public KW_COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATION, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public a_expr(): A_exprContext[]; public a_expr(i: number): A_exprContext; @@ -97358,98 +97992,98 @@ export class Func_expr_common_subexprContext extends ParserRuleContext { } } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public CURRENT_DATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_DATE, 0); } - public CURRENT_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_TIME, 0); } + public KW_CURRENT_DATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_DATE, 0); } + public KW_CURRENT_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_TIME, 0); } public iconst(): IconstContext | undefined { return this.tryGetRuleContext(0, IconstContext); } - public CURRENT_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_TIMESTAMP, 0); } - public LOCALTIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCALTIME, 0); } - public LOCALTIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCALTIMESTAMP, 0); } - public CURRENT_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_ROLE, 0); } - public CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_USER, 0); } - public SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SESSION_USER, 0); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } - public CURRENT_CATALOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_CATALOG, 0); } - public CURRENT_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_SCHEMA, 0); } - public CAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CAST, 0); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_CURRENT_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_TIMESTAMP, 0); } + public KW_LOCALTIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCALTIME, 0); } + public KW_LOCALTIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCALTIMESTAMP, 0); } + public KW_CURRENT_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_ROLE, 0); } + public KW_CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_USER, 0); } + public KW_SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SESSION_USER, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } + public KW_CURRENT_CATALOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_CATALOG, 0); } + public KW_CURRENT_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_SCHEMA, 0); } + public KW_CAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CAST, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public typename(): TypenameContext | undefined { return this.tryGetRuleContext(0, TypenameContext); } - public EXTRACT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXTRACT, 0); } + public KW_EXTRACT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXTRACT, 0); } public extract_list(): Extract_listContext | undefined { return this.tryGetRuleContext(0, Extract_listContext); } - public NORMALIZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NORMALIZE, 0); } + public KW_NORMALIZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NORMALIZE, 0); } public COMMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMA, 0); } public unicode_normal_form(): Unicode_normal_formContext | undefined { return this.tryGetRuleContext(0, Unicode_normal_formContext); } - public OVERLAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OVERLAY, 0); } + public KW_OVERLAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OVERLAY, 0); } public overlay_list(): Overlay_listContext | undefined { return this.tryGetRuleContext(0, Overlay_listContext); } - public POSITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.POSITION, 0); } + public KW_POSITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_POSITION, 0); } public position_list(): Position_listContext | undefined { return this.tryGetRuleContext(0, Position_listContext); } - public SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SUBSTRING, 0); } + public KW_SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SUBSTRING, 0); } public substr_list(): Substr_listContext | undefined { return this.tryGetRuleContext(0, Substr_listContext); } - public TREAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TREAT, 0); } - public TRIM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRIM, 0); } + public KW_TREAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TREAT, 0); } + public KW_TRIM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIM, 0); } public trim_list(): Trim_listContext | undefined { return this.tryGetRuleContext(0, Trim_listContext); } - public BOTH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BOTH, 0); } - public LEADING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEADING, 0); } - public TRAILING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRAILING, 0); } - public NULLIF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULLIF, 0); } - public COALESCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COALESCE, 0); } + public KW_BOTH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BOTH, 0); } + public KW_LEADING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEADING, 0); } + public KW_TRAILING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRAILING, 0); } + public KW_NULLIF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULLIF, 0); } + public KW_COALESCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COALESCE, 0); } public expr_list(): Expr_listContext | undefined { return this.tryGetRuleContext(0, Expr_listContext); } - public GREATEST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GREATEST, 0); } - public LEAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEAST, 0); } - public XMLCONCAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLCONCAT, 0); } - public XMLELEMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLELEMENT, 0); } - public NAME_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NAME_P, 0); } + public KW_GREATEST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GREATEST, 0); } + public KW_LEAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEAST, 0); } + public KW_XMLCONCAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLCONCAT, 0); } + public KW_XMLELEMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLELEMENT, 0); } + public KW_NAME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NAME, 0); } public collabel(): CollabelContext | undefined { return this.tryGetRuleContext(0, CollabelContext); } public xml_attributes(): Xml_attributesContext | undefined { return this.tryGetRuleContext(0, Xml_attributesContext); } - public XMLEXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLEXISTS, 0); } + public KW_XMLEXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLEXISTS, 0); } public c_expr(): C_exprContext | undefined { return this.tryGetRuleContext(0, C_exprContext); } public xmlexists_argument(): Xmlexists_argumentContext | undefined { return this.tryGetRuleContext(0, Xmlexists_argumentContext); } - public XMLFOREST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLFOREST, 0); } + public KW_XMLFOREST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLFOREST, 0); } public xml_attribute_list(): Xml_attribute_listContext | undefined { return this.tryGetRuleContext(0, Xml_attribute_listContext); } - public XMLPARSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLPARSE, 0); } + public KW_XMLPARSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLPARSE, 0); } public document_or_content(): Document_or_contentContext | undefined { return this.tryGetRuleContext(0, Document_or_contentContext); } public xml_whitespace_option(): Xml_whitespace_optionContext | undefined { return this.tryGetRuleContext(0, Xml_whitespace_optionContext); } - public XMLPI(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLPI, 0); } - public XMLROOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLROOT, 0); } - public XML_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XML_P, 0); } + public KW_XMLPI(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLPI, 0); } + public KW_XMLROOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLROOT, 0); } + public KW_XML(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XML, 0); } public xml_root_version(): Xml_root_versionContext | undefined { return this.tryGetRuleContext(0, Xml_root_versionContext); } public opt_xml_root_standalone(): Opt_xml_root_standaloneContext | undefined { return this.tryGetRuleContext(0, Opt_xml_root_standaloneContext); } - public XMLSERIALIZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLSERIALIZE, 0); } + public KW_XMLSERIALIZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLSERIALIZE, 0); } public simpletypename(): SimpletypenameContext | undefined { return this.tryGetRuleContext(0, SimpletypenameContext); } @@ -97482,12 +98116,12 @@ export class Func_expr_common_subexprContext extends ParserRuleContext { export class Xml_root_versionContext extends ParserRuleContext { - public VERSION_P(): TerminalNode { return this.getToken(PostgreSQLParser.VERSION_P, 0); } + public KW_VERSION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_VERSION, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public VALUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALUE_P, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_VALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALUE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -97518,10 +98152,10 @@ export class Xml_root_versionContext extends ParserRuleContext { export class Opt_xml_root_standaloneContext extends ParserRuleContext { public COMMA(): TerminalNode { return this.getToken(PostgreSQLParser.COMMA, 0); } - public STANDALONE_P(): TerminalNode { return this.getToken(PostgreSQLParser.STANDALONE_P, 0); } - public YES_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.YES_P, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public VALUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALUE_P, 0); } + public KW_STANDALONE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_STANDALONE, 0); } + public KW_YES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_YES, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_VALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALUE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -97551,7 +98185,7 @@ export class Opt_xml_root_standaloneContext extends ParserRuleContext { export class Xml_attributesContext extends ParserRuleContext { - public XMLATTRIBUTES(): TerminalNode { return this.getToken(PostgreSQLParser.XMLATTRIBUTES, 0); } + public KW_XMLATTRIBUTES(): TerminalNode { return this.getToken(PostgreSQLParser.KW_XMLATTRIBUTES, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public xml_attribute_list(): Xml_attribute_listContext { return this.getRuleContext(0, Xml_attribute_listContext); @@ -97636,7 +98270,7 @@ export class Xml_attribute_elContext extends ParserRuleContext { public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public collabel(): CollabelContext | undefined { return this.tryGetRuleContext(0, CollabelContext); } @@ -97669,8 +98303,8 @@ export class Xml_attribute_elContext extends ParserRuleContext { export class Document_or_contentContext extends ParserRuleContext { - public DOCUMENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOCUMENT_P, 0); } - public CONTENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONTENT_P, 0); } + public KW_DOCUMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOCUMENT, 0); } + public KW_CONTENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONTENT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -97700,9 +98334,9 @@ export class Document_or_contentContext extends ParserRuleContext { export class Xml_whitespace_optionContext extends ParserRuleContext { - public PRESERVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRESERVE, 0); } - public WHITESPACE_P(): TerminalNode { return this.getToken(PostgreSQLParser.WHITESPACE_P, 0); } - public STRIP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STRIP_P, 0); } + public KW_PRESERVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRESERVE, 0); } + public KW_WHITESPACE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHITESPACE, 0); } + public KW_STRIP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STRIP, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -97732,7 +98366,7 @@ export class Xml_whitespace_optionContext extends ParserRuleContext { export class Xmlexists_argumentContext extends ParserRuleContext { - public PASSING(): TerminalNode { return this.getToken(PostgreSQLParser.PASSING, 0); } + public KW_PASSING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PASSING, 0); } public c_expr(): C_exprContext { return this.getRuleContext(0, C_exprContext); } @@ -97774,9 +98408,9 @@ export class Xmlexists_argumentContext extends ParserRuleContext { export class Xml_passing_mechContext extends ParserRuleContext { - public BY(): TerminalNode { return this.getToken(PostgreSQLParser.BY, 0); } - public REF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REF, 0); } - public VALUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALUE_P, 0); } + public KW_BY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BY, 0); } + public KW_REF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REF, 0); } + public KW_VALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALUE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -97806,8 +98440,8 @@ export class Xml_passing_mechContext extends ParserRuleContext { export class Within_group_clauseContext extends ParserRuleContext { - public WITHIN(): TerminalNode { return this.getToken(PostgreSQLParser.WITHIN, 0); } - public GROUP_P(): TerminalNode { return this.getToken(PostgreSQLParser.GROUP_P, 0); } + public KW_WITHIN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WITHIN, 0); } + public KW_GROUP(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GROUP, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public sort_clause(): Sort_clauseContext { return this.getRuleContext(0, Sort_clauseContext); @@ -97842,9 +98476,9 @@ export class Within_group_clauseContext extends ParserRuleContext { export class Filter_clauseContext extends ParserRuleContext { - public FILTER(): TerminalNode { return this.getToken(PostgreSQLParser.FILTER, 0); } + public KW_FILTER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FILTER, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } - public WHERE(): TerminalNode { return this.getToken(PostgreSQLParser.WHERE, 0); } + public KW_WHERE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHERE, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } @@ -97878,7 +98512,7 @@ export class Filter_clauseContext extends ParserRuleContext { export class Window_clauseContext extends ParserRuleContext { - public WINDOW(): TerminalNode { return this.getToken(PostgreSQLParser.WINDOW, 0); } + public KW_WINDOW(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WINDOW, 0); } public window_definition_list(): Window_definition_listContext { return this.getRuleContext(0, Window_definition_listContext); } @@ -97961,7 +98595,7 @@ export class Window_definitionContext extends ParserRuleContext { public colid(): ColidContext { return this.getRuleContext(0, ColidContext); } - public AS(): TerminalNode { return this.getToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AS, 0); } public window_specification(): Window_specificationContext { return this.getRuleContext(0, Window_specificationContext); } @@ -97994,7 +98628,7 @@ export class Window_definitionContext extends ParserRuleContext { export class Over_clauseContext extends ParserRuleContext { - public OVER(): TerminalNode { return this.getToken(PostgreSQLParser.OVER, 0); } + public KW_OVER(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OVER, 0); } public window_specification(): Window_specificationContext | undefined { return this.tryGetRuleContext(0, Window_specificationContext); } @@ -98105,8 +98739,8 @@ export class Opt_existing_window_nameContext extends ParserRuleContext { export class Opt_partition_clauseContext extends ParserRuleContext { - public PARTITION(): TerminalNode { return this.getToken(PostgreSQLParser.PARTITION, 0); } - public BY(): TerminalNode { return this.getToken(PostgreSQLParser.BY, 0); } + public KW_PARTITION(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PARTITION, 0); } + public KW_BY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BY, 0); } public expr_list(): Expr_listContext { return this.getRuleContext(0, Expr_listContext); } @@ -98139,15 +98773,15 @@ export class Opt_partition_clauseContext extends ParserRuleContext { export class Opt_frame_clauseContext extends ParserRuleContext { - public RANGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RANGE, 0); } + public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RANGE, 0); } public frame_extent(): Frame_extentContext { return this.getRuleContext(0, Frame_extentContext); } public opt_window_exclusion_clause(): Opt_window_exclusion_clauseContext | undefined { return this.tryGetRuleContext(0, Opt_window_exclusion_clauseContext); } - public ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROWS, 0); } - public GROUPS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUPS, 0); } + public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROWS, 0); } + public KW_GROUPS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUPS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -98186,8 +98820,8 @@ export class Frame_extentContext extends ParserRuleContext { return this.getRuleContext(i, Frame_boundContext); } } - public BETWEEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BETWEEN, 0); } - public AND(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AND, 0); } + public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BETWEEN, 0); } + public KW_AND(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AND, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -98217,11 +98851,11 @@ export class Frame_extentContext extends ParserRuleContext { export class Frame_boundContext extends ParserRuleContext { - public UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNBOUNDED, 0); } - public PRECEDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRECEDING, 0); } - public FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOLLOWING, 0); } - public CURRENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_P, 0); } - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } + public KW_UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNBOUNDED, 0); } + public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRECEDING, 0); } + public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOLLOWING, 0); } + public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } @@ -98254,13 +98888,13 @@ export class Frame_boundContext extends ParserRuleContext { export class Opt_window_exclusion_clauseContext extends ParserRuleContext { - public EXCLUDE(): TerminalNode { return this.getToken(PostgreSQLParser.EXCLUDE, 0); } - public CURRENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_P, 0); } - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } - public GROUP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUP_P, 0); } - public TIES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIES, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public OTHERS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OTHERS, 0); } + public KW_EXCLUDE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXCLUDE, 0); } + public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUP, 0); } + public KW_TIES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIES, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_OTHERS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OTHERS, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -98290,7 +98924,7 @@ export class Opt_window_exclusion_clauseContext extends ParserRuleContext { export class RowContext extends ParserRuleContext { - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public CLOSE_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); } public expr_list(): Expr_listContext | undefined { @@ -98329,7 +98963,7 @@ export class RowContext extends ParserRuleContext { export class Explicit_rowContext extends ParserRuleContext { - public ROW(): TerminalNode { return this.getToken(PostgreSQLParser.ROW, 0); } + public KW_ROW(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ROW, 0); } public OPEN_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN_PAREN, 0); } public CLOSE_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); } public expr_list(): Expr_listContext | undefined { @@ -98402,9 +99036,9 @@ export class Implicit_rowContext extends ParserRuleContext { export class Sub_typeContext extends ParserRuleContext { - public ANY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ANY, 0); } - public SOME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SOME, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_ANY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ANY, 0); } + public KW_SOME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SOME, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -98509,7 +99143,7 @@ export class MathopContext extends ParserRuleContext { export class Qual_opContext extends ParserRuleContext { public Operator(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.Operator, 0); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public any_operator(): Any_operatorContext | undefined { return this.tryGetRuleContext(0, Any_operatorContext); @@ -98547,7 +99181,7 @@ export class Qual_all_opContext extends ParserRuleContext { public all_op(): All_opContext | undefined { return this.tryGetRuleContext(0, All_opContext); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public any_operator(): Any_operatorContext | undefined { return this.tryGetRuleContext(0, Any_operatorContext); @@ -98585,15 +99219,15 @@ export class Subquery_OpContext extends ParserRuleContext { public all_op(): All_opContext | undefined { return this.tryGetRuleContext(0, All_opContext); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } public any_operator(): Any_operatorContext | undefined { return this.tryGetRuleContext(0, Any_operatorContext); } public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } - public LIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LIKE, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public ILIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ILIKE, 0); } + public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LIKE, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_ILIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ILIKE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -98888,7 +99522,7 @@ export class Extract_listContext extends ParserRuleContext { public extract_arg(): Extract_argContext { return this.getRuleContext(0, Extract_argContext); } - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } @@ -98924,12 +99558,12 @@ export class Extract_argContext extends ParserRuleContext { public identifier(): IdentifierContext | undefined { return this.tryGetRuleContext(0, IdentifierContext); } - public YEAR_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.YEAR_P, 0); } - public MONTH_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MONTH_P, 0); } - public DAY_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DAY_P, 0); } - public HOUR_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HOUR_P, 0); } - public MINUTE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MINUTE_P, 0); } - public SECOND_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SECOND_P, 0); } + public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_YEAR, 0); } + public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MONTH, 0); } + public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DAY, 0); } + public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HOUR, 0); } + public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MINUTE, 0); } + public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SECOND, 0); } public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } @@ -98962,10 +99596,10 @@ export class Extract_argContext extends ParserRuleContext { export class Unicode_normal_formContext extends ParserRuleContext { - public NFC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NFC, 0); } - public NFD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NFD, 0); } - public NFKC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NFKC, 0); } - public NFKD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NFKD, 0); } + public KW_NFC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NFC, 0); } + public KW_NFD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NFD, 0); } + public KW_NFKC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NFKC, 0); } + public KW_NFKD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NFKD, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -99004,9 +99638,9 @@ export class Overlay_listContext extends ParserRuleContext { return this.getRuleContext(i, A_exprContext); } } - public PLACING(): TerminalNode { return this.getToken(PostgreSQLParser.PLACING, 0); } - public FROM(): TerminalNode { return this.getToken(PostgreSQLParser.FROM, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } + public KW_PLACING(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PLACING, 0); } + public KW_FROM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FROM, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -99045,7 +99679,7 @@ export class Position_listContext extends ParserRuleContext { return this.getRuleContext(i, B_exprContext); } } - public IN_P(): TerminalNode { return this.getToken(PostgreSQLParser.IN_P, 0); } + public KW_IN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -99084,10 +99718,10 @@ export class Substr_listContext extends ParserRuleContext { return this.getRuleContext(i, A_exprContext); } } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } - public SIMILAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SIMILAR, 0); } - public ESCAPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ESCAPE, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } + public KW_SIMILAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SIMILAR, 0); } + public KW_ESCAPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ESCAPE, 0); } public expr_list(): Expr_listContext | undefined { return this.tryGetRuleContext(0, Expr_listContext); } @@ -99123,7 +99757,7 @@ export class Trim_listContext extends ParserRuleContext { public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } public expr_list(): Expr_listContext { return this.getRuleContext(0, Expr_listContext); } @@ -99228,11 +99862,11 @@ export class In_expr_listContext extends In_exprContext { export class Case_exprContext extends ParserRuleContext { - public CASE(): TerminalNode { return this.getToken(PostgreSQLParser.CASE, 0); } + public KW_CASE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CASE, 0); } public when_clause_list(): When_clause_listContext { return this.getRuleContext(0, When_clause_listContext); } - public END_P(): TerminalNode { return this.getToken(PostgreSQLParser.END_P, 0); } + public KW_END(): TerminalNode { return this.getToken(PostgreSQLParser.KW_END, 0); } public case_arg(): Case_argContext | undefined { return this.tryGetRuleContext(0, Case_argContext); } @@ -99306,7 +99940,7 @@ export class When_clause_listContext extends ParserRuleContext { export class When_clauseContext extends ParserRuleContext { - public WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.WHEN, 0); } + public KW_WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHEN, 0); } public a_expr(): A_exprContext[]; public a_expr(i: number): A_exprContext; public a_expr(i?: number): A_exprContext | A_exprContext[] { @@ -99316,7 +99950,7 @@ export class When_clauseContext extends ParserRuleContext { return this.getRuleContext(i, A_exprContext); } } - public THEN(): TerminalNode { return this.getToken(PostgreSQLParser.THEN, 0); } + public KW_THEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_THEN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -99346,7 +99980,7 @@ export class When_clauseContext extends ParserRuleContext { export class Case_defaultContext extends ParserRuleContext { - public ELSE(): TerminalNode { return this.getToken(PostgreSQLParser.ELSE, 0); } + public KW_ELSE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ELSE, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } @@ -99695,7 +100329,7 @@ export class Target_labelContext extends Target_elContext { public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } public collabel(): CollabelContext | undefined { return this.tryGetRuleContext(0, CollabelContext); } @@ -99803,6 +100437,41 @@ export class Qualified_name_listContext extends ParserRuleContext { } +export class Table_qualified_nameContext extends ParserRuleContext { + public colid(): ColidContext { + return this.getRuleContext(0, ColidContext); + } + public indirection(): IndirectionContext | undefined { + return this.tryGetRuleContext(0, IndirectionContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_table_qualified_name; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterTable_qualified_name) { + listener.enterTable_qualified_name(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitTable_qualified_name) { + listener.exitTable_qualified_name(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitTable_qualified_name) { + return visitor.visitTable_qualified_name(this); + } else { + return visitor.visitChildren(this); + } + } +} + + export class Qualified_nameContext extends ParserRuleContext { public colid(): ColidContext { return this.getRuleContext(0, ColidContext); @@ -100055,9 +100724,9 @@ export class AexprconstContext extends ParserRuleContext { public opt_interval(): Opt_intervalContext | undefined { return this.tryGetRuleContext(0, Opt_intervalContext); } - public TRUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRUE_P, 0); } - public FALSE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FALSE_P, 0); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } + public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRUE, 0); } + public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FALSE, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -100285,7 +100954,7 @@ export class AnysconstContext extends ParserRuleContext { export class Opt_uescapeContext extends ParserRuleContext { - public UESCAPE(): TerminalNode { return this.getToken(PostgreSQLParser.UESCAPE, 0); } + public KW_UESCAPE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_UESCAPE, 0); } public anysconst(): AnysconstContext { return this.getRuleContext(0, AnysconstContext); } @@ -100351,6 +101020,38 @@ export class SignediconstContext extends ParserRuleContext { } +export class GroupnameContext extends ParserRuleContext { + public rolespec(): RolespecContext { + return this.getRuleContext(0, RolespecContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_groupname; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterGroupname) { + listener.enterGroupname(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitGroupname) { + listener.exitGroupname(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitGroupname) { + return visitor.visitGroupname(this); + } else { + return visitor.visitChildren(this); + } + } +} + + export class RoleidContext extends ParserRuleContext { public rolespec(): RolespecContext { return this.getRuleContext(0, RolespecContext); @@ -100387,8 +101088,9 @@ export class RolespecContext extends ParserRuleContext { public nonreservedword(): NonreservedwordContext | undefined { return this.tryGetRuleContext(0, NonreservedwordContext); } - public CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_USER, 0); } - public SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SESSION_USER, 0); } + public KW_CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_USER, 0); } + public KW_SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SESSION_USER, 0); } + public KW_PUBLIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PUBLIC, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -100505,6 +101207,153 @@ export class ColidContext extends ParserRuleContext { } +export class Index_method_choicesContext extends ParserRuleContext { + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_index_method_choices; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterIndex_method_choices) { + listener.enterIndex_method_choices(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitIndex_method_choices) { + listener.exitIndex_method_choices(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitIndex_method_choices) { + return visitor.visitIndex_method_choices(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class Exclude_elementContext extends ParserRuleContext { + public opt_definition(): Opt_definitionContext | undefined { + return this.tryGetRuleContext(0, Opt_definitionContext); + } + public identifier(): IdentifierContext | undefined { + return this.tryGetRuleContext(0, IdentifierContext); + } + public OPEN_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN_PAREN, 0); } + public a_expr(): A_exprContext | undefined { + return this.tryGetRuleContext(0, A_exprContext); + } + public CLOSE_PAREN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE_PAREN, 0); } + public opt_asc_desc(): Opt_asc_descContext | undefined { + return this.tryGetRuleContext(0, Opt_asc_descContext); + } + public opt_nulls_order(): Opt_nulls_orderContext | undefined { + return this.tryGetRuleContext(0, Opt_nulls_orderContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_exclude_element; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterExclude_element) { + listener.enterExclude_element(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitExclude_element) { + listener.exitExclude_element(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitExclude_element) { + return visitor.visitExclude_element(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class Index_paramentersContext extends ParserRuleContext { + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } + public reloptions(): ReloptionsContext | undefined { + return this.tryGetRuleContext(0, ReloptionsContext); + } + public optconstablespace(): OptconstablespaceContext | undefined { + return this.tryGetRuleContext(0, OptconstablespaceContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_index_paramenters; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterIndex_paramenters) { + listener.enterIndex_paramenters(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitIndex_paramenters) { + listener.exitIndex_paramenters(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitIndex_paramenters) { + return visitor.visitIndex_paramenters(this); + } else { + return visitor.visitChildren(this); + } + } +} + + +export class WherePredicateContext extends ParserRuleContext { + public KW_WHERE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHERE, 0); } + public identifier(): IdentifierContext { + return this.getRuleContext(0, IdentifierContext); + } + constructor(parent: ParserRuleContext | undefined, invokingState: number) { + super(parent, invokingState); + } + // @Override + public get ruleIndex(): number { return PostgreSQLParser.RULE_wherePredicate; } + // @Override + public enterRule(listener: PostgreSQLParserListener): void { + if (listener.enterWherePredicate) { + listener.enterWherePredicate(this); + } + } + // @Override + public exitRule(listener: PostgreSQLParserListener): void { + if (listener.exitWherePredicate) { + listener.exitWherePredicate(this); + } + } + // @Override + public accept(visitor: PostgreSQLParserVisitor): Result { + if (visitor.visitWherePredicate) { + return visitor.visitWherePredicate(this); + } else { + return visitor.visitChildren(this); + } + } +} + + export class Type_function_nameContext extends ParserRuleContext { public identifier(): IdentifierContext | undefined { return this.tryGetRuleContext(0, IdentifierContext); @@ -100709,305 +101558,305 @@ export class PlsqlidentifierContext extends ParserRuleContext { export class Unreserved_keywordContext extends ParserRuleContext { - public ABORT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ABORT_P, 0); } - public ABSOLUTE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ABSOLUTE_P, 0); } - public ACCESS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ACCESS, 0); } - public ACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ACTION, 0); } - public ADD_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADD_P, 0); } - public ADMIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ADMIN, 0); } - public AFTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AFTER, 0); } - public AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AGGREGATE, 0); } - public ALSO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALSO, 0); } - public ALTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALTER, 0); } - public ALWAYS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALWAYS, 0); } - public ASSERTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ASSERTION, 0); } - public ASSIGNMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ASSIGNMENT, 0); } - public AT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AT, 0); } - public ATTACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ATTACH, 0); } - public ATTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ATTRIBUTE, 0); } - public BACKWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BACKWARD, 0); } - public BEFORE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BEFORE, 0); } - public BEGIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BEGIN_P, 0); } - public BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BY, 0); } - public CACHE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CACHE, 0); } - public CALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CALL, 0); } - public CALLED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CALLED, 0); } - public CASCADE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CASCADE, 0); } - public CASCADED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CASCADED, 0); } - public CATALOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CATALOG, 0); } - public CHAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHAIN, 0); } - public CHARACTERISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHARACTERISTICS, 0); } - public CHECKPOINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHECKPOINT, 0); } - public CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLASS, 0); } - public CLOSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE, 0); } - public CLUSTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLUSTER, 0); } - public COLUMNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLUMNS, 0); } - public COMMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMENT, 0); } - public COMMENTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMENTS, 0); } - public COMMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMIT, 0); } - public COMMITTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMITTED, 0); } - public CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONFIGURATION, 0); } - public CONFLICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONFLICT, 0); } - public CONNECTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONNECTION, 0); } - public CONSTRAINTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINTS, 0); } - public CONTENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONTENT_P, 0); } - public CONTINUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONTINUE_P, 0); } - public CONVERSION_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONVERSION_P, 0); } - public COPY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COPY, 0); } - public COST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COST, 0); } - public CSV(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CSV, 0); } - public CUBE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CUBE, 0); } - public CURRENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_P, 0); } - public CURSOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURSOR, 0); } - public CYCLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CYCLE, 0); } - public DATA_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATA_P, 0); } - public DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DATABASE, 0); } - public DAY_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DAY_P, 0); } - public DEALLOCATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEALLOCATE, 0); } - public DECLARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DECLARE, 0); } - public DEFAULTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULTS, 0); } - public DEFERRED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFERRED, 0); } - public DEFINER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFINER, 0); } - public DELETE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DELETE_P, 0); } - public DELIMITER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DELIMITER, 0); } - public DELIMITERS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DELIMITERS, 0); } - public DEPENDS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEPENDS, 0); } - public DETACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DETACH, 0); } - public DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DICTIONARY, 0); } - public DISABLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISABLE_P, 0); } - public DISCARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISCARD, 0); } - public DOCUMENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOCUMENT_P, 0); } - public DOMAIN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOMAIN_P, 0); } - public DOUBLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DOUBLE_P, 0); } - public DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DROP, 0); } - public EACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EACH, 0); } - public ENABLE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENABLE_P, 0); } - public ENCODING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENCODING, 0); } - public ENCRYPTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENCRYPTED, 0); } - public ENUM_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ENUM_P, 0); } - public ESCAPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ESCAPE, 0); } - public EVENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EVENT, 0); } - public EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCLUDE, 0); } - public EXCLUDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCLUDING, 0); } - public EXCLUSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCLUSIVE, 0); } - public EXECUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXECUTE, 0); } - public EXPLAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXPLAIN, 0); } - public EXPRESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXPRESSION, 0); } - public EXTENSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXTENSION, 0); } - public EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXTERNAL, 0); } - public FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FAMILY, 0); } - public FILTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FILTER, 0); } - public FIRST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FIRST_P, 0); } - public FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOLLOWING, 0); } - public FORCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FORCE, 0); } - public FORWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FORWARD, 0); } - public FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTION, 0); } - public FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FUNCTIONS, 0); } - public GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GENERATED, 0); } - public GLOBAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GLOBAL, 0); } - public GRANTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GRANTED, 0); } - public GROUPS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUPS, 0); } - public HANDLER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HANDLER, 0); } - public HEADER_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HEADER_P, 0); } - public HOLD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HOLD, 0); } - public HOUR_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HOUR_P, 0); } - public IDENTITY_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IDENTITY_P, 0); } - public IF_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IF_P, 0); } - public IMMEDIATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IMMEDIATE, 0); } - public IMMUTABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IMMUTABLE, 0); } - public IMPLICIT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IMPLICIT_P, 0); } - public IMPORT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IMPORT_P, 0); } - public INCLUDE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INCLUDE, 0); } - public INCLUDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INCLUDING, 0); } - public INCREMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INCREMENT, 0); } - public INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEX, 0); } - public INDEXES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INDEXES, 0); } - public INHERIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INHERIT, 0); } - public INHERITS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INHERITS, 0); } - public INLINE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INLINE_P, 0); } - public INPUT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INPUT_P, 0); } - public INSENSITIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INSENSITIVE, 0); } - public INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INSERT, 0); } - public INSTEAD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INSTEAD, 0); } - public INVOKER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INVOKER, 0); } - public ISOLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ISOLATION, 0); } - public KEY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KEY, 0); } - public LABEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LABEL, 0); } - public LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LANGUAGE, 0); } - public LARGE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LARGE_P, 0); } - public LAST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LAST_P, 0); } - public LEAKPROOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEAKPROOF, 0); } - public LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEVEL, 0); } - public LISTEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LISTEN, 0); } - public LOAD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOAD, 0); } - public LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCAL, 0); } - public LOCATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCATION, 0); } - public LOCK_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCK_P, 0); } - public LOCKED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCKED, 0); } - public LOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOGGED, 0); } - public MAPPING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MAPPING, 0); } - public MATCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MATCH, 0); } - public MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MATERIALIZED, 0); } - public MAXVALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MAXVALUE, 0); } - public METHOD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.METHOD, 0); } - public MINUTE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MINUTE_P, 0); } - public MINVALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MINVALUE, 0); } - public MODE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MODE, 0); } - public MONTH_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MONTH_P, 0); } - public MOVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MOVE, 0); } - public NAME_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NAME_P, 0); } - public NAMES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NAMES, 0); } - public NEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NEW, 0); } - public NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NEXT, 0); } - public NFC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NFC, 0); } - public NFD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NFD, 0); } - public NFKC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NFKC, 0); } - public NFKD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NFKD, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public NORMALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NORMALIZED, 0); } - public NOTHING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOTHING, 0); } - public NOTIFY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOTIFY, 0); } - public NOWAIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOWAIT, 0); } - public NULLS_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULLS_P, 0); } - public OBJECT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OBJECT_P, 0); } - public OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OF, 0); } - public OFF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OFF, 0); } - public OIDS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OIDS, 0); } - public OLD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OLD, 0); } - public OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPERATOR, 0); } - public OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPTION, 0); } - public OPTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPTIONS, 0); } - public ORDINALITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ORDINALITY, 0); } - public OTHERS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OTHERS, 0); } - public OVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OVER, 0); } - public OVERRIDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OVERRIDING, 0); } - public OWNED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OWNED, 0); } - public OWNER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OWNER, 0); } - public PARALLEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARALLEL, 0); } - public PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARSER, 0); } - public PARTIAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARTIAL, 0); } - public PARTITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PARTITION, 0); } - public PASSING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PASSING, 0); } - public PASSWORD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PASSWORD, 0); } - public PLANS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PLANS, 0); } - public POLICY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.POLICY, 0); } - public PRECEDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRECEDING, 0); } - public PREPARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PREPARE, 0); } - public PREPARED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PREPARED, 0); } - public PRESERVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRESERVE, 0); } - public PRIOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRIOR, 0); } - public PRIVILEGES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRIVILEGES, 0); } - public PROCEDURAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURAL, 0); } - public PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURE, 0); } - public PROCEDURES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROCEDURES, 0); } - public PROGRAM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PROGRAM, 0); } - public PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PUBLICATION, 0); } - public QUOTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.QUOTE, 0); } - public RANGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RANGE, 0); } - public READ(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.READ, 0); } - public REASSIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REASSIGN, 0); } - public RECHECK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RECHECK, 0); } - public RECURSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RECURSIVE, 0); } - public REF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REF, 0); } - public REFERENCING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REFERENCING, 0); } - public REFRESH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REFRESH, 0); } - public REINDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REINDEX, 0); } - public RELATIVE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RELATIVE_P, 0); } - public RELEASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RELEASE, 0); } - public RENAME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RENAME, 0); } - public REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REPEATABLE, 0); } - public REPLACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REPLACE, 0); } - public REPLICA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REPLICA, 0); } - public RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESET, 0); } - public RESTART(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESTART, 0); } - public RESTRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESTRICT, 0); } - public RETURNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RETURNS, 0); } - public REVOKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REVOKE, 0); } - public ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLE, 0); } - public ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLLBACK, 0); } - public ROLLUP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLLUP, 0); } - public ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINE, 0); } - public ROUTINES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROUTINES, 0); } - public ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROWS, 0); } - public RULE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RULE, 0); } - public SAVEPOINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SAVEPOINT, 0); } - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } - public SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMAS, 0); } - public SCROLL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCROLL, 0); } - public SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEARCH, 0); } - public SECOND_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SECOND_P, 0); } - public SECURITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SECURITY, 0); } - public SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCE, 0); } - public SEQUENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SEQUENCES, 0); } - public SERIALIZABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SERIALIZABLE, 0); } - public SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SERVER, 0); } - public SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SESSION, 0); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public SETS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SETS, 0); } - public SHARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SHARE, 0); } - public SHOW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SHOW, 0); } - public SIMPLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SIMPLE, 0); } - public SKIP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SKIP_P, 0); } - public SNAPSHOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SNAPSHOT, 0); } - public SQL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SQL_P, 0); } - public STABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STABLE, 0); } - public STANDALONE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STANDALONE_P, 0); } - public START(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.START, 0); } - public STATEMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STATEMENT, 0); } - public STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STATISTICS, 0); } - public STDIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STDIN, 0); } - public STDOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STDOUT, 0); } - public STORAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STORAGE, 0); } - public STORED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STORED, 0); } - public STRICT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STRICT_P, 0); } - public STRIP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STRIP_P, 0); } - public SUBSCRIPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SUBSCRIPTION, 0); } - public SUPPORT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SUPPORT, 0); } - public SYSID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SYSID, 0); } - public SYSTEM_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SYSTEM_P, 0); } - public TABLES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLES, 0); } - public TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLESPACE, 0); } - public TEMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMP, 0); } - public TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPLATE, 0); } - public TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEMPORARY, 0); } - public TEXT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TEXT_P, 0); } - public TIES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIES, 0); } - public TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSACTION, 0); } - public TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRANSFORM, 0); } - public TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRIGGER, 0); } - public TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRUNCATE, 0); } - public TRUSTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRUSTED, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } - public TYPES_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPES_P, 0); } - public UESCAPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UESCAPE, 0); } - public UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNBOUNDED, 0); } - public UNCOMMITTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNCOMMITTED, 0); } - public UNENCRYPTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNENCRYPTED, 0); } - public UNKNOWN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNKNOWN, 0); } - public UNLISTEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNLISTEN, 0); } - public UNLOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNLOGGED, 0); } - public UNTIL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNTIL, 0); } - public UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UPDATE, 0); } - public VACUUM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VACUUM, 0); } - public VALID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALID, 0); } - public VALIDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALIDATE, 0); } - public VALIDATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALIDATOR, 0); } - public VALUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALUE_P, 0); } - public VARYING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VARYING, 0); } - public VERSION_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VERSION_P, 0); } - public VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VIEW, 0); } - public VIEWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VIEWS, 0); } - public VOLATILE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VOLATILE, 0); } - public WHITESPACE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WHITESPACE_P, 0); } - public WITHIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITHIN, 0); } - public WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITHOUT, 0); } - public WORK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WORK, 0); } - public WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WRAPPER, 0); } - public WRITE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WRITE, 0); } - public XML_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XML_P, 0); } - public YEAR_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.YEAR_P, 0); } - public YES_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.YES_P, 0); } - public ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ZONE, 0); } + public KW_ABORT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ABORT, 0); } + public KW_ABSOLUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ABSOLUTE, 0); } + public KW_ACCESS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ACCESS, 0); } + public KW_ACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ACTION, 0); } + public KW_ADD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADD, 0); } + public KW_ADMIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ADMIN, 0); } + public KW_AFTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AFTER, 0); } + public KW_AGGREGATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AGGREGATE, 0); } + public KW_ALSO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALSO, 0); } + public KW_ALTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALTER, 0); } + public KW_ALWAYS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALWAYS, 0); } + public KW_ASSERTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ASSERTION, 0); } + public KW_ASSIGNMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ASSIGNMENT, 0); } + public KW_AT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AT, 0); } + public KW_ATTACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ATTACH, 0); } + public KW_ATTRIBUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ATTRIBUTE, 0); } + public KW_BACKWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BACKWARD, 0); } + public KW_BEFORE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BEFORE, 0); } + public KW_BEGIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BEGIN, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BY, 0); } + public KW_CACHE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CACHE, 0); } + public KW_CALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CALL, 0); } + public KW_CALLED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CALLED, 0); } + public KW_CASCADE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CASCADE, 0); } + public KW_CASCADED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CASCADED, 0); } + public KW_CATALOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CATALOG, 0); } + public KW_CHAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHAIN, 0); } + public KW_CHARACTERISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHARACTERISTICS, 0); } + public KW_CHECKPOINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHECKPOINT, 0); } + public KW_CLASS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLASS, 0); } + public KW_CLOSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLOSE, 0); } + public KW_CLUSTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLUSTER, 0); } + public KW_COLUMNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLUMNS, 0); } + public KW_COMMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COMMENT, 0); } + public KW_COMMENTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COMMENTS, 0); } + public KW_COMMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COMMIT, 0); } + public KW_COMMITTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COMMITTED, 0); } + public KW_CONFIGURATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONFIGURATION, 0); } + public KW_CONFLICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONFLICT, 0); } + public KW_CONNECTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONNECTION, 0); } + public KW_CONSTRAINTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINTS, 0); } + public KW_CONTENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONTENT, 0); } + public KW_CONTINUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONTINUE, 0); } + public KW_CONVERSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONVERSION, 0); } + public KW_COPY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COPY, 0); } + public KW_COST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COST, 0); } + public KW_CSV(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CSV, 0); } + public KW_CUBE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CUBE, 0); } + public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT, 0); } + public KW_CURSOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURSOR, 0); } + public KW_CYCLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CYCLE, 0); } + public KW_DATA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATA, 0); } + public KW_DATABASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DATABASE, 0); } + public KW_DAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DAY, 0); } + public KW_DEALLOCATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEALLOCATE, 0); } + public KW_DECLARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DECLARE, 0); } + public KW_DEFAULTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULTS, 0); } + public KW_DEFERRED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFERRED, 0); } + public KW_DEFINER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFINER, 0); } + public KW_DELETE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DELETE, 0); } + public KW_DELIMITER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DELIMITER, 0); } + public KW_DELIMITERS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DELIMITERS, 0); } + public KW_DEPENDS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEPENDS, 0); } + public KW_DETACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DETACH, 0); } + public KW_DICTIONARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DICTIONARY, 0); } + public KW_DISABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISABLE, 0); } + public KW_DISCARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISCARD, 0); } + public KW_DOCUMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOCUMENT, 0); } + public KW_DOMAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOMAIN, 0); } + public KW_DOUBLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DOUBLE, 0); } + public KW_DROP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DROP, 0); } + public KW_EACH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EACH, 0); } + public KW_ENABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENABLE, 0); } + public KW_ENCODING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENCODING, 0); } + public KW_ENCRYPTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENCRYPTED, 0); } + public KW_ENUM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ENUM, 0); } + public KW_ESCAPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ESCAPE, 0); } + public KW_EVENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EVENT, 0); } + public KW_EXCLUDE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCLUDE, 0); } + public KW_EXCLUDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCLUDING, 0); } + public KW_EXCLUSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCLUSIVE, 0); } + public KW_EXECUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXECUTE, 0); } + public KW_EXPLAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXPLAIN, 0); } + public KW_EXPRESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXPRESSION, 0); } + public KW_EXTENSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXTENSION, 0); } + public KW_EXTERNAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXTERNAL, 0); } + public KW_FAMILY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FAMILY, 0); } + public KW_FILTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FILTER, 0); } + public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FIRST, 0); } + public KW_FOLLOWING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOLLOWING, 0); } + public KW_FORCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FORCE, 0); } + public KW_FORWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FORWARD, 0); } + public KW_FUNCTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTION, 0); } + public KW_FUNCTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FUNCTIONS, 0); } + public KW_GENERATED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GENERATED, 0); } + public KW_GLOBAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GLOBAL, 0); } + public KW_GRANTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GRANTED, 0); } + public KW_GROUPS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUPS, 0); } + public KW_HANDLER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HANDLER, 0); } + public KW_HEADER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HEADER, 0); } + public KW_HOLD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HOLD, 0); } + public KW_HOUR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HOUR, 0); } + public KW_IDENTITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IDENTITY, 0); } + public KW_IF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IF, 0); } + public KW_IMMEDIATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IMMEDIATE, 0); } + public KW_IMMUTABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IMMUTABLE, 0); } + public KW_IMPLICIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IMPLICIT, 0); } + public KW_IMPORT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IMPORT, 0); } + public KW_INCLUDE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INCLUDE, 0); } + public KW_INCLUDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INCLUDING, 0); } + public KW_INCREMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INCREMENT, 0); } + public KW_INDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEX, 0); } + public KW_INDEXES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INDEXES, 0); } + public KW_INHERIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INHERIT, 0); } + public KW_INHERITS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INHERITS, 0); } + public KW_INLINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INLINE, 0); } + public KW_INPUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INPUT, 0); } + public KW_INSENSITIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSENSITIVE, 0); } + public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSERT, 0); } + public KW_INSTEAD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSTEAD, 0); } + public KW_INVOKER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INVOKER, 0); } + public KW_ISOLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ISOLATION, 0); } + public KW_KEY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_KEY, 0); } + public KW_LABEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LABEL, 0); } + public KW_LANGUAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LANGUAGE, 0); } + public KW_LARGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LARGE, 0); } + public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LAST, 0); } + public KW_LEAKPROOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEAKPROOF, 0); } + public KW_LEVEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEVEL, 0); } + public KW_LISTEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LISTEN, 0); } + public KW_LOAD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOAD, 0); } + public KW_LOCAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCAL, 0); } + public KW_LOCATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCATION, 0); } + public KW_LOCK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCK, 0); } + public KW_LOCKED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCKED, 0); } + public KW_LOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOGGED, 0); } + public KW_MAPPING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MAPPING, 0); } + public KW_MATCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MATCH, 0); } + public KW_MATERIALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MATERIALIZED, 0); } + public KW_MAXVALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MAXVALUE, 0); } + public KW_METHOD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_METHOD, 0); } + public KW_MINUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MINUTE, 0); } + public KW_MINVALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MINVALUE, 0); } + public KW_MODE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MODE, 0); } + public KW_MONTH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MONTH, 0); } + public KW_MOVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MOVE, 0); } + public KW_NAME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NAME, 0); } + public KW_NAMES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NAMES, 0); } + public KW_NEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NEW, 0); } + public KW_NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NEXT, 0); } + public KW_NFC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NFC, 0); } + public KW_NFD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NFD, 0); } + public KW_NFKC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NFKC, 0); } + public KW_NFKD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NFKD, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_NORMALIZED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NORMALIZED, 0); } + public KW_NOTHING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOTHING, 0); } + public KW_NOTIFY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOTIFY, 0); } + public KW_NOWAIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOWAIT, 0); } + public KW_NULLS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULLS, 0); } + public KW_OBJECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OBJECT, 0); } + public KW_OF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OF, 0); } + public KW_OFF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OFF, 0); } + public KW_OIDS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OIDS, 0); } + public KW_OLD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OLD, 0); } + public KW_OPERATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPERATOR, 0); } + public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPTION, 0); } + public KW_OPTIONS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPTIONS, 0); } + public KW_ORDINALITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ORDINALITY, 0); } + public KW_OTHERS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OTHERS, 0); } + public KW_OVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OVER, 0); } + public KW_OVERRIDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OVERRIDING, 0); } + public KW_OWNED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OWNED, 0); } + public KW_OWNER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OWNER, 0); } + public KW_PARALLEL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARALLEL, 0); } + public KW_PARSER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARSER, 0); } + public KW_PARTIAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARTIAL, 0); } + public KW_PARTITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PARTITION, 0); } + public KW_PASSING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PASSING, 0); } + public KW_PASSWORD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PASSWORD, 0); } + public KW_PLANS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PLANS, 0); } + public KW_POLICY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_POLICY, 0); } + public KW_PRECEDING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRECEDING, 0); } + public KW_PREPARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PREPARE, 0); } + public KW_PREPARED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PREPARED, 0); } + public KW_PRESERVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRESERVE, 0); } + public KW_PRIOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRIOR, 0); } + public KW_PRIVILEGES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRIVILEGES, 0); } + public KW_PROCEDURAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURAL, 0); } + public KW_PROCEDURE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURE, 0); } + public KW_PROCEDURES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROCEDURES, 0); } + public KW_PROGRAM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PROGRAM, 0); } + public KW_PUBLICATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PUBLICATION, 0); } + public KW_QUOTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_QUOTE, 0); } + public KW_RANGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RANGE, 0); } + public KW_READ(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_READ, 0); } + public KW_REASSIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REASSIGN, 0); } + public KW_RECHECK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RECHECK, 0); } + public KW_RECURSIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RECURSIVE, 0); } + public KW_REF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REF, 0); } + public KW_REFERENCING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REFERENCING, 0); } + public KW_REFRESH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REFRESH, 0); } + public KW_REINDEX(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REINDEX, 0); } + public KW_RELATIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RELATIVE, 0); } + public KW_RELEASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RELEASE, 0); } + public KW_RENAME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RENAME, 0); } + public KW_REPEATABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REPEATABLE, 0); } + public KW_REPLACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REPLACE, 0); } + public KW_REPLICA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REPLICA, 0); } + public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESET, 0); } + public KW_RESTART(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESTART, 0); } + public KW_RESTRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESTRICT, 0); } + public KW_RETURNS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RETURNS, 0); } + public KW_REVOKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REVOKE, 0); } + public KW_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLE, 0); } + public KW_ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLLBACK, 0); } + public KW_ROLLUP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLLUP, 0); } + public KW_ROUTINE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINE, 0); } + public KW_ROUTINES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROUTINES, 0); } + public KW_ROWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROWS, 0); } + public KW_RULE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RULE, 0); } + public KW_SAVEPOINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SAVEPOINT, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } + public KW_SCHEMAS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMAS, 0); } + public KW_SCROLL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCROLL, 0); } + public KW_SEARCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEARCH, 0); } + public KW_SECOND(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SECOND, 0); } + public KW_SECURITY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SECURITY, 0); } + public KW_SEQUENCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCE, 0); } + public KW_SEQUENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SEQUENCES, 0); } + public KW_SERIALIZABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SERIALIZABLE, 0); } + public KW_SERVER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SERVER, 0); } + public KW_SESSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SESSION, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_SETS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SETS, 0); } + public KW_SHARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SHARE, 0); } + public KW_SHOW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SHOW, 0); } + public KW_SIMPLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SIMPLE, 0); } + public KW_SKIP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SKIP, 0); } + public KW_SNAPSHOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SNAPSHOT, 0); } + public KW_SQL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SQL, 0); } + public KW_STABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STABLE, 0); } + public KW_STANDALONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STANDALONE, 0); } + public KW_START(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_START, 0); } + public KW_STATEMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATEMENT, 0); } + public KW_STATISTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STATISTICS, 0); } + public KW_STDIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STDIN, 0); } + public KW_STDOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STDOUT, 0); } + public KW_STORAGE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STORAGE, 0); } + public KW_STORED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STORED, 0); } + public KW_STRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STRICT, 0); } + public KW_STRIP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STRIP, 0); } + public KW_SUBSCRIPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SUBSCRIPTION, 0); } + public KW_SUPPORT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SUPPORT, 0); } + public KW_SYSID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SYSID, 0); } + public KW_SYSTEM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SYSTEM, 0); } + public KW_TABLES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLES, 0); } + public KW_TABLESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLESPACE, 0); } + public KW_TEMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMP, 0); } + public KW_TEMPLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPLATE, 0); } + public KW_TEMPORARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEMPORARY, 0); } + public KW_TEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TEXT, 0); } + public KW_TIES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIES, 0); } + public KW_TRANSACTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSACTION, 0); } + public KW_TRANSFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRANSFORM, 0); } + public KW_TRIGGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIGGER, 0); } + public KW_TRUNCATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRUNCATE, 0); } + public KW_TRUSTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRUSTED, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } + public KW_TYPES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPES, 0); } + public KW_UESCAPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UESCAPE, 0); } + public KW_UNBOUNDED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNBOUNDED, 0); } + public KW_UNCOMMITTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNCOMMITTED, 0); } + public KW_UNENCRYPTED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNENCRYPTED, 0); } + public KW_UNKNOWN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNKNOWN, 0); } + public KW_UNLISTEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNLISTEN, 0); } + public KW_UNLOGGED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNLOGGED, 0); } + public KW_UNTIL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNTIL, 0); } + public KW_UPDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UPDATE, 0); } + public KW_VACUUM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VACUUM, 0); } + public KW_VALID(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALID, 0); } + public KW_VALIDATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALIDATE, 0); } + public KW_VALIDATOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALIDATOR, 0); } + public KW_VALUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALUE, 0); } + public KW_VARYING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VARYING, 0); } + public KW_VERSION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VERSION, 0); } + public KW_VIEW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VIEW, 0); } + public KW_VIEWS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VIEWS, 0); } + public KW_VOLATILE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VOLATILE, 0); } + public KW_WHITESPACE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WHITESPACE, 0); } + public KW_WITHIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITHIN, 0); } + public KW_WITHOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITHOUT, 0); } + public KW_WORK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WORK, 0); } + public KW_WRAPPER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WRAPPER, 0); } + public KW_WRITE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WRITE, 0); } + public KW_XML(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XML, 0); } + public KW_YEAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_YEAR, 0); } + public KW_YES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_YES, 0); } + public KW_ZONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ZONE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -101037,63 +101886,63 @@ export class Unreserved_keywordContext extends ParserRuleContext { export class Col_name_keywordContext extends ParserRuleContext { - public BETWEEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BETWEEN, 0); } - public BIGINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BIGINT, 0); } + public KW_BETWEEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BETWEEN, 0); } + public KW_BIGINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BIGINT, 0); } public bit(): BitContext | undefined { return this.tryGetRuleContext(0, BitContext); } - public BOOLEAN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BOOLEAN_P, 0); } - public CHAR_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHAR_P, 0); } + public KW_BOOLEAN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BOOLEAN, 0); } + public KW_CHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHAR, 0); } public character(): CharacterContext | undefined { return this.tryGetRuleContext(0, CharacterContext); } - public COALESCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COALESCE, 0); } - public DEC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEC, 0); } - public DECIMAL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DECIMAL_P, 0); } - public EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXISTS, 0); } - public EXTRACT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXTRACT, 0); } - public FLOAT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FLOAT_P, 0); } - public GREATEST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GREATEST, 0); } - public GROUPING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUPING, 0); } - public INOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INOUT, 0); } - public INT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INT_P, 0); } - public INTEGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INTEGER, 0); } - public INTERVAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INTERVAL, 0); } - public LEAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEAST, 0); } - public NATIONAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NATIONAL, 0); } - public NCHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NCHAR, 0); } - public NONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NONE, 0); } - public NORMALIZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NORMALIZE, 0); } - public NULLIF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULLIF, 0); } + public KW_COALESCE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COALESCE, 0); } + public KW_DEC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEC, 0); } + public KW_DECIMAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DECIMAL, 0); } + public KW_EXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXISTS, 0); } + public KW_EXTRACT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXTRACT, 0); } + public KW_FLOAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FLOAT, 0); } + public KW_GREATEST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GREATEST, 0); } + public KW_GROUPING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUPING, 0); } + public KW_INOUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INOUT, 0); } + public KW_INT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INT, 0); } + public KW_INTEGER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INTEGER, 0); } + public KW_INTERVAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INTERVAL, 0); } + public KW_LEAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEAST, 0); } + public KW_NATIONAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NATIONAL, 0); } + public KW_NCHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NCHAR, 0); } + public KW_NONE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NONE, 0); } + public KW_NORMALIZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NORMALIZE, 0); } + public KW_NULLIF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULLIF, 0); } public numeric(): NumericContext | undefined { return this.tryGetRuleContext(0, NumericContext); } - public OUT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OUT_P, 0); } - public OVERLAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OVERLAY, 0); } - public POSITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.POSITION, 0); } - public PRECISION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRECISION, 0); } - public REAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REAL, 0); } - public ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROW, 0); } - public SETOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SETOF, 0); } - public SMALLINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SMALLINT, 0); } - public SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SUBSTRING, 0); } - public TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIME, 0); } - public TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TIMESTAMP, 0); } - public TREAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TREAT, 0); } - public TRIM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRIM, 0); } - public VALUES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VALUES, 0); } - public VARCHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VARCHAR, 0); } - public XMLATTRIBUTES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLATTRIBUTES, 0); } - public XMLCONCAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLCONCAT, 0); } - public XMLELEMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLELEMENT, 0); } - public XMLEXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLEXISTS, 0); } - public XMLFOREST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLFOREST, 0); } - public XMLNAMESPACES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLNAMESPACES, 0); } - public XMLPARSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLPARSE, 0); } - public XMLPI(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLPI, 0); } - public XMLROOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLROOT, 0); } - public XMLSERIALIZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLSERIALIZE, 0); } - public XMLTABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.XMLTABLE, 0); } + public KW_OUT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OUT, 0); } + public KW_OVERLAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OVERLAY, 0); } + public KW_POSITION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_POSITION, 0); } + public KW_PRECISION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRECISION, 0); } + public KW_REAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REAL, 0); } + public KW_ROW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROW, 0); } + public KW_SETOF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SETOF, 0); } + public KW_SMALLINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SMALLINT, 0); } + public KW_SUBSTRING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SUBSTRING, 0); } + public KW_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIME, 0); } + public KW_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TIMESTAMP, 0); } + public KW_TREAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TREAT, 0); } + public KW_TRIM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRIM, 0); } + public KW_VALUES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VALUES, 0); } + public KW_VARCHAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VARCHAR, 0); } + public KW_XMLATTRIBUTES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLATTRIBUTES, 0); } + public KW_XMLCONCAT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLCONCAT, 0); } + public KW_XMLELEMENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLELEMENT, 0); } + public KW_XMLEXISTS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLEXISTS, 0); } + public KW_XMLFOREST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLFOREST, 0); } + public KW_XMLNAMESPACES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLNAMESPACES, 0); } + public KW_XMLPARSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLPARSE, 0); } + public KW_XMLPI(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLPI, 0); } + public KW_XMLROOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLROOT, 0); } + public KW_XMLSERIALIZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLSERIALIZE, 0); } + public KW_XMLTABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_XMLTABLE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -101123,29 +101972,29 @@ export class Col_name_keywordContext extends ParserRuleContext { export class Type_func_name_keywordContext extends ParserRuleContext { - public AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AUTHORIZATION, 0); } - public BINARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BINARY, 0); } - public COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATION, 0); } - public CONCURRENTLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONCURRENTLY, 0); } - public CROSS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CROSS, 0); } - public CURRENT_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_SCHEMA, 0); } - public FREEZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FREEZE, 0); } - public FULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FULL, 0); } - public ILIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ILIKE, 0); } - public INNER_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INNER_P, 0); } - public IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IS, 0); } - public ISNULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ISNULL, 0); } - public JOIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.JOIN, 0); } - public LEFT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEFT, 0); } - public LIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LIKE, 0); } - public NATURAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NATURAL, 0); } - public NOTNULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOTNULL, 0); } - public OUTER_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OUTER_P, 0); } - public OVERLAPS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OVERLAPS, 0); } - public RIGHT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RIGHT, 0); } - public SIMILAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SIMILAR, 0); } - public TABLESAMPLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLESAMPLE, 0); } - public VERBOSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VERBOSE, 0); } + public KW_AUTHORIZATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AUTHORIZATION, 0); } + public KW_BINARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BINARY, 0); } + public KW_COLLATION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATION, 0); } + public KW_CONCURRENTLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONCURRENTLY, 0); } + public KW_CROSS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CROSS, 0); } + public KW_CURRENT_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_SCHEMA, 0); } + public KW_FREEZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FREEZE, 0); } + public KW_FULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FULL, 0); } + public KW_ILIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ILIKE, 0); } + public KW_INNER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INNER, 0); } + public KW_IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IS, 0); } + public KW_ISNULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ISNULL, 0); } + public KW_JOIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_JOIN, 0); } + public KW_LEFT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEFT, 0); } + public KW_LIKE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LIKE, 0); } + public KW_NATURAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NATURAL, 0); } + public KW_NOTNULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOTNULL, 0); } + public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OUTER, 0); } + public KW_OVERLAPS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OVERLAPS, 0); } + public KW_RIGHT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RIGHT, 0); } + public KW_SIMILAR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SIMILAR, 0); } + public KW_TABLESAMPLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLESAMPLE, 0); } + public KW_VERBOSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VERBOSE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -101175,81 +102024,81 @@ export class Type_func_name_keywordContext extends ParserRuleContext { export class Reserved_keywordContext extends ParserRuleContext { - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public ANALYSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ANALYSE, 0); } - public ANALYZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ANALYZE, 0); } - public AND(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AND, 0); } - public ANY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ANY, 0); } - public ARRAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ARRAY, 0); } - public AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AS, 0); } - public ASC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ASC, 0); } - public ASYMMETRIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ASYMMETRIC, 0); } - public BOTH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BOTH, 0); } - public CASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CASE, 0); } - public CAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CAST, 0); } - public CHECK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHECK, 0); } - public COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATE, 0); } - public COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLUMN, 0); } - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } - public CREATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CREATE, 0); } - public CURRENT_CATALOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_CATALOG, 0); } - public CURRENT_DATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_DATE, 0); } - public CURRENT_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_ROLE, 0); } - public CURRENT_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_TIME, 0); } - public CURRENT_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_TIMESTAMP, 0); } - public CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_USER, 0); } - public DEFERRABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFERRABLE, 0); } - public DESC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DESC, 0); } - public DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DISTINCT, 0); } - public DO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DO, 0); } - public ELSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ELSE, 0); } - public END_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.END_P, 0); } - public EXCEPT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCEPT, 0); } - public FALSE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FALSE_P, 0); } - public FETCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FETCH, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } - public FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOREIGN, 0); } - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public GRANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GRANT, 0); } - public GROUP_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GROUP_P, 0); } - public HAVING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.HAVING, 0); } - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } - public INITIALLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INITIALLY, 0); } - public INTERSECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INTERSECT, 0); } - public LATERAL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LATERAL_P, 0); } - public LEADING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LEADING, 0); } - public LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LIMIT, 0); } - public LOCALTIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCALTIME, 0); } - public LOCALTIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOCALTIMESTAMP, 0); } - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } - public OFFSET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OFFSET, 0); } - public ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ON, 0); } - public ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ONLY, 0); } - public OR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OR, 0); } - public ORDER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ORDER, 0); } - public PLACING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PLACING, 0); } - public PRIMARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRIMARY, 0); } - public REFERENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REFERENCES, 0); } - public RETURNING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RETURNING, 0); } - public SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SELECT, 0); } - public SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SESSION_USER, 0); } - public SOME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SOME, 0); } - public SYMMETRIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SYMMETRIC, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } - public THEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.THEN, 0); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } - public TRAILING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRAILING, 0); } - public TRUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TRUE_P, 0); } - public UNION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNION, 0); } - public UNIQUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.UNIQUE, 0); } - public USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USER, 0); } - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } - public VARIADIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VARIADIC, 0); } - public WHEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WHEN, 0); } - public WHERE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WHERE, 0); } - public WINDOW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WINDOW, 0); } - public WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WITH, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_ANALYSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ANALYSE, 0); } + public KW_ANALYZE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ANALYZE, 0); } + public KW_AND(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AND, 0); } + public KW_ANY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ANY, 0); } + public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ARRAY, 0); } + public KW_AS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AS, 0); } + public KW_ASC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ASC, 0); } + public KW_ASYMMETRIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ASYMMETRIC, 0); } + public KW_BOTH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BOTH, 0); } + public KW_CASE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CASE, 0); } + public KW_CAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CAST, 0); } + public KW_CHECK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHECK, 0); } + public KW_COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATE, 0); } + public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLUMN, 0); } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } + public KW_CREATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CREATE, 0); } + public KW_CURRENT_CATALOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_CATALOG, 0); } + public KW_CURRENT_DATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_DATE, 0); } + public KW_CURRENT_ROLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_ROLE, 0); } + public KW_CURRENT_TIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_TIME, 0); } + public KW_CURRENT_TIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_TIMESTAMP, 0); } + public KW_CURRENT_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT_USER, 0); } + public KW_DEFERRABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFERRABLE, 0); } + public KW_DESC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DESC, 0); } + public KW_DISTINCT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DISTINCT, 0); } + public KW_DO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DO, 0); } + public KW_ELSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ELSE, 0); } + public KW_END(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_END, 0); } + public KW_EXCEPT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCEPT, 0); } + public KW_FALSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FALSE, 0); } + public KW_FETCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FETCH, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } + public KW_FOREIGN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOREIGN, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_GRANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GRANT, 0); } + public KW_GROUP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GROUP, 0); } + public KW_HAVING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_HAVING, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } + public KW_INITIALLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INITIALLY, 0); } + public KW_INTERSECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INTERSECT, 0); } + public KW_LATERAL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LATERAL, 0); } + public KW_LEADING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LEADING, 0); } + public KW_LIMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LIMIT, 0); } + public KW_LOCALTIME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCALTIME, 0); } + public KW_LOCALTIMESTAMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOCALTIMESTAMP, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } + public KW_OFFSET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OFFSET, 0); } + public KW_ON(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ON, 0); } + public KW_ONLY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ONLY, 0); } + public KW_OR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OR, 0); } + public KW_ORDER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ORDER, 0); } + public KW_PLACING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PLACING, 0); } + public KW_PRIMARY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRIMARY, 0); } + public KW_REFERENCES(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REFERENCES, 0); } + public KW_RETURNING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RETURNING, 0); } + public KW_SELECT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SELECT, 0); } + public KW_SESSION_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SESSION_USER, 0); } + public KW_SOME(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SOME, 0); } + public KW_SYMMETRIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SYMMETRIC, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } + public KW_THEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_THEN, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } + public KW_TRAILING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRAILING, 0); } + public KW_TRUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TRUE, 0); } + public KW_UNION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNION, 0); } + public KW_UNIQUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_UNIQUE, 0); } + public KW_USER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USER, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } + public KW_VARIADIC(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VARIADIC, 0); } + public KW_WHEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WHEN, 0); } + public KW_WHERE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WHERE, 0); } + public KW_WINDOW(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WINDOW, 0); } + public KW_WITH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WITH, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -101358,16 +102207,16 @@ export class Comp_optionContext extends ParserRuleContext { public sharp(): SharpContext { return this.getRuleContext(0, SharpContext); } - public OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPTION, 0); } - public DUMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DUMP, 0); } - public PRINT_STRICT_PARAMS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRINT_STRICT_PARAMS, 0); } + public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPTION, 0); } + public KW_DUMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DUMP, 0); } + public KW_PRINT_STRICT_PARAMS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRINT_STRICT_PARAMS, 0); } public option_value(): Option_valueContext | undefined { return this.tryGetRuleContext(0, Option_valueContext); } - public VARIABLE_CONFLICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VARIABLE_CONFLICT, 0); } - public ERROR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ERROR, 0); } - public USE_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USE_VARIABLE, 0); } - public USE_COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USE_COLUMN, 0); } + public KW_VARIABLE_CONFLICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VARIABLE_CONFLICT, 0); } + public KW_ERROR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ERROR, 0); } + public KW_USE_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USE_VARIABLE, 0); } + public KW_USE_COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USE_COLUMN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -101501,14 +102350,14 @@ export class Pl_blockContext extends ParserRuleContext { public decl_sect(): Decl_sectContext { return this.getRuleContext(0, Decl_sectContext); } - public BEGIN_P(): TerminalNode { return this.getToken(PostgreSQLParser.BEGIN_P, 0); } + public KW_BEGIN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_BEGIN, 0); } public proc_sect(): Proc_sectContext { return this.getRuleContext(0, Proc_sectContext); } public exception_sect(): Exception_sectContext { return this.getRuleContext(0, Exception_sectContext); } - public END_P(): TerminalNode { return this.getToken(PostgreSQLParser.END_P, 0); } + public KW_END(): TerminalNode { return this.getToken(PostgreSQLParser.KW_END, 0); } public opt_label(): Opt_labelContext { return this.getRuleContext(0, Opt_labelContext); } @@ -101579,7 +102428,7 @@ export class Decl_sectContext extends ParserRuleContext { export class Decl_startContext extends ParserRuleContext { - public DECLARE(): TerminalNode { return this.getToken(PostgreSQLParser.DECLARE, 0); } + public KW_DECLARE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DECLARE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -101684,7 +102533,7 @@ export class Decl_stmtContext extends ParserRuleContext { public decl_statement(): Decl_statementContext | undefined { return this.tryGetRuleContext(0, Decl_statementContext); } - public DECLARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DECLARE, 0); } + public KW_DECLARE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DECLARE, 0); } public label_decl(): Label_declContext | undefined { return this.tryGetRuleContext(0, Label_declContext); } @@ -101721,8 +102570,8 @@ export class Decl_statementContext extends ParserRuleContext { return this.getRuleContext(0, Decl_varnameContext); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } - public ALIAS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALIAS, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } + public KW_ALIAS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALIAS, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } public decl_aliasitem(): Decl_aliasitemContext | undefined { return this.tryGetRuleContext(0, Decl_aliasitemContext); } @@ -101744,7 +102593,7 @@ export class Decl_statementContext extends ParserRuleContext { public opt_scrollable(): Opt_scrollableContext | undefined { return this.tryGetRuleContext(0, Opt_scrollableContext); } - public CURSOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURSOR, 0); } + public KW_CURSOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURSOR, 0); } public decl_cursor_args(): Decl_cursor_argsContext | undefined { return this.tryGetRuleContext(0, Decl_cursor_argsContext); } @@ -101783,8 +102632,8 @@ export class Decl_statementContext extends ParserRuleContext { export class Opt_scrollableContext extends ParserRuleContext { - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public SCROLL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCROLL, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_SCROLL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCROLL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -101962,8 +102811,8 @@ export class Decl_cursor_argContext extends ParserRuleContext { export class Decl_is_forContext extends ParserRuleContext { - public IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IS, 0); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } + public KW_IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IS, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -102058,7 +102907,7 @@ export class Decl_varnameContext extends ParserRuleContext { export class Decl_constContext extends ParserRuleContext { - public CONSTANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTANT, 0); } + public KW_CONSTANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTANT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -102120,7 +102969,7 @@ export class Decl_datatypeContext extends ParserRuleContext { export class Decl_collateContext extends ParserRuleContext { - public COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATE, 0); } + public KW_COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATE, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } @@ -102153,8 +103002,8 @@ export class Decl_collateContext extends ParserRuleContext { export class Decl_notnullContext extends ParserRuleContext { - public NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOT, 0); } - public NULL_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NULL_P, 0); } + public KW_NOT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOT, 0); } + public KW_NULL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NULL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -102222,7 +103071,7 @@ export class Decl_defkeyContext extends ParserRuleContext { public assign_operator(): Assign_operatorContext | undefined { return this.tryGetRuleContext(0, Assign_operatorContext); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -102426,7 +103275,7 @@ export class Proc_stmtContext extends ParserRuleContext { export class Stmt_performContext extends ParserRuleContext { - public PERFORM(): TerminalNode { return this.getToken(PostgreSQLParser.PERFORM, 0); } + public KW_PERFORM(): TerminalNode { return this.getToken(PostgreSQLParser.KW_PERFORM, 0); } public expr_until_semi(): Expr_until_semiContext { return this.getRuleContext(0, Expr_until_semiContext); } @@ -102460,7 +103309,7 @@ export class Stmt_performContext extends ParserRuleContext { export class Stmt_callContext extends ParserRuleContext { - public CALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CALL, 0); } + public KW_CALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CALL, 0); } public any_identifier(): Any_identifierContext { return this.getRuleContext(0, Any_identifierContext); } @@ -102470,7 +103319,7 @@ export class Stmt_callContext extends ParserRuleContext { } public CLOSE_PAREN(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE_PAREN, 0); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } - public DO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DO, 0); } + public KW_DO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -102571,11 +103420,11 @@ export class Stmt_assignContext extends ParserRuleContext { export class Stmt_getdiagContext extends ParserRuleContext { - public GET(): TerminalNode { return this.getToken(PostgreSQLParser.GET, 0); } + public KW_GET(): TerminalNode { return this.getToken(PostgreSQLParser.KW_GET, 0); } public getdiag_area_opt(): Getdiag_area_optContext { return this.getRuleContext(0, Getdiag_area_optContext); } - public DIAGNOSTICS(): TerminalNode { return this.getToken(PostgreSQLParser.DIAGNOSTICS, 0); } + public KW_DIAGNOSTICS(): TerminalNode { return this.getToken(PostgreSQLParser.KW_DIAGNOSTICS, 0); } public getdiag_list(): Getdiag_listContext { return this.getRuleContext(0, Getdiag_listContext); } @@ -102609,8 +103458,8 @@ export class Stmt_getdiagContext extends ParserRuleContext { export class Getdiag_area_optContext extends ParserRuleContext { - public CURRENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_P, 0); } - public STACKED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STACKED, 0); } + public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT, 0); } + public KW_STACKED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STACKED, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -102849,19 +103698,19 @@ export class Assign_varContext extends ParserRuleContext { export class Stmt_ifContext extends ParserRuleContext { - public IF_P(): TerminalNode[]; - public IF_P(i: number): TerminalNode; - public IF_P(i?: number): TerminalNode | TerminalNode[] { + public KW_IF(): TerminalNode[]; + public KW_IF(i: number): TerminalNode; + public KW_IF(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.IF_P); + return this.getTokens(PostgreSQLParser.KW_IF); } else { - return this.getToken(PostgreSQLParser.IF_P, i); + return this.getToken(PostgreSQLParser.KW_IF, i); } } public expr_until_then(): Expr_until_thenContext { return this.getRuleContext(0, Expr_until_thenContext); } - public THEN(): TerminalNode { return this.getToken(PostgreSQLParser.THEN, 0); } + public KW_THEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_THEN, 0); } public proc_sect(): Proc_sectContext { return this.getRuleContext(0, Proc_sectContext); } @@ -102871,7 +103720,7 @@ export class Stmt_ifContext extends ParserRuleContext { public stmt_else(): Stmt_elseContext { return this.getRuleContext(0, Stmt_elseContext); } - public END_P(): TerminalNode { return this.getToken(PostgreSQLParser.END_P, 0); } + public KW_END(): TerminalNode { return this.getToken(PostgreSQLParser.KW_END, 0); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); @@ -102902,13 +103751,13 @@ export class Stmt_ifContext extends ParserRuleContext { export class Stmt_elsifsContext extends ParserRuleContext { - public ELSIF(): TerminalNode[]; - public ELSIF(i: number): TerminalNode; - public ELSIF(i?: number): TerminalNode | TerminalNode[] { + public KW_ELSIF(): TerminalNode[]; + public KW_ELSIF(i: number): TerminalNode; + public KW_ELSIF(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.ELSIF); + return this.getTokens(PostgreSQLParser.KW_ELSIF); } else { - return this.getToken(PostgreSQLParser.ELSIF, i); + return this.getToken(PostgreSQLParser.KW_ELSIF, i); } } public a_expr(): A_exprContext[]; @@ -102920,13 +103769,13 @@ export class Stmt_elsifsContext extends ParserRuleContext { return this.getRuleContext(i, A_exprContext); } } - public THEN(): TerminalNode[]; - public THEN(i: number): TerminalNode; - public THEN(i?: number): TerminalNode | TerminalNode[] { + public KW_THEN(): TerminalNode[]; + public KW_THEN(i: number): TerminalNode; + public KW_THEN(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.THEN); + return this.getTokens(PostgreSQLParser.KW_THEN); } else { - return this.getToken(PostgreSQLParser.THEN, i); + return this.getToken(PostgreSQLParser.KW_THEN, i); } } public proc_sect(): Proc_sectContext[]; @@ -102967,7 +103816,7 @@ export class Stmt_elsifsContext extends ParserRuleContext { export class Stmt_elseContext extends ParserRuleContext { - public ELSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ELSE, 0); } + public KW_ELSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ELSE, 0); } public proc_sect(): Proc_sectContext | undefined { return this.tryGetRuleContext(0, Proc_sectContext); } @@ -103000,13 +103849,13 @@ export class Stmt_elseContext extends ParserRuleContext { export class Stmt_caseContext extends ParserRuleContext { - public CASE(): TerminalNode[]; - public CASE(i: number): TerminalNode; - public CASE(i?: number): TerminalNode | TerminalNode[] { + public KW_CASE(): TerminalNode[]; + public KW_CASE(i: number): TerminalNode; + public KW_CASE(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.CASE); + return this.getTokens(PostgreSQLParser.KW_CASE); } else { - return this.getToken(PostgreSQLParser.CASE, i); + return this.getToken(PostgreSQLParser.KW_CASE, i); } } public opt_expr_until_when(): Opt_expr_until_whenContext { @@ -103018,7 +103867,7 @@ export class Stmt_caseContext extends ParserRuleContext { public opt_case_else(): Opt_case_elseContext { return this.getRuleContext(0, Opt_case_elseContext); } - public END_P(): TerminalNode { return this.getToken(PostgreSQLParser.END_P, 0); } + public KW_END(): TerminalNode { return this.getToken(PostgreSQLParser.KW_END, 0); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); @@ -103119,11 +103968,11 @@ export class Case_when_listContext extends ParserRuleContext { export class Case_whenContext extends ParserRuleContext { - public WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.WHEN, 0); } + public KW_WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHEN, 0); } public expr_list(): Expr_listContext { return this.getRuleContext(0, Expr_listContext); } - public THEN(): TerminalNode { return this.getToken(PostgreSQLParser.THEN, 0); } + public KW_THEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_THEN, 0); } public proc_sect(): Proc_sectContext { return this.getRuleContext(0, Proc_sectContext); } @@ -103156,7 +104005,7 @@ export class Case_whenContext extends ParserRuleContext { export class Opt_case_elseContext extends ParserRuleContext { - public ELSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ELSE, 0); } + public KW_ELSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ELSE, 0); } public proc_sect(): Proc_sectContext | undefined { return this.tryGetRuleContext(0, Proc_sectContext); } @@ -103227,7 +104076,7 @@ export class Stmt_whileContext extends ParserRuleContext { public opt_loop_label(): Opt_loop_labelContext { return this.getRuleContext(0, Opt_loop_labelContext); } - public WHILE(): TerminalNode { return this.getToken(PostgreSQLParser.WHILE, 0); } + public KW_WHILE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHILE, 0); } public expr_until_loop(): Expr_until_loopContext { return this.getRuleContext(0, Expr_until_loopContext); } @@ -103266,7 +104115,7 @@ export class Stmt_forContext extends ParserRuleContext { public opt_loop_label(): Opt_loop_labelContext { return this.getRuleContext(0, Opt_loop_labelContext); } - public FOR(): TerminalNode { return this.getToken(PostgreSQLParser.FOR, 0); } + public KW_FOR(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOR, 0); } public for_control(): For_controlContext { return this.getRuleContext(0, For_controlContext); } @@ -103305,7 +104154,7 @@ export class For_controlContext extends ParserRuleContext { public for_variable(): For_variableContext { return this.getRuleContext(0, For_variableContext); } - public IN_P(): TerminalNode { return this.getToken(PostgreSQLParser.IN_P, 0); } + public KW_IN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IN, 0); } public cursor_name(): Cursor_nameContext | undefined { return this.tryGetRuleContext(0, Cursor_nameContext); } @@ -103318,7 +104167,7 @@ export class For_controlContext extends ParserRuleContext { public explainstmt(): ExplainstmtContext | undefined { return this.tryGetRuleContext(0, ExplainstmtContext); } - public EXECUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXECUTE, 0); } + public KW_EXECUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXECUTE, 0); } public a_expr(): A_exprContext[]; public a_expr(i: number): A_exprContext; public a_expr(i?: number): A_exprContext | A_exprContext[] { @@ -103367,7 +104216,7 @@ export class For_controlContext extends ParserRuleContext { export class Opt_for_using_expressionContext extends ParserRuleContext { - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } public expr_list(): Expr_listContext | undefined { return this.tryGetRuleContext(0, Expr_listContext); } @@ -103449,7 +104298,7 @@ export class Opt_cursor_parametersContext extends ParserRuleContext { export class Opt_reverseContext extends ParserRuleContext { - public REVERSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REVERSE, 0); } + public KW_REVERSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REVERSE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -103479,7 +104328,7 @@ export class Opt_reverseContext extends ParserRuleContext { export class Opt_by_expressionContext extends ParserRuleContext { - public BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BY, 0); } + public KW_BY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BY, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } @@ -103547,15 +104396,15 @@ export class Stmt_foreach_aContext extends ParserRuleContext { public opt_loop_label(): Opt_loop_labelContext { return this.getRuleContext(0, Opt_loop_labelContext); } - public FOREACH(): TerminalNode { return this.getToken(PostgreSQLParser.FOREACH, 0); } + public KW_FOREACH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FOREACH, 0); } public for_variable(): For_variableContext { return this.getRuleContext(0, For_variableContext); } public foreach_slice(): Foreach_sliceContext { return this.getRuleContext(0, Foreach_sliceContext); } - public IN_P(): TerminalNode { return this.getToken(PostgreSQLParser.IN_P, 0); } - public ARRAY(): TerminalNode { return this.getToken(PostgreSQLParser.ARRAY, 0); } + public KW_IN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_IN, 0); } + public KW_ARRAY(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ARRAY, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } @@ -103591,7 +104440,7 @@ export class Stmt_foreach_aContext extends ParserRuleContext { export class Foreach_sliceContext extends ParserRuleContext { - public SLICE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SLICE, 0); } + public KW_SLICE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SLICE, 0); } public iconst(): IconstContext | undefined { return this.tryGetRuleContext(0, IconstContext); } @@ -103663,8 +104512,8 @@ export class Stmt_exitContext extends ParserRuleContext { export class Exit_typeContext extends ParserRuleContext { - public EXIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXIT, 0); } - public CONTINUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONTINUE_P, 0); } + public KW_EXIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXIT, 0); } + public KW_CONTINUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONTINUE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -103694,17 +104543,17 @@ export class Exit_typeContext extends ParserRuleContext { export class Stmt_returnContext extends ParserRuleContext { - public RETURN(): TerminalNode { return this.getToken(PostgreSQLParser.RETURN, 0); } + public KW_RETURN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_RETURN, 0); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } - public NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NEXT, 0); } + public KW_NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NEXT, 0); } public sql_expression(): Sql_expressionContext | undefined { return this.tryGetRuleContext(0, Sql_expressionContext); } - public QUERY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.QUERY, 0); } + public KW_QUERY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_QUERY, 0); } public opt_return_result(): Opt_return_resultContext | undefined { return this.tryGetRuleContext(0, Opt_return_resultContext); } - public EXECUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXECUTE, 0); } + public KW_EXECUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXECUTE, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } @@ -103775,7 +104624,7 @@ export class Opt_return_resultContext extends ParserRuleContext { export class Stmt_raiseContext extends ParserRuleContext { - public RAISE(): TerminalNode { return this.getToken(PostgreSQLParser.RAISE, 0); } + public KW_RAISE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_RAISE, 0); } public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } @@ -103792,7 +104641,7 @@ export class Stmt_raiseContext extends ParserRuleContext { public identifier(): IdentifierContext | undefined { return this.tryGetRuleContext(0, IdentifierContext); } - public SQLSTATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SQLSTATE, 0); } + public KW_SQLSTATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SQLSTATE, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -103822,12 +104671,12 @@ export class Stmt_raiseContext extends ParserRuleContext { export class Opt_stmt_raise_levelContext extends ParserRuleContext { - public DEBUG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEBUG, 0); } - public LOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOG, 0); } - public INFO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INFO, 0); } - public NOTICE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOTICE, 0); } - public WARNING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WARNING, 0); } - public EXCEPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCEPTION, 0); } + public KW_DEBUG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEBUG, 0); } + public KW_LOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOG, 0); } + public KW_INFO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INFO, 0); } + public KW_NOTICE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOTICE, 0); } + public KW_WARNING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WARNING, 0); } + public KW_EXCEPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCEPTION, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -103904,7 +104753,7 @@ export class Opt_raise_listContext extends ParserRuleContext { export class Opt_raise_usingContext extends ParserRuleContext { - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } public opt_raise_using_elem_list(): Opt_raise_using_elem_listContext | undefined { return this.tryGetRuleContext(0, Opt_raise_using_elem_listContext); } @@ -104020,7 +104869,7 @@ export class Opt_raise_using_elem_listContext extends ParserRuleContext { export class Stmt_assertContext extends ParserRuleContext { - public ASSERT(): TerminalNode { return this.getToken(PostgreSQLParser.ASSERT, 0); } + public KW_ASSERT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ASSERT, 0); } public sql_expression(): Sql_expressionContext { return this.getRuleContext(0, Sql_expressionContext); } @@ -104090,19 +104939,19 @@ export class Opt_stmt_assert_messageContext extends ParserRuleContext { export class Loop_bodyContext extends ParserRuleContext { - public LOOP(): TerminalNode[]; - public LOOP(i: number): TerminalNode; - public LOOP(i?: number): TerminalNode | TerminalNode[] { + public KW_LOOP(): TerminalNode[]; + public KW_LOOP(i: number): TerminalNode; + public KW_LOOP(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.LOOP); + return this.getTokens(PostgreSQLParser.KW_LOOP); } else { - return this.getToken(PostgreSQLParser.LOOP, i); + return this.getToken(PostgreSQLParser.KW_LOOP, i); } } public proc_sect(): Proc_sectContext { return this.getRuleContext(0, Proc_sectContext); } - public END_P(): TerminalNode { return this.getToken(PostgreSQLParser.END_P, 0); } + public KW_END(): TerminalNode { return this.getToken(PostgreSQLParser.KW_END, 0); } public opt_label(): Opt_labelContext { return this.getRuleContext(0, Opt_labelContext); } @@ -104169,7 +105018,7 @@ export class Stmt_execsqlContext extends ParserRuleContext { export class Stmt_dynexecuteContext extends ParserRuleContext { - public EXECUTE(): TerminalNode { return this.getToken(PostgreSQLParser.EXECUTE, 0); } + public KW_EXECUTE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_EXECUTE, 0); } public a_expr(): A_exprContext { return this.getRuleContext(0, A_exprContext); } @@ -104209,7 +105058,7 @@ export class Stmt_dynexecuteContext extends ParserRuleContext { export class Opt_execute_usingContext extends ParserRuleContext { - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } public opt_execute_using_list(): Opt_execute_using_listContext | undefined { return this.tryGetRuleContext(0, Opt_execute_using_listContext); } @@ -104289,11 +105138,11 @@ export class Opt_execute_using_listContext extends ParserRuleContext { export class Opt_execute_intoContext extends ParserRuleContext { - public INTO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INTO, 0); } + public KW_INTO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INTO, 0); } public into_target(): Into_targetContext | undefined { return this.tryGetRuleContext(0, Into_targetContext); } - public STRICT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STRICT_P, 0); } + public KW_STRICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STRICT, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -104323,7 +105172,7 @@ export class Opt_execute_intoContext extends ParserRuleContext { export class Stmt_openContext extends ParserRuleContext { - public OPEN(): TerminalNode { return this.getToken(PostgreSQLParser.OPEN, 0); } + public KW_OPEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_OPEN, 0); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } public cursor_variable(): Cursor_variableContext | undefined { return this.tryGetRuleContext(0, Cursor_variableContext); @@ -104331,14 +105180,14 @@ export class Stmt_openContext extends ParserRuleContext { public opt_scroll_option(): Opt_scroll_optionContext | undefined { return this.tryGetRuleContext(0, Opt_scroll_optionContext); } - public FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FOR, 0); } + public KW_FOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FOR, 0); } public colid(): ColidContext | undefined { return this.tryGetRuleContext(0, ColidContext); } public selectstmt(): SelectstmtContext | undefined { return this.tryGetRuleContext(0, SelectstmtContext); } - public EXECUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXECUTE, 0); } + public KW_EXECUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXECUTE, 0); } public sql_expression(): Sql_expressionContext | undefined { return this.tryGetRuleContext(0, Sql_expressionContext); } @@ -104462,7 +105311,7 @@ export class Opt_open_bound_listContext extends ParserRuleContext { export class Opt_open_usingContext extends ParserRuleContext { - public USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USING, 0); } + public KW_USING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USING, 0); } public expr_list(): Expr_listContext | undefined { return this.tryGetRuleContext(0, Expr_listContext); } @@ -104498,7 +105347,7 @@ export class Opt_scroll_optionContext extends ParserRuleContext { public opt_scroll_option_no(): Opt_scroll_option_noContext | undefined { return this.tryGetRuleContext(0, Opt_scroll_option_noContext); } - public SCROLL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCROLL, 0); } + public KW_SCROLL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCROLL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -104528,7 +105377,7 @@ export class Opt_scroll_optionContext extends ParserRuleContext { export class Opt_scroll_option_noContext extends ParserRuleContext { - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -104559,14 +105408,14 @@ export class Opt_scroll_option_noContext extends ParserRuleContext { export class Stmt_fetchContext extends ParserRuleContext { public _direction!: Opt_fetch_directionContext; - public FETCH(): TerminalNode { return this.getToken(PostgreSQLParser.FETCH, 0); } + public KW_FETCH(): TerminalNode { return this.getToken(PostgreSQLParser.KW_FETCH, 0); } public opt_cursor_from(): Opt_cursor_fromContext { return this.getRuleContext(0, Opt_cursor_fromContext); } public cursor_variable(): Cursor_variableContext { return this.getRuleContext(0, Cursor_variableContext); } - public INTO(): TerminalNode { return this.getToken(PostgreSQLParser.INTO, 0); } + public KW_INTO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INTO, 0); } public into_target(): Into_targetContext { return this.getRuleContext(0, Into_targetContext); } @@ -104635,8 +105484,8 @@ export class Into_targetContext extends ParserRuleContext { export class Opt_cursor_fromContext extends ParserRuleContext { - public FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FROM, 0); } - public IN_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IN_P, 0); } + public KW_FROM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FROM, 0); } + public KW_IN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IN, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -104666,18 +105515,18 @@ export class Opt_cursor_fromContext extends ParserRuleContext { export class Opt_fetch_directionContext extends ParserRuleContext { - public NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NEXT, 0); } - public PRIOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRIOR, 0); } - public FIRST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FIRST_P, 0); } - public LAST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LAST_P, 0); } - public ABSOLUTE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ABSOLUTE_P, 0); } + public KW_NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NEXT, 0); } + public KW_PRIOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRIOR, 0); } + public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FIRST, 0); } + public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LAST, 0); } + public KW_ABSOLUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ABSOLUTE, 0); } public a_expr(): A_exprContext | undefined { return this.tryGetRuleContext(0, A_exprContext); } - public RELATIVE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RELATIVE_P, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } - public FORWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FORWARD, 0); } - public BACKWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BACKWARD, 0); } + public KW_RELATIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RELATIVE, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } + public KW_FORWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FORWARD, 0); } + public KW_BACKWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BACKWARD, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -104707,7 +105556,7 @@ export class Opt_fetch_directionContext extends ParserRuleContext { export class Stmt_moveContext extends ParserRuleContext { - public MOVE(): TerminalNode { return this.getToken(PostgreSQLParser.MOVE, 0); } + public KW_MOVE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_MOVE, 0); } public cursor_variable(): Cursor_variableContext { return this.getRuleContext(0, Cursor_variableContext); } @@ -104744,7 +105593,7 @@ export class Stmt_moveContext extends ParserRuleContext { export class Stmt_closeContext extends ParserRuleContext { - public CLOSE(): TerminalNode { return this.getToken(PostgreSQLParser.CLOSE, 0); } + public KW_CLOSE(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CLOSE, 0); } public cursor_variable(): Cursor_variableContext { return this.getRuleContext(0, Cursor_variableContext); } @@ -104778,7 +105627,7 @@ export class Stmt_closeContext extends ParserRuleContext { export class Stmt_nullContext extends ParserRuleContext { - public NULL_P(): TerminalNode { return this.getToken(PostgreSQLParser.NULL_P, 0); } + public KW_NULL(): TerminalNode { return this.getToken(PostgreSQLParser.KW_NULL, 0); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); @@ -104809,7 +105658,7 @@ export class Stmt_nullContext extends ParserRuleContext { export class Stmt_commitContext extends ParserRuleContext { - public COMMIT(): TerminalNode { return this.getToken(PostgreSQLParser.COMMIT, 0); } + public KW_COMMIT(): TerminalNode { return this.getToken(PostgreSQLParser.KW_COMMIT, 0); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } public plsql_opt_transaction_chain(): Plsql_opt_transaction_chainContext | undefined { return this.tryGetRuleContext(0, Plsql_opt_transaction_chainContext); @@ -104843,7 +105692,7 @@ export class Stmt_commitContext extends ParserRuleContext { export class Stmt_rollbackContext extends ParserRuleContext { - public ROLLBACK(): TerminalNode { return this.getToken(PostgreSQLParser.ROLLBACK, 0); } + public KW_ROLLBACK(): TerminalNode { return this.getToken(PostgreSQLParser.KW_ROLLBACK, 0); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } public plsql_opt_transaction_chain(): Plsql_opt_transaction_chainContext | undefined { return this.tryGetRuleContext(0, Plsql_opt_transaction_chainContext); @@ -104877,9 +105726,9 @@ export class Stmt_rollbackContext extends ParserRuleContext { export class Plsql_opt_transaction_chainContext extends ParserRuleContext { - public AND(): TerminalNode { return this.getToken(PostgreSQLParser.AND, 0); } - public CHAIN(): TerminalNode { return this.getToken(PostgreSQLParser.CHAIN, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } + public KW_AND(): TerminalNode { return this.getToken(PostgreSQLParser.KW_AND, 0); } + public KW_CHAIN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_CHAIN, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -104909,15 +105758,15 @@ export class Plsql_opt_transaction_chainContext extends ParserRuleContext { export class Stmt_setContext extends ParserRuleContext { - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } public any_name(): Any_nameContext | undefined { return this.tryGetRuleContext(0, Any_nameContext); } - public TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TO, 0); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } + public KW_TO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TO, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } public SEMI(): TerminalNode { return this.getToken(PostgreSQLParser.SEMI, 0); } - public RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESET, 0); } - public ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALL, 0); } + public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESET, 0); } + public KW_ALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALL, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -104980,7 +105829,7 @@ export class Cursor_variableContext extends ParserRuleContext { export class Exception_sectContext extends ParserRuleContext { - public EXCEPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCEPTION, 0); } + public KW_EXCEPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCEPTION, 0); } public proc_exceptions(): Proc_exceptionsContext | undefined { return this.tryGetRuleContext(0, Proc_exceptionsContext); } @@ -105051,11 +105900,11 @@ export class Proc_exceptionsContext extends ParserRuleContext { export class Proc_exceptionContext extends ParserRuleContext { - public WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.WHEN, 0); } + public KW_WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHEN, 0); } public proc_conditions(): Proc_conditionsContext { return this.getRuleContext(0, Proc_conditionsContext); } - public THEN(): TerminalNode { return this.getToken(PostgreSQLParser.THEN, 0); } + public KW_THEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_THEN, 0); } public proc_sect(): Proc_sectContext { return this.getRuleContext(0, Proc_sectContext); } @@ -105097,13 +105946,13 @@ export class Proc_conditionsContext extends ParserRuleContext { return this.getRuleContext(i, Proc_conditionContext); } } - public OR(): TerminalNode[]; - public OR(i: number): TerminalNode; - public OR(i?: number): TerminalNode | TerminalNode[] { + public KW_OR(): TerminalNode[]; + public KW_OR(i: number): TerminalNode; + public KW_OR(i?: number): TerminalNode | TerminalNode[] { if (i === undefined) { - return this.getTokens(PostgreSQLParser.OR); + return this.getTokens(PostgreSQLParser.KW_OR); } else { - return this.getToken(PostgreSQLParser.OR, i); + return this.getToken(PostgreSQLParser.KW_OR, i); } } constructor(parent: ParserRuleContext | undefined, invokingState: number) { @@ -105138,7 +105987,7 @@ export class Proc_conditionContext extends ParserRuleContext { public any_identifier(): Any_identifierContext | undefined { return this.tryGetRuleContext(0, Any_identifierContext); } - public SQLSTATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SQLSTATE, 0); } + public KW_SQLSTATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SQLSTATE, 0); } public sconst(): SconstContext | undefined { return this.tryGetRuleContext(0, SconstContext); } @@ -105267,7 +106116,7 @@ export class Opt_labelContext extends ParserRuleContext { export class Opt_exitcondContext extends ParserRuleContext { - public WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.WHEN, 0); } + public KW_WHEN(): TerminalNode { return this.getToken(PostgreSQLParser.KW_WHEN, 0); } public expr_until_semi(): Expr_until_semiContext { return this.getRuleContext(0, Expr_until_semiContext); } @@ -105335,71 +106184,71 @@ export class Any_identifierContext extends ParserRuleContext { export class Plsql_unreserved_keywordContext extends ParserRuleContext { - public ABSOLUTE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ABSOLUTE_P, 0); } - public ALIAS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ALIAS, 0); } - public AND(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.AND, 0); } - public ARRAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ARRAY, 0); } - public ASSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ASSERT, 0); } - public BACKWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.BACKWARD, 0); } - public CALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CALL, 0); } - public CHAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CHAIN, 0); } - public CLOSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CLOSE, 0); } - public COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLLATE, 0); } - public COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COLUMN, 0); } - public COMMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.COMMIT, 0); } - public CONSTANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTANT, 0); } - public CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONSTRAINT, 0); } - public CONTINUE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CONTINUE_P, 0); } - public CURRENT_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURRENT_P, 0); } - public CURSOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.CURSOR, 0); } - public DEBUG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEBUG, 0); } - public DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DEFAULT, 0); } - public DIAGNOSTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DIAGNOSTICS, 0); } - public DO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DO, 0); } - public DUMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.DUMP, 0); } - public ELSIF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ELSIF, 0); } - public ERROR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ERROR, 0); } - public EXCEPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXCEPTION, 0); } - public EXIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.EXIT, 0); } - public FETCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FETCH, 0); } - public FIRST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FIRST_P, 0); } - public FORWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.FORWARD, 0); } - public GET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.GET, 0); } - public INFO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INFO, 0); } - public INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.INSERT, 0); } - public IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.IS, 0); } - public LAST_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LAST_P, 0); } - public LOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.LOG, 0); } - public MOVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.MOVE, 0); } - public NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NEXT, 0); } - public NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NO, 0); } - public NOTICE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.NOTICE, 0); } - public OPEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPEN, 0); } - public OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OPTION, 0); } - public PERFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PERFORM, 0); } - public PRINT_STRICT_PARAMS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRINT_STRICT_PARAMS, 0); } - public PRIOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.PRIOR, 0); } - public QUERY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.QUERY, 0); } - public RAISE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RAISE, 0); } - public RELATIVE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RELATIVE_P, 0); } - public RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RESET, 0); } - public RETURN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.RETURN, 0); } - public REVERSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.REVERSE, 0); } - public ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROLLBACK, 0); } - public ROWTYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.ROWTYPE, 0); } - public SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCHEMA, 0); } - public SCROLL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SCROLL, 0); } - public SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SET, 0); } - public SLICE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SLICE, 0); } - public SQLSTATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.SQLSTATE, 0); } - public STACKED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.STACKED, 0); } - public TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TABLE, 0); } - public TYPE_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.TYPE_P, 0); } - public USE_COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USE_COLUMN, 0); } - public USE_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.USE_VARIABLE, 0); } - public VARIABLE_CONFLICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.VARIABLE_CONFLICT, 0); } - public WARNING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.WARNING, 0); } - public OUTER_P(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.OUTER_P, 0); } + public KW_ABSOLUTE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ABSOLUTE, 0); } + public KW_ALIAS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ALIAS, 0); } + public KW_AND(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_AND, 0); } + public KW_ARRAY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ARRAY, 0); } + public KW_ASSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ASSERT, 0); } + public KW_BACKWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_BACKWARD, 0); } + public KW_CALL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CALL, 0); } + public KW_CHAIN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CHAIN, 0); } + public KW_CLOSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CLOSE, 0); } + public KW_COLLATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLLATE, 0); } + public KW_COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COLUMN, 0); } + public KW_COMMIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_COMMIT, 0); } + public KW_CONSTANT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTANT, 0); } + public KW_CONSTRAINT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONSTRAINT, 0); } + public KW_CONTINUE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CONTINUE, 0); } + public KW_CURRENT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURRENT, 0); } + public KW_CURSOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_CURSOR, 0); } + public KW_DEBUG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEBUG, 0); } + public KW_DEFAULT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DEFAULT, 0); } + public KW_DIAGNOSTICS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DIAGNOSTICS, 0); } + public KW_DO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DO, 0); } + public KW_DUMP(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_DUMP, 0); } + public KW_ELSIF(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ELSIF, 0); } + public KW_ERROR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ERROR, 0); } + public KW_EXCEPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXCEPTION, 0); } + public KW_EXIT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_EXIT, 0); } + public KW_FETCH(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FETCH, 0); } + public KW_FIRST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FIRST, 0); } + public KW_FORWARD(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_FORWARD, 0); } + public KW_GET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_GET, 0); } + public KW_INFO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INFO, 0); } + public KW_INSERT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_INSERT, 0); } + public KW_IS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_IS, 0); } + public KW_LAST(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LAST, 0); } + public KW_LOG(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_LOG, 0); } + public KW_MOVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_MOVE, 0); } + public KW_NEXT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NEXT, 0); } + public KW_NO(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NO, 0); } + public KW_NOTICE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_NOTICE, 0); } + public KW_OPEN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPEN, 0); } + public KW_OPTION(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OPTION, 0); } + public KW_PERFORM(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PERFORM, 0); } + public KW_PRINT_STRICT_PARAMS(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRINT_STRICT_PARAMS, 0); } + public KW_PRIOR(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_PRIOR, 0); } + public KW_QUERY(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_QUERY, 0); } + public KW_RAISE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RAISE, 0); } + public KW_RELATIVE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RELATIVE, 0); } + public KW_RESET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RESET, 0); } + public KW_RETURN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_RETURN, 0); } + public KW_REVERSE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_REVERSE, 0); } + public KW_ROLLBACK(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROLLBACK, 0); } + public KW_ROWTYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_ROWTYPE, 0); } + public KW_SCHEMA(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCHEMA, 0); } + public KW_SCROLL(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SCROLL, 0); } + public KW_SET(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SET, 0); } + public KW_SLICE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SLICE, 0); } + public KW_SQLSTATE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_SQLSTATE, 0); } + public KW_STACKED(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_STACKED, 0); } + public KW_TABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TABLE, 0); } + public KW_TYPE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_TYPE, 0); } + public KW_USE_COLUMN(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USE_COLUMN, 0); } + public KW_USE_VARIABLE(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_USE_VARIABLE, 0); } + public KW_VARIABLE_CONFLICT(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_VARIABLE_CONFLICT, 0); } + public KW_WARNING(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_WARNING, 0); } + public KW_OUTER(): TerminalNode | undefined { return this.tryGetToken(PostgreSQLParser.KW_OUTER, 0); } constructor(parent: ParserRuleContext | undefined, invokingState: number) { super(parent, invokingState); } @@ -105642,7 +106491,7 @@ export class Make_execsql_stmtContext extends ParserRuleContext { export class Opt_returning_clause_intoContext extends ParserRuleContext { - public INTO(): TerminalNode { return this.getToken(PostgreSQLParser.INTO, 0); } + public KW_INTO(): TerminalNode { return this.getToken(PostgreSQLParser.KW_INTO, 0); } public opt_strict(): Opt_strictContext { return this.getRuleContext(0, Opt_strictContext); } diff --git a/src/lib/pgsql/PostgreSQLParserBase.ts b/src/lib/pgsql/PostgreSQLParserBase.ts deleted file mode 100644 index a89441d..0000000 --- a/src/lib/pgsql/PostgreSQLParserBase.ts +++ /dev/null @@ -1,97 +0,0 @@ -import { CharStreams, CommonTokenStream, Parser } from 'antlr4ts'; -import { PostgreSQLLexer } from './PostgreSQLLexer'; -import { PostgreSQLParser } from './PostgreSQLParser'; - -export default abstract class PostgreSQLParserBase extends Parser { - constructor( input) { - super(input); - } - - GetParsedSqlTree( script, line) { - const ph = this.getPostgreSQLParser(script); - return ph.program(); - } - - ParseRoutineBody( _localctx) { - let lang = null; - for (let _i = 0, _a = _localctx.createfunc_opt_item(); _i < _a.length; _i++) { - const coi = _a[_i]; - if (!!coi.LANGUAGE()) { - if (!!coi.nonreservedword_or_sconst()) { - if (!!coi.nonreservedword_or_sconst().nonreservedword()) { - if (!!coi.nonreservedword_or_sconst().nonreservedword().identifier()) { - if (!!coi.nonreservedword_or_sconst().nonreservedword().identifier().Identifier()) { - lang = coi.nonreservedword_or_sconst().nonreservedword().identifier().Identifier().getText(); - break; - } - } - } - } - } - } - if (!lang) return; - let func_as = null; - for (const a of _localctx.createfunc_opt_item()) { - if (!a.func_as()) { - func_as = a; - break; - } - } - 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.program(); - break; - } - } - } - - TrimQuotes( s) { - return (!s) ? s : s.substring(1, s.length() - 1); - } - - unquote( s) { - const slength = s.length(); - let r = ''; - let i = 0; - while (i < slength) { - const c = s.charAt(i); - r = r.concat(c); - if (c === '\'' && i < slength - 1 && (s.charAt(i + 1) === '\'')) i++; - i++; - } - return r.toString(); - } - - GetRoutineBodyString( rule) { - const anysconst = rule.anysconst(); - 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; - } - - 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(); - return parser; - } -} \ No newline at end of file diff --git a/src/lib/pgsql/PostgreSQLParserListener.ts b/src/lib/pgsql/PostgreSQLParserListener.ts index 47fab31..ff71dff 100644 --- a/src/lib/pgsql/PostgreSQLParserListener.ts +++ b/src/lib/pgsql/PostgreSQLParserListener.ts @@ -1,7 +1,4 @@ -// Generated from /Users/ziv/github.com/dt-sql-parser/src/grammar/pgsql/PostgreSQLParser.g4 by ANTLR 4.9.0-SNAPSHOT - - -import PostgreSQLParserBase from "./PostgreSQLParserBase"; +// Generated from /Users/xuxiaoqi/Documents/work/daishu-code/dt-sql-parser/src/grammar/pgsql/PostgreSQLParser.g4 by ANTLR 4.9.0-SNAPSHOT import { ParseTreeListener } from "antlr4ts/tree/ParseTreeListener"; @@ -103,6 +100,7 @@ import { Copy_generic_opt_arg_listContext } from "./PostgreSQLParser"; import { Copy_generic_opt_arg_list_itemContext } from "./PostgreSQLParser"; import { CreatestmtContext } from "./PostgreSQLParser"; import { OpttempContext } from "./PostgreSQLParser"; +import { Table_column_listContext } from "./PostgreSQLParser"; import { OpttableelementlistContext } from "./PostgreSQLParser"; import { OpttypedtableelementlistContext } from "./PostgreSQLParser"; import { TableelementlistContext } from "./PostgreSQLParser"; @@ -115,7 +113,8 @@ import { ColquallistContext } from "./PostgreSQLParser"; import { ColconstraintContext } from "./PostgreSQLParser"; import { ColconstraintelemContext } from "./PostgreSQLParser"; import { Generated_whenContext } from "./PostgreSQLParser"; -import { ConstraintattrContext } from "./PostgreSQLParser"; +import { Deferrable_triggerContext } from "./PostgreSQLParser"; +import { Initially_triggerContext } from "./PostgreSQLParser"; import { TablelikeclauseContext } from "./PostgreSQLParser"; import { TablelikeoptionlistContext } from "./PostgreSQLParser"; import { TablelikeoptionContext } from "./PostgreSQLParser"; @@ -219,6 +218,8 @@ import { CreateamstmtContext } from "./PostgreSQLParser"; import { Am_typeContext } from "./PostgreSQLParser"; import { CreatetrigstmtContext } from "./PostgreSQLParser"; import { TriggeractiontimeContext } from "./PostgreSQLParser"; +import { ForeachrowContext } from "./PostgreSQLParser"; +import { RoworstatmentContext } from "./PostgreSQLParser"; import { TriggereventsContext } from "./PostgreSQLParser"; import { TriggeroneeventContext } from "./PostgreSQLParser"; import { TriggerreferencingContext } from "./PostgreSQLParser"; @@ -294,6 +295,8 @@ import { Opt_from_inContext } from "./PostgreSQLParser"; import { GrantstmtContext } from "./PostgreSQLParser"; import { RevokestmtContext } from "./PostgreSQLParser"; import { PrivilegesContext } from "./PostgreSQLParser"; +import { BeforeprivilegeselectlistContext } from "./PostgreSQLParser"; +import { BeforeprivilegeselectContext } from "./PostgreSQLParser"; import { Privilege_listContext } from "./PostgreSQLParser"; import { PrivilegeContext } from "./PostgreSQLParser"; import { Privilege_targetContext } from "./PostgreSQLParser"; @@ -324,6 +327,7 @@ import { Opt_classContext } from "./PostgreSQLParser"; import { Opt_asc_descContext } from "./PostgreSQLParser"; import { Opt_nulls_orderContext } from "./PostgreSQLParser"; import { CreatefunctionstmtContext } from "./PostgreSQLParser"; +import { AttrilistContext } from "./PostgreSQLParser"; import { Opt_or_replaceContext } from "./PostgreSQLParser"; import { Func_argsContext } from "./PostgreSQLParser"; import { Func_args_listContext } from "./PostgreSQLParser"; @@ -677,6 +681,7 @@ import { Opt_target_listContext } from "./PostgreSQLParser"; import { Target_listContext } from "./PostgreSQLParser"; import { Target_elContext } from "./PostgreSQLParser"; import { Qualified_name_listContext } from "./PostgreSQLParser"; +import { Table_qualified_nameContext } from "./PostgreSQLParser"; import { Qualified_nameContext } from "./PostgreSQLParser"; import { Name_listContext } from "./PostgreSQLParser"; import { NameContext } from "./PostgreSQLParser"; @@ -692,10 +697,15 @@ import { SconstContext } from "./PostgreSQLParser"; import { AnysconstContext } from "./PostgreSQLParser"; import { Opt_uescapeContext } from "./PostgreSQLParser"; import { SignediconstContext } from "./PostgreSQLParser"; +import { GroupnameContext } from "./PostgreSQLParser"; import { RoleidContext } from "./PostgreSQLParser"; import { RolespecContext } from "./PostgreSQLParser"; import { Role_listContext } from "./PostgreSQLParser"; import { ColidContext } from "./PostgreSQLParser"; +import { Index_method_choicesContext } from "./PostgreSQLParser"; +import { Exclude_elementContext } from "./PostgreSQLParser"; +import { Index_paramentersContext } from "./PostgreSQLParser"; +import { WherePredicateContext } from "./PostgreSQLParser"; import { Type_function_nameContext } from "./PostgreSQLParser"; import { NonreservedwordContext } from "./PostgreSQLParser"; import { CollabelContext } from "./PostgreSQLParser"; @@ -1913,6 +1923,17 @@ export interface PostgreSQLParserListener extends ParseTreeListener { */ exitOpttemp?: (ctx: OpttempContext) => void; + /** + * Enter a parse tree produced by `PostgreSQLParser.table_column_list`. + * @param ctx the parse tree + */ + enterTable_column_list?: (ctx: Table_column_listContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.table_column_list`. + * @param ctx the parse tree + */ + exitTable_column_list?: (ctx: Table_column_listContext) => void; + /** * Enter a parse tree produced by `PostgreSQLParser.opttableelementlist`. * @param ctx the parse tree @@ -2046,15 +2067,26 @@ export interface PostgreSQLParserListener extends ParseTreeListener { exitGenerated_when?: (ctx: Generated_whenContext) => void; /** - * Enter a parse tree produced by `PostgreSQLParser.constraintattr`. + * Enter a parse tree produced by `PostgreSQLParser.deferrable_trigger`. * @param ctx the parse tree */ - enterConstraintattr?: (ctx: ConstraintattrContext) => void; + enterDeferrable_trigger?: (ctx: Deferrable_triggerContext) => void; /** - * Exit a parse tree produced by `PostgreSQLParser.constraintattr`. + * Exit a parse tree produced by `PostgreSQLParser.deferrable_trigger`. * @param ctx the parse tree */ - exitConstraintattr?: (ctx: ConstraintattrContext) => void; + exitDeferrable_trigger?: (ctx: Deferrable_triggerContext) => void; + + /** + * Enter a parse tree produced by `PostgreSQLParser.initially_trigger`. + * @param ctx the parse tree + */ + enterInitially_trigger?: (ctx: Initially_triggerContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.initially_trigger`. + * @param ctx the parse tree + */ + exitInitially_trigger?: (ctx: Initially_triggerContext) => void; /** * Enter a parse tree produced by `PostgreSQLParser.tablelikeclause`. @@ -3189,6 +3221,28 @@ export interface PostgreSQLParserListener extends ParseTreeListener { */ exitTriggeractiontime?: (ctx: TriggeractiontimeContext) => void; + /** + * Enter a parse tree produced by `PostgreSQLParser.foreachrow`. + * @param ctx the parse tree + */ + enterForeachrow?: (ctx: ForeachrowContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.foreachrow`. + * @param ctx the parse tree + */ + exitForeachrow?: (ctx: ForeachrowContext) => void; + + /** + * Enter a parse tree produced by `PostgreSQLParser.roworstatment`. + * @param ctx the parse tree + */ + enterRoworstatment?: (ctx: RoworstatmentContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.roworstatment`. + * @param ctx the parse tree + */ + exitRoworstatment?: (ctx: RoworstatmentContext) => void; + /** * Enter a parse tree produced by `PostgreSQLParser.triggerevents`. * @param ctx the parse tree @@ -4014,6 +4068,28 @@ export interface PostgreSQLParserListener extends ParseTreeListener { */ exitPrivileges?: (ctx: PrivilegesContext) => void; + /** + * Enter a parse tree produced by `PostgreSQLParser.beforeprivilegeselectlist`. + * @param ctx the parse tree + */ + enterBeforeprivilegeselectlist?: (ctx: BeforeprivilegeselectlistContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.beforeprivilegeselectlist`. + * @param ctx the parse tree + */ + exitBeforeprivilegeselectlist?: (ctx: BeforeprivilegeselectlistContext) => void; + + /** + * Enter a parse tree produced by `PostgreSQLParser.beforeprivilegeselect`. + * @param ctx the parse tree + */ + enterBeforeprivilegeselect?: (ctx: BeforeprivilegeselectContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.beforeprivilegeselect`. + * @param ctx the parse tree + */ + exitBeforeprivilegeselect?: (ctx: BeforeprivilegeselectContext) => void; + /** * Enter a parse tree produced by `PostgreSQLParser.privilege_list`. * @param ctx the parse tree @@ -4344,6 +4420,17 @@ export interface PostgreSQLParserListener extends ParseTreeListener { */ exitCreatefunctionstmt?: (ctx: CreatefunctionstmtContext) => void; + /** + * Enter a parse tree produced by `PostgreSQLParser.attrilist`. + * @param ctx the parse tree + */ + enterAttrilist?: (ctx: AttrilistContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.attrilist`. + * @param ctx the parse tree + */ + exitAttrilist?: (ctx: AttrilistContext) => void; + /** * Enter a parse tree produced by `PostgreSQLParser.opt_or_replace`. * @param ctx the parse tree @@ -8227,6 +8314,17 @@ export interface PostgreSQLParserListener extends ParseTreeListener { */ exitQualified_name_list?: (ctx: Qualified_name_listContext) => void; + /** + * Enter a parse tree produced by `PostgreSQLParser.table_qualified_name`. + * @param ctx the parse tree + */ + enterTable_qualified_name?: (ctx: Table_qualified_nameContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.table_qualified_name`. + * @param ctx the parse tree + */ + exitTable_qualified_name?: (ctx: Table_qualified_nameContext) => void; + /** * Enter a parse tree produced by `PostgreSQLParser.qualified_name`. * @param ctx the parse tree @@ -8392,6 +8490,17 @@ export interface PostgreSQLParserListener extends ParseTreeListener { */ exitSignediconst?: (ctx: SignediconstContext) => void; + /** + * Enter a parse tree produced by `PostgreSQLParser.groupname`. + * @param ctx the parse tree + */ + enterGroupname?: (ctx: GroupnameContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.groupname`. + * @param ctx the parse tree + */ + exitGroupname?: (ctx: GroupnameContext) => void; + /** * Enter a parse tree produced by `PostgreSQLParser.roleid`. * @param ctx the parse tree @@ -8436,6 +8545,50 @@ export interface PostgreSQLParserListener extends ParseTreeListener { */ exitColid?: (ctx: ColidContext) => void; + /** + * Enter a parse tree produced by `PostgreSQLParser.index_method_choices`. + * @param ctx the parse tree + */ + enterIndex_method_choices?: (ctx: Index_method_choicesContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.index_method_choices`. + * @param ctx the parse tree + */ + exitIndex_method_choices?: (ctx: Index_method_choicesContext) => void; + + /** + * Enter a parse tree produced by `PostgreSQLParser.exclude_element`. + * @param ctx the parse tree + */ + enterExclude_element?: (ctx: Exclude_elementContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.exclude_element`. + * @param ctx the parse tree + */ + exitExclude_element?: (ctx: Exclude_elementContext) => void; + + /** + * Enter a parse tree produced by `PostgreSQLParser.index_paramenters`. + * @param ctx the parse tree + */ + enterIndex_paramenters?: (ctx: Index_paramentersContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.index_paramenters`. + * @param ctx the parse tree + */ + exitIndex_paramenters?: (ctx: Index_paramentersContext) => void; + + /** + * Enter a parse tree produced by `PostgreSQLParser.wherePredicate`. + * @param ctx the parse tree + */ + enterWherePredicate?: (ctx: WherePredicateContext) => void; + /** + * Exit a parse tree produced by `PostgreSQLParser.wherePredicate`. + * @param ctx the parse tree + */ + exitWherePredicate?: (ctx: WherePredicateContext) => void; + /** * Enter a parse tree produced by `PostgreSQLParser.type_function_name`. * @param ctx the parse tree diff --git a/src/lib/pgsql/PostgreSQLParserVisitor.ts b/src/lib/pgsql/PostgreSQLParserVisitor.ts index 1f74a45..6104116 100644 --- a/src/lib/pgsql/PostgreSQLParserVisitor.ts +++ b/src/lib/pgsql/PostgreSQLParserVisitor.ts @@ -1,7 +1,4 @@ -// Generated from /Users/ziv/github.com/dt-sql-parser/src/grammar/pgsql/PostgreSQLParser.g4 by ANTLR 4.9.0-SNAPSHOT - - -import PostgreSQLParserBase from "./PostgreSQLParserBase"; +// Generated from /Users/xuxiaoqi/Documents/work/daishu-code/dt-sql-parser/src/grammar/pgsql/PostgreSQLParser.g4 by ANTLR 4.9.0-SNAPSHOT import { ParseTreeVisitor } from "antlr4ts/tree/ParseTreeVisitor"; @@ -103,6 +100,7 @@ import { Copy_generic_opt_arg_listContext } from "./PostgreSQLParser"; import { Copy_generic_opt_arg_list_itemContext } from "./PostgreSQLParser"; import { CreatestmtContext } from "./PostgreSQLParser"; import { OpttempContext } from "./PostgreSQLParser"; +import { Table_column_listContext } from "./PostgreSQLParser"; import { OpttableelementlistContext } from "./PostgreSQLParser"; import { OpttypedtableelementlistContext } from "./PostgreSQLParser"; import { TableelementlistContext } from "./PostgreSQLParser"; @@ -115,7 +113,8 @@ import { ColquallistContext } from "./PostgreSQLParser"; import { ColconstraintContext } from "./PostgreSQLParser"; import { ColconstraintelemContext } from "./PostgreSQLParser"; import { Generated_whenContext } from "./PostgreSQLParser"; -import { ConstraintattrContext } from "./PostgreSQLParser"; +import { Deferrable_triggerContext } from "./PostgreSQLParser"; +import { Initially_triggerContext } from "./PostgreSQLParser"; import { TablelikeclauseContext } from "./PostgreSQLParser"; import { TablelikeoptionlistContext } from "./PostgreSQLParser"; import { TablelikeoptionContext } from "./PostgreSQLParser"; @@ -219,6 +218,8 @@ import { CreateamstmtContext } from "./PostgreSQLParser"; import { Am_typeContext } from "./PostgreSQLParser"; import { CreatetrigstmtContext } from "./PostgreSQLParser"; import { TriggeractiontimeContext } from "./PostgreSQLParser"; +import { ForeachrowContext } from "./PostgreSQLParser"; +import { RoworstatmentContext } from "./PostgreSQLParser"; import { TriggereventsContext } from "./PostgreSQLParser"; import { TriggeroneeventContext } from "./PostgreSQLParser"; import { TriggerreferencingContext } from "./PostgreSQLParser"; @@ -294,6 +295,8 @@ import { Opt_from_inContext } from "./PostgreSQLParser"; import { GrantstmtContext } from "./PostgreSQLParser"; import { RevokestmtContext } from "./PostgreSQLParser"; import { PrivilegesContext } from "./PostgreSQLParser"; +import { BeforeprivilegeselectlistContext } from "./PostgreSQLParser"; +import { BeforeprivilegeselectContext } from "./PostgreSQLParser"; import { Privilege_listContext } from "./PostgreSQLParser"; import { PrivilegeContext } from "./PostgreSQLParser"; import { Privilege_targetContext } from "./PostgreSQLParser"; @@ -324,6 +327,7 @@ import { Opt_classContext } from "./PostgreSQLParser"; import { Opt_asc_descContext } from "./PostgreSQLParser"; import { Opt_nulls_orderContext } from "./PostgreSQLParser"; import { CreatefunctionstmtContext } from "./PostgreSQLParser"; +import { AttrilistContext } from "./PostgreSQLParser"; import { Opt_or_replaceContext } from "./PostgreSQLParser"; import { Func_argsContext } from "./PostgreSQLParser"; import { Func_args_listContext } from "./PostgreSQLParser"; @@ -677,6 +681,7 @@ import { Opt_target_listContext } from "./PostgreSQLParser"; import { Target_listContext } from "./PostgreSQLParser"; import { Target_elContext } from "./PostgreSQLParser"; import { Qualified_name_listContext } from "./PostgreSQLParser"; +import { Table_qualified_nameContext } from "./PostgreSQLParser"; import { Qualified_nameContext } from "./PostgreSQLParser"; import { Name_listContext } from "./PostgreSQLParser"; import { NameContext } from "./PostgreSQLParser"; @@ -692,10 +697,15 @@ import { SconstContext } from "./PostgreSQLParser"; import { AnysconstContext } from "./PostgreSQLParser"; import { Opt_uescapeContext } from "./PostgreSQLParser"; import { SignediconstContext } from "./PostgreSQLParser"; +import { GroupnameContext } from "./PostgreSQLParser"; import { RoleidContext } from "./PostgreSQLParser"; import { RolespecContext } from "./PostgreSQLParser"; import { Role_listContext } from "./PostgreSQLParser"; import { ColidContext } from "./PostgreSQLParser"; +import { Index_method_choicesContext } from "./PostgreSQLParser"; +import { Exclude_elementContext } from "./PostgreSQLParser"; +import { Index_paramentersContext } from "./PostgreSQLParser"; +import { WherePredicateContext } from "./PostgreSQLParser"; import { Type_function_nameContext } from "./PostgreSQLParser"; import { NonreservedwordContext } from "./PostgreSQLParser"; import { CollabelContext } from "./PostgreSQLParser"; @@ -1518,6 +1528,13 @@ export interface PostgreSQLParserVisitor extends ParseTreeVisitor Result; + /** + * Visit a parse tree produced by `PostgreSQLParser.table_column_list`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTable_column_list?: (ctx: Table_column_listContext) => Result; + /** * Visit a parse tree produced by `PostgreSQLParser.opttableelementlist`. * @param ctx the parse tree @@ -1603,11 +1620,18 @@ export interface PostgreSQLParserVisitor extends ParseTreeVisitor Result; /** - * Visit a parse tree produced by `PostgreSQLParser.constraintattr`. + * Visit a parse tree produced by `PostgreSQLParser.deferrable_trigger`. * @param ctx the parse tree * @return the visitor result */ - visitConstraintattr?: (ctx: ConstraintattrContext) => Result; + visitDeferrable_trigger?: (ctx: Deferrable_triggerContext) => Result; + + /** + * Visit a parse tree produced by `PostgreSQLParser.initially_trigger`. + * @param ctx the parse tree + * @return the visitor result + */ + visitInitially_trigger?: (ctx: Initially_triggerContext) => Result; /** * Visit a parse tree produced by `PostgreSQLParser.tablelikeclause`. @@ -2330,6 +2354,20 @@ export interface PostgreSQLParserVisitor extends ParseTreeVisitor Result; + /** + * Visit a parse tree produced by `PostgreSQLParser.foreachrow`. + * @param ctx the parse tree + * @return the visitor result + */ + visitForeachrow?: (ctx: ForeachrowContext) => Result; + + /** + * Visit a parse tree produced by `PostgreSQLParser.roworstatment`. + * @param ctx the parse tree + * @return the visitor result + */ + visitRoworstatment?: (ctx: RoworstatmentContext) => Result; + /** * Visit a parse tree produced by `PostgreSQLParser.triggerevents`. * @param ctx the parse tree @@ -2855,6 +2893,20 @@ export interface PostgreSQLParserVisitor extends ParseTreeVisitor Result; + /** + * Visit a parse tree produced by `PostgreSQLParser.beforeprivilegeselectlist`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBeforeprivilegeselectlist?: (ctx: BeforeprivilegeselectlistContext) => Result; + + /** + * Visit a parse tree produced by `PostgreSQLParser.beforeprivilegeselect`. + * @param ctx the parse tree + * @return the visitor result + */ + visitBeforeprivilegeselect?: (ctx: BeforeprivilegeselectContext) => Result; + /** * Visit a parse tree produced by `PostgreSQLParser.privilege_list`. * @param ctx the parse tree @@ -3065,6 +3117,13 @@ export interface PostgreSQLParserVisitor extends ParseTreeVisitor Result; + /** + * Visit a parse tree produced by `PostgreSQLParser.attrilist`. + * @param ctx the parse tree + * @return the visitor result + */ + visitAttrilist?: (ctx: AttrilistContext) => Result; + /** * Visit a parse tree produced by `PostgreSQLParser.opt_or_replace`. * @param ctx the parse tree @@ -5536,6 +5595,13 @@ export interface PostgreSQLParserVisitor extends ParseTreeVisitor Result; + /** + * Visit a parse tree produced by `PostgreSQLParser.table_qualified_name`. + * @param ctx the parse tree + * @return the visitor result + */ + visitTable_qualified_name?: (ctx: Table_qualified_nameContext) => Result; + /** * Visit a parse tree produced by `PostgreSQLParser.qualified_name`. * @param ctx the parse tree @@ -5641,6 +5707,13 @@ export interface PostgreSQLParserVisitor extends ParseTreeVisitor Result; + /** + * Visit a parse tree produced by `PostgreSQLParser.groupname`. + * @param ctx the parse tree + * @return the visitor result + */ + visitGroupname?: (ctx: GroupnameContext) => Result; + /** * Visit a parse tree produced by `PostgreSQLParser.roleid`. * @param ctx the parse tree @@ -5669,6 +5742,34 @@ export interface PostgreSQLParserVisitor extends ParseTreeVisitor Result; + /** + * Visit a parse tree produced by `PostgreSQLParser.index_method_choices`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIndex_method_choices?: (ctx: Index_method_choicesContext) => Result; + + /** + * Visit a parse tree produced by `PostgreSQLParser.exclude_element`. + * @param ctx the parse tree + * @return the visitor result + */ + visitExclude_element?: (ctx: Exclude_elementContext) => Result; + + /** + * Visit a parse tree produced by `PostgreSQLParser.index_paramenters`. + * @param ctx the parse tree + * @return the visitor result + */ + visitIndex_paramenters?: (ctx: Index_paramentersContext) => Result; + + /** + * Visit a parse tree produced by `PostgreSQLParser.wherePredicate`. + * @param ctx the parse tree + * @return the visitor result + */ + visitWherePredicate?: (ctx: WherePredicateContext) => Result; + /** * Visit a parse tree produced by `PostgreSQLParser.type_function_name`. * @param ctx the parse tree diff --git a/test/parser/pgsql/fixtures/select.sql b/test/parser/pgsql/fixtures/select.sql deleted file mode 100644 index 732aca6..0000000 --- a/test/parser/pgsql/fixtures/select.sql +++ /dev/null @@ -1,244 +0,0 @@ - -SELECT * FROM onek - WHERE onek.unique1 < 10 - ORDER BY onek.unique1; - -SELECT onek.unique1, onek.stringu1 FROM onek - WHERE onek.unique1 < 20 - ORDER BY unique1 using >; - -SELECT onek.unique1, onek.stringu1 FROM onek - WHERE onek.unique1 > 980 - ORDER BY stringu1 using <; - -SELECT onek.unique1, onek.string4 FROM onek - WHERE onek.unique1 > 980 - ORDER BY string4 using <, unique1 using >; - -SELECT onek.unique1, onek.string4 FROM onek - WHERE onek.unique1 > 980 - ORDER BY string4 using >, unique1 using <; - --- --- awk '{if($1<20){print $1,$16;}else{next;}}' onek.data | --- sort +0nr -1 +1d -2 --- -SELECT onek.unique1, onek.string4 FROM onek - WHERE onek.unique1 < 20 - ORDER BY unique1 using >, string4 using <; - --- --- awk '{if($1<20){print $1,$16;}else{next;}}' onek.data | --- sort +0n -1 +1dr -2 --- -SELECT onek.unique1, onek.string4 FROM onek - WHERE onek.unique1 < 20 - ORDER BY unique1 using <, string4 using >; - --- --- test partial btree indexes --- --- As of 7.2, planner probably won't pick an indexscan without stats, --- so ANALYZE first. Also, we want to prevent it from picking a bitmapscan --- followed by sort, because that could hide index ordering problems. --- -ANALYZE onek2; - -SET enable_seqscan TO off; -SET enable_bitmapscan TO off; -SET enable_sort TO off; - --- --- awk '{if($1<10){print $0;}else{next;}}' onek.data | sort +0n -1 --- -SELECT onek2.* FROM onek2 WHERE onek2.unique1 < 10; - --- --- awk '{if($1<20){print $1,$14;}else{next;}}' onek.data | sort +0nr -1 --- -SELECT onek2.unique1, onek2.stringu1 FROM onek2 - WHERE onek2.unique1 < 20 - ORDER BY unique1 using >; - --- --- awk '{if($1>980){print $1,$14;}else{next;}}' onek.data | sort +1d -2 --- -SELECT onek2.unique1, onek2.stringu1 FROM onek2 - WHERE onek2.unique1 > 980; - -RESET enable_seqscan; -RESET enable_bitmapscan; -RESET enable_sort; - - -SELECT two, stringu1, ten, string4 - INTO TABLE tmp - FROM onek; - --- --- awk '{print $1,$2;}' person.data | --- awk '{if(NF!=2){print $3,$2;}else{print;}}' - emp.data | --- awk '{if(NF!=2){print $3,$2;}else{print;}}' - student.data | --- awk 'BEGIN{FS=" ";}{if(NF!=2){print $4,$5;}else{print;}}' - stud_emp.data --- --- SELECT name, age FROM person*; ??? check if different -SELECT p.name, p.age FROM person* p; - --- --- awk '{print $1,$2;}' person.data | --- awk '{if(NF!=2){print $3,$2;}else{print;}}' - emp.data | --- awk '{if(NF!=2){print $3,$2;}else{print;}}' - student.data | --- awk 'BEGIN{FS=" ";}{if(NF!=1){print $4,$5;}else{print;}}' - stud_emp.data | --- sort +1nr -2 --- -SELECT p.name, p.age FROM person* p ORDER BY age using >, name; - --- --- Test some cases involving whole-row Var referencing a subquery --- -select foo from (select 1 offset 0) as foo; -select foo from (select null offset 0) as foo; -select foo from (select 'xyzzy',1,null offset 0) as foo; - --- --- Test VALUES lists --- -select * from onek, (values(147, 'RFAAAA'), (931, 'VJAAAA')) as v (i, j) - WHERE onek.unique1 = v.i and onek.stringu1 = v.j; - --- a more complex case --- looks like we're coding lisp :-) -select * from onek, - (values ((select i from - (values(10000), (2), (389), (1000), (2000), ((select 10029))) as foo(i) - order by i asc limit 1))) bar (i) - where onek.unique1 = bar.i; - --- try VALUES in a subquery -select * from onek - where (unique1,ten) in (values (1,1), (20,0), (99,9), (17,99)) - order by unique1; - --- VALUES is also legal as a standalone query or a set-operation member -VALUES (1,2), (3,4+4), (7,77.7); - -VALUES (1,2), (3,4+4), (7,77.7) -UNION ALL -SELECT 2+2, 57 -UNION ALL -TABLE int8_tbl; - --- --- Test ORDER BY options --- - -CREATE TEMP TABLE foo (f1 int); - -INSERT INTO foo VALUES (42),(3),(10),(7),(null),(null),(1); - -SELECT * FROM foo ORDER BY f1; -SELECT * FROM foo ORDER BY f1 ASC; -- same thing -SELECT * FROM foo ORDER BY f1 NULLS FIRST; -SELECT * FROM foo ORDER BY f1 DESC; -SELECT * FROM foo ORDER BY f1 DESC NULLS LAST; - --- check if indexscans do the right things -CREATE INDEX fooi ON foo (f1); -SET enable_sort = false; - -SELECT * FROM foo ORDER BY f1; -SELECT * FROM foo ORDER BY f1 NULLS FIRST; -SELECT * FROM foo ORDER BY f1 DESC; -SELECT * FROM foo ORDER BY f1 DESC NULLS LAST; - -DROP INDEX fooi; -CREATE INDEX fooi ON foo (f1 DESC); - -SELECT * FROM foo ORDER BY f1; -SELECT * FROM foo ORDER BY f1 NULLS FIRST; -SELECT * FROM foo ORDER BY f1 DESC; -SELECT * FROM foo ORDER BY f1 DESC NULLS LAST; - -DROP INDEX fooi; -CREATE INDEX fooi ON foo (f1 DESC NULLS LAST); - -SELECT * FROM foo ORDER BY f1; -SELECT * FROM foo ORDER BY f1 NULLS FIRST; -SELECT * FROM foo ORDER BY f1 DESC; -SELECT * FROM foo ORDER BY f1 DESC NULLS LAST; - --- --- Test planning of some cases with partial indexes --- - --- partial index is usable -explain (costs off) -select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; -select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; --- actually run the query with an analyze to use the partial index -explain (costs off, analyze on, timing off, summary off) -select * from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; -explain (costs off) -select unique2 from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; -select unique2 from onek2 where unique2 = 11 and stringu1 = 'ATAAAA'; --- partial index predicate implies clause, so no need for retest -explain (costs off) -select * from onek2 where unique2 = 11 and stringu1 < 'B'; -select * from onek2 where unique2 = 11 and stringu1 < 'B'; -explain (costs off) -select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; -select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; --- but if it's an update target, must retest anyway -explain (costs off) -select unique2 from onek2 where unique2 = 11 and stringu1 < 'B' for update; -select unique2 from onek2 where unique2 = 11 and stringu1 < 'B' for update; --- partial index is not applicable -explain (costs off) -select unique2 from onek2 where unique2 = 11 and stringu1 < 'C'; -select unique2 from onek2 where unique2 = 11 and stringu1 < 'C'; --- partial index implies clause, but bitmap scan must recheck predicate anyway -SET enable_indexscan TO off; -explain (costs off) -select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; -select unique2 from onek2 where unique2 = 11 and stringu1 < 'B'; -RESET enable_indexscan; --- check multi-index cases too -explain (costs off) -select unique1, unique2 from onek2 - where (unique2 = 11 or unique1 = 0) and stringu1 < 'B'; -select unique1, unique2 from onek2 - where (unique2 = 11 or unique1 = 0) and stringu1 < 'B'; -explain (costs off) -select unique1, unique2 from onek2 - where (unique2 = 11 and stringu1 < 'B') or unique1 = 0; -select unique1, unique2 from onek2 - where (unique2 = 11 and stringu1 < 'B') or unique1 = 0; - --- --- Test some corner cases that have been known to confuse the planner --- - --- ORDER BY on a constant doesn't really need any sorting -SELECT 1 AS x ORDER BY x; - --- But ORDER BY on a set-valued expression does -create function sillysrf(int) returns setof int as - 'values (1),(10),(2),($1)' language sql immutable; - -select sillysrf(42); -select sillysrf(-1) order by 1; - -drop function sillysrf(int); - --- X = X isn't a no-op, it's effectively X IS NOT NULL assuming = is strict --- (see bug #5084) -select * from (values (2),(null),(1)) v(k) where k = k order by k; -select * from (values (2),(null),(1)) v(k) where k = k; - --- Test partitioned tables with no partitions, which should be handled the --- same as the non-inheritance case when expanding its RTE. -create table list_parted_tbl (a int,b int) partition by list (a); -create table list_parted_tbl1 partition of list_parted_tbl - for values in (1) partition by list(b); -explain (costs off) select * from list_parted_tbl; -drop table list_parted_tbl; \ No newline at end of file diff --git a/test/parser/pgsql/selectStatement.test.ts b/test/parser/pgsql/selectStatement.test.ts deleted file mode 100644 index d44eb54..0000000 --- a/test/parser/pgsql/selectStatement.test.ts +++ /dev/null @@ -1,18 +0,0 @@ -import PostgresSQL from '../../../src/parser/pgsql'; -import { readSQL } from '../../helper'; - -const parser = new PostgresSQL(); - -const features = { - base: readSQL(__dirname, 'select.sql'), -}; - -describe('Postgre SQL Query Statement Tests', () => { - describe('Base Select', () => { - features.base.forEach((sql) => { - it(sql, () => { - expect(parser.validate(sql).length).toBe(0); - }); - }); - }); -}); diff --git a/test/parser/pgsql/syntax.test.ts b/test/parser/pgsql/syntax.test.ts deleted file mode 100644 index 3711f7e..0000000 --- a/test/parser/pgsql/syntax.test.ts +++ /dev/null @@ -1,24 +0,0 @@ -import PostgresSQL from '../../../src/parser/pgsql'; - -describe('PostgresSQL SQL Syntax Tests', () => { - const parser = new PostgresSQL(); - - test('Select Statement', () => { - const sql = 'select id, t_name from user1;'; - const result = parser.validate(sql); - - expect(result.length).toBe(0); - }); - - test('Select 1+1', () => { - const sql = 'SELECT 1+1;'; - const result = parser.validate(sql); - expect(result.length).toBe(0); - }); - - test('Select 1+1', () => { - const sql = 'SELECT 1+1;'; - const result = parser.validate(sql); - expect(result.length).toBe(0); - }); -}); diff --git a/test/parser/pgsql/syntax/alterStatement.test.ts b/test/parser/pgsql/syntax/alterStatement.test.ts new file mode 100644 index 0000000..1db34d9 --- /dev/null +++ b/test/parser/pgsql/syntax/alterStatement.test.ts @@ -0,0 +1,16 @@ +import PgSQL from '../../../../src/parser/pgsql'; +import { readSQL } from '../../../helper'; + +const parser = new PgSQL(); + +const features = { + alters: readSQL(__dirname, 'alter.sql'), +}; + +describe('PgSQL Create Syntax Tests', () => { + features.alters.forEach((alters) => { + it(alters, () => { + expect(parser.validate(alters).length).toBe(0); + }); + }); +}); diff --git a/test/parser/pgsql/syntax/createStatement.test.ts b/test/parser/pgsql/syntax/createStatement.test.ts new file mode 100644 index 0000000..0f0854d --- /dev/null +++ b/test/parser/pgsql/syntax/createStatement.test.ts @@ -0,0 +1,16 @@ +import PgSQL from '../../../../src/parser/pgsql'; +import { readSQL } from '../../../helper'; + +const parser = new PgSQL(); + +const features = { + creates: readSQL(__dirname, 'create.sql'), +}; + +describe('PgSQL Create Syntax Tests', () => { + features.creates.forEach((create) => { + it(create, () => { + expect(parser.validate(create).length).toBe(0); + }); + }); +}); diff --git a/test/parser/pgsql/syntax/deleteStatement.test.ts b/test/parser/pgsql/syntax/deleteStatement.test.ts new file mode 100644 index 0000000..30e6717 --- /dev/null +++ b/test/parser/pgsql/syntax/deleteStatement.test.ts @@ -0,0 +1,16 @@ +import PgSQL from '../../../../src/parser/pgsql'; +import { readSQL } from '../../../helper'; + +const parser = new PgSQL(); + +const features = { + deletes: readSQL(__dirname, 'delete.sql'), +}; + +describe('PgSQL Delete Syntax Tests', () => { + features.deletes.forEach((deleteItem) => { + it(deleteItem, () => { + expect(parser.validate(deleteItem).length).toBe(0); + }); + }); +}); diff --git a/test/parser/pgsql/syntax/dropStatement.test.ts b/test/parser/pgsql/syntax/dropStatement.test.ts new file mode 100644 index 0000000..f29b079 --- /dev/null +++ b/test/parser/pgsql/syntax/dropStatement.test.ts @@ -0,0 +1,16 @@ +import PgSQL from '../../../../src/parser/pgsql'; +import { readSQL } from '../../../helper'; + +const parser = new PgSQL(); + +const features = { + drops: readSQL(__dirname, 'drop.sql'), +}; + +describe('PgSQL Delete Syntax Tests', () => { + features.drops.forEach((drop) => { + it(drop, () => { + expect(parser.validate(drop).length).toBe(0); + }); + }); +}); diff --git a/test/parser/pgsql/syntax/fixtures/alter.sql b/test/parser/pgsql/syntax/fixtures/alter.sql new file mode 100644 index 0000000..702446b --- /dev/null +++ b/test/parser/pgsql/syntax/fixtures/alter.sql @@ -0,0 +1,314 @@ +-- Modifying Tables +-- Adding a Column +ALTER TABLE products ADD COLUMN description text CHECK (description <> ''); + +-- Removing a Column +ALTER TABLE products DROP COLUMN description; + +ALTER TABLE products DROP COLUMN description CASCADE; + +-- Adding a Constraint +ALTER TABLE products ADD CHECK (name <> ''); + +ALTER TABLE products ADD CONSTRAINT some_name UNIQUE (product_no); + +ALTER TABLE products ADD FOREIGN KEY (product_group_id) REFERENCES product_groups; + +-- Removing a Constraint +ALTER TABLE products DROP CONSTRAINT some_name; + +ALTER TABLE products ALTER COLUMN product_no SET NOT NULL; + +-- Changing a Column's Default Value +ALTER TABLE products ALTER COLUMN price SET DEFAULT 7.77; + +ALTER TABLE products ALTER COLUMN price DROP DEFAULT; + +-- Changing a Column's Data Type +ALTER TABLE products ALTER COLUMN price TYPE numeric(10,2); + +-- Renaming a Column +ALTER TABLE products RENAME COLUMN product_no TO product_number; + +-- Renaming a Table +ALTER TABLE products RENAME TO items; + +-- Managing Partitions +ALTER TABLE measurement_y2006m02 NO INHERIT measurement; + +ALTER TABLE measurement_y2008m02 ADD CONSTRAINT y2008m02 + CHECK ( logdate >= DATE '2008-02-01' AND logdate < DATE '2008-03-01' ); + +-- ALTER AGGREGATE +ALTER AGGREGATE name ( int, integer) RENAME TO new_name; +ALTER AGGREGATE name ( text,int ) OWNER TO new_owner; +ALTER AGGREGATE name ( integer ) SET SCHEMA new_schema; + +-- ALTER COLLATION +ALTER COLLATION name RENAME TO new_name; +ALTER COLLATION name OWNER TO new_owner; +ALTER COLLATION name SET SCHEMA new_schema; + +-- ALTER CONVERSION +ALTER CONVERSION name RENAME TO new_name; +ALTER CONVERSION name OWNER TO new_owner; +ALTER CONVERSION name SET SCHEMA new_schema; + +-- ALTER DATABASE +ALTER DATABASE name WITH CONNECTION LIMIT connlimit; +ALTER DATABASE name RENAME TO new_name; +ALTER DATABASE name OWNER TO new_owner; +ALTER DATABASE name SET TABLESPACE new_tablespace; +ALTER DATABASE name SET configuration_parameter TO DEFAULT; +ALTER DATABASE name SET configuration_parameter FROM CURRENT; +ALTER DATABASE name RESET configuration_parameter; +ALTER DATABASE name RESET ALL; + +-- ALTER DEFAULT PRIVILEGES +ALTER DEFAULT PRIVILEGES + FOR ROLE target_role, target_role2 + IN SCHEMA schema_name, schema_name2 + GRANT SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER + ON TABLES + TO GROUP role_name, PUBLIC WITH GRANT OPTION; + +-- ALTER DOMAIN +ALTER DOMAIN name SET DEFAULT expression; +ALTER DOMAIN name DROP DEFAULT; +ALTER DOMAIN name SET NOT NULL; +ALTER DOMAIN name ADD CONSTRAINT constraint_name +CHECK (char_length(VALUE) = 5) NOT VALID; +ALTER DOMAIN name + DROP CONSTRAINT IF EXISTS constraint_name RESTRICT; +ALTER DOMAIN name + RENAME CONSTRAINT constraint_name TO new_constraint_name; +ALTER DOMAIN name + VALIDATE CONSTRAINT constraint_name; +ALTER DOMAIN name + OWNER TO new_owner; +ALTER DOMAIN name + RENAME TO new_name; +ALTER DOMAIN name + SET SCHEMA new_schema; + +-- ALTER EVENT TRIGGER +ALTER EVENT TRIGGER name DISABLE; +ALTER EVENT TRIGGER name ENABLE REPLICA; +ALTER EVENT TRIGGER name OWNER TO new_owner; +ALTER EVENT TRIGGER name RENAME TO new_name; + +-- ALTER EXTENSION +ALTER EXTENSION name UPDATE TO new_version; +ALTER EXTENSION name SET SCHEMA new_schema; +ALTER EXTENSION name ADD AGGREGATE agg_name (agg_type, agg_type2); +ALTER EXTENSION name DROP CAST (source_type AS target_type); +ALTER EXTENSION name DROP COLLATION object_name; +ALTER EXTENSION name DROP CONVERSION object_name; +ALTER EXTENSION name DROP DOMAIN object_name; +ALTER EXTENSION name DROP EVENT TRIGGER object_name; +ALTER EXTENSION name DROP FOREIGN DATA WRAPPER object_name; +ALTER EXTENSION name DROP FOREIGN TABLE object_name ; +ALTER EXTENSION name DROP FUNCTION function_name ( IN argname int); +ALTER EXTENSION name DROP MATERIALIZED VIEW object_name; +ALTER EXTENSION name DROP OPERATOR > (int, int); +ALTER EXTENSION name DROP OPERATOR CLASS object_name USING index_method; +ALTER EXTENSION name DROP OPERATOR FAMILY object_name USING index_method; +ALTER EXTENSION name DROP PROCEDURAL LANGUAGE object_name; +ALTER EXTENSION name DROP SCHEMA object_name; +ALTER EXTENSION name DROP SEQUENCE object_name; +ALTER EXTENSION name DROP SERVER object_name; +ALTER EXTENSION name DROP TABLE object_name; +ALTER EXTENSION name DROP TEXT SEARCH CONFIGURATION object_name; +ALTER EXTENSION name DROP TEXT SEARCH DICTIONARY object_name; +ALTER EXTENSION name DROP TEXT SEARCH PARSER object_name; +ALTER EXTENSION name DROP TEXT SEARCH TEMPLATE object_name; +ALTER EXTENSION name DROP TYPE object_name; +ALTER EXTENSION name DROP VIEW object_name; + +-- ALTER FOREIGN DATA WRAPPER +ALTER FOREIGN DATA WRAPPER name +HANDLER handler_function +VALIDATOR validator_function +OPTIONS (ADD option_1 'value', DROP option_2 'value'); +ALTER FOREIGN DATA WRAPPER name OWNER TO new_owner; +ALTER FOREIGN DATA WRAPPER name RENAME TO new_name; + +-- ALTER FOREIGN TABLE +ALTER FOREIGN TABLE IF EXISTS name + ADD COLUMN column_name data_type COLLATE collation_name, DROP COLUMN IF EXISTS column_name CASCADE, ALTER COLUMN column_name SET DATA TYPE data_type, OWNER TO new_owner, OPTIONS (ADD option_1 'value', DROP option_2 'value'); +ALTER FOREIGN TABLE table_name ALTER column_name DROP DEFAULT; +ALTER FOREIGN TABLE IF EXISTS name + RENAME COLUMN column_name TO new_column_name; +ALTER FOREIGN TABLE IF EXISTS name + RENAME TO new_name; +ALTER FOREIGN TABLE IF EXISTS name + SET SCHEMA new_schema; + +-- ALTER FUNCTION +ALTER FUNCTION name (VARIADIC argname argtype) + CALLED ON NULL INPUT RESTRICT; +ALTER FUNCTION name ( INOUT argname argtype, OUT argname argtype) + RENAME TO new_name; +ALTER FUNCTION name (INOUT argname argtype) + OWNER TO new_owner; +ALTER FUNCTION name (IN argname argtype) + SET SCHEMA new_schema; + +-- ALTER GROUP +ALTER GROUP group_name ADD USER user_name, user_name1; +ALTER GROUP group_name DROP USER user_name,user_name2; +ALTER GROUP group_name RENAME TO new_name; + +-- ALTER INDEX +ALTER INDEX IF EXISTS name RENAME TO new_name; +ALTER INDEX IF EXISTS name SET TABLESPACE tablespace_name; +ALTER INDEX IF EXISTS name SET ( storage_parameter = value2 ); +ALTER INDEX IF EXISTS name RESET ( storage_parameter ); + +-- ALTER LANGUAGE +ALTER PROCEDURAL LANGUAGE name RENAME TO new_name; +ALTER LANGUAGE name OWNER TO new_owner; + +-- ALTER LARGE OBJECT +ALTER LARGE OBJECT 32423 OWNER TO new_owner; + +-- ALTER MATERIALIZED VIEW +ALTER MATERIALIZED VIEW IF EXISTS name + SET WITHOUT CLUSTER,CLUSTER ON index_name; +ALTER MATERIALIZED VIEW IF EXISTS name + RENAME COLUMN column_name TO new_column_name; +ALTER MATERIALIZED VIEW IF EXISTS name + RENAME TO new_name; +ALTER MATERIALIZED VIEW IF EXISTS name + SET SCHEMA new_schema; +ALTER MATERIALIZED VIEW name SET SCHEMA new_schema; + +-- ALTER OPERATOR +ALTER OPERATOR - ( NONE , int ) OWNER TO new_owner; +ALTER OPERATOR = ( integer , NONE ) SET SCHEMA new_schema; + +-- ALTER OPERATOR CLASS +ALTER OPERATOR CLASS name USING index_method RENAME TO new_name; +ALTER OPERATOR CLASS name USING index_method OWNER TO new_owner; +ALTER OPERATOR CLASS name USING index_method SET SCHEMA new_schema; + +-- ALTER OPERATOR FAMILY +ALTER OPERATOR FAMILY name USING index_method ADD +OPERATOR 4 > ( int, integer ) FOR SEARCH, + FUNCTION 3 ( int, int) function_name ( numeric ); +ALTER OPERATOR FAMILY name USING index_method DROP +OPERATOR 4 ( op_type, op_type ), + FUNCTION 4 ( op_type, op_type ); +ALTER OPERATOR FAMILY name USING index_method RENAME TO new_name; +ALTER OPERATOR FAMILY name USING index_method OWNER TO new_owner; +ALTER OPERATOR FAMILY name USING index_method SET SCHEMA new_schema; + +-- ALTER ROLE +ALTER ROLE name WITH SUPERUSER CREATEDB CREATEROLE VALID UNTIL 'timestamp'; +ALTER ROLE name RENAME TO new_name; +ALTER ROLE ALL IN DATABASE database_name SET configuration_parameter = DEFAULT; +ALTER ROLE name IN DATABASE database_name SET configuration_parameter FROM CURRENT; +ALTER ROLE ALL IN DATABASE database_name RESET configuration_parameter; +ALTER ROLE name IN DATABASE database_name RESET ALL; + +-- ALTER RULE +ALTER RULE name ON table_name RENAME TO new_name; + +-- ALTER SCHEMA +ALTER SCHEMA name RENAME TO new_name; +ALTER SCHEMA name OWNER TO new_owner; + +-- ALTER SEQUENCE +ALTER SEQUENCE IF EXISTS name INCREMENT BY 324 +MINVALUE 34 MAXVALUE 66 +START WITH 12 RESTART WITH 34 +CACHE 324 NO CYCLE +OWNED BY table_name.column_name; +ALTER SEQUENCE name OWNER TO new_owner; +ALTER SEQUENCE IF EXISTS name RENAME TO new_name; +ALTER SEQUENCE name SET SCHEMA new_schema; + +-- ALTER SERVER +ALTER SERVER name VERSION 'new_version' OPTIONS ( ADD option 'value', SET option 'value', DROP option 'value'); +ALTER SERVER name OWNER TO new_owner; +ALTER SERVER name RENAME TO new_name; + +-- ALTER TABLE +ALTER TABLE IF EXISTS ONLY name * +ALTER COLUMN column_name SET DEFAULT expression, DISABLE RULE rewrite_rule_name, ADD CONSTRAINT constraint_name + UNIQUE USING INDEX index_name DEFERRABLE INITIALLY DEFERRED; +ALTER TABLE name +RENAME column_name TO new_column_name; +ALTER TABLE IF EXISTS ONLY name * + RENAME CONSTRAINT constraint_name TO new_constraint_name; +ALTER TABLE IF EXISTS name + RENAME TO new_name; +ALTER TABLE name + SET SCHEMA new_schema; + +-- ALTER TABLESPACE +ALTER TABLESPACE name RENAME TO new_name; +ALTER TABLESPACE name OWNER TO new_owner; +ALTER TABLESPACE name SET ( tablespace_option = value, tablespace_option = value2 ); +ALTER TABLESPACE name RESET ( tablespace_option, tablespace_option2 ); + +-- ALTER TEXT SEARCH CONFIGURATION +ALTER TEXT SEARCH CONFIGURATION name + ADD MAPPING FOR token_type, token_type2 WITH dictionary_name, dictionary_name2; +ALTER TEXT SEARCH CONFIGURATION name + ALTER MAPPING FOR token_type, token_type2 WITH dictionary_name, dictionary_name2; +ALTER TEXT SEARCH CONFIGURATION name + ALTER MAPPING REPLACE old_dictionary WITH new_dictionary; +ALTER TEXT SEARCH CONFIGURATION name + ALTER MAPPING FOR token_type REPLACE old_dictionary WITH new_dictionary; +ALTER TEXT SEARCH CONFIGURATION name + DROP MAPPING IF EXISTS FOR token_type; +ALTER TEXT SEARCH CONFIGURATION name RENAME TO new_name; +ALTER TEXT SEARCH CONFIGURATION name OWNER TO new_owner; +ALTER TEXT SEARCH CONFIGURATION name SET SCHEMA new_schema; + +-- ALTER TEXT SEARCH DICTIONARY +ALTER TEXT SEARCH DICTIONARY name ( + option_1 = value1, option_2 +); +ALTER TEXT SEARCH DICTIONARY name RENAME TO new_name; +ALTER TEXT SEARCH DICTIONARY name OWNER TO new_owner; +ALTER TEXT SEARCH DICTIONARY name SET SCHEMA new_schema; + +-- ALTER TEXT SEARCH PARSER +ALTER TEXT SEARCH PARSER name RENAME TO new_name; +ALTER TEXT SEARCH PARSER name SET SCHEMA new_schema; + +-- ALTER TEXT SEARCH TEMPLATE +ALTER TEXT SEARCH TEMPLATE name RENAME TO new_name; +ALTER TEXT SEARCH TEMPLATE name SET SCHEMA new_schema; + +-- ALTER TRIGGER +ALTER TRIGGER name ON table_name RENAME TO new_name; + +-- ALTER TYPE +ALTER TYPE name ADD ATTRIBUTE attribute_name data_type COLLATE collation_name CASCADE; +ALTER TYPE name OWNER TO new_owner; +ALTER TYPE name RENAME ATTRIBUTE attribute_name TO new_attribute_name RESTRICT; +ALTER TYPE name RENAME TO new_name; +ALTER TYPE name SET SCHEMA new_schema; +ALTER TYPE name ADD VALUE IF NOT EXISTS 'new_enum_value' BEFORE 'existing_enum_value'; + +-- ALTER USER +ALTER USER name WITH NOSUPERUSER NOCREATEDB NOCREATEROLE NOCREATEUSER NOINHERIT NOLOGIN NOREPLICATION CONNECTION LIMIT 23 PASSWORD 'password' VALID UNTIL 'timestamp'; +ALTER USER name; + +-- ALTER USER MAPPING +ALTER USER MAPPING FOR CURRENT_USER + SERVER server_name + OPTIONS (ADD option 'value', SET option 'value', DROP option 'value'); + +-- ALTER VIEW +ALTER VIEW name ALTER COLUMN column_name SET DEFAULT expression; +ALTER VIEW IF EXISTS name ALTER column_name DROP DEFAULT; +ALTER VIEW name OWNER TO new_owner; +ALTER VIEW IF EXISTS name RENAME TO new_name; +ALTER VIEW name SET SCHEMA new_schema; +ALTER VIEW IF EXISTS name SET ( view_option_name = view_option_value, view_option_name2 = view_option_value2); +ALTER VIEW name RESET ( view_option_name, view_option_name ); + diff --git a/test/parser/pgsql/syntax/fixtures/create.sql b/test/parser/pgsql/syntax/fixtures/create.sql new file mode 100644 index 0000000..2e0bbae --- /dev/null +++ b/test/parser/pgsql/syntax/fixtures/create.sql @@ -0,0 +1,512 @@ +-- Creating a New Table +-- index_method: btree, hash, gist, spgist and gin +-- The Most Complicated +CREATE GLOBAL TEMPORARY TABLE IF NOT EXISTS table1 (col1 int COLLATE collation1 CONSTRAINT constraint_name NOT NULL DEFERRABLE) INHERITS (table_parent) WITH (storage_parameter = 1) ON COMMIT PRESERVE ROWS TABLESPACE tablespace_name; + +CREATE LOCAL TEMP TABLE table1 (col1 int CONSTRAINT constraint_name NULL NOT DEFERRABLE, col2 text CHECK (age > 5) NOT DEFERRABLE INITIALLY DEFERRED, LIKE source_table INCLUDING DEFAULTS) INHERITS (table_parent) WITH OIDS TABLESPACE tablespace_name; + +CREATE LOCAL TEMP TABLE table1 (col1 int) INHERITS (table_parent) WITH OIDS ON COMMIT DELETE ROWS; + +CREATE UNLOGGED TABLE table1 (col1 int) INHERITS (table_parent) WITHOUT OIDS ON COMMIT DROP; + +CREATE TABLE table_name1 OF type_name (col1 WITH OPTIONS CONSTRAINT constraint_name NOT NULL, col2 WITH OPTIONS CONSTRAINT constraint_name CHECK (age > 5) NOT DEFERRABLE INITIALLY DEFERRED); + +CREATE TABLE table_name1 OF type_name (col1 WITH OPTIONS CONSTRAINT constraint_name NOT NULL, EXCLUDE USING hash (c WITH &&+) WITH (storage_parameter=3) USING INDEX TABLESPACE tablespace_name WHERE (predicate1=123) NOT DEFERRABLE INITIALLY DEFERRED); + + +CREATE TABLE weather ( + city varchar(80), + temp_lo int, + -- low temperature + temp_hi int, + -- high temperature + prcp real, + -- precipitation + date date +); + +CREATE TABLE cities ( + name varchar(80), + location point +); + +-- remove it +DROP TABLE weather; + +-- operate view +CREATE VIEW myview AS +SELECT + city, + temp_lo, + temp_hi, + prcp, + date, + location +FROM + weather, + cities +WHERE + city = name; + +-- Foreign Keys +CREATE TABLE cities ( + city varchar(80) primary key, + location point +); + +CREATE TABLE weather ( + city varchar(80) references cities(city), + temp_lo int, + temp_hi int, + prcp real, + date date +); + +-- Schemas + +-- Creating a Schema +CREATE SCHEMA myschema; + +CREATE SCHEMA database1.schema1.table1; + +CREATE SCHEMA schemaname AUTHORIZATION username; + +-- The Public Schema +CREATE TABLE public7.products(col1 int); + +-- Inheritance +CREATE TABLE capitals ( + state char(2) +) INHERITS (cities); + +-- Partitioning Implementing Partitioning +CREATE TABLE measurement_y2006m02 ( + CHECK ( logdate >= DATE '2006-02-01' AND logdate < DATE '2006-03-01' ) +) INHERITS (measurement); + +CREATE TRIGGER insert_measurement_trigger + BEFORE INSERT ON measurement + FOR EACH ROW EXECUTE PROCEDURE measurement_insert_trigger(); + +CREATE TABLE measurement ( + city_id int not null, + logdate date not null, + peaktemp int, + unitsales int +); + +CREATE VIEW measurement AS + SELECT * FROM measurement_y2006m02 +UNION ALL SELECT * FROM measurement_y2006m03; + +-- create Function +CREATE FUNCTION get_color_note (rainbow) RETURNS text AS + 'SELECT note FROM my_colors WHERE color = $1' + LANGUAGE SQL; + +-- Data types +CREATE TABLE products ( + product_no integer, + price numeric, + col4 smallint, + col5 int, + col6 bigint, + col7 decimal, + col8 smallserial, + col9 serial, + col10 bigserial, + col11 real +); + +-- Character Types +CREATE TABLE test1 ( + name text, + a character(4), + b character varying(4), + c varchar(4) +); + +-- Enumerated Types +CREATE TYPE mood AS ENUM ('sad', 'ok', 'happy'); + +-- Bit String Types +CREATE TABLE test (a BIT(3), b BIT VARYING(5)); + +-- Arrays +CREATE TABLE sal_emp ( + name text, + pay_by_quarter integer[], + schedule text[][] +); + +-- Composite Types +CREATE TYPE inventory_item AS ( + name text, + supplier_id integer, + price numeric +); +CREATE TABLE on_hand ( + item inventory_item, + count integer +); + +-- Ranger Types +CREATE TYPE floatrange AS RANGE ( + subtype = float8, + subtype_diff = float8mi +); + +-- CREATE AGGREGATE +CREATE AGGREGATE agg_name1 ( int, integer) ( + SFUNC = sfunc, + STYPE = state_data_type, + FINALFUNC = ffunc, + INITCOND = initial_condition, + SORTOP = sort_operator +); +CREATE AGGREGATE agg_name2 ( int, integer) ( + SFUNC = sfunc, + STYPE = state_data_type +); +CREATE AGGREGATE agg_name3 ( + BASETYPE = base_type, + SFUNC = sfunc, + STYPE = state_data_type, + FINALFUNC = ffunc, + INITCOND = initial_condition, + SORTOP = sort_operator +); +CREATE AGGREGATE agg_name4 ( + BASETYPE = base_type, + SFUNC = sfunc, + STYPE = state_data_type +); + +-- CREATE CAST +CREATE CAST (source_type1 AS target_type1) + WITH FUNCTION function_name1 (argument_type1,argument_type2) + AS ASSIGNMENT; +CREATE CAST (source_type1 AS target_type1) + WITH FUNCTION function_name1 (argument_type1); +CREATE CAST (source_type2 AS target_type2) + WITHOUT FUNCTION + AS IMPLICIT; +CREATE CAST (source_type2 AS target_type2) + WITHOUT FUNCTION; +CREATE CAST (source_type3 AS target_type3) + WITH INOUT + AS ASSIGNMENT; +CREATE CAST (source_type3 AS target_type3) + WITH INOUT; + +-- CREATE COLLATION +CREATE COLLATION coll_name ( + LOCALE = locale, + LC_COLLATE = lc_collate, + LC_CTYPE = lc_ctype +); +CREATE COLLATION coll_name FROM existing_collation; + +-- CREATE CONVERSION +CREATE DEFAULT CONVERSION conver_name + FOR 'source_encoding' TO 'dest_encoding' FROM function_name; +CREATE CONVERSION conver_name1 + FOR 'source_encoding' TO 'dest_encoding' FROM function_name; + +-- CREATE DATABASE +CREATE DATABASE name1 + WITH + OWNER = user_name + TEMPLATE = template + ENCODING = encoding + LC_COLLATE = lc_collate + LC_CTYPE = lc_ctype + TABLESPACE = tablespace_name + CONNECTION LIMIT = connlimit; +CREATE DATABASE name2; + +-- CREATE DOMAIN +CREATE DOMAIN name AS data_type +COLLATE collation +DEFAULT expression +CONSTRAINT constraint_name NOT NULL +NULL +CHECK( + VALUE ~ '^\d{5}$' +OR VALUE ~ '^\d{5}-\d{4}$' +); +CREATE DOMAIN domain_name my_type; + +-- CREATE EVENT TRIGGER +CREATE EVENT TRIGGER trigger_name + ON event_name + WHEN TAG IN ('filter_value1', 'filter_value2') AND filter_variable IN ('filter_value1', 'filter_value2') + EXECUTE PROCEDURE function_name(); +CREATE EVENT TRIGGER trigger_name + ON event_name + EXECUTE PROCEDURE function_name(); + +-- CREATE EXTENSION +CREATE EXTENSION IF NOT EXISTS extension_name + WITH SCHEMA schema_name + VERSION version + FROM old_version; +CREATE EXTENSION extension_name1; + +-- CREATE FOREIGN DATA WRAPPER +CREATE FOREIGN DATA WRAPPER name1 +HANDLER handler_function +VALIDATOR validator_function +OPTIONS ( option_name 'value', option_name1 'value2'); +CREATE FOREIGN DATA WRAPPER name2 +NO HANDLER +NO VALIDATOR +OPTIONS ( option_name 'value'); +CREATE FOREIGN DATA WRAPPER name3; + +-- CREATE FOREIGN TABLE +CREATE FOREIGN TABLE IF NOT EXISTS table_name (column_name varchar(10) OPTIONS ( option_name1 'value', option_name2 'values') COLLATE coll_name CONSTRAINT constraint_name NOT NULL) + SERVER server_name + OPTIONS ( option_name1 'value', option_name2 'value3'); +CREATE FOREIGN TABLE films ( + code char(5) NOT NULL, + title varchar(40) NOT NULL, + did integer NOT NULL, + date_prod date, + kind varchar(10), + len interval hour to minute +) +SERVER film_server; + +-- CREATE FUNCTION +CREATE OR REPLACE FUNCTION + name ( INOUT argname int DEFAULT a>3) + RETURNS integer + AS 'obj_file' + WITH (isStrict, isCachable); + +-- CREATE GROUP +CREATE GROUP group_name WITH SUPERUSER; +CREATE GROUP group_name WITH ENCRYPTED PASSWORD 'password'; +CREATE GROUP group_name; + +-- CREATE INDEX +CREATE UNIQUE INDEX CONCURRENTLY index_name ON table_name USING btree + ((a > 4) COLLATE collation_name ASC NULLS LAST ) + WITH ( storage_parameter = 1) + TABLESPACE tablespace_name + WHERE (y > 4); +CREATE INDEX ON table_name (col1); + +-- CREATE LANGUAGE +CREATE OR REPLACE PROCEDURAL LANGUAGE lan_name +CREATE OR REPLACE TRUSTED PROCEDURAL LANGUAGE lan_name1 + HANDLER call_handler INLINE inline_handler VALIDATOR valfunction; + +-- CREATE MATERIALIZED VIEW +CREATE MATERIALIZED VIEW table_name + (column_name, column_name2) + WITH ( storage_parameter=3, storage_parameter1=4) + TABLESPACE tablespace_name + AS SELECT * FROM product + WITH NO DATA; +CREATE MATERIALIZED VIEW table_name2 AS SELECT * FROM product; + +-- CREATE OPERATOR +CREATE OPERATOR - ( + PROCEDURE = function_name, + LEFTARG = left_type, + RIGHTARG = right_type, + COMMUTATOR = com_op, + NEGATOR = neg_op, + RESTRICT = res_proc, + JOIN = join_proc, + HASHES, + MERGES +); +CREATE OPERATOR == ( + PROCEDURE = function_name +); + +-- CREATE OPERATOR CLASS +CREATE OPERATOR CLASS op_class_name DEFAULT FOR TYPE type4 + USING index_method FAMILY family_name AS + OPERATOR 2 = (arraytype, arraytype1) FOR ORDER BY sort_family_name, + FUNCTION 4 (op_type1, op_type2 ) function_name ( argument_type, argument_type2 ), + STORAGE storage_type; +CREATE OPERATOR CLASS gist__int_ops +FOR TYPE _int4 USING gist AS + OPERATOR 3 &&; + +-- CREATE OPERATOR FAMILY +CREATE OPERATOR FAMILY name USING index_method; + +-- CREATE ROLE +CREATE ROLE name WITH SUPERUSER CREATEDB CREATEROLE + CREATEUSER + INHERIT + LOGIN + REPLICATION + CONNECTION LIMIT 234 + ENCRYPTED PASSWORD 'password' + VALID UNTIL '2013-09-20' + IN ROLE role_name, role_name2 + IN GROUP role_name2, role_name3 + ROLE role_name3, role_name4 + ADMIN role_name4, role_name5 + USER role_name5, role_name6 + SYSID 234; + +-- CREATE RULE +CREATE OR REPLACE RULE name AS ON SELECT + TO table_name WHERE y=3 + DO INSTEAD NOTHING; +CREATE OR REPLACE RULE name AS ON SELECT + TO table_name WHERE y=3 + DO ALSO (SELECT bb FROM prod); +CREATE RULE rule_name AS ON UPDATE TO table_name DO NOTHING; + +-- CREATE SCHEMA +CREATE SCHEMA schema_name AUTHORIZATION user_name CREATE TABLE films (title text, release date, awards text[]) CREATE VIEW winners AS + SELECT title, release FROM films WHERE awards IS NOT NULL; +CREATE SCHEMA AUTHORIZATION user_name CREATE TABLE films (title text, release date, awards text[]); +CREATE SCHEMA IF NOT EXISTS schema_name AUTHORIZATION user_name; +CREATE SCHEMA IF NOT EXISTS AUTHORIZATION user_name; + +-- CREATE SEQUENCE +CREATE TEMPORARY SEQUENCE squen_name INCREMENT BY 2432 MINVALUE 45 MAXVALUE 12 + START WITH 4654 CACHE 1232 NO CYCLE + OWNED BY table_name.column_name; +CREATE SEQUENCE squen_name; + +-- CREATE SERVER +CREATE SERVER server_name TYPE 'server_type' VERSION 'server_version' + FOREIGN DATA WRAPPER fdw_name + OPTIONS ( option 'value', option 'value3'); +CREATE SERVER server_name FOREIGN DATA WRAPPER fdw_name; + +-- CREATE TABLE AS +CREATE GLOBAL TEMPORARY TABLE table_name +(column_name, column_name2) +WITH ( storage_parameter = 4) +ON COMMIT PRESERVE ROWS +TABLESPACE tablespace_name +AS SELECT * FROM ad +WITH NO DATA; +CREATE TABLE table_name AS SELECT * FROM ad; + +-- CREATE TABLESPACE +CREATE TABLESPACE tablespace_name OWNER user_name LOCATION 'directory'; +CREATE TABLESPACE tablespace_name LOCATION 'directory'; + +-- CREATE TEXT SEARCH CONFIGURATION +CREATE TEXT SEARCH CONFIGURATION name ( + PARSER = parser_name +); +CREATE TEXT SEARCH CONFIGURATION name ( + COPY = source_config +); + +-- CREATE TEXT SEARCH DICTIONARY +CREATE TEXT SEARCH DICTIONARY name ( + TEMPLATE = template +); + +-- CREATE TEXT SEARCH PARSER +CREATE TEXT SEARCH PARSER name ( + START = start_function , + GETTOKEN = gettoken_function , + END = end_function , + LEXTYPES = lextypes_function, + HEADLINE = headline_function +); +CREATE TEXT SEARCH PARSER name ( + START = start_function , + GETTOKEN = gettoken_function , + END = end_function , + LEXTYPES = lextypes_function +); + +-- CREATE TEXT SEARCH TEMPLATE +CREATE TEXT SEARCH TEMPLATE name ( + INIT = init_function, + LEXIZE = lexize_function +); +CREATE TEXT SEARCH TEMPLATE name ( + LEXIZE = lexize_function +); + +-- CREATE TRIGGER +CREATE CONSTRAINT TRIGGER trig_name INSTEAD OF INSERT OR UPDATE + ON table_name + FROM referenced_table_name + DEFERRABLE INITIALLY IMMEDIATE + FOR EACH STATEMENT + WHEN (OLD.balance IS DISTINCT FROM NEW.balance) + EXECUTE PROCEDURE function_name (); + +-- CREATE TYPE +CREATE TYPE name AS + (attribute_name int COLLATE collation_name, attribute_name integer COLLATE collation_name); + +CREATE TYPE name AS ENUM + ('label', 'name'); + +CREATE TYPE name AS RANGE ( + SUBTYPE = subtype, + SUBTYPE_OPCLASS = subtype_operator_class, + COLLATION = collation, + CANONICAL = canonical_function, + SUBTYPE_DIFF = subtype_diff_function + ); +CREATE TYPE name ( + INPUT = input_function, + OUTPUT = output_function, + RECEIVE = receive_function, + SEND = send_function, + TYPMOD_IN = type_modifier_input_function, + TYPMOD_OUT = type_modifier_output_function, + ANALYZE = analyze_function, + INTERNALLENGTH = 13, + PASSEDBYVALUE, + ALIGNMENT = alignment, + STORAGE = storage, + LIKE = like_type, + CATEGORY = category, + PREFERRED = preferred, + DEFAULT = default_value, + ELEMENT = float4, + DELIMITER = delimiter, + COLLATABLE = collatable +); +CREATE TYPE name; + +-- CREATE USER +CREATE USER name WITH NOSUPERUSER NOCREATEDB NOCREATEROLE + NOCREATEUSER + NOINHERIT + NOLOGIN + NOREPLICATION + CONNECTION LIMIT 234 + UNENCRYPTED PASSWORD 'password' + VALID UNTIL '2013-09-20' + IN ROLE role_name, role_name2 + IN GROUP role_name2, role_name3 + ROLE role_name3, role_name4 + ADMIN role_name4, role_name5 + USER role_name5, role_name6 + SYSID 234; + +-- CREATE USER MAPPING +CREATE USER MAPPING FOR CURRENT_USER + SERVER server_name + OPTIONS ( option 'value'); +CREATE USER MAPPING FOR PUBLIC + SERVER server_name; + +-- CREATE VIEW +CREATE OR REPLACE TEMP RECURSIVE VIEW name ( column_name, column_name2) +WITH ( view_option_name = 2321, view_option_name2='ewfwe') +AS SELECT * FROM my_view; +CREATE VIEW view_name AS SELECT * FROM my_view; + diff --git a/test/parser/pgsql/syntax/fixtures/delete.sql b/test/parser/pgsql/syntax/fixtures/delete.sql new file mode 100644 index 0000000..d9ad843 --- /dev/null +++ b/test/parser/pgsql/syntax/fixtures/delete.sql @@ -0,0 +1,11 @@ +DELETE FROM weather WHERE city = 'Hayward'; + +DELETE FROM products + WHERE obsoletion_date = 'today' + RETURNING ab AS abc_name; + +WITH RECURSIVE a AS (SELECT * from bt ) +DELETE FROM ONLY table_name * AS alias +USING using_list +WHERE y > 4 +RETURNING *; diff --git a/test/parser/pgsql/syntax/fixtures/drop.sql b/test/parser/pgsql/syntax/fixtures/drop.sql new file mode 100644 index 0000000..bda776e --- /dev/null +++ b/test/parser/pgsql/syntax/fixtures/drop.sql @@ -0,0 +1,144 @@ +-- Drop Table +DROP TABLE IF EXISTS table1, table2 RESTRICT; +DROP TABLE products CASCADE; +DROP TABLE products1; + +-- DROP AGGREGATE +DROP AGGREGATE IF EXISTS aggname1(int, integer) CASCADE; +DROP AGGREGATE aggname2(int); + +-- DROP CAST +DROP CAST IF EXISTS (integer AS int) RESTRICT; +DROP CAST (int AS integer); + +-- DROP COLLATION +DROP COLLATION IF EXISTS collation_name CASCADE; +DROP COLLATION collation_name1; + +-- DROP CONVERSION +DROP CONVERSION IF EXISTS conver_name RESTRICT; +DROP CONVERSION conver_name1; + +-- DROP DATABASE +DROP DATABASE IF EXISTS db_name; +DROP DATABASE db_name; + +-- DROP DOMAIN +DROP DOMAIN IF EXISTS domain_name1, domain_name2 CASCADE; +DROP DOMAIN domain_name3; + +-- DROP EVENT TRIGGER +DROP EVENT TRIGGER IF EXISTS trigger_name RESTRICT; +DROP EVENT TRIGGER trigger_name1; + +-- DROP EXTENSION +DROP EXTENSION IF EXISTS extension_name1, extension_name2 CASCADE; +DROP EXTENSION extension_name3; + +-- DROP FOREIGN DATA WRAPPER +DROP FOREIGN DATA WRAPPER IF EXISTS foreigndata_name RESTRICT; +DROP FOREIGN DATA WRAPPER foreigndata_name2; + +-- DROP FOREIGN TABLE +DROP FOREIGN TABLE IF EXISTS foreigntable_name1, foreigntable_name2 CASCADE; +DROP FOREIGN TABLE foreigntable_name3; + +-- DROP FUNCTION +DROP FUNCTION IF EXISTS function_name (IN argname integer) RESTRICT; +DROP FUNCTION function_name (integer); + +-- DROP GROUP +DROP GROUP IF EXISTS group_name1, group_name2; +DROP GROUP group_name3; + +-- DROP INDEX +DROP INDEX CONCURRENTLY IF EXISTS index_name1, index_name2 CASCADE; +DROP INDEX index_name3; + +-- DROP LANGUAGE +DROP PROCEDURAL LANGUAGE IF EXISTS lan_name RESTRICT; +DROP LANGUAGE lan_name1; + +-- DROP MATERIALIZED VIEW +DROP MATERIALIZED VIEW IF EXISTS view_name1, view_name2 CASCADE; +DROP MATERIALIZED VIEW view_name3; + +-- DROP OPERATOR +DROP OPERATOR IF EXISTS ! ( NONE , int ) RESTRICT; +DROP OPERATOR - (int, int); +DROP OPERATOR ^ (int, int); + +-- DROP OPERATOR CLASS +DROP OPERATOR CLASS IF EXISTS classs_name USING btree CASCADE; +DROP OPERATOR CLASS classs_name USING index_method; + +-- DROP OPERATOR FAMILY +DROP OPERATOR FAMILY IF EXISTS family_name USING index_method RESTRICT; +DROP OPERATOR FAMILY family_name1 USING index_method; + +-- DROP OWNED +DROP OWNED BY owner_name1, owner_name2 CASCADE; +DROP OWNED BY owner_name3; + +-- DROP ROLE +DROP ROLE IF EXISTS role_name1, role_name2; +DROP ROLE role_name3; + +-- DROP RULE +DROP RULE IF EXISTS rule_name ON table_name CASCADE; +DROP RULE rule_name1 ON table_name1; + +-- DROP SCHEMA +DROP SCHEMA IF EXISTS schema_name1, schema_name2 RESTRICT; +DROP SCHEMA myschema; + +-- DROP SEQUENCE +DROP SEQUENCE IF EXISTS con_name1, con_name2 CASCADE; +DROP SEQUENCE con_name3; + +-- DROP SERVER +DROP SERVER IF EXISTS server_name RESTRICT; +DROP SERVER server_name1; + +-- DROP TABLESPACE +DROP TABLESPACE IF EXISTS tbspace_name1; +DROP TABLESPACE tbspace_name2; + +-- DROP TEXT SEARCH CONFIGURATION +DROP TEXT SEARCH CONFIGURATION IF EXISTS text_name CASCADE; +DROP TEXT SEARCH CONFIGURATION text_name1; + +-- DROP TEXT SEARCH DICTIONARY +DROP TEXT SEARCH DICTIONARY IF EXISTS dic_name1 RESTRICT; +DROP TEXT SEARCH DICTIONARY dic_name2; + +-- DROP TEXT SEARCH PARSER +DROP TEXT SEARCH PARSER IF EXISTS parser_name1 CASCADE; +DROP TEXT SEARCH PARSER parser_name2; + +-- DROP TEXT SEARCH TEMPLATE +DROP TEXT SEARCH TEMPLATE IF EXISTS temp_name1 RESTRICT; +DROP TEXT SEARCH TEMPLATE temp_name2; + +-- DROP TRIGGER +DROP TRIGGER IF EXISTS trigger_name1 ON table_name1 CASCADE; +DROP TRIGGER trigger_name2 ON table_name2; + +-- DROP TYPE +DROP TYPE IF EXISTS type_name1, type_name2 RESTRICT; +DROP TYPE type_name3; + +-- DROP USER +DROP USER IF EXISTS user_name1, user_name2; +DROP USER user_name3; + +-- DROP USER MAPPING +DROP USER MAPPING IF EXISTS FOR user_name SERVER server_name; +DROP USER MAPPING IF EXISTS FOR USER SERVER server_name; +DROP USER MAPPING IF EXISTS FOR CURRENT_USER SERVER server_name; +DROP USER MAPPING IF EXISTS FOR PUBLIC SERVER server_name; +DROP USER MAPPING FOR PUBLIC SERVER server_name; + +-- DROP VIEW +DROP VIEW IF EXISTS view_name1, view_name2 RESTRICT; +DROP VIEW view_name3; diff --git a/test/parser/pgsql/syntax/fixtures/insert.sql b/test/parser/pgsql/syntax/fixtures/insert.sql new file mode 100644 index 0000000..820a91a --- /dev/null +++ b/test/parser/pgsql/syntax/fixtures/insert.sql @@ -0,0 +1,37 @@ +-- Inserting Data +INSERT INTO weather VALUES ('San Francisco', 46, 50, 0.25, '1994-11-27'); + +INSERT INTO weather (city, temp_lo, temp_hi, prcp, date) + VALUES ('San Francisco', 43, 57, 0.0, '1994-11-29'); + +INSERT INTO weather (date, city, temp_hi, temp_lo) + VALUES ('1994-11-29', 'Hayward', 54, 37); + +INSERT INTO products (product_no, name, price) + SELECT product_no, name, price FROM new_products + WHERE release_date = 'today'; + +INSERT INTO products DEFAULT VALUES; + +INSERT INTO cities (name, population, altitude, state) +VALUES ('New York', NULL, NULL, 'NY'); + +-- Boolean Type +INSERT INTO test1 VALUES (FALSE, TRUE, 'non est', 't', 'true', 'y', 'on', '1', 'f', 'false', 'n', 'no', 'off', 0); + +-- Arrays -- . Array Value Input +INSERT INTO sal_emp + VALUES ('Bill', + '{10000, 10000, 10000, 10000}', + '{{"meeting", "lunch"}, {"training", "presentation"}}'); + +-- Range Types +INSERT INTO reservation VALUES + (1108, '[2010-01-01 14:30, 2010-01-01 15:30)'); + +-- INSERT +WITH RECURSIVE a AS (SELECT * from bt ) +INSERT INTO table_name ( column_name, column_name2) + VALUES (1, 2) + RETURNING * ; +INSERT INTO films DEFAULT VALUES; \ No newline at end of file diff --git a/test/parser/pgsql/syntax/fixtures/others.sql b/test/parser/pgsql/syntax/fixtures/others.sql new file mode 100644 index 0000000..fc292c9 --- /dev/null +++ b/test/parser/pgsql/syntax/fixtures/others.sql @@ -0,0 +1,287 @@ +-- ABORT +ABORT WORK; +ABORT TRANSACTION; + +-- ANALYZE +ANALYZE VERBOSE table_name ( column_name, column_name2); +ANALYZE; + +-- BEGIN +BEGIN WORK ISOLATION LEVEL READ UNCOMMITTED + READ WRITE + NOT DEFERRABLE; +-- CHECKPOINT +CHECKPOINT; + +-- CLUSTER +CLUSTER VERBOSE table_name USING index_name; +CLUSTER VERBOSE; + +-- CLOSE +CLOSE ALL; +CLOSE name_2; + +-- COMMENT +COMMENT ON +AGGREGATE agg_name (agg_type, agg_type2) IS 'text'; +COMMENT ON CAST (source_type AS target_type) IS 'text'; +COMMENT ON COLLATION object_name IS 'text'; +COMMENT ON COLUMN relation_name.column_name IS 'text' +COMMENT ON CONVERSION object_name IS 'text'; +COMMENT ON CONSTRAINT constraint_name ON table_name IS 'text'; +COMMENT ON DATABASE object_name IS 'text'; +COMMENT ON DOMAIN object_name IS 'text'; +COMMENT ON EXTENSION object_name IS 'text'; +COMMENT ON EVENT TRIGGER object_name IS 'text'; +COMMENT ON FOREIGN DATA WRAPPER object_name IS 'text'; +COMMENT ON FOREIGN TABLE object_name IS 'text'; +COMMENT ON FUNCTION function_name ( INOUT argname timestamp) IS 'text'; +COMMENT ON INDEX object_name IS 'text'; +COMMENT ON LARGE OBJECT 346344 IS 'text'; +COMMENT ON MATERIALIZED VIEW object_name IS 'text'; +COMMENT ON OPERATOR -(int, NONE) IS 'text'; +COMMENT ON OPERATOR CLASS object_name USING index_method IS 'text'; +COMMENT ON OPERATOR FAMILY object_name USING index_method IS 'text'; +COMMENT ON PROCEDURAL LANGUAGE object_name IS 'text'; +COMMENT ON ROLE object_name IS 'text'; +COMMENT ON RULE rule_name ON table_name IS 'text'; +COMMENT ON SCHEMA object_name IS 'text'; +COMMENT ON SEQUENCE object_name IS 'text'; +COMMENT ON SERVER object_name IS 'text'; +COMMENT ON TABLE object_name IS 'text'; +COMMENT ON TABLESPACE object_name IS 'text'; +COMMENT ON TEXT SEARCH CONFIGURATION object_name IS 'text'; +COMMENT ON TEXT SEARCH DICTIONARY object_name IS 'text'; +COMMENT ON TEXT SEARCH PARSER object_name IS 'text'; +COMMENT ON TEXT SEARCH TEMPLATE object_name IS 'text'; +COMMENT ON TRIGGER trigger_name ON table_name IS 'text'; +COMMENT ON TYPE object_name IS 'text'; +COMMENT ON VIEW object_name IS 'text'; + +-- COMMIT +COMMIT TRANSACTION; +COMMIT WORK; + +-- COMMIT PREPARED +COMMIT PREPARED 'foobar'; + +-- COPY +COPY table_name ( column_name, column_name2) +FROM PROGRAM 'command' +WITH ( FORMAT format_name); +COPY (SELECT * FROM td) + TO STDOUT + WITH (DELIMITER 'delimiter_character'); + + +-- DEALLOCATE +DEALLOCATE PREPARE name; +DEALLOCATE PREPARE ALL; + +-- DECLARE +DECLARE name BINARY INSENSITIVE NO SCROLL CURSOR WITH HOLD FOR +SELECT + * +FROM + tb; + +DECLARE name CURSOR FOR +SELECT + * +FROM + abs; + +-- DISCARD +DISCARD TEMPORARY; +DISCARD PLANS; +DISCARD ALL; +DISCARD TEMP; + +-- DO +DO LANGUAGE lang_name '$$DECLARE' r record; +DO '$$DECLARE' r record; + +-- END +END TRANSACTION; +END WORK; + +-- EXECUTE +EXECUTE name ( parameter, parameter2); + +-- EXPLAIN +EXPLAIN ( ANALYZE 'true',VERBOSE true, COSTS TRUE, FORMAT TEXT) SELECT * FROM no_nw; +EXPLAIN ANALYZE VERBOSE SELECT * FROM no_nw; + +-- FETCH +FETCH NEXT FROM cursor_name; + +-- GRANT +GRANT SELECT, INSERT, UPDATE, DELETE, TRUNCATE, REFERENCES, TRIGGER + ON TABLE table_name, table_name2 + TO GROUP role_name,PUBLIC WITH GRANT OPTION; +GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA schema_name, schema_name2 TO PUBLIC; +GRANT SELECT( column_name, column_name2), INSERT( column_name, column_name2), UPDATE( column_name, column_name2), REFERENCES ( column_name, column_name2) + ON TABLE table_name + TO GROUP role_name WITH GRANT OPTION; +GRANT ALL PRIVILEGES ( column_name, column_name2) ON table_name TO role_name; +GRANT USAGE, SELECT, UPDATE + ON SEQUENCE sequence_name + TO GROUP role_name, PUBLIC WITH GRANT OPTION; +GRANT ALL PRIVILEGES + ON ALL SEQUENCES IN SCHEMA schema_name + TO PUBLIC WITH GRANT OPTION; +GRANT CREATE, CONNECT, TEMPORARY, TEMP + ON DATABASE database_name + TO GROUP role_name, PUBLIC WITH GRANT OPTION; +GRANT role_name TO role_name; + + +-- LISTEN +LISTEN channel; + +-- LOAD +LOAD 'filename'; + +-- LOCK +-- lockmode：ACCESS SHARE | ROW SHARE | ROW EXCLUSIVE | SHARE UPDATE EXCLUSIVE +-- | SHARE | SHARE ROW EXCLUSIVE | EXCLUSIVE | ACCESS EXCLUSIVE +LOCK TABLE ONLY name * IN ACCESS SHARE MODE NOWAIT; + +-- MOVE +MOVE NEXT FROM cursor_name; + +-- NOTIFY +NOTIFY virtual, 'This is the payload'; + +-- PREPARE +PREPARE name ( int, numeric) AS INSERT INTO foo VALUES($1, $2, $3, $4); + +-- PREPARE TRANSACTION +PREPARE TRANSACTION 'foobar'; + +-- REASSIGN OWNED +REASSIGN OWNED BY old_role TO new_role; + +-- REFRESH MATERIALIZED VIEW +REFRESH MATERIALIZED VIEW name WITH NO DATA; + +-- REINDEX +REINDEX DATABASE name FORCE; +REINDEX TABLE name; +REINDEX INDEX name; +REINDEX SYSTEM name; + +-- RELEASE SAVEPOINT +RELEASE SAVEPOINT savepoint_name; + +-- RESET +RESET configuration_parameter; +RESET ALL; + +-- REVOKE +REVOKE GRANT OPTION FOR +REFERENCES, CREATE + ON TABLE table_name + FROM GROUP role_name, PUBLIC + RESTRICT; +REVOKE ALL PRIVILEGES ON accounts FROM PUBLIC; +REVOKE CREATE ON SCHEMA public_name FROM PUBLIC; + +-- ROLLBACK +ROLLBACK TRANSACTION; +ROLLBACK WORK; + +-- ROLLBACK PREPARED +ROLLBACK PREPARED 'foobar'; + +-- ROLLBACK TO SAVEPOINT +ROLLBACK TRANSACTION TO SAVEPOINT savepoint_name; +ROLLBACK WORK TO SAVEPOINT savepoint_name; +ROLLBACK TO savepoint_name; + +-- SAVEPOINT +SAVEPOINT savepoint_name; + +-- SECURITY LABEL +SECURITY LABEL FOR provider ON TABLE object_name IS 'label'; +SECURITY LABEL FOR provider ON COLUMN table_name.column_name IS 'label'; +SECURITY LABEL FOR provider ON AGGREGATE agg_name (agg_type, agg_type2) IS 'label'; +SECURITY LABEL FOR provider ON DATABASE object_name IS 'label'; +SECURITY LABEL FOR provider ON DOMAIN object_name IS 'label'; +SECURITY LABEL FOR provider ON EVENT TRIGGER object_name IS 'label'; +SECURITY LABEL FOR provider ON FOREIGN TABLE object_name IS 'label'; +SECURITY LABEL FOR provider ON FUNCTION function_name ( VARIADIC arg_name timestamp) IS 'label'; +SECURITY LABEL FOR provider ON LARGE OBJECT 2432 IS 'label'; +SECURITY LABEL FOR provider ON MATERIALIZED VIEW object_name IS 'label'; +SECURITY LABEL FOR provider ON PROCEDURAL LANGUAGE object_name IS 'label'; +SECURITY LABEL FOR provider ON ROLE object_name IS 'label'; +SECURITY LABEL FOR provider ON SCHEMA object_name IS 'label'; +SECURITY LABEL FOR provider ON SEQUENCE object_name IS 'label'; +SECURITY LABEL FOR provider ON TABLESPACE object_name IS 'label'; +SECURITY LABEL FOR provider ON TYPE object_name IS 'label'; +SECURITY LABEL FOR provider ON VIEW object_name IS 'label'; + +-- SET +SET SESSION configuration_parameter TO DEFAULT; +SET LOCAL TIME ZONE LOCAL; + +-- SET CONSTRAINTS +SET CONSTRAINTS ALL IMMEDIATE; +SET CONSTRAINTS name1, name2 DEFERRED; + +-- SET ROLE +SET SESSION ROLE role_name; +SET LOCAL ROLE NONE; +RESET ROLE; + +-- SET SESSION AUTHORIZATION +SET SESSION SESSION AUTHORIZATION user_name; +SET LOCAL SESSION AUTHORIZATION DEFAULT; +RESET SESSION AUTHORIZATION; + +-- SET TRANSACTION +SET TRANSACTION ISOLATION LEVEL SERIALIZABLE + READ WRITE + NOT DEFERRABLE; +SET TRANSACTION SNAPSHOT '000003A1-1'; +SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL REPEATABLE READ READ ONLY DEFERRABLE; + +-- SHOW +SHOW name; +SHOW ALL; + +-- START TRANSACTION +START TRANSACTION ISOLATION LEVEL SERIALIZABLE + READ WRITE + NOT DEFERRABLE, ISOLATION LEVEL REPEATABLE READ READ ONLY DEFERRABLE; +START TRANSACTION; + +-- TRUNCATE +TRUNCATE TABLE ONLY name + RESTART IDENTITY CASCADE; +TRUNCATE TABLE ONLY name + CONTINUE IDENTITY RESTRICT; +TRUNCATE name; + +-- UNLISTEN +UNLISTEN *; +UNLISTEN channel; + +-- VACUUM +VACUUM ( FULL, FREEZE, VERBOSE, ANALYZE) table_name (column_name, column_name2); +VACUUM FULL FREEZE VERBOSE table_name; +VACUUM FULL FREEZE VERBOSE ANALYZE table_name (column_name,column_name2); +VACUUM ANALYZE; +ANALYZE; + +-- VALUES +VALUES (1, '3'), (3, 'sdsd') + ORDER BY sort_expression ASC + LIMIT 20 + OFFSET 324 ROW + FETCH NEXT 343 ROWS ONLY ; +VALUES (1, '3'), (3, 'sdsd'); + +-- Caveats +ANALYZE measurement; + diff --git a/test/parser/pgsql/syntax/fixtures/select.sql b/test/parser/pgsql/syntax/fixtures/select.sql new file mode 100644 index 0000000..90e19af --- /dev/null +++ b/test/parser/pgsql/syntax/fixtures/select.sql @@ -0,0 +1,176 @@ +-- SELECT +WITH RECURSIVE query_name (id) AS (SELECT id FROM table_expression) SELECT ALL random() AS name1 FROM table_expression WHERE name1=name1 GROUP BY id HAVING sum(len) < interval '5 hours' WINDOW w AS (PARTITION BY depname ORDER BY salary DESC) UNION ALL (SELECT * FROM others) ORDER BY salary DESC LIMIT ALL OFFSET start FETCH NEXT ROWS ONLY FOR UPDATE; + +WITH query_name (id) AS (SELECT id FROM table_expression) SELECT DISTINCT random() AS name1 FROM table_expression WHERE name1=name1 GROUP BY id HAVING sum(len) < interval '5 hours' WINDOW w AS (PARTITION BY depname ORDER BY salary DESC) INTERSECT DISTINCT (SELECT * FROM others) ORDER BY salary ASC LIMIT ALL OFFSET start FETCH NEXT ROW ONLY FOR NO KEY UPDATE; + +WITH query_name (id) AS (SELECT id FROM table_expression) SELECT DISTINCT ON (col1) random() AS name1 FROM table_expression WHERE name1=name1 GROUP BY id HAVING sum(len) < interval '5 hours' WINDOW w AS (PARTITION BY depname ORDER BY salary DESC) EXCEPT (SELECT * FROM others) ORDER BY salary USING > NULL FIRST LIMIT 40 OFFSET start FETCH NEXT ROW ONLY FOR SHARE; + +WITH query_name (id) AS (SELECT id FROM table_expression) SELECT DISTINCT ON (col1) random() AS name1 FROM table_expression WHERE name1=name1 GROUP BY id HAVING sum(len) < interval '5 hours' WINDOW w AS (PARTITION BY depname ORDER BY salary DESC) EXCEPT (SELECT * FROM others) ORDER BY salary USING > NULL FIRST LIMIT 40 OFFSET start FETCH NEXT ROW ONLY FOR KEY SHARE OF table_name NOWAIT; + +-- SELECT INTO +WITH RECURSIVE query_name (id) AS (SELECT id FROM table_expression) +SELECT DISTINCT ON (col2) +INTO TEMPORARY TABLE new_table + FROM from_item + WHERE name2=name1 + GROUP BY name + HAVING s > 8 + WINDOW window_name AS ( RANGE UNBOUNDED PRECEDING ) + INTERSECT DISTINCT (SELECT * FROM tb) + ORDER BY expression_1 USING > NULLS FIRST + LIMIT ALL + OFFSET start ROW + FETCH FIRST 234 ROWS ONLY + FOR UPDATE OF table_name NOWAIT; + +-- The Most Easy +SELECT * ; + +-- Querying a Table + +SELECT city, temp_lo, temp_hi, prcp, date FROM weather; + +SELECT city, (temp_hi+temp_lo)/2 AS temp_avg, date FROM weather; + +SELECT * FROM weather + WHERE city = 'San Francisco' AND prcp > 0.0; + +SELECT * FROM weather + ORDER BY city; + +SELECT * FROM weather + ORDER BY city, temp_lo; + +SELECT DISTINCT city + FROM weather; + +SELECT DISTINCT city + FROM weather + ORDER BY city; + +-- Joins Between Tables +SELECT weather.city, weather.temp_lo, weather.temp_hi, + weather.prcp, weather.date, cities.location + FROM weather NATURAL LEFT OUTER JOIN cities + WHERE cities.name = weather.city; + +SELECT W1.city, W1.temp_lo AS low, W1.temp_hi AS high, + W2.city, W2.temp_lo AS low, W2.temp_hi AS high + FROM weather W1 NATURAL RIGHT OUTER JOIN weather W2 + WHERE W1.temp_lo < W2.temp_lo + AND W1.temp_hi > W2.temp_hi; + +SELECT * + FROM weather w NATURAL FULL OUTER JOIN cities c + WHERE w.city = c.name; + +SELECT * + FROM weather w CROSS JOIN cities c + WHERE w.city = c.name; + +-- Aggregate Functions + +SELECT city, max(temp_lo) + FROM weather + WHERE city LIKE 'S%' + GROUP BY city + HAVING max(temp_lo) < 40; + +-- Window Functions + +SELECT depname, empno, salary, enroll_date +FROM + (SELECT depname, empno, salary, enroll_date, + rank() OVER (PARTITION BY depname ORDER BY salary DESC, empno) AS pos + FROM empsalary + ) AS ss +WHERE pos < 3; + +SELECT sum(salary) OVER w, avg(salary) OVER w + FROM empsalary + WINDOW w AS (PARTITION BY depname ORDER BY salary DESC); + +SELECT name, altitude + FROM ONLY cities + WHERE altitude > 500; + +SELECT name, altitude + FROM cities* + WHERE altitude > 500; + +SELECT c.tableoid, c.name, c.altitude +FROM cities c +WHERE c.altitude > 500; + +-- Overview +WITH query_name (id) AS (SELECT id FROM table_expression) SELECT random() FROM table_expression ORDER BY salary DESC + +-- Partitioning and Constraint Exclusion +SET constraint_exclusion = on; +SELECT count(*) FROM measurement WHERE logdate >= DATE '2008-01-01'; + +-- Table Functions + +SELECT * FROM foo + WHERE foosubid IN ( + SELECT foosubid + FROM getfoo(foo.fooid) z + WHERE z.fooid = foo.fooid + ); + +SELECT * + FROM dblink('dbname=mydb', 'SELECT proname, prosrc FROM pg_proc') + AS t1(proname name, prosrc text) + WHERE proname LIKE 'bytea%'; + +-- The Schema Search Path +SELECT 3 OPERATOR(pg_catalog.+) 4; + + +-- Monetary Types +SELECT '12.34'::float8::numeric::money; + +-- Binary Data Types +SELECT '\xDEADBEEF'; + +-- bytea Escape Format +SELECT 'abc \153\154\155 \052\251\124'::bytea; + +-- Date/Time Types Interval Input +SELECT EXTRACT(days from '80 hours'::interval); + +-- Text Search Types +SELECT 'a fat cat sat on a mat and ate a fat rat'::tsvector; + +SELECT $$the lexeme ' ' contains spaces$$::tsvector; + +SELECT $$the lexeme 'Joe''s' contains a quote$$::tsvector; + +SELECT 'a:1 fat:2 cat:3 sat:4 on:5 a:6 mat:7 and:8 ate:9 a:10 fat:11 rat:12'::tsvector; + +SELECT to_tsvector('english', 'The Fat Rats'); + +SELECT 'fat & rat & ! cat'::tsquery; + +SELECT to_tsquery('Fat:ab & Cats'); + +-- Arrays --Accessing Arrays +SELECT name FROM sal_emp WHERE pay_by_quarter[1] <> pay_by_quarter[2]; + +SELECT schedule[1:2][2] FROM sal_emp WHERE name = 'Bill'; + +-- Arrays -- Searching in Arrays +SELECT * FROM sal_emp WHERE pay_by_quarter[1] = 10000 OR + pay_by_quarter[2] = 10000 OR + pay_by_quarter[3] = 10000 OR + pay_by_quarter[4] = 10000; + +-- Array Input and Output Syntax +SELECT f1[1][-2][3] AS e1, f1[1][-1][5] AS e2 + FROM (SELECT '[1:1][-2:-1][3:5]={{{1,2,3},{4,5,6}}}'::int[] AS f1) AS ss; + +-- Containment +SELECT int4range(10, 20) @> 3; + +-- Object Identifier Types +SELECT * FROM pg_attribute WHERE attrelid = 'mytable'::regclass; \ No newline at end of file diff --git a/test/parser/pgsql/syntax/fixtures/update.sql b/test/parser/pgsql/syntax/fixtures/update.sql new file mode 100644 index 0000000..9456421 --- /dev/null +++ b/test/parser/pgsql/syntax/fixtures/update.sql @@ -0,0 +1,38 @@ +UPDATE MY_TABLE SET A = 5; + +UPDATE weather + SET temp_hi = temp_hi - 2, temp_lo = temp_lo - 2 + WHERE date > '1994-11-28'; + +-- Transactions +UPDATE accounts SET balance = balance - 100.00 + WHERE name = 'Alice'; +UPDATE branches SET balance = balance - 100.00 + WHERE name = (SELECT branch_name FROM accounts WHERE name = 'Alice'); +UPDATE accounts SET balance = balance + 100.00 + WHERE name = 'Bob'; +UPDATE branches SET balance = balance + 100.00 + WHERE name = (SELECT branch_name FROM accounts WHERE name = 'Bob'); + +UPDATE accounts SET balance = balance - 100.00 + WHERE name = 'Alice'; + +UPDATE mytable SET a = 5, b = b * 3, c = c + 1 WHERE a > 0; + +-- Arrays -- Modifying Arrays +UPDATE sal_emp SET pay_by_quarter = ARRAY[25000,25000,27000,27000] + WHERE name = 'Carol'; + +UPDATE sal_emp SET pay_by_quarter[1:2] = '{27000,27000}' + WHERE name = 'Carol'; + +-- + +-- UPDATE +WITH RECURSIVE query_name (id) AS (SELECT id FROM table_expression) +UPDATE ONLY table_name * AS alias + SET column_name = DEFAULT, (column_name, column_nam2) = ( a+1,DEFAULT) + FROM from_list + WHERE a=b + RETURNING * AS output_name; +UPDATE table_name SET column_name = a + 3; diff --git a/test/parser/pgsql/syntax/insertStatement.test.ts b/test/parser/pgsql/syntax/insertStatement.test.ts new file mode 100644 index 0000000..da2e64d --- /dev/null +++ b/test/parser/pgsql/syntax/insertStatement.test.ts @@ -0,0 +1,16 @@ +import PgSQL from '../../../../src/parser/pgsql'; +import { readSQL } from '../../../helper'; + +const parser = new PgSQL(); + +const features = { + inserts: readSQL(__dirname, 'insert.sql'), +}; + +describe('PgSQL Insert Syntax Tests', () => { + features.inserts.forEach((insertItem) => { + it(insertItem, () => { + expect(parser.validate(insertItem).length).toBe(0); + }); + }); +}); diff --git a/test/parser/pgsql/syntax/others.test.ts b/test/parser/pgsql/syntax/others.test.ts new file mode 100644 index 0000000..73d5bba --- /dev/null +++ b/test/parser/pgsql/syntax/others.test.ts @@ -0,0 +1,16 @@ +import PgSQL from '../../../../src/parser/pgsql'; +import { readSQL } from '../../../helper'; + +const parser = new PgSQL(); + +const features = { + others: readSQL(__dirname, 'others.sql'), +}; + +describe('PgSQL Other SQL Syntax Tests', () => { + features.others.forEach((other) => { + it(other, () => { + expect(parser.validate(other).length).toBe(0); + }); + }); +}); diff --git a/test/parser/pgsql/syntax/selectStatement.test.ts b/test/parser/pgsql/syntax/selectStatement.test.ts new file mode 100644 index 0000000..af4439c --- /dev/null +++ b/test/parser/pgsql/syntax/selectStatement.test.ts @@ -0,0 +1,16 @@ +import PgSQL from '../../../../src/parser/pgsql'; +import { readSQL } from '../../../helper'; + +const parser = new PgSQL(); + +const features = { + selects: readSQL(__dirname, 'select.sql'), +}; + +describe('PgSQL Select Syntax Tests', () => { + features.selects.forEach((select) => { + it(select, () => { + expect(parser.validate(select).length).toBe(0); + }); + }); +}); diff --git a/test/parser/pgsql/syntax/updateStatement.test.ts b/test/parser/pgsql/syntax/updateStatement.test.ts new file mode 100644 index 0000000..ffa03b2 --- /dev/null +++ b/test/parser/pgsql/syntax/updateStatement.test.ts @@ -0,0 +1,16 @@ +import PgSQL from '../../../../src/parser/pgsql'; +import { readSQL } from '../../../helper'; + +const parser = new PgSQL(); + +const features = { + updates: readSQL(__dirname, 'update.sql'), +}; + +describe('PgSQL Update Syntax Tests', () => { + features.updates.forEach((update) => { + it(update, () => { + expect(parser.validate(update).length).toBe(0); + }); + }); +});